Remove Bind and Callback.
Uses std::function instead.
Had to work around being unable to bind unique_ptr once in setup.cc, but
otherwise this was straightforward.
Change-Id: I0a5380412b5eba602d4e26ffc2cc1e5f1c2e525c
Reviewed-on: https://gn-review.googlesource.com/c/gn/+/6100
Reviewed-by: Scott Graham <scottmg@chromium.org>
Commit-Queue: Brett Wilson <brettw@chromium.org>
diff --git a/base/bind.h b/base/bind.h
deleted file mode 100644
index 71df0fe..0000000
--- a/base/bind.h
+++ /dev/null
@@ -1,457 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_BIND_H_
-#define BASE_BIND_H_
-
-#include <utility>
-
-#include "base/bind_internal.h"
-
-// -----------------------------------------------------------------------------
-// Usage documentation
-// -----------------------------------------------------------------------------
-//
-// Overview:
-// base::BindOnce() and base::BindRepeating() are helpers for creating
-// base::OnceCallback and base::RepeatingCallback objects respectively.
-//
-// For a runnable object of n-arity, the base::Bind*() family allows partial
-// application of the first m arguments. The remaining n - m arguments must be
-// passed when invoking the callback with Run().
-//
-// // The first argument is bound at callback creation; the remaining
-// // two must be passed when calling Run() on the callback object.
-// base::OnceCallback<void(int, long)> cb = base::BindOnce(
-// [](short x, int y, long z) { return x * y * z; }, 42);
-//
-// When binding to a method, the receiver object must also be specified at
-// callback creation time. When Run() is invoked, the method will be invoked on
-// the specified receiver object.
-//
-// class C : public base::RefCounted<C> { void F(); };
-// auto instance = base::MakeRefCounted<C>();
-// auto cb = base::BindOnce(&C::F, instance);
-// cb.Run(); // Identical to instance->F()
-//
-// base::Bind is currently a type alias for base::BindRepeating(). In the
-// future, we expect to flip this to default to base::BindOnce().
-//
-// See //docs/callback.md for the full documentation.
-//
-// -----------------------------------------------------------------------------
-// Implementation notes
-// -----------------------------------------------------------------------------
-//
-// If you're reading the implementation, before proceeding further, you should
-// read the top comment of base/bind_internal.h for a definition of common
-// terms and concepts.
-
-namespace base {
-
-namespace internal {
-
-// IsOnceCallback<T> is a std::true_type if |T| is a OnceCallback.
-template <typename T>
-struct IsOnceCallback : std::false_type {};
-
-template <typename Signature>
-struct IsOnceCallback<OnceCallback<Signature>> : std::true_type {};
-
-// Helper to assert that parameter |i| of type |Arg| can be bound, which means:
-// - |Arg| can be retained internally as |Storage|.
-// - |Arg| can be forwarded as |Unwrapped| to |Param|.
-template <size_t i,
- typename Arg,
- typename Storage,
- typename Unwrapped,
- typename Param>
-struct AssertConstructible {
- private:
- static constexpr bool param_is_forwardable =
- std::is_constructible<Param, Unwrapped>::value;
- // Unlike the check for binding into storage below, the check for
- // forwardability drops the const qualifier for repeating callbacks. This is
- // to try to catch instances where std::move()--which forwards as a const
- // reference with repeating callbacks--is used instead of base::Passed().
- static_assert(
- param_is_forwardable ||
- !std::is_constructible<Param, std::decay_t<Unwrapped>&&>::value,
- "Bound argument |i| is move-only but will be forwarded by copy. "
- "Ensure |Arg| is bound using base::Passed(), not std::move().");
- static_assert(
- param_is_forwardable,
- "Bound argument |i| of type |Arg| cannot be forwarded as "
- "|Unwrapped| to the bound functor, which declares it as |Param|.");
-
- static constexpr bool arg_is_storable =
- std::is_constructible<Storage, Arg>::value;
- static_assert(arg_is_storable ||
- !std::is_constructible<Storage, std::decay_t<Arg>&&>::value,
- "Bound argument |i| is move-only but will be bound by copy. "
- "Ensure |Arg| is mutable and bound using std::move().");
- static_assert(arg_is_storable,
- "Bound argument |i| of type |Arg| cannot be converted and "
- "bound as |Storage|.");
-};
-
-// Takes three same-length TypeLists, and applies AssertConstructible for each
-// triples.
-template <typename Index,
- typename Args,
- typename UnwrappedTypeList,
- typename ParamsList>
-struct AssertBindArgsValidity;
-
-template <size_t... Ns,
- typename... Args,
- typename... Unwrapped,
- typename... Params>
-struct AssertBindArgsValidity<std::index_sequence<Ns...>,
- TypeList<Args...>,
- TypeList<Unwrapped...>,
- TypeList<Params...>>
- : AssertConstructible<Ns, Args, std::decay_t<Args>, Unwrapped, Params>... {
- static constexpr bool ok = true;
-};
-
-// The implementation of TransformToUnwrappedType below.
-template <bool is_once, typename T>
-struct TransformToUnwrappedTypeImpl;
-
-template <typename T>
-struct TransformToUnwrappedTypeImpl<true, T> {
- using StoredType = std::decay_t<T>;
- using ForwardType = StoredType&&;
- using Unwrapped = decltype(Unwrap(std::declval<ForwardType>()));
-};
-
-template <typename T>
-struct TransformToUnwrappedTypeImpl<false, T> {
- using StoredType = std::decay_t<T>;
- using ForwardType = const StoredType&;
- using Unwrapped = decltype(Unwrap(std::declval<ForwardType>()));
-};
-
-// Transform |T| into `Unwrapped` type, which is passed to the target function.
-// Example:
-// In is_once == true case,
-// `int&&` -> `int&&`,
-// `const int&` -> `int&&`,
-// `OwnedWrapper<int>&` -> `int*&&`.
-// In is_once == false case,
-// `int&&` -> `const int&`,
-// `const int&` -> `const int&`,
-// `OwnedWrapper<int>&` -> `int* const &`.
-template <bool is_once, typename T>
-using TransformToUnwrappedType =
- typename TransformToUnwrappedTypeImpl<is_once, T>::Unwrapped;
-
-// Transforms |Args| into `Unwrapped` types, and packs them into a TypeList.
-// If |is_method| is true, tries to dereference the first argument to support
-// smart pointers.
-template <bool is_once, bool is_method, typename... Args>
-struct MakeUnwrappedTypeListImpl {
- using Type = TypeList<TransformToUnwrappedType<is_once, Args>...>;
-};
-
-// Performs special handling for this pointers.
-// Example:
-// int* -> int*,
-// std::unique_ptr<int> -> int*.
-template <bool is_once, typename Receiver, typename... Args>
-struct MakeUnwrappedTypeListImpl<is_once, true, Receiver, Args...> {
- using UnwrappedReceiver = TransformToUnwrappedType<is_once, Receiver>;
- using Type = TypeList<decltype(&*std::declval<UnwrappedReceiver>()),
- TransformToUnwrappedType<is_once, Args>...>;
-};
-
-template <bool is_once, bool is_method, typename... Args>
-using MakeUnwrappedTypeList =
- typename MakeUnwrappedTypeListImpl<is_once, is_method, Args...>::Type;
-
-} // namespace internal
-
-// Bind as OnceCallback.
-template <typename Functor, typename... Args>
-inline OnceCallback<MakeUnboundRunType<Functor, Args...>> BindOnce(
- Functor&& functor,
- Args&&... args) {
- static_assert(!internal::IsOnceCallback<std::decay_t<Functor>>() ||
- (std::is_rvalue_reference<Functor&&>() &&
- !std::is_const<std::remove_reference_t<Functor>>()),
- "BindOnce requires non-const rvalue for OnceCallback binding."
- " I.e.: base::BindOnce(std::move(callback)).");
-
- // This block checks if each |args| matches to the corresponding params of the
- // target function. This check does not affect the behavior of Bind, but its
- // error message should be more readable.
- using Helper = internal::BindTypeHelper<Functor, Args...>;
- using FunctorTraits = typename Helper::FunctorTraits;
- using BoundArgsList = typename Helper::BoundArgsList;
- using UnwrappedArgsList =
- internal::MakeUnwrappedTypeList<true, FunctorTraits::is_method,
- Args&&...>;
- using BoundParamsList = typename Helper::BoundParamsList;
- static_assert(internal::AssertBindArgsValidity<
- std::make_index_sequence<Helper::num_bounds>, BoundArgsList,
- UnwrappedArgsList, BoundParamsList>::ok,
- "The bound args need to be convertible to the target params.");
-
- using BindState = internal::MakeBindStateType<Functor, Args...>;
- using UnboundRunType = MakeUnboundRunType<Functor, Args...>;
- using Invoker = internal::Invoker<BindState, UnboundRunType>;
- using CallbackType = OnceCallback<UnboundRunType>;
-
- // Store the invoke func into PolymorphicInvoke before casting it to
- // InvokeFuncStorage, so that we can ensure its type matches to
- // PolymorphicInvoke, to which CallbackType will cast back.
- using PolymorphicInvoke = typename CallbackType::PolymorphicInvoke;
- PolymorphicInvoke invoke_func = &Invoker::RunOnce;
-
- using InvokeFuncStorage = internal::BindStateBase::InvokeFuncStorage;
- return CallbackType(new BindState(
- reinterpret_cast<InvokeFuncStorage>(invoke_func),
- std::forward<Functor>(functor), std::forward<Args>(args)...));
-}
-
-// Bind as RepeatingCallback.
-template <typename Functor, typename... Args>
-inline RepeatingCallback<MakeUnboundRunType<Functor, Args...>> BindRepeating(
- Functor&& functor,
- Args&&... args) {
- static_assert(
- !internal::IsOnceCallback<std::decay_t<Functor>>(),
- "BindRepeating cannot bind OnceCallback. Use BindOnce with std::move().");
-
- // This block checks if each |args| matches to the corresponding params of the
- // target function. This check does not affect the behavior of Bind, but its
- // error message should be more readable.
- using Helper = internal::BindTypeHelper<Functor, Args...>;
- using FunctorTraits = typename Helper::FunctorTraits;
- using BoundArgsList = typename Helper::BoundArgsList;
- using UnwrappedArgsList =
- internal::MakeUnwrappedTypeList<false, FunctorTraits::is_method,
- Args&&...>;
- using BoundParamsList = typename Helper::BoundParamsList;
- static_assert(internal::AssertBindArgsValidity<
- std::make_index_sequence<Helper::num_bounds>, BoundArgsList,
- UnwrappedArgsList, BoundParamsList>::ok,
- "The bound args need to be convertible to the target params.");
-
- using BindState = internal::MakeBindStateType<Functor, Args...>;
- using UnboundRunType = MakeUnboundRunType<Functor, Args...>;
- using Invoker = internal::Invoker<BindState, UnboundRunType>;
- using CallbackType = RepeatingCallback<UnboundRunType>;
-
- // Store the invoke func into PolymorphicInvoke before casting it to
- // InvokeFuncStorage, so that we can ensure its type matches to
- // PolymorphicInvoke, to which CallbackType will cast back.
- using PolymorphicInvoke = typename CallbackType::PolymorphicInvoke;
- PolymorphicInvoke invoke_func = &Invoker::Run;
-
- using InvokeFuncStorage = internal::BindStateBase::InvokeFuncStorage;
- return CallbackType(new BindState(
- reinterpret_cast<InvokeFuncStorage>(invoke_func),
- std::forward<Functor>(functor), std::forward<Args>(args)...));
-}
-
-// Unannotated Bind.
-// TODO(tzik): Deprecate this and migrate to OnceCallback and
-// RepeatingCallback, once they get ready.
-template <typename Functor, typename... Args>
-inline Callback<MakeUnboundRunType<Functor, Args...>> Bind(Functor&& functor,
- Args&&... args) {
- return base::BindRepeating(std::forward<Functor>(functor),
- std::forward<Args>(args)...);
-}
-
-// Special cases for binding to a base::Callback without extra bound arguments.
-template <typename Signature>
-OnceCallback<Signature> BindOnce(OnceCallback<Signature> closure) {
- return closure;
-}
-
-template <typename Signature>
-RepeatingCallback<Signature> BindRepeating(
- RepeatingCallback<Signature> closure) {
- return closure;
-}
-
-template <typename Signature>
-Callback<Signature> Bind(Callback<Signature> closure) {
- return closure;
-}
-
-// Unretained() allows Bind() to bind a non-refcounted class, and to disable
-// refcounting on arguments that are refcounted objects.
-//
-// EXAMPLE OF Unretained():
-//
-// class Foo {
-// public:
-// void func() { cout << "Foo:f" << endl; }
-// };
-//
-// // In some function somewhere.
-// Foo foo;
-// Closure foo_callback =
-// Bind(&Foo::func, Unretained(&foo));
-// foo_callback.Run(); // Prints "Foo:f".
-//
-// Without the Unretained() wrapper on |&foo|, the above call would fail
-// to compile because Foo does not support the AddRef() and Release() methods.
-template <typename T>
-static inline internal::UnretainedWrapper<T> Unretained(T* o) {
- return internal::UnretainedWrapper<T>(o);
-}
-
-// RetainedRef() accepts a ref counted object and retains a reference to it.
-// When the callback is called, the object is passed as a raw pointer.
-//
-// EXAMPLE OF RetainedRef():
-//
-// void foo(RefCountedBytes* bytes) {}
-//
-// scoped_refptr<RefCountedBytes> bytes = ...;
-// Closure callback = Bind(&foo, base::RetainedRef(bytes));
-// callback.Run();
-//
-// Without RetainedRef, the scoped_refptr would try to implicitly convert to
-// a raw pointer and fail compilation:
-//
-// Closure callback = Bind(&foo, bytes); // ERROR!
-template <typename T>
-static inline internal::RetainedRefWrapper<T> RetainedRef(T* o) {
- return internal::RetainedRefWrapper<T>(o);
-}
-template <typename T>
-static inline internal::RetainedRefWrapper<T> RetainedRef(scoped_refptr<T> o) {
- return internal::RetainedRefWrapper<T>(std::move(o));
-}
-
-// ConstRef() allows binding a constant reference to an argument rather
-// than a copy.
-//
-// EXAMPLE OF ConstRef():
-//
-// void foo(int arg) { cout << arg << endl }
-//
-// int n = 1;
-// Closure no_ref = Bind(&foo, n);
-// Closure has_ref = Bind(&foo, ConstRef(n));
-//
-// no_ref.Run(); // Prints "1"
-// has_ref.Run(); // Prints "1"
-//
-// n = 2;
-// no_ref.Run(); // Prints "1"
-// has_ref.Run(); // Prints "2"
-//
-// Note that because ConstRef() takes a reference on |n|, |n| must outlive all
-// its bound callbacks.
-template <typename T>
-static inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
- return internal::ConstRefWrapper<T>(o);
-}
-
-// Owned() transfers ownership of an object to the Callback resulting from
-// bind; the object will be deleted when the Callback is deleted.
-//
-// EXAMPLE OF Owned():
-//
-// void foo(int* arg) { cout << *arg << endl }
-//
-// int* pn = new int(1);
-// Closure foo_callback = Bind(&foo, Owned(pn));
-//
-// foo_callback.Run(); // Prints "1"
-// foo_callback.Run(); // Prints "1"
-// *n = 2;
-// foo_callback.Run(); // Prints "2"
-//
-// foo_callback.Reset(); // |pn| is deleted. Also will happen when
-// // |foo_callback| goes out of scope.
-//
-// Without Owned(), someone would have to know to delete |pn| when the last
-// reference to the Callback is deleted.
-template <typename T>
-static inline internal::OwnedWrapper<T> Owned(T* o) {
- return internal::OwnedWrapper<T>(o);
-}
-
-// Passed() is for transferring movable-but-not-copyable types (eg. unique_ptr)
-// through a Callback. Logically, this signifies a destructive transfer of
-// the state of the argument into the target function. Invoking
-// Callback::Run() twice on a Callback that was created with a Passed()
-// argument will CHECK() because the first invocation would have already
-// transferred ownership to the target function.
-//
-// Note that Passed() is not necessary with BindOnce(), as std::move() does the
-// same thing. Avoid Passed() in favor of std::move() with BindOnce().
-//
-// EXAMPLE OF Passed():
-//
-// void TakesOwnership(std::unique_ptr<Foo> arg) { }
-// std::unique_ptr<Foo> CreateFoo() { return std::make_unique<Foo>();
-// }
-//
-// auto f = std::make_unique<Foo>();
-//
-// // |cb| is given ownership of Foo(). |f| is now NULL.
-// // You can use std::move(f) in place of &f, but it's more verbose.
-// Closure cb = Bind(&TakesOwnership, Passed(&f));
-//
-// // Run was never called so |cb| still owns Foo() and deletes
-// // it on Reset().
-// cb.Reset();
-//
-// // |cb| is given a new Foo created by CreateFoo().
-// cb = Bind(&TakesOwnership, Passed(CreateFoo()));
-//
-// // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
-// // no longer owns Foo() and, if reset, would not delete Foo().
-// cb.Run(); // Foo() is now transferred to |arg| and deleted.
-// cb.Run(); // This CHECK()s since Foo() already been used once.
-//
-// We offer 2 syntaxes for calling Passed(). The first takes an rvalue and
-// is best suited for use with the return value of a function or other temporary
-// rvalues. The second takes a pointer to the scoper and is just syntactic sugar
-// to avoid having to write Passed(std::move(scoper)).
-//
-// Both versions of Passed() prevent T from being an lvalue reference. The first
-// via use of enable_if, and the second takes a T* which will not bind to T&.
-template <typename T,
- std::enable_if_t<!std::is_lvalue_reference<T>::value>* = nullptr>
-static inline internal::PassedWrapper<T> Passed(T&& scoper) {
- return internal::PassedWrapper<T>(std::move(scoper));
-}
-template <typename T>
-static inline internal::PassedWrapper<T> Passed(T* scoper) {
- return internal::PassedWrapper<T>(std::move(*scoper));
-}
-
-// IgnoreResult() is used to adapt a function or Callback with a return type to
-// one with a void return. This is most useful if you have a function with,
-// say, a pesky ignorable bool return that you want to use with PostTask or
-// something else that expect a Callback with a void return.
-//
-// EXAMPLE OF IgnoreResult():
-//
-// int DoSomething(int arg) { cout << arg << endl; }
-//
-// // Assign to a Callback with a void return type.
-// Callback<void(int)> cb = Bind(IgnoreResult(&DoSomething));
-// cb->Run(1); // Prints "1".
-//
-// // Prints "1" on |ml|.
-// ml->PostTask(FROM_HERE, Bind(IgnoreResult(&DoSomething), 1);
-template <typename T>
-static inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
- return internal::IgnoreResultHelper<T>(std::move(data));
-}
-
-} // namespace base
-
-#endif // BASE_BIND_H_
diff --git a/base/bind_internal.h b/base/bind_internal.h
deleted file mode 100644
index 89c1600..0000000
--- a/base/bind_internal.h
+++ /dev/null
@@ -1,913 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_BIND_INTERNAL_H_
-#define BASE_BIND_INTERNAL_H_
-
-#include <stddef.h>
-
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "base/callback_internal.h"
-#include "base/memory/raw_scoped_refptr_mismatch_checker.h"
-#include "base/memory/weak_ptr.h"
-#include "base/template_util.h"
-#include "util/build_config.h"
-
-// See base/callback.h for user documentation.
-//
-//
-// CONCEPTS:
-// Functor -- A movable type representing something that should be called.
-// All function pointers and Callback<> are functors even if the
-// invocation syntax differs.
-// RunType -- A function type (as opposed to function _pointer_ type) for
-// a Callback<>::Run(). Usually just a convenience typedef.
-// (Bound)Args -- A set of types that stores the arguments.
-//
-// Types:
-// ForceVoidReturn<> -- Helper class for translating function signatures to
-// equivalent forms with a "void" return type.
-// FunctorTraits<> -- Type traits used to determine the correct RunType and
-// invocation manner for a Functor. This is where function
-// signature adapters are applied.
-// InvokeHelper<> -- Take a Functor + arguments and actully invokes it.
-// Handle the differing syntaxes needed for WeakPtr<>
-// support. This is separate from Invoker to avoid creating
-// multiple version of Invoker<>.
-// Invoker<> -- Unwraps the curried parameters and executes the Functor.
-// BindState<> -- Stores the curried parameters, and is the main entry point
-// into the Bind() system.
-
-namespace base {
-
-template <typename T>
-struct IsWeakReceiver;
-
-template <typename>
-struct BindUnwrapTraits;
-
-template <typename Functor, typename BoundArgsTuple, typename SFINAE = void>
-struct CallbackCancellationTraits;
-
-namespace internal {
-
-template <typename Functor, typename SFINAE = void>
-struct FunctorTraits;
-
-template <typename T>
-class UnretainedWrapper {
- public:
- explicit UnretainedWrapper(T* o) : ptr_(o) {}
- T* get() const { return ptr_; }
-
- private:
- T* ptr_;
-};
-
-template <typename T>
-class ConstRefWrapper {
- public:
- explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
- const T& get() const { return *ptr_; }
-
- private:
- const T* ptr_;
-};
-
-template <typename T>
-class RetainedRefWrapper {
- public:
- explicit RetainedRefWrapper(T* o) : ptr_(o) {}
- explicit RetainedRefWrapper(scoped_refptr<T> o) : ptr_(std::move(o)) {}
- T* get() const { return ptr_.get(); }
-
- private:
- scoped_refptr<T> ptr_;
-};
-
-template <typename T>
-struct IgnoreResultHelper {
- explicit IgnoreResultHelper(T functor) : functor_(std::move(functor)) {}
- explicit operator bool() const { return !!functor_; }
-
- T functor_;
-};
-
-// An alternate implementation is to avoid the destructive copy, and instead
-// specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to
-// a class that is essentially a std::unique_ptr<>.
-//
-// The current implementation has the benefit though of leaving ParamTraits<>
-// fully in callback_internal.h as well as avoiding type conversions during
-// storage.
-template <typename T>
-class OwnedWrapper {
- public:
- explicit OwnedWrapper(T* o) : ptr_(o) {}
- ~OwnedWrapper() { delete ptr_; }
- T* get() const { return ptr_; }
- OwnedWrapper(OwnedWrapper&& other) {
- ptr_ = other.ptr_;
- other.ptr_ = NULL;
- }
-
- private:
- mutable T* ptr_;
-};
-
-// PassedWrapper is a copyable adapter for a scoper that ignores const.
-//
-// It is needed to get around the fact that Bind() takes a const reference to
-// all its arguments. Because Bind() takes a const reference to avoid
-// unnecessary copies, it is incompatible with movable-but-not-copyable
-// types; doing a destructive "move" of the type into Bind() would violate
-// the const correctness.
-//
-// This conundrum cannot be solved without either C++11 rvalue references or
-// a O(2^n) blowup of Bind() templates to handle each combination of regular
-// types and movable-but-not-copyable types. Thus we introduce a wrapper type
-// that is copyable to transmit the correct type information down into
-// BindState<>. Ignoring const in this type makes sense because it is only
-// created when we are explicitly trying to do a destructive move.
-//
-// Two notes:
-// 1) PassedWrapper supports any type that has a move constructor, however
-// the type will need to be specifically whitelisted in order for it to be
-// bound to a Callback. We guard this explicitly at the call of Passed()
-// to make for clear errors. Things not given to Passed() will be forwarded
-// and stored by value which will not work for general move-only types.
-// 2) is_valid_ is distinct from NULL because it is valid to bind a "NULL"
-// scoper to a Callback and allow the Callback to execute once.
-template <typename T>
-class PassedWrapper {
- public:
- explicit PassedWrapper(T&& scoper)
- : is_valid_(true), scoper_(std::move(scoper)) {}
- PassedWrapper(PassedWrapper&& other)
- : is_valid_(other.is_valid_), scoper_(std::move(other.scoper_)) {}
- T Take() const {
- CHECK(is_valid_);
- is_valid_ = false;
- return std::move(scoper_);
- }
-
- private:
- mutable bool is_valid_;
- mutable T scoper_;
-};
-
-template <typename T>
-using Unwrapper = BindUnwrapTraits<std::decay_t<T>>;
-
-template <typename T>
-decltype(auto) Unwrap(T&& o) {
- return Unwrapper<T>::Unwrap(std::forward<T>(o));
-}
-
-// IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
-// method. It is used internally by Bind() to select the correct
-// InvokeHelper that will no-op itself in the event the WeakPtr<> for
-// the target object is invalidated.
-//
-// The first argument should be the type of the object that will be received by
-// the method.
-template <bool is_method, typename... Args>
-struct IsWeakMethod : std::false_type {};
-
-template <typename T, typename... Args>
-struct IsWeakMethod<true, T, Args...> : IsWeakReceiver<T> {};
-
-// Packs a list of types to hold them in a single type.
-template <typename... Types>
-struct TypeList {};
-
-// Used for DropTypeListItem implementation.
-template <size_t n, typename List>
-struct DropTypeListItemImpl;
-
-// Do not use enable_if and SFINAE here to avoid MSVC2013 compile failure.
-template <size_t n, typename T, typename... List>
-struct DropTypeListItemImpl<n, TypeList<T, List...>>
- : DropTypeListItemImpl<n - 1, TypeList<List...>> {};
-
-template <typename T, typename... List>
-struct DropTypeListItemImpl<0, TypeList<T, List...>> {
- using Type = TypeList<T, List...>;
-};
-
-template <>
-struct DropTypeListItemImpl<0, TypeList<>> {
- using Type = TypeList<>;
-};
-
-// A type-level function that drops |n| list item from given TypeList.
-template <size_t n, typename List>
-using DropTypeListItem = typename DropTypeListItemImpl<n, List>::Type;
-
-// Used for TakeTypeListItem implementation.
-template <size_t n, typename List, typename... Accum>
-struct TakeTypeListItemImpl;
-
-// Do not use enable_if and SFINAE here to avoid MSVC2013 compile failure.
-template <size_t n, typename T, typename... List, typename... Accum>
-struct TakeTypeListItemImpl<n, TypeList<T, List...>, Accum...>
- : TakeTypeListItemImpl<n - 1, TypeList<List...>, Accum..., T> {};
-
-template <typename T, typename... List, typename... Accum>
-struct TakeTypeListItemImpl<0, TypeList<T, List...>, Accum...> {
- using Type = TypeList<Accum...>;
-};
-
-template <typename... Accum>
-struct TakeTypeListItemImpl<0, TypeList<>, Accum...> {
- using Type = TypeList<Accum...>;
-};
-
-// A type-level function that takes first |n| list item from given TypeList.
-// E.g. TakeTypeListItem<3, TypeList<A, B, C, D>> is evaluated to
-// TypeList<A, B, C>.
-template <size_t n, typename List>
-using TakeTypeListItem = typename TakeTypeListItemImpl<n, List>::Type;
-
-// Used for ConcatTypeLists implementation.
-template <typename List1, typename List2>
-struct ConcatTypeListsImpl;
-
-template <typename... Types1, typename... Types2>
-struct ConcatTypeListsImpl<TypeList<Types1...>, TypeList<Types2...>> {
- using Type = TypeList<Types1..., Types2...>;
-};
-
-// A type-level function that concats two TypeLists.
-template <typename List1, typename List2>
-using ConcatTypeLists = typename ConcatTypeListsImpl<List1, List2>::Type;
-
-// Used for MakeFunctionType implementation.
-template <typename R, typename ArgList>
-struct MakeFunctionTypeImpl;
-
-template <typename R, typename... Args>
-struct MakeFunctionTypeImpl<R, TypeList<Args...>> {
- // MSVC 2013 doesn't support Type Alias of function types.
- // Revisit this after we update it to newer version.
- typedef R Type(Args...);
-};
-
-// A type-level function that constructs a function type that has |R| as its
-// return type and has TypeLists items as its arguments.
-template <typename R, typename ArgList>
-using MakeFunctionType = typename MakeFunctionTypeImpl<R, ArgList>::Type;
-
-// Used for ExtractArgs and ExtractReturnType.
-template <typename Signature>
-struct ExtractArgsImpl;
-
-template <typename R, typename... Args>
-struct ExtractArgsImpl<R(Args...)> {
- using ReturnType = R;
- using ArgsList = TypeList<Args...>;
-};
-
-// A type-level function that extracts function arguments into a TypeList.
-// E.g. ExtractArgs<R(A, B, C)> is evaluated to TypeList<A, B, C>.
-template <typename Signature>
-using ExtractArgs = typename ExtractArgsImpl<Signature>::ArgsList;
-
-// A type-level function that extracts the return type of a function.
-// E.g. ExtractReturnType<R(A, B, C)> is evaluated to R.
-template <typename Signature>
-using ExtractReturnType = typename ExtractArgsImpl<Signature>::ReturnType;
-
-template <typename Callable,
- typename Signature = decltype(&Callable::operator())>
-struct ExtractCallableRunTypeImpl;
-
-template <typename Callable, typename R, typename... Args>
-struct ExtractCallableRunTypeImpl<Callable, R (Callable::*)(Args...)> {
- using Type = R(Args...);
-};
-
-template <typename Callable, typename R, typename... Args>
-struct ExtractCallableRunTypeImpl<Callable, R (Callable::*)(Args...) const> {
- using Type = R(Args...);
-};
-
-// Evaluated to RunType of the given callable type.
-// Example:
-// auto f = [](int, char*) { return 0.1; };
-// ExtractCallableRunType<decltype(f)>
-// is evaluated to
-// double(int, char*);
-template <typename Callable>
-using ExtractCallableRunType =
- typename ExtractCallableRunTypeImpl<Callable>::Type;
-
-// IsCallableObject<Functor> is std::true_type if |Functor| has operator().
-// Otherwise, it's std::false_type.
-// Example:
-// IsCallableObject<void(*)()>::value is false.
-//
-// struct Foo {};
-// IsCallableObject<void(Foo::*)()>::value is false.
-//
-// int i = 0;
-// auto f = [i]() {};
-// IsCallableObject<decltype(f)>::value is false.
-template <typename Functor, typename SFINAE = void>
-struct IsCallableObject : std::false_type {};
-
-template <typename Callable>
-struct IsCallableObject<Callable, std::void_t<decltype(&Callable::operator())>>
- : std::true_type {};
-
-// HasRefCountedTypeAsRawPtr selects true_type when any of the |Args| is a raw
-// pointer to a RefCounted type.
-// Implementation note: This non-specialized case handles zero-arity case only.
-// Non-zero-arity cases should be handled by the specialization below.
-template <typename... Args>
-struct HasRefCountedTypeAsRawPtr : std::false_type {};
-
-// Implementation note: Select true_type if the first parameter is a raw pointer
-// to a RefCounted type. Otherwise, skip the first parameter and check rest of
-// parameters recursively.
-template <typename T, typename... Args>
-struct HasRefCountedTypeAsRawPtr<T, Args...>
- : std::conditional_t<NeedsScopedRefptrButGetsRawPtr<T>::value,
- std::true_type,
- HasRefCountedTypeAsRawPtr<Args...>> {};
-
-// ForceVoidReturn<>
-//
-// Set of templates that support forcing the function return type to void.
-template <typename Sig>
-struct ForceVoidReturn;
-
-template <typename R, typename... Args>
-struct ForceVoidReturn<R(Args...)> {
- using RunType = void(Args...);
-};
-
-// FunctorTraits<>
-//
-// See description at top of file.
-template <typename Functor, typename SFINAE>
-struct FunctorTraits;
-
-// For empty callable types.
-// This specialization is intended to allow binding captureless lambdas by
-// base::Bind(), based on the fact that captureless lambdas are empty while
-// capturing lambdas are not. This also allows any functors as far as it's an
-// empty class.
-// Example:
-//
-// // Captureless lambdas are allowed.
-// []() {return 42;};
-//
-// // Capturing lambdas are *not* allowed.
-// int x;
-// [x]() {return x;};
-//
-// // Any empty class with operator() is allowed.
-// struct Foo {
-// void operator()() const {}
-// // No non-static member variable and no virtual functions.
-// };
-template <typename Functor>
-struct FunctorTraits<Functor,
- std::enable_if_t<IsCallableObject<Functor>::value &&
- std::is_empty<Functor>::value>> {
- using RunType = ExtractCallableRunType<Functor>;
- static constexpr bool is_method = false;
- static constexpr bool is_nullable = false;
-
- template <typename RunFunctor, typename... RunArgs>
- static ExtractReturnType<RunType> Invoke(RunFunctor&& functor,
- RunArgs&&... args) {
- return std::forward<RunFunctor>(functor)(std::forward<RunArgs>(args)...);
- }
-};
-
-// For functions.
-template <typename R, typename... Args>
-struct FunctorTraits<R (*)(Args...)> {
- using RunType = R(Args...);
- static constexpr bool is_method = false;
- static constexpr bool is_nullable = true;
-
- template <typename Function, typename... RunArgs>
- static R Invoke(Function&& function, RunArgs&&... args) {
- return std::forward<Function>(function)(std::forward<RunArgs>(args)...);
- }
-};
-
-#if defined(OS_WIN) && !defined(ARCH_CPU_X86_64)
-
-// For functions.
-template <typename R, typename... Args>
-struct FunctorTraits<R(__stdcall*)(Args...)> {
- using RunType = R(Args...);
- static constexpr bool is_method = false;
- static constexpr bool is_nullable = true;
-
- template <typename... RunArgs>
- static R Invoke(R(__stdcall* function)(Args...), RunArgs&&... args) {
- return function(std::forward<RunArgs>(args)...);
- }
-};
-
-// For functions.
-template <typename R, typename... Args>
-struct FunctorTraits<R(__fastcall*)(Args...)> {
- using RunType = R(Args...);
- static constexpr bool is_method = false;
- static constexpr bool is_nullable = true;
-
- template <typename... RunArgs>
- static R Invoke(R(__fastcall* function)(Args...), RunArgs&&... args) {
- return function(std::forward<RunArgs>(args)...);
- }
-};
-
-#endif // defined(OS_WIN) && !defined(ARCH_CPU_X86_64)
-
-// For methods.
-template <typename R, typename Receiver, typename... Args>
-struct FunctorTraits<R (Receiver::*)(Args...)> {
- using RunType = R(Receiver*, Args...);
- static constexpr bool is_method = true;
- static constexpr bool is_nullable = true;
-
- template <typename Method, typename ReceiverPtr, typename... RunArgs>
- static R Invoke(Method method,
- ReceiverPtr&& receiver_ptr,
- RunArgs&&... args) {
- return ((*receiver_ptr).*method)(std::forward<RunArgs>(args)...);
- }
-};
-
-// For const methods.
-template <typename R, typename Receiver, typename... Args>
-struct FunctorTraits<R (Receiver::*)(Args...) const> {
- using RunType = R(const Receiver*, Args...);
- static constexpr bool is_method = true;
- static constexpr bool is_nullable = true;
-
- template <typename Method, typename ReceiverPtr, typename... RunArgs>
- static R Invoke(Method method,
- ReceiverPtr&& receiver_ptr,
- RunArgs&&... args) {
- return ((*receiver_ptr).*method)(std::forward<RunArgs>(args)...);
- }
-};
-
-#ifdef __cpp_noexcept_function_type
-// noexcept makes a distinct function type in C++17.
-// I.e. `void(*)()` and `void(*)() noexcept` are same in pre-C++17, and
-// different in C++17.
-template <typename R, typename... Args>
-struct FunctorTraits<R (*)(Args...) noexcept> : FunctorTraits<R (*)(Args...)> {
-};
-
-template <typename R, typename Receiver, typename... Args>
-struct FunctorTraits<R (Receiver::*)(Args...) noexcept>
- : FunctorTraits<R (Receiver::*)(Args...)> {};
-
-template <typename R, typename Receiver, typename... Args>
-struct FunctorTraits<R (Receiver::*)(Args...) const noexcept>
- : FunctorTraits<R (Receiver::*)(Args...) const> {};
-#endif
-
-// For IgnoreResults.
-template <typename T>
-struct FunctorTraits<IgnoreResultHelper<T>> : FunctorTraits<T> {
- using RunType =
- typename ForceVoidReturn<typename FunctorTraits<T>::RunType>::RunType;
-
- template <typename IgnoreResultType, typename... RunArgs>
- static void Invoke(IgnoreResultType&& ignore_result_helper,
- RunArgs&&... args) {
- FunctorTraits<T>::Invoke(
- std::forward<IgnoreResultType>(ignore_result_helper).functor_,
- std::forward<RunArgs>(args)...);
- }
-};
-
-// For OnceCallbacks.
-template <typename R, typename... Args>
-struct FunctorTraits<OnceCallback<R(Args...)>> {
- using RunType = R(Args...);
- static constexpr bool is_method = false;
- static constexpr bool is_nullable = true;
-
- template <typename CallbackType, typename... RunArgs>
- static R Invoke(CallbackType&& callback, RunArgs&&... args) {
- DCHECK(!callback.is_null());
- return std::forward<CallbackType>(callback).Run(
- std::forward<RunArgs>(args)...);
- }
-};
-
-// For RepeatingCallbacks.
-template <typename R, typename... Args>
-struct FunctorTraits<RepeatingCallback<R(Args...)>> {
- using RunType = R(Args...);
- static constexpr bool is_method = false;
- static constexpr bool is_nullable = true;
-
- template <typename CallbackType, typename... RunArgs>
- static R Invoke(CallbackType&& callback, RunArgs&&... args) {
- DCHECK(!callback.is_null());
- return std::forward<CallbackType>(callback).Run(
- std::forward<RunArgs>(args)...);
- }
-};
-
-template <typename Functor>
-using MakeFunctorTraits = FunctorTraits<std::decay_t<Functor>>;
-
-// InvokeHelper<>
-//
-// There are 2 logical InvokeHelper<> specializations: normal, WeakCalls.
-//
-// The normal type just calls the underlying runnable.
-//
-// WeakCalls need special syntax that is applied to the first argument to check
-// if they should no-op themselves.
-template <bool is_weak_call, typename ReturnType>
-struct InvokeHelper;
-
-template <typename ReturnType>
-struct InvokeHelper<false, ReturnType> {
- template <typename Functor, typename... RunArgs>
- static inline ReturnType MakeItSo(Functor&& functor, RunArgs&&... args) {
- using Traits = MakeFunctorTraits<Functor>;
- return Traits::Invoke(std::forward<Functor>(functor),
- std::forward<RunArgs>(args)...);
- }
-};
-
-template <typename ReturnType>
-struct InvokeHelper<true, ReturnType> {
- // WeakCalls are only supported for functions with a void return type.
- // Otherwise, the function result would be undefined if the the WeakPtr<>
- // is invalidated.
- static_assert(std::is_void<ReturnType>::value,
- "weak_ptrs can only bind to methods without return values");
-
- template <typename Functor, typename BoundWeakPtr, typename... RunArgs>
- static inline void MakeItSo(Functor&& functor,
- BoundWeakPtr&& weak_ptr,
- RunArgs&&... args) {
- if (!weak_ptr)
- return;
- using Traits = MakeFunctorTraits<Functor>;
- Traits::Invoke(std::forward<Functor>(functor),
- std::forward<BoundWeakPtr>(weak_ptr),
- std::forward<RunArgs>(args)...);
- }
-};
-
-// Invoker<>
-//
-// See description at the top of the file.
-template <typename StorageType, typename UnboundRunType>
-struct Invoker;
-
-template <typename StorageType, typename R, typename... UnboundArgs>
-struct Invoker<StorageType, R(UnboundArgs...)> {
- static R RunOnce(BindStateBase* base,
- PassingTraitsType<UnboundArgs>... unbound_args) {
- // Local references to make debugger stepping easier. If in a debugger,
- // you really want to warp ahead and step through the
- // InvokeHelper<>::MakeItSo() call below.
- StorageType* storage = static_cast<StorageType*>(base);
- static constexpr size_t num_bound_args =
- std::tuple_size<decltype(storage->bound_args_)>::value;
- return RunImpl(std::move(storage->functor_),
- std::move(storage->bound_args_),
- std::make_index_sequence<num_bound_args>(),
- std::forward<UnboundArgs>(unbound_args)...);
- }
-
- static R Run(BindStateBase* base,
- PassingTraitsType<UnboundArgs>... unbound_args) {
- // Local references to make debugger stepping easier. If in a debugger,
- // you really want to warp ahead and step through the
- // InvokeHelper<>::MakeItSo() call below.
- const StorageType* storage = static_cast<StorageType*>(base);
- static constexpr size_t num_bound_args =
- std::tuple_size<decltype(storage->bound_args_)>::value;
- return RunImpl(storage->functor_, storage->bound_args_,
- std::make_index_sequence<num_bound_args>(),
- std::forward<UnboundArgs>(unbound_args)...);
- }
-
- private:
- template <typename Functor, typename BoundArgsTuple, size_t... indices>
- static inline R RunImpl(Functor&& functor,
- BoundArgsTuple&& bound,
- std::index_sequence<indices...>,
- UnboundArgs&&... unbound_args) {
- static constexpr bool is_method = MakeFunctorTraits<Functor>::is_method;
-
- using DecayedArgsTuple = std::decay_t<BoundArgsTuple>;
- static constexpr bool is_weak_call =
- IsWeakMethod<is_method,
- std::tuple_element_t<indices, DecayedArgsTuple>...>();
-
- return InvokeHelper<is_weak_call, R>::MakeItSo(
- std::forward<Functor>(functor),
- Unwrap(std::get<indices>(std::forward<BoundArgsTuple>(bound)))...,
- std::forward<UnboundArgs>(unbound_args)...);
- }
-};
-
-// Extracts necessary type info from Functor and BoundArgs.
-// Used to implement MakeUnboundRunType, BindOnce and BindRepeating.
-template <typename Functor, typename... BoundArgs>
-struct BindTypeHelper {
- static constexpr size_t num_bounds = sizeof...(BoundArgs);
- using FunctorTraits = MakeFunctorTraits<Functor>;
-
- // Example:
- // When Functor is `double (Foo::*)(int, const std::string&)`, and BoundArgs
- // is a template pack of `Foo*` and `int16_t`:
- // - RunType is `double(Foo*, int, const std::string&)`,
- // - ReturnType is `double`,
- // - RunParamsList is `TypeList<Foo*, int, const std::string&>`,
- // - BoundParamsList is `TypeList<Foo*, int>`,
- // - UnboundParamsList is `TypeList<const std::string&>`,
- // - BoundArgsList is `TypeList<Foo*, int16_t>`,
- // - UnboundRunType is `double(const std::string&)`.
- using RunType = typename FunctorTraits::RunType;
- using ReturnType = ExtractReturnType<RunType>;
-
- using RunParamsList = ExtractArgs<RunType>;
- using BoundParamsList = TakeTypeListItem<num_bounds, RunParamsList>;
- using UnboundParamsList = DropTypeListItem<num_bounds, RunParamsList>;
-
- using BoundArgsList = TypeList<BoundArgs...>;
-
- using UnboundRunType = MakeFunctionType<ReturnType, UnboundParamsList>;
-};
-
-template <typename Functor>
-std::enable_if_t<FunctorTraits<Functor>::is_nullable, bool> IsNull(
- const Functor& functor) {
- return !functor;
-}
-
-template <typename Functor>
-std::enable_if_t<!FunctorTraits<Functor>::is_nullable, bool> IsNull(
- const Functor&) {
- return false;
-}
-
-// Used by ApplyCancellationTraits below.
-template <typename Functor, typename BoundArgsTuple, size_t... indices>
-bool ApplyCancellationTraitsImpl(const Functor& functor,
- const BoundArgsTuple& bound_args,
- std::index_sequence<indices...>) {
- return CallbackCancellationTraits<Functor, BoundArgsTuple>::IsCancelled(
- functor, std::get<indices>(bound_args)...);
-}
-
-// Relays |base| to corresponding CallbackCancellationTraits<>::Run(). Returns
-// true if the callback |base| represents is canceled.
-template <typename BindStateType>
-bool ApplyCancellationTraits(const BindStateBase* base) {
- const BindStateType* storage = static_cast<const BindStateType*>(base);
- static constexpr size_t num_bound_args =
- std::tuple_size<decltype(storage->bound_args_)>::value;
- return ApplyCancellationTraitsImpl(
- storage->functor_, storage->bound_args_,
- std::make_index_sequence<num_bound_args>());
-};
-
-// BindState<>
-//
-// This stores all the state passed into Bind().
-template <typename Functor, typename... BoundArgs>
-struct BindState final : BindStateBase {
- using IsCancellable = std::integral_constant<
- bool,
- CallbackCancellationTraits<Functor,
- std::tuple<BoundArgs...>>::is_cancellable>;
-
- template <typename ForwardFunctor, typename... ForwardBoundArgs>
- explicit BindState(BindStateBase::InvokeFuncStorage invoke_func,
- ForwardFunctor&& functor,
- ForwardBoundArgs&&... bound_args)
- // IsCancellable is std::false_type if
- // CallbackCancellationTraits<>::IsCancelled returns always false.
- // Otherwise, it's std::true_type.
- : BindState(IsCancellable{},
- invoke_func,
- std::forward<ForwardFunctor>(functor),
- std::forward<ForwardBoundArgs>(bound_args)...) {}
-
- Functor functor_;
- std::tuple<BoundArgs...> bound_args_;
-
- private:
- template <typename ForwardFunctor, typename... ForwardBoundArgs>
- explicit BindState(std::true_type,
- BindStateBase::InvokeFuncStorage invoke_func,
- ForwardFunctor&& functor,
- ForwardBoundArgs&&... bound_args)
- : BindStateBase(invoke_func,
- &Destroy,
- &ApplyCancellationTraits<BindState>),
- functor_(std::forward<ForwardFunctor>(functor)),
- bound_args_(std::forward<ForwardBoundArgs>(bound_args)...) {
- DCHECK(!IsNull(functor_));
- }
-
- template <typename ForwardFunctor, typename... ForwardBoundArgs>
- explicit BindState(std::false_type,
- BindStateBase::InvokeFuncStorage invoke_func,
- ForwardFunctor&& functor,
- ForwardBoundArgs&&... bound_args)
- : BindStateBase(invoke_func, &Destroy),
- functor_(std::forward<ForwardFunctor>(functor)),
- bound_args_(std::forward<ForwardBoundArgs>(bound_args)...) {
- DCHECK(!IsNull(functor_));
- }
-
- ~BindState() = default;
-
- static void Destroy(const BindStateBase* self) {
- delete static_cast<const BindState*>(self);
- }
-};
-
-// Used to implement MakeBindStateType.
-template <bool is_method, typename Functor, typename... BoundArgs>
-struct MakeBindStateTypeImpl;
-
-template <typename Functor, typename... BoundArgs>
-struct MakeBindStateTypeImpl<false, Functor, BoundArgs...> {
- static_assert(!HasRefCountedTypeAsRawPtr<std::decay_t<BoundArgs>...>::value,
- "A parameter is a refcounted type and needs scoped_refptr.");
- using Type = BindState<std::decay_t<Functor>, std::decay_t<BoundArgs>...>;
-};
-
-template <typename Functor>
-struct MakeBindStateTypeImpl<true, Functor> {
- using Type = BindState<std::decay_t<Functor>>;
-};
-
-template <typename Functor, typename Receiver, typename... BoundArgs>
-struct MakeBindStateTypeImpl<true, Functor, Receiver, BoundArgs...> {
- private:
- using DecayedReceiver = std::decay_t<Receiver>;
-
- static_assert(!std::is_array<std::remove_reference_t<Receiver>>::value,
- "First bound argument to a method cannot be an array.");
- static_assert(
- !std::is_pointer<DecayedReceiver>::value ||
- IsRefCountedType<std::remove_pointer_t<DecayedReceiver>>::value,
- "Receivers may not be raw pointers. If using a raw pointer here is safe"
- " and has no lifetime concerns, use base::Unretained() and document why"
- " it's safe.");
- static_assert(!HasRefCountedTypeAsRawPtr<std::decay_t<BoundArgs>...>::value,
- "A parameter is a refcounted type and needs scoped_refptr.");
-
- public:
- using Type = BindState<
- std::decay_t<Functor>,
- std::conditional_t<std::is_pointer<DecayedReceiver>::value,
- scoped_refptr<std::remove_pointer_t<DecayedReceiver>>,
- DecayedReceiver>,
- std::decay_t<BoundArgs>...>;
-};
-
-template <typename Functor, typename... BoundArgs>
-using MakeBindStateType =
- typename MakeBindStateTypeImpl<MakeFunctorTraits<Functor>::is_method,
- Functor,
- BoundArgs...>::Type;
-
-} // namespace internal
-
-// An injection point to control |this| pointer behavior on a method invocation.
-// If IsWeakReceiver<> is true_type for |T| and |T| is used for a receiver of a
-// method, base::Bind cancels the method invocation if the receiver is tested as
-// false.
-// E.g. Foo::bar() is not called:
-// struct Foo : base::SupportsWeakPtr<Foo> {
-// void bar() {}
-// };
-//
-// WeakPtr<Foo> oo = nullptr;
-// base::Bind(&Foo::bar, oo).Run();
-template <typename T>
-struct IsWeakReceiver : std::false_type {};
-
-template <typename T>
-struct IsWeakReceiver<internal::ConstRefWrapper<T>> : IsWeakReceiver<T> {};
-
-template <typename T>
-struct IsWeakReceiver<WeakPtr<T>> : std::true_type {};
-
-// An injection point to control how bound objects passed to the target
-// function. BindUnwrapTraits<>::Unwrap() is called for each bound objects right
-// before the target function is invoked.
-template <typename>
-struct BindUnwrapTraits {
- template <typename T>
- static T&& Unwrap(T&& o) {
- return std::forward<T>(o);
- }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::UnretainedWrapper<T>> {
- static T* Unwrap(const internal::UnretainedWrapper<T>& o) { return o.get(); }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::ConstRefWrapper<T>> {
- static const T& Unwrap(const internal::ConstRefWrapper<T>& o) {
- return o.get();
- }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::RetainedRefWrapper<T>> {
- static T* Unwrap(const internal::RetainedRefWrapper<T>& o) { return o.get(); }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::OwnedWrapper<T>> {
- static T* Unwrap(const internal::OwnedWrapper<T>& o) { return o.get(); }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::PassedWrapper<T>> {
- static T Unwrap(const internal::PassedWrapper<T>& o) { return o.Take(); }
-};
-
-// CallbackCancellationTraits allows customization of Callback's cancellation
-// semantics. By default, callbacks are not cancellable. A specialization should
-// set is_cancellable = true and implement an IsCancelled() that returns if the
-// callback should be cancelled.
-template <typename Functor, typename BoundArgsTuple, typename SFINAE>
-struct CallbackCancellationTraits {
- static constexpr bool is_cancellable = false;
-};
-
-// Specialization for method bound to weak pointer receiver.
-template <typename Functor, typename... BoundArgs>
-struct CallbackCancellationTraits<
- Functor,
- std::tuple<BoundArgs...>,
- std::enable_if_t<
- internal::IsWeakMethod<internal::FunctorTraits<Functor>::is_method,
- BoundArgs...>::value>> {
- static constexpr bool is_cancellable = true;
-
- template <typename Receiver, typename... Args>
- static bool IsCancelled(const Functor&,
- const Receiver& receiver,
- const Args&...) {
- return !receiver;
- }
-};
-
-// Specialization for a nested bind.
-template <typename Signature, typename... BoundArgs>
-struct CallbackCancellationTraits<OnceCallback<Signature>,
- std::tuple<BoundArgs...>> {
- static constexpr bool is_cancellable = true;
-
- template <typename Functor>
- static bool IsCancelled(const Functor& functor, const BoundArgs&...) {
- return functor.IsCancelled();
- }
-};
-
-template <typename Signature, typename... BoundArgs>
-struct CallbackCancellationTraits<RepeatingCallback<Signature>,
- std::tuple<BoundArgs...>> {
- static constexpr bool is_cancellable = true;
-
- template <typename Functor>
- static bool IsCancelled(const Functor& functor, const BoundArgs&...) {
- return functor.IsCancelled();
- }
-};
-
-// Returns a RunType of bound functor.
-// E.g. MakeUnboundRunType<R(A, B, C), A, B> is evaluated to R(C).
-template <typename Functor, typename... BoundArgs>
-using MakeUnboundRunType =
- typename internal::BindTypeHelper<Functor, BoundArgs...>::UnboundRunType;
-
-} // namespace base
-
-#endif // BASE_BIND_INTERNAL_H_
diff --git a/base/callback.h b/base/callback.h
deleted file mode 100644
index 1b84f40..0000000
--- a/base/callback.h
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// NOTE: Header files that do not require the full definition of Callback or
-// Closure should #include "base/callback_forward.h" instead of this file.
-
-#ifndef BASE_CALLBACK_H_
-#define BASE_CALLBACK_H_
-
-#include "base/callback_forward.h"
-#include "base/callback_internal.h"
-
-// -----------------------------------------------------------------------------
-// Usage documentation
-// -----------------------------------------------------------------------------
-//
-// Overview:
-// A callback is similar in concept to a function pointer: it wraps a runnable
-// object such as a function, method, lambda, or even another callback, allowing
-// the runnable object to be invoked later via the callback object.
-//
-// Unlike function pointers, callbacks are created with base::BindOnce() or
-// base::BindRepeating() and support partial function application.
-//
-// A base::OnceCallback may be Run() at most once; a base::RepeatingCallback may
-// be Run() any number of times. |is_null()| is guaranteed to return true for a
-// moved-from callback.
-//
-// // The lambda takes two arguments, but the first argument |x| is bound at
-// // callback creation.
-// base::OnceCallback<int(int)> cb = base::BindOnce([] (int x, int y) {
-// return x + y;
-// }, 1);
-// // Run() only needs the remaining unbound argument |y|.
-// printf("1 + 2 = %d\n", std::move(cb).Run(2)); // Prints 3
-// printf("cb is null? %s\n",
-// cb.is_null() ? "true" : "false"); // Prints true
-// std::move(cb).Run(2); // Crashes since |cb| has already run.
-//
-// Callbacks also support cancellation. A common use is binding the receiver
-// object as a WeakPtr<T>. If that weak pointer is invalidated, calling Run()
-// will be a no-op. Note that |is_cancelled()| and |is_null()| are distinct:
-// simply cancelling a callback will not also make it null.
-//
-// base::Callback is currently a type alias for base::RepeatingCallback. In the
-// future, we expect to flip this to default to base::OnceCallback.
-//
-// See //docs/callback.md for the full documentation.
-
-namespace base {
-
-template <typename R, typename... Args>
-class OnceCallback<R(Args...)> : public internal::CallbackBase {
- public:
- using RunType = R(Args...);
- using PolymorphicInvoke = R (*)(internal::BindStateBase*,
- internal::PassingTraitsType<Args>...);
-
- constexpr OnceCallback() = default;
-
- explicit OnceCallback(internal::BindStateBase* bind_state)
- : internal::CallbackBase(bind_state) {}
-
- OnceCallback(const OnceCallback&) = delete;
- OnceCallback& operator=(const OnceCallback&) = delete;
-
- OnceCallback(OnceCallback&&) noexcept = default;
- OnceCallback& operator=(OnceCallback&&) noexcept = default;
-
- OnceCallback(RepeatingCallback<RunType> other)
- : internal::CallbackBase(std::move(other)) {}
-
- OnceCallback& operator=(RepeatingCallback<RunType> other) {
- static_cast<internal::CallbackBase&>(*this) = std::move(other);
- return *this;
- }
-
- bool Equals(const OnceCallback& other) const { return EqualsInternal(other); }
-
- R Run(Args... args) const& {
- static_assert(!sizeof(*this),
- "OnceCallback::Run() may only be invoked on a non-const "
- "rvalue, i.e. std::move(callback).Run().");
- NOTREACHED();
- }
-
- R Run(Args... args) && {
- // Move the callback instance into a local variable before the invocation,
- // that ensures the internal state is cleared after the invocation.
- // It's not safe to touch |this| after the invocation, since running the
- // bound function may destroy |this|.
- OnceCallback cb = std::move(*this);
- PolymorphicInvoke f =
- reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
- return f(cb.bind_state_.get(), std::forward<Args>(args)...);
- }
-};
-
-template <typename R, typename... Args>
-class RepeatingCallback<R(Args...)> : public internal::CallbackBaseCopyable {
- public:
- using RunType = R(Args...);
- using PolymorphicInvoke = R (*)(internal::BindStateBase*,
- internal::PassingTraitsType<Args>...);
-
- constexpr RepeatingCallback() = default;
-
- explicit RepeatingCallback(internal::BindStateBase* bind_state)
- : internal::CallbackBaseCopyable(bind_state) {}
-
- // Copyable and movable.
- RepeatingCallback(const RepeatingCallback&) = default;
- RepeatingCallback& operator=(const RepeatingCallback&) = default;
- RepeatingCallback(RepeatingCallback&&) noexcept = default;
- RepeatingCallback& operator=(RepeatingCallback&&) noexcept = default;
-
- bool Equals(const RepeatingCallback& other) const {
- return EqualsInternal(other);
- }
-
- R Run(Args... args) const& {
- PolymorphicInvoke f =
- reinterpret_cast<PolymorphicInvoke>(this->polymorphic_invoke());
- return f(this->bind_state_.get(), std::forward<Args>(args)...);
- }
-
- R Run(Args... args) && {
- // Move the callback instance into a local variable before the invocation,
- // that ensures the internal state is cleared after the invocation.
- // It's not safe to touch |this| after the invocation, since running the
- // bound function may destroy |this|.
- RepeatingCallback cb = std::move(*this);
- PolymorphicInvoke f =
- reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
- return f(cb.bind_state_.get(), std::forward<Args>(args)...);
- }
-};
-
-} // namespace base
-
-#endif // BASE_CALLBACK_H_
diff --git a/base/callback_forward.h b/base/callback_forward.h
deleted file mode 100644
index f1851c4..0000000
--- a/base/callback_forward.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CALLBACK_FORWARD_H_
-#define BASE_CALLBACK_FORWARD_H_
-
-namespace base {
-
-template <typename Signature>
-class OnceCallback;
-
-template <typename Signature>
-class RepeatingCallback;
-
-template <typename Signature>
-using Callback = RepeatingCallback<Signature>;
-
-// Syntactic sugar to make Callback<void()> easier to declare since it
-// will be used in a lot of APIs with delayed execution.
-using OnceClosure = OnceCallback<void()>;
-using RepeatingClosure = RepeatingCallback<void()>;
-using Closure = Callback<void()>;
-
-} // namespace base
-
-#endif // BASE_CALLBACK_FORWARD_H_
diff --git a/base/callback_internal.cc b/base/callback_internal.cc
deleted file mode 100644
index c52d8af..0000000
--- a/base/callback_internal.cc
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/callback_internal.h"
-
-#include "base/logging.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-bool ReturnFalse(const BindStateBase*) {
- return false;
-}
-
-} // namespace
-
-void BindStateBaseRefCountTraits::Destruct(const BindStateBase* bind_state) {
- bind_state->destructor_(bind_state);
-}
-
-BindStateBase::BindStateBase(InvokeFuncStorage polymorphic_invoke,
- void (*destructor)(const BindStateBase*))
- : BindStateBase(polymorphic_invoke, destructor, &ReturnFalse) {}
-
-BindStateBase::BindStateBase(InvokeFuncStorage polymorphic_invoke,
- void (*destructor)(const BindStateBase*),
- bool (*is_cancelled)(const BindStateBase*))
- : polymorphic_invoke_(polymorphic_invoke),
- destructor_(destructor),
- is_cancelled_(is_cancelled) {}
-
-CallbackBase::CallbackBase(CallbackBase&& c) noexcept = default;
-CallbackBase& CallbackBase::operator=(CallbackBase&& c) noexcept = default;
-CallbackBase::CallbackBase(const CallbackBaseCopyable& c)
- : bind_state_(c.bind_state_) {}
-
-CallbackBase& CallbackBase::operator=(const CallbackBaseCopyable& c) {
- bind_state_ = c.bind_state_;
- return *this;
-}
-
-CallbackBase::CallbackBase(CallbackBaseCopyable&& c) noexcept
- : bind_state_(std::move(c.bind_state_)) {}
-
-CallbackBase& CallbackBase::operator=(CallbackBaseCopyable&& c) noexcept {
- bind_state_ = std::move(c.bind_state_);
- return *this;
-}
-
-void CallbackBase::Reset() {
- // NULL the bind_state_ last, since it may be holding the last ref to whatever
- // object owns us, and we may be deleted after that.
- bind_state_ = nullptr;
-}
-
-bool CallbackBase::IsCancelled() const {
- DCHECK(bind_state_);
- return bind_state_->IsCancelled();
-}
-
-bool CallbackBase::EqualsInternal(const CallbackBase& other) const {
- return bind_state_ == other.bind_state_;
-}
-
-CallbackBase::CallbackBase(BindStateBase* bind_state)
- : bind_state_(bind_state ? AdoptRef(bind_state) : nullptr) {
- DCHECK(!bind_state_.get() || bind_state_->HasOneRef());
-}
-
-CallbackBase::~CallbackBase() = default;
-
-CallbackBaseCopyable::CallbackBaseCopyable(const CallbackBaseCopyable& c)
- : CallbackBase(nullptr) {
- bind_state_ = c.bind_state_;
-}
-
-CallbackBaseCopyable::CallbackBaseCopyable(CallbackBaseCopyable&& c) noexcept =
- default;
-
-CallbackBaseCopyable& CallbackBaseCopyable::operator=(
- const CallbackBaseCopyable& c) {
- bind_state_ = c.bind_state_;
- return *this;
-}
-
-CallbackBaseCopyable& CallbackBaseCopyable::operator=(
- CallbackBaseCopyable&& c) noexcept = default;
-
-} // namespace internal
-} // namespace base
diff --git a/base/callback_internal.h b/base/callback_internal.h
deleted file mode 100644
index 7e5180f..0000000
--- a/base/callback_internal.h
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file contains utility functions and classes that help the
-// implementation, and management of the Callback objects.
-
-#ifndef BASE_CALLBACK_INTERNAL_H_
-#define BASE_CALLBACK_INTERNAL_H_
-
-#include "base/callback_forward.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-
-namespace base {
-
-struct FakeBindState;
-
-namespace internal {
-
-class CallbackBase;
-class CallbackBaseCopyable;
-
-class BindStateBase;
-
-template <typename Functor, typename... BoundArgs>
-struct BindState;
-
-struct BindStateBaseRefCountTraits {
- static void Destruct(const BindStateBase*);
-};
-
-template <typename T, bool IsScalar = std::is_scalar<T>::value>
-struct PassingTraits;
-
-template <typename T>
-struct PassingTraits<T, false> {
- using Type = T&&;
-};
-
-template <typename T>
-struct PassingTraits<T, true> {
- using Type = T;
-};
-
-template <typename T>
-using PassingTraitsType = typename PassingTraits<T>::Type;
-
-// BindStateBase is used to provide an opaque handle that the Callback
-// class can use to represent a function object with bound arguments. It
-// behaves as an existential type that is used by a corresponding
-// DoInvoke function to perform the function execution. This allows
-// us to shield the Callback class from the types of the bound argument via
-// "type erasure."
-// At the base level, the only task is to add reference counting data. Don't use
-// RefCountedThreadSafe since it requires the destructor to be a virtual method.
-// Creating a vtable for every BindState template instantiation results in a lot
-// of bloat. Its only task is to call the destructor which can be done with a
-// function pointer.
-class BindStateBase
- : public RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits> {
- public:
- REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
-
- using InvokeFuncStorage = void (*)();
-
- private:
- BindStateBase(InvokeFuncStorage polymorphic_invoke,
- void (*destructor)(const BindStateBase*));
- BindStateBase(InvokeFuncStorage polymorphic_invoke,
- void (*destructor)(const BindStateBase*),
- bool (*is_cancelled)(const BindStateBase*));
-
- ~BindStateBase() = default;
-
- friend struct BindStateBaseRefCountTraits;
- friend class RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits>;
-
- friend class CallbackBase;
- friend class CallbackBaseCopyable;
-
- // Whitelist subclasses that access the destructor of BindStateBase.
- template <typename Functor, typename... BoundArgs>
- friend struct BindState;
- friend struct ::base::FakeBindState;
-
- bool IsCancelled() const { return is_cancelled_(this); }
-
- // In C++, it is safe to cast function pointers to function pointers of
- // another type. It is not okay to use void*. We create a InvokeFuncStorage
- // that that can store our function pointer, and then cast it back to
- // the original type on usage.
- InvokeFuncStorage polymorphic_invoke_;
-
- // Pointer to a function that will properly destroy |this|.
- void (*destructor_)(const BindStateBase*);
- bool (*is_cancelled_)(const BindStateBase*);
-
- DISALLOW_COPY_AND_ASSIGN(BindStateBase);
-};
-
-// Holds the Callback methods that don't require specialization to reduce
-// template bloat.
-// CallbackBase<MoveOnly> is a direct base class of MoveOnly callbacks, and
-// CallbackBase<Copyable> uses CallbackBase<MoveOnly> for its implementation.
-class CallbackBase {
- public:
- CallbackBase(CallbackBase&& c) noexcept;
- CallbackBase& operator=(CallbackBase&& c) noexcept;
-
- explicit CallbackBase(const CallbackBaseCopyable& c);
- CallbackBase& operator=(const CallbackBaseCopyable& c);
-
- explicit CallbackBase(CallbackBaseCopyable&& c) noexcept;
- CallbackBase& operator=(CallbackBaseCopyable&& c) noexcept;
-
- // Returns true if Callback is null (doesn't refer to anything).
- bool is_null() const { return !bind_state_; }
- explicit operator bool() const { return !is_null(); }
-
- // Returns true if the callback invocation will be nop due to an cancellation.
- // It's invalid to call this on uninitialized callback.
- bool IsCancelled() const;
-
- // Returns the Callback into an uninitialized state.
- void Reset();
-
- protected:
- using InvokeFuncStorage = BindStateBase::InvokeFuncStorage;
-
- // Returns true if this callback equals |other|. |other| may be null.
- bool EqualsInternal(const CallbackBase& other) const;
-
- constexpr inline CallbackBase();
-
- // Allow initializing of |bind_state_| via the constructor to avoid default
- // initialization of the scoped_refptr.
- explicit CallbackBase(BindStateBase* bind_state);
-
- InvokeFuncStorage polymorphic_invoke() const {
- return bind_state_->polymorphic_invoke_;
- }
-
- // Force the destructor to be instantiated inside this translation unit so
- // that our subclasses will not get inlined versions. Avoids more template
- // bloat.
- ~CallbackBase();
-
- scoped_refptr<BindStateBase> bind_state_;
-};
-
-constexpr CallbackBase::CallbackBase() = default;
-
-// CallbackBase<Copyable> is a direct base class of Copyable Callbacks.
-class CallbackBaseCopyable : public CallbackBase {
- public:
- CallbackBaseCopyable(const CallbackBaseCopyable& c);
- CallbackBaseCopyable(CallbackBaseCopyable&& c) noexcept;
- CallbackBaseCopyable& operator=(const CallbackBaseCopyable& c);
- CallbackBaseCopyable& operator=(CallbackBaseCopyable&& c) noexcept;
-
- protected:
- constexpr CallbackBaseCopyable() = default;
- explicit CallbackBaseCopyable(BindStateBase* bind_state)
- : CallbackBase(bind_state) {}
- ~CallbackBaseCopyable() = default;
-};
-
-} // namespace internal
-} // namespace base
-
-#endif // BASE_CALLBACK_INTERNAL_H_
diff --git a/base/logging.cc b/base/logging.cc
index 11cef81..a8ccd6f 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -46,8 +46,6 @@
#include <string_view>
#include <utility>
-#include "base/callback.h"
-#include "base/containers/stack.h"
#include "base/posix/eintr_wrapper.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
diff --git a/base/logging.h b/base/logging.h
index 78c0861..c581d33 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -15,7 +15,6 @@
#include <type_traits>
#include <utility>
-#include "base/callback_forward.h"
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/template_util.h"
diff --git a/build/gen.py b/build/gen.py
index 5011ea9..64e3f55 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -387,7 +387,6 @@
static_libraries = {
'base': {'sources': [
- 'base/callback_internal.cc',
'base/command_line.cc',
'base/environment.cc',
'base/files/file.cc',
diff --git a/tools/gn/build_settings.cc b/tools/gn/build_settings.cc
index 711c6b8..46e7944 100644
--- a/tools/gn/build_settings.cc
+++ b/tools/gn/build_settings.cc
@@ -70,6 +70,6 @@
void BuildSettings::ItemDefined(std::unique_ptr<Item> item) const {
DCHECK(item);
- if (!item_defined_callback_.is_null())
- item_defined_callback_.Run(std::move(item));
+ if (item_defined_callback_)
+ item_defined_callback_(std::move(item));
}
diff --git a/tools/gn/build_settings.h b/tools/gn/build_settings.h
index 40049d9..ef84f15 100644
--- a/tools/gn/build_settings.h
+++ b/tools/gn/build_settings.h
@@ -5,12 +5,12 @@
#ifndef TOOLS_GN_BUILD_SETTINGS_H_
#define TOOLS_GN_BUILD_SETTINGS_H_
+#include <functional>
#include <map>
#include <memory>
#include <set>
#include <utility>
-#include "base/callback.h"
#include "base/files/file_path.h"
#include "base/macros.h"
#include "tools/gn/args.h"
@@ -25,8 +25,8 @@
// may be multiple Settings objects that refer to this, one for each toolchain.
class BuildSettings {
public:
- using ItemDefinedCallback = base::Callback<void(std::unique_ptr<Item>)>;
- using PrintCallback = base::Callback<void(const std::string&)>;
+ using ItemDefinedCallback = std::function<void(std::unique_ptr<Item>)>;
+ using PrintCallback = std::function<void(const std::string&)>;
BuildSettings();
BuildSettings(const BuildSettings& other);
diff --git a/tools/gn/builder.cc b/tools/gn/builder.cc
index bbdb182..2482983 100644
--- a/tools/gn/builder.cc
+++ b/tools/gn/builder.cc
@@ -438,8 +438,8 @@
record->set_should_generate(true);
// This may have caused the item to go into "resolved and generated" state.
- if (record->resolved() && !resolved_and_generated_callback_.is_null())
- resolved_and_generated_callback_.Run(record);
+ if (record->resolved() && resolved_and_generated_callback_)
+ resolved_and_generated_callback_(record);
} else if (!force) {
return; // Already set and we're not required to iterate dependencies.
}
@@ -487,8 +487,8 @@
if (!record->item()->OnResolved(err))
return false;
- if (record->should_generate() && !resolved_and_generated_callback_.is_null())
- resolved_and_generated_callback_.Run(record);
+ if (record->should_generate() && resolved_and_generated_callback_)
+ resolved_and_generated_callback_(record);
// Recursively update everybody waiting on this item to be resolved.
for (BuilderRecord* waiting : record->waiting_on_resolution()) {
diff --git a/tools/gn/builder.h b/tools/gn/builder.h
index 62f4f96..f2996ca 100644
--- a/tools/gn/builder.h
+++ b/tools/gn/builder.h
@@ -5,10 +5,10 @@
#ifndef TOOLS_GN_BUILDER_H_
#define TOOLS_GN_BUILDER_H_
+#include <functional>
#include <map>
#include <memory>
-#include "base/callback.h"
#include "base/macros.h"
#include "tools/gn/builder_record.h"
#include "tools/gn/label.h"
@@ -24,7 +24,7 @@
// the main thread only. See also BuilderRecord.
class Builder {
public:
- using ResolvedGeneratedCallback = base::Callback<void(const BuilderRecord*)>;
+ using ResolvedGeneratedCallback = std::function<void(const BuilderRecord*)>;
explicit Builder(Loader* loader);
~Builder();
diff --git a/tools/gn/command_gen.cc b/tools/gn/command_gen.cc
index 200aad8..707c9e2 100644
--- a/tools/gn/command_gen.cc
+++ b/tools/gn/command_gen.cc
@@ -4,7 +4,6 @@
#include <mutex>
-#include "base/bind.h"
#include "base/command_line.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
@@ -78,7 +77,7 @@
const Target* target = item->AsTarget();
if (target) {
g_scheduler->ScheduleWork(
- base::Bind(&BackgroundDoWrite, write_info, target));
+ [write_info, target]() { BackgroundDoWrite(write_info, target); });
}
}
@@ -461,7 +460,9 @@
// Cause the load to also generate the ninja files for each target.
TargetWriteInfo write_info;
setup->builder().set_resolved_and_generated_callback(
- base::Bind(&ItemResolvedAndGeneratedCallback, &write_info));
+ [&write_info](const BuilderRecord* record) {
+ ItemResolvedAndGeneratedCallback(&write_info, record);
+ });
// Do the actual load. This will also write out the target ninja files.
if (!setup->Run())
diff --git a/tools/gn/functions.cc b/tools/gn/functions.cc
index 74b48bc..937ffd2 100644
--- a/tools/gn/functions.cc
+++ b/tools/gn/functions.cc
@@ -1022,11 +1022,12 @@
const BuildSettings::PrintCallback& cb =
scope->settings()->build_settings()->print_callback();
- if (cb.is_null()) {
+ if (cb) {
+ cb(output);
+ } else {
printf("%s", output.c_str());
fflush(stdout);
- } else
- cb.Run(output);
+ }
return Value();
}
diff --git a/tools/gn/header_checker.cc b/tools/gn/header_checker.cc
index f4af9d8..d9ff4b2 100644
--- a/tools/gn/header_checker.cc
+++ b/tools/gn/header_checker.cc
@@ -6,7 +6,6 @@
#include <algorithm>
-#include "base/bind.h"
#include "base/containers/queue.h"
#include "base/files/file_util.h"
#include "base/strings/string_util.h"
@@ -173,8 +172,9 @@
for (const auto& vect_i : file.second) {
if (vect_i.target->check_includes()) {
task_count_.Increment();
- pool.PostTask(base::BindOnce(&HeaderChecker::DoWork, this,
- vect_i.target, file.first));
+ pool.PostTask([this, target = vect_i.target, file = file.first]() {
+ DoWork(target, file);
+ });
}
}
}
diff --git a/tools/gn/header_checker.h b/tools/gn/header_checker.h
index 786edcb..b668441 100644
--- a/tools/gn/header_checker.h
+++ b/tools/gn/header_checker.h
@@ -6,6 +6,7 @@
#define TOOLS_GN_HEADER_CHECKER_H_
#include <condition_variable>
+#include <functional>
#include <map>
#include <mutex>
#include <set>
@@ -96,8 +97,7 @@
using TargetVector = std::vector<TargetInfo>;
using FileMap = std::map<SourceFile, TargetVector>;
- using PathExistsCallback =
- base::RepeatingCallback<bool(const base::FilePath& path)>;
+ using PathExistsCallback = std::function<bool(const base::FilePath& path)>;
// Backend for Run() that takes the list of files to check. The errors_ list
// will be populate on failure.
diff --git a/tools/gn/header_checker_unittest.cc b/tools/gn/header_checker_unittest.cc
index c6529d5..4243696 100644
--- a/tools/gn/header_checker_unittest.cc
+++ b/tools/gn/header_checker_unittest.cc
@@ -5,7 +5,6 @@
#include <ostream>
#include <vector>
-#include "base/bind.h"
#include "tools/gn/config.h"
#include "tools/gn/header_checker.h"
#include "tools/gn/scheduler.h"
diff --git a/tools/gn/input_file_manager.cc b/tools/gn/input_file_manager.cc
index aad8cc8..320e7a5 100644
--- a/tools/gn/input_file_manager.cc
+++ b/tools/gn/input_file_manager.cc
@@ -7,7 +7,6 @@
#include <memory>
#include <utility>
-#include "base/bind.h"
#include "base/stl_util.h"
#include "tools/gn/filesystem_utils.h"
#include "tools/gn/parser.h"
@@ -31,7 +30,7 @@
void InvokeFileLoadCallback(const InputFileManager::FileLoadCallback& cb,
const ParseNode* node) {
- cb.Run(node);
+ cb(node);
}
bool DoLoadFile(const LocationRange& origin,
@@ -111,7 +110,7 @@
// Try not to schedule callbacks while holding the lock. All cases that don't
// want to schedule should return early. Otherwise, this will be scheduled
// after we leave the lock.
- Task schedule_this;
+ std::function<void()> schedule_this;
{
std::lock_guard<std::mutex> lock(lock_);
@@ -121,9 +120,10 @@
std::unique_ptr<InputFileData> data =
std::make_unique<InputFileData>(file_name);
data->scheduled_callbacks.push_back(callback);
- schedule_this =
- base::BindOnce(&InputFileManager::BackgroundLoadFile, this, origin,
- build_settings, file_name, &data->file);
+ schedule_this = [this, origin, build_settings, file_name,
+ file = &data->file]() {
+ BackgroundLoadFile(origin, build_settings, file_name, file);
+ };
input_files_[file_name] = std::move(data);
} else {
@@ -146,8 +146,9 @@
if (data->loaded) {
// Can just directly issue the callback on the background thread.
- schedule_this = base::BindOnce(&InvokeFileLoadCallback, callback,
- data->parsed_root.get());
+ schedule_this = [callback, root = data->parsed_root.get()]() {
+ InvokeFileLoadCallback(callback, root);
+ };
} else {
// Load is pending on this file, schedule the invoke.
data->scheduled_callbacks.push_back(callback);
@@ -326,7 +327,7 @@
// item in the list, so that's extra overhead and complexity for no gain.
if (success) {
for (const auto& cb : callbacks)
- cb.Run(unowned_root);
+ cb(unowned_root);
}
return success;
}
diff --git a/tools/gn/input_file_manager.h b/tools/gn/input_file_manager.h
index c4f19e9..9676f2f 100644
--- a/tools/gn/input_file_manager.h
+++ b/tools/gn/input_file_manager.h
@@ -5,13 +5,13 @@
#ifndef TOOLS_GN_INPUT_FILE_MANAGER_H_
#define TOOLS_GN_INPUT_FILE_MANAGER_H_
+#include <functional>
#include <mutex>
#include <set>
#include <unordered_map>
#include <utility>
#include <vector>
-#include "base/callback.h"
#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
@@ -38,7 +38,7 @@
public:
// Callback issued when a file is laoded. On auccess, the parse node will
// refer to the root block of the file. On failure, this will be NULL.
- using FileLoadCallback = base::Callback<void(const ParseNode*)>;
+ using FileLoadCallback = std::function<void(const ParseNode*)>;
InputFileManager();
diff --git a/tools/gn/loader.cc b/tools/gn/loader.cc
index d1a2953..148ba39 100644
--- a/tools/gn/loader.cc
+++ b/tools/gn/loader.cc
@@ -6,7 +6,6 @@
#include <memory>
-#include "base/bind.h"
#include "tools/gn/build_settings.h"
#include "tools/gn/err.h"
#include "tools/gn/filesystem_utils.h"
@@ -208,10 +207,12 @@
const SourceFile& file) {
Err err;
pending_loads_++;
- if (!AsyncLoadFile(origin, settings->build_settings(), file,
- base::Bind(&LoaderImpl::BackgroundLoadFile, this, settings,
- file, origin),
- &err)) {
+ if (!AsyncLoadFile(
+ origin, settings->build_settings(), file,
+ [this, settings, file, origin](const ParseNode* parse_node) {
+ BackgroundLoadFile(settings, file, origin, parse_node);
+ },
+ &err)) {
g_scheduler->FailWithError(err);
DecrementPendingLoads();
}
@@ -222,11 +223,13 @@
const Scope::KeyValueMap& toolchain_overrides) {
Err err;
pending_loads_++;
- if (!AsyncLoadFile(LocationRange(), settings->build_settings(),
- settings->build_settings()->build_config_file(),
- base::Bind(&LoaderImpl::BackgroundLoadBuildConfig, this,
- settings, toolchain_overrides),
- &err)) {
+ if (!AsyncLoadFile(
+ LocationRange(), settings->build_settings(),
+ settings->build_settings()->build_config_file(),
+ [this, settings, toolchain_overrides](const ParseNode* root) {
+ BackgroundLoadBuildConfig(settings, toolchain_overrides, root);
+ },
+ &err)) {
g_scheduler->FailWithError(err);
DecrementPendingLoads();
}
@@ -237,8 +240,7 @@
const LocationRange& origin,
const ParseNode* root) {
if (!root) {
- task_runner_->PostTask(
- base::BindOnce(&LoaderImpl::DecrementPendingLoads, this));
+ task_runner_->PostTask([this]() { DecrementPendingLoads(); });
return;
}
@@ -277,7 +279,7 @@
trace.Done();
- task_runner_->PostTask(base::BindOnce(&LoaderImpl::DidLoadFile, this));
+ task_runner_->PostTask([this]() { DidLoadFile(); });
}
void LoaderImpl::BackgroundLoadBuildConfig(
@@ -285,8 +287,7 @@
const Scope::KeyValueMap& toolchain_overrides,
const ParseNode* root) {
if (!root) {
- task_runner_->PostTask(
- base::BindOnce(&LoaderImpl::DecrementPendingLoads, this));
+ task_runner_->PostTask([this]() { DecrementPendingLoads(); });
return;
}
@@ -348,8 +349,10 @@
}
}
- task_runner_->PostTask(base::BindOnce(&LoaderImpl::DidLoadBuildConfig, this,
- settings->toolchain_label()));
+ task_runner_->PostTask(
+ [this, toolchain_label = settings->toolchain_label()]() {
+ DidLoadBuildConfig(toolchain_label);
+ });
}
void LoaderImpl::DidLoadFile() {
@@ -419,19 +422,19 @@
void LoaderImpl::DecrementPendingLoads() {
DCHECK_GT(pending_loads_, 0);
pending_loads_--;
- if (pending_loads_ == 0 && !complete_callback_.is_null())
- complete_callback_.Run();
+ if (pending_loads_ == 0 && complete_callback_)
+ complete_callback_();
}
-bool LoaderImpl::AsyncLoadFile(
- const LocationRange& origin,
- const BuildSettings* build_settings,
- const SourceFile& file_name,
- const base::Callback<void(const ParseNode*)>& callback,
- Err* err) {
- if (async_load_file_.is_null()) {
- return g_scheduler->input_file_manager()->AsyncLoadFile(
- origin, build_settings, file_name, callback, err);
+bool LoaderImpl::AsyncLoadFile(const LocationRange& origin,
+ const BuildSettings* build_settings,
+ const SourceFile& file_name,
+ std::function<void(const ParseNode*)> callback,
+ Err* err) {
+ if (async_load_file_) {
+ return async_load_file_(origin, build_settings, file_name,
+ std::move(callback), err);
}
- return async_load_file_.Run(origin, build_settings, file_name, callback, err);
+ return g_scheduler->input_file_manager()->AsyncLoadFile(
+ origin, build_settings, file_name, std::move(callback), err);
}
diff --git a/tools/gn/loader.h b/tools/gn/loader.h
index 06737c3..bd679bb 100644
--- a/tools/gn/loader.h
+++ b/tools/gn/loader.h
@@ -5,11 +5,11 @@
#ifndef TOOLS_GN_LOADER_H_
#define TOOLS_GN_LOADER_H_
+#include <functional>
#include <map>
#include <memory>
#include <set>
-#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "tools/gn/label.h"
#include "tools/gn/scope.h"
@@ -72,11 +72,11 @@
public:
// Callback to emulate InputFileManager::AsyncLoadFile.
using AsyncLoadFileCallback =
- base::Callback<bool(const LocationRange&,
- const BuildSettings*,
- const SourceFile&,
- const base::Callback<void(const ParseNode*)>&,
- Err*)>;
+ std::function<bool(const LocationRange&,
+ const BuildSettings*,
+ const SourceFile&,
+ std::function<void(const ParseNode*)>,
+ Err*)>;
explicit LoaderImpl(const BuildSettings* build_settings);
@@ -96,13 +96,13 @@
// The complete callback is called whenever there are no more pending loads.
// Called on the main thread only. This may be called more than once if the
// queue is drained, but then more stuff gets added.
- void set_complete_callback(const base::Closure& cb) {
- complete_callback_ = cb;
+ void set_complete_callback(std::function<void()> cb) {
+ complete_callback_ = std::move(cb);
}
// This callback is used when the loader finds it wants to load a file.
- void set_async_load_file(const AsyncLoadFileCallback& cb) {
- async_load_file_ = cb;
+ void set_async_load_file(AsyncLoadFileCallback cb) {
+ async_load_file_ = std::move(cb);
}
const Label& default_toolchain_label() const {
@@ -152,13 +152,13 @@
bool AsyncLoadFile(const LocationRange& origin,
const BuildSettings* build_settings,
const SourceFile& file_name,
- const base::Callback<void(const ParseNode*)>& callback,
+ std::function<void(const ParseNode*)> callback,
Err* err);
MsgLoop* task_runner_;
int pending_loads_;
- base::Closure complete_callback_;
+ std::function<void()> complete_callback_;
// When non-null, use this callback instead of the InputFileManager for
// mocking purposes.
diff --git a/tools/gn/loader_unittest.cc b/tools/gn/loader_unittest.cc
index 83a2389..ede20d7 100644
--- a/tools/gn/loader_unittest.cc
+++ b/tools/gn/loader_unittest.cc
@@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <functional>
#include <map>
#include <memory>
#include <utility>
#include <vector>
-#include "base/bind.h"
#include "tools/gn/build_settings.h"
#include "tools/gn/err.h"
#include "tools/gn/loader.h"
@@ -52,7 +52,7 @@
class MockInputFileManager {
public:
- using Callback = base::Callback<void(const ParseNode*)>;
+ using Callback = std::function<void(const ParseNode*)>;
MockInputFileManager() = default;
@@ -91,8 +91,11 @@
};
LoaderImpl::AsyncLoadFileCallback MockInputFileManager::GetCallback() {
- return base::Bind(&MockInputFileManager::AsyncLoadFile,
- base::Unretained(this));
+ return
+ [this](const LocationRange& origin, const BuildSettings* build_settings,
+ const SourceFile& file_name, const Callback& callback, Err* err) {
+ return AsyncLoadFile(origin, build_settings, file_name, callback, err);
+ };
}
// Sets a given response for a given source file.
@@ -131,9 +134,9 @@
for (const auto& cur : pending_) {
CannedResponseMap::const_iterator found = canned_responses_.find(cur.first);
if (found == canned_responses_.end())
- cur.second.Run(&block);
+ cur.second(&block);
else
- cur.second.Run(found->second->root.get());
+ cur.second(found->second->root.get());
}
pending_.clear();
}
@@ -217,8 +220,10 @@
SourceFile build_config("//build/config/BUILDCONFIG.gn");
SourceFile root_build("//BUILD.gn");
build_settings_.set_build_config_file(build_config);
- build_settings_.set_item_defined_callback(base::Bind(
- &MockBuilder::OnItemDefined, base::Unretained(&mock_builder_)));
+ build_settings_.set_item_defined_callback(
+ [builder = &mock_builder_](std::unique_ptr<Item> item) {
+ builder->OnItemDefined(std::move(item));
+ });
scoped_refptr<LoaderImpl> loader(new LoaderImpl(&build_settings_));
mock_ifm_.AddCannedResponse(build_config,
diff --git a/tools/gn/scheduler.cc b/tools/gn/scheduler.cc
index f4960b9..a37d62d 100644
--- a/tools/gn/scheduler.cc
+++ b/tools/gn/scheduler.cc
@@ -6,7 +6,6 @@
#include <algorithm>
-#include "base/bind.h"
#include "tools/gn/standard_out.h"
#include "tools/gn/target.h"
@@ -40,8 +39,7 @@
}
void Scheduler::Log(const std::string& verb, const std::string& msg) {
- task_runner()->PostTask(base::BindOnce(&Scheduler::LogOnMainThread,
- base::Unretained(this), verb, msg));
+ task_runner()->PostTask([this, verb, msg]() { LogOnMainThread(verb, msg); });
}
void Scheduler::FailWithError(const Err& err) {
@@ -54,23 +52,20 @@
is_failed_ = true;
}
- task_runner()->PostTask(base::BindOnce(&Scheduler::FailWithErrorOnMainThread,
- base::Unretained(this), err));
+ task_runner()->PostTask([this, err]() { FailWithErrorOnMainThread(err); });
}
-void Scheduler::ScheduleWork(Task work) {
+void Scheduler::ScheduleWork(std::function<void()> work) {
IncrementWorkCount();
pool_work_count_.Increment();
- worker_pool_.PostTask(base::BindOnce(
- [](Scheduler* self, Task work) {
- std::move(work).Run();
- self->DecrementWorkCount();
- if (!self->pool_work_count_.Decrement()) {
- std::unique_lock<std::mutex> auto_lock(self->pool_work_count_lock_);
- self->pool_work_count_cv_.notify_one();
- }
- },
- this, std::move(work)));
+ worker_pool_.PostTask([this, work = std::move(work)]() {
+ work();
+ DecrementWorkCount();
+ if (!pool_work_count_.Decrement()) {
+ std::unique_lock<std::mutex> auto_lock(pool_work_count_lock_);
+ pool_work_count_cv_.notify_one();
+ }
+ });
}
void Scheduler::AddGenDependency(const base::FilePath& file) {
@@ -154,8 +149,7 @@
void Scheduler::DecrementWorkCount() {
if (!work_count_.Decrement()) {
- task_runner()->PostTask(
- base::BindOnce(&Scheduler::OnComplete, base::Unretained(this)));
+ task_runner()->PostTask([this]() { OnComplete(); });
}
}
diff --git a/tools/gn/scheduler.h b/tools/gn/scheduler.h
index d005df5..395b115 100644
--- a/tools/gn/scheduler.h
+++ b/tools/gn/scheduler.h
@@ -6,6 +6,7 @@
#define TOOLS_GN_SCHEDULER_H_
#include <condition_variable>
+#include <functional>
#include <map>
#include <mutex>
@@ -17,7 +18,6 @@
#include "tools/gn/source_file.h"
#include "tools/gn/token.h"
#include "util/msg_loop.h"
-#include "util/task.h"
#include "util/worker_pool.h"
class Target;
@@ -46,7 +46,7 @@
void Log(const std::string& verb, const std::string& msg);
void FailWithError(const Err& err);
- void ScheduleWork(Task work);
+ void ScheduleWork(std::function<void()> work);
void Shutdown();
diff --git a/tools/gn/setup.cc b/tools/gn/setup.cc
index 16e09fe..7540a8c 100644
--- a/tools/gn/setup.cc
+++ b/tools/gn/setup.cc
@@ -11,7 +11,6 @@
#include <sstream>
#include <utility>
-#include "base/bind.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
@@ -178,13 +177,15 @@
// this call completing on the main thread, the 'Complete' function will
// be signaled and we'll stop running with an incomplete build.
g_scheduler->IncrementWorkCount();
- task_runner->PostTask(base::BindOnce(
- [](Builder* builder_call_on_main_thread_only,
- std::unique_ptr<Item> item) {
- builder_call_on_main_thread_only->ItemDefined(std::move(item));
+
+ // Work around issue binding a unique_ptr with std::function by moving into a
+ // shared_ptr.
+ auto item_shared = std::make_shared<std::unique_ptr<Item>>(std::move(item));
+ task_runner->PostTask(
+ [builder_call_on_main_thread_only, item_shared]() mutable {
+ builder_call_on_main_thread_only->ItemDefined(std::move(*item_shared));
g_scheduler->DecrementWorkCount();
- },
- builder_call_on_main_thread_only, base::Passed(&item)));
+ });
}
void DecrementWorkCount() {
@@ -306,9 +307,12 @@
dotfile_settings_.set_toolchain_label(Label());
build_settings_.set_item_defined_callback(
- base::Bind(&ItemDefinedCallback, scheduler_.task_runner(), &builder_));
+ [task_runner = scheduler_.task_runner(),
+ builder = &builder_](std::unique_ptr<Item> item) {
+ ItemDefinedCallback(task_runner, builder, std::move(item));
+ });
- loader_->set_complete_callback(base::Bind(&DecrementWorkCount));
+ loader_->set_complete_callback(&DecrementWorkCount);
// The scheduler's task runner wasn't created when the Loader was created, so
// we need to set it now.
loader_->set_task_runner(scheduler_.task_runner());
diff --git a/tools/gn/target.cc b/tools/gn/target.cc
index 8a5b989..5b3d603 100644
--- a/tools/gn/target.cc
+++ b/tools/gn/target.cc
@@ -6,7 +6,6 @@
#include <stddef.h>
-#include "base/bind.h"
#include "base/stl_util.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
diff --git a/tools/gn/test_with_scope.cc b/tools/gn/test_with_scope.cc
index 80d9692..5025420 100644
--- a/tools/gn/test_with_scope.cc
+++ b/tools/gn/test_with_scope.cc
@@ -7,7 +7,6 @@
#include <memory>
#include <utility>
-#include "base/bind.h"
#include "tools/gn/parser.h"
#include "tools/gn/tokenizer.h"
@@ -28,7 +27,7 @@
scope_(&settings_),
scope_progammatic_provider_(&scope_, true) {
build_settings_.set_print_callback(
- base::Bind(&TestWithScope::AppendPrintOutput, base::Unretained(this)));
+ [this](const std::string& str) { AppendPrintOutput(str); });
settings_.set_toolchain_label(toolchain_.label());
settings_.set_default_toolchain_label(toolchain_.label());
diff --git a/util/msg_loop.cc b/util/msg_loop.cc
index dbb92cf..1566532 100644
--- a/util/msg_loop.cc
+++ b/util/msg_loop.cc
@@ -23,7 +23,7 @@
void MsgLoop::Run() {
while (!should_quit_) {
- Task task;
+ std::function<void()> task;
{
std::unique_lock<std::mutex> queue_lock(queue_mutex_);
notifier_.wait(queue_lock, [this]() {
@@ -37,16 +37,15 @@
task_queue_.pop();
}
- std::move(task).Run();
+ task();
}
}
void MsgLoop::PostQuit() {
- PostTask(
- base::BindOnce([](MsgLoop* self) { self->should_quit_ = true; }, this));
+ PostTask([this]() { should_quit_ = true; });
}
-void MsgLoop::PostTask(Task work) {
+void MsgLoop::PostTask(std::function<void()> work) {
{
std::unique_lock<std::mutex> queue_lock(queue_mutex_);
task_queue_.emplace(std::move(work));
@@ -57,7 +56,7 @@
void MsgLoop::RunUntilIdleForTesting() {
for (bool done = false; !done;) {
- Task task;
+ std::function<void()> task;
{
std::unique_lock<std::mutex> queue_lock(queue_mutex_);
task = std::move(task_queue_.front());
@@ -67,7 +66,7 @@
done = true;
}
- std::move(task).Run();
+ task();
}
}
diff --git a/util/msg_loop.h b/util/msg_loop.h
index 267d2a9..b6e1ec7 100644
--- a/util/msg_loop.h
+++ b/util/msg_loop.h
@@ -6,9 +6,9 @@
#define UTIL_RUN_LOOP_H_
#include "base/macros.h"
-#include "util/task.h"
#include <condition_variable>
+#include <functional>
#include <mutex>
#include <queue>
@@ -26,7 +26,7 @@
// Posts a work item to this queue. All items will be run on the thread from
// which Run() was called. Can be called from any thread.
- void PostTask(Task task);
+ void PostTask(std::function<void()> task);
// Run()s until the queue is empty. Should only be used (carefully) in tests.
void RunUntilIdleForTesting();
@@ -37,7 +37,7 @@
private:
std::mutex queue_mutex_;
- std::queue<Task> task_queue_;
+ std::queue<std::function<void()>> task_queue_;
std::condition_variable notifier_;
bool should_quit_ = false;
diff --git a/util/task.h b/util/task.h
deleted file mode 100644
index 278ff13..0000000
--- a/util/task.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef UTIL_TASK_H_
-#define UTIL_TASK_H_
-
-#include "base/bind.h"
-#include "base/callback.h"
-
-using Task = base::OnceClosure;
-
-#endif // UTIL_TASK_H_
diff --git a/util/worker_pool.cc b/util/worker_pool.cc
index 60bcfbf..3c049a9 100644
--- a/util/worker_pool.cc
+++ b/util/worker_pool.cc
@@ -117,7 +117,7 @@
}
}
-void WorkerPool::PostTask(Task work) {
+void WorkerPool::PostTask(std::function<void()> work) {
{
std::unique_lock<std::mutex> queue_lock(queue_mutex_);
CHECK(!should_stop_processing_);
@@ -129,7 +129,7 @@
void WorkerPool::Worker() {
for (;;) {
- Task task;
+ std::function<void()> task;
{
std::unique_lock<std::mutex> queue_lock(queue_mutex_);
@@ -145,6 +145,6 @@
task_queue_.pop();
}
- std::move(task).Run();
+ task();
}
}
diff --git a/util/worker_pool.h b/util/worker_pool.h
index d061644..7284ebe 100644
--- a/util/worker_pool.h
+++ b/util/worker_pool.h
@@ -6,13 +6,13 @@
#define UTIL_WORKER_POOL_H_
#include <condition_variable>
+#include <functional>
#include <mutex>
#include <queue>
#include <thread>
#include "base/logging.h"
#include "base/macros.h"
-#include "util/task.h"
class WorkerPool {
public:
@@ -20,13 +20,13 @@
WorkerPool(size_t thread_count);
~WorkerPool();
- void PostTask(Task work);
+ void PostTask(std::function<void()> work);
private:
void Worker();
std::vector<std::thread> threads_;
- std::queue<base::OnceClosure> task_queue_;
+ std::queue<std::function<void()>> task_queue_;
std::mutex queue_mutex_;
std::condition_variable_any pool_notifier_;
bool should_stop_processing_;
