Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e0c454ed authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Remove usage of base::internal::MakeUnboundRunType" into main am: 28e15953 am: 0ab7b87a 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/2908987



Change-Id: I5496914dda4a670b8aaac1ceef1bda17167d90b6
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 16f70b84 0ab7b87a

system/common/message_loop_thread.h

+8 −17
Original line number Diff line number Diff line
@@ -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);

system/gd/common/bind.h

+1 −7
Original line number Diff line number Diff line
@@ -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)...);

}

system/gd/common/contextual_callback.h

+8 −0
Original line number Diff line number Diff line
@@ -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

system/gd/os/handler.h

+8 −11
Original line number Diff line number Diff line
@@ -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);

  }