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

Commit c48b787e authored by Ren-Pei Zeng's avatar Ren-Pei Zeng Committed by Byron Lee
Browse files

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
parent 9b331a18

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);

  }