Merge "Remove usage of base::internal::MakeUnboundRunType" into main (28e15953) · Commits · e / os / android_packages_modules_Bluetooth

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