Remove usage of base::internal::MakeUnboundRunType

Chromium removes base::internal::MakeUnboundRunType in
https://crrev.com/c/5110744. Remove the usage, and use auto and template
deduction guides instead.

Bug: 316060144
Tag: #floss
Flag: EXEMPT, no logical change. Done for compatibility with Floss.
Test: emerge floss in cros_sdk
Test: m Bluetooth
Change-Id: I35f5f29c70dcb0084f3a60331fd73cb93760c46d

4 files changed, 25 insertions, 35 deletions

diff --git a/system/common/message_loop_thread.h b/system/common/message_loop_thread.h
index 3889c57a59..525fcf2ba7 100644
--- a/system/common/message_loop_thread.h
+++ b/system/common/message_loop_thread.h
@@ -174,41 +174,32 @@ class MessageLoopThread final : public IPostableContext {
   void Post(base::OnceClosure closure) override;
 
   template <typename Functor, typename... Args>
-  common::ContextualOnceCallback<common::MakeUnboundRunType<Functor, Args...>>
-  BindOnce(Functor&& functor, Args&&... args) {
-    return common::ContextualOnceCallback<
-        common::MakeUnboundRunType<Functor, Args...>>(
+  auto BindOnce(Functor&& functor, Args&&... args) {
+    return common::ContextualOnceCallback(
         common::BindOnce(std::forward<Functor>(functor),
                          std::forward<Args>(args)...),
         this);
   }
 
   template <typename Functor, typename T, typename... Args>
-  common::ContextualOnceCallback<
-      common::MakeUnboundRunType<Functor, T, Args...>>
-  BindOnceOn(T* obj, Functor&& functor, Args&&... args) {
-    return common::ContextualOnceCallback<
-        common::MakeUnboundRunType<Functor, T, Args...>>(
+  auto BindOnceOn(T* obj, Functor&& functor, Args&&... args) {
+    return common::ContextualOnceCallback(
         common::BindOnce(std::forward<Functor>(functor),
                          common::Unretained(obj), std::forward<Args>(args)...),
         this);
   }
 
   template <typename Functor, typename... Args>
-  common::ContextualCallback<common::MakeUnboundRunType<Functor, Args...>> Bind(
-      Functor&& functor, Args&&... args) {
-    return common::ContextualCallback<
-        common::MakeUnboundRunType<Functor, Args...>>(
+  auto Bind(Functor&& functor, Args&&... args) {
+    return common::ContextualCallback(
         common::Bind(std::forward<Functor>(functor),
                      std::forward<Args>(args)...),
         this);
   }
 
   template <typename Functor, typename T, typename... Args>
-  common::ContextualCallback<common::MakeUnboundRunType<Functor, T, Args...>>
-  BindOn(T* obj, Functor&& functor, Args&&... args) {
-    return common::ContextualCallback<
-        common::MakeUnboundRunType<Functor, T, Args...>>(
+  auto BindOn(T* obj, Functor&& functor, Args&&... args) {
+    return common::ContextualCallback(
         common::Bind(std::forward<Functor>(functor), common::Unretained(obj),
                      std::forward<Args>(args)...),
         this);
diff --git a/system/gd/common/bind.h b/system/gd/common/bind.h
index 5692e02b03..f653976431 100644
--- a/system/gd/common/bind.h
+++ b/system/gd/common/bind.h
@@ -24,19 +24,13 @@ namespace common {
 using base::Bind;
 using base::BindOnce;
 using base::IgnoreResult;
-#if defined(BASE_VER) && BASE_VER >= 860220
-// TODO(b/189293646): find a way to avoid base::internal.
-using base::internal::MakeUnboundRunType;
-#else
-using base::MakeUnboundRunType;
-#endif
 using base::Owned;
 using base::Passed;
 using base::RetainedRef;
 using base::Unretained;
 
 template <typename T, typename Functor, typename... Args>
-inline base::Callback<MakeUnboundRunType<Functor, T, Args...>> BindOn(T* obj, Functor&& functor, Args&&... args) {
+inline auto BindOn(T* obj, Functor&& functor, Args&&... args) {
   return common::Bind(std::forward<Functor>(functor), common::Unretained(obj), std::forward<Args>(args)...);
 }
 
diff --git a/system/gd/common/contextual_callback.h b/system/gd/common/contextual_callback.h
index af4929663a..6c8dcc1e1d 100644
--- a/system/gd/common/contextual_callback.h
+++ b/system/gd/common/contextual_callback.h
@@ -59,6 +59,10 @@ class ContextualOnceCallback<R(Args...)> {
   IPostableContext* context_;
 };
 
+template <typename Callback>
+ContextualOnceCallback(Callback&& callback, IPostableContext* context)
+    -> ContextualOnceCallback<typename Callback::RunType>;
+
 template <typename R, typename... Args>
 class ContextualCallback;
 
@@ -95,5 +99,9 @@ class ContextualCallback<R(Args...)> {
   IPostableContext* context_;
 };
 
+template <typename Callback>
+ContextualCallback(Callback&& callback, IPostableContext* context)
+    -> ContextualCallback<typename Callback::RunType>;
+
 }  // namespace common
 }  // namespace bluetooth
diff --git a/system/gd/os/handler.h b/system/gd/os/handler.h
index 1dabbde7ff..2609ea8486 100644
--- a/system/gd/os/handler.h
+++ b/system/gd/os/handler.h
@@ -64,29 +64,26 @@ class Handler : public common::IPostableContext {
   }
 
   template <typename Functor, typename... Args>
-  common::ContextualOnceCallback<common::MakeUnboundRunType<Functor, Args...>> BindOnce(
-      Functor&& functor, Args&&... args) {
-    return common::ContextualOnceCallback<common::MakeUnboundRunType<Functor, Args...>>(
+  auto BindOnce(Functor&& functor, Args&&... args) {
+    return common::ContextualOnceCallback(
         common::BindOnce(std::forward<Functor>(functor), std::forward<Args>(args)...), this);
   }
 
   template <typename Functor, typename T, typename... Args>
-  common::ContextualOnceCallback<common::MakeUnboundRunType<Functor, T, Args...>> BindOnceOn(
-      T* obj, Functor&& functor, Args&&... args) {
-    return common::ContextualOnceCallback<common::MakeUnboundRunType<Functor, T, Args...>>(
+  auto BindOnceOn(T* obj, Functor&& functor, Args&&... args) {
+    return common::ContextualOnceCallback(
         common::BindOnce(std::forward<Functor>(functor), common::Unretained(obj), std::forward<Args>(args)...), this);
   }
 
   template <typename Functor, typename... Args>
-  common::ContextualCallback<common::MakeUnboundRunType<Functor, Args...>> Bind(Functor&& functor, Args&&... args) {
-    return common::ContextualCallback<common::MakeUnboundRunType<Functor, Args...>>(
+  auto Bind(Functor&& functor, Args&&... args) {
+    return common::ContextualCallback(
         common::Bind(std::forward<Functor>(functor), std::forward<Args>(args)...), this);
   }
 
   template <typename Functor, typename T, typename... Args>
-  common::ContextualCallback<common::MakeUnboundRunType<Functor, T, Args...>> BindOn(
-      T* obj, Functor&& functor, Args&&... args) {
-    return common::ContextualCallback<common::MakeUnboundRunType<Functor, T, Args...>>(
+  auto BindOn(T* obj, Functor&& functor, Args&&... args) {
+    return common::ContextualCallback(
         common::Bind(std::forward<Functor>(functor), common::Unretained(obj), std::forward<Args>(args)...), this);
   }