// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011 // Google Inc. All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the name Chromium Embedded // Framework nor the names of its contributors may be used to endorse // or promote products derived from this software without specific prior // written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /// /// \file /// 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 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 { void F(); };
///   auto instance = base::MakeRefCounted();
///   auto cb = base::BindOnce(&C::F, instance);
///   std::move(cb).Run();  // Identical to instance->F()
/// 
/// /// See https://chromium.googlesource.com/chromium/src/+/lkgr/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/internal/cef_bind_internal.h for a definition // of common terms and concepts. #ifndef CEF_INCLUDE_BASE_CEF_BIND_H_ #define CEF_INCLUDE_BASE_CEF_BIND_H_ #pragma once #if defined(USING_CHROMIUM_INCLUDES) // When building CEF include the Chromium header directly. #include "base/bind.h" #else // !USING_CHROMIUM_INCLUDES // The following is substantially similar to the Chromium implementation. // If the Chromium implementation diverges the below implementation should be // updated to match. #include #include #include #include #include "include/base/cef_build.h" #include "include/base/cef_compiler_specific.h" #include "include/base/cef_template_util.h" #include "include/base/internal/cef_bind_internal.h" #if defined(OS_APPLE) && !HAS_FEATURE(objc_arc) #include "include/base/internal/cef_scoped_block_mac.h" #endif namespace base { /// /// Bind as OnceCallback. /// template inline OnceCallback> BindOnce( Functor&& functor, Args&&... args) { static_assert(!internal::IsOnceCallback>() || (std::is_rvalue_reference() && !std::is_const>()), "BindOnce requires non-const rvalue for OnceCallback binding." " I.e.: base::BindOnce(std::move(callback))."); static_assert( conjunction< internal::AssertBindArgIsNotBasePassed>...>::value, "Use std::move() instead of base::Passed() with base::BindOnce()"); return internal::BindImpl(std::forward(functor), std::forward(args)...); } /// /// Bind as RepeatingCallback. /// template inline RepeatingCallback> BindRepeating(Functor&& functor, Args&&... args) { static_assert( !internal::IsOnceCallback>(), "BindRepeating cannot bind OnceCallback. Use BindOnce with std::move()."); return internal::BindImpl(std::forward(functor), std::forward(args)...); } /// /// Special cases for binding to a base::Callback without extra bound arguments. /// We CHECK() the validity of callback to guard against null pointers /// accidentally ending up in posted tasks, causing hard-to-debug crashes. /// template OnceCallback BindOnce(OnceCallback callback) { CHECK(callback); return callback; } template OnceCallback BindOnce(RepeatingCallback callback) { CHECK(callback); return callback; } template RepeatingCallback BindRepeating( RepeatingCallback callback) { CHECK(callback); return callback; } /// /// Unretained() allows binding 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;
///   OnceClosure foo_callback =
///       BindOnce(&Foo::func, Unretained(&foo));
///   std::move(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 inline internal::UnretainedWrapper Unretained(T* o) { return internal::UnretainedWrapper(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 bytes = ...;
///    OnceClosure callback = BindOnce(&foo, base::RetainedRef(bytes));
///    std::move(callback).Run();
/// 
/// /// Without RetainedRef, the scoped_refptr would try to implicitly convert to /// a raw pointer and fail compilation: /// ///
///    OnceClosure callback = BindOnce(&foo, bytes); // ERROR!
/// 
/// template inline internal::RetainedRefWrapper RetainedRef(T* o) { return internal::RetainedRefWrapper(o); } template inline internal::RetainedRefWrapper RetainedRef(scoped_refptr o) { return internal::RetainedRefWrapper(std::move(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);
///   RepeatingClosure foo_callback = BindRepeating(&foo, Owned(pn));
///
///   foo_callback.Run();  // Prints "1"
///   foo_callback.Run();  // Prints "1"
///   *pn = 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 inline internal::OwnedWrapper Owned(T* o) { return internal::OwnedWrapper(o); } template inline internal::OwnedWrapper Owned( std::unique_ptr&& ptr) { return internal::OwnedWrapper(std::move(ptr)); } /// /// OwnedRef() stores an object in the callback resulting from /// bind and passes a reference to the object to the bound function. /// /// EXAMPLE OF OwnedRef(): /// ///
///   void foo(int& arg) { cout << ++arg << endl }
///
///   int counter = 0;
///   RepeatingClosure foo_callback = BindRepeating(&foo, OwnedRef(counter));
///
///   foo_callback.Run();  // Prints "1"
///   foo_callback.Run();  // Prints "2"
///   foo_callback.Run();  // Prints "3"
///
///   cout << counter;     // Prints "0", OwnedRef creates a copy of counter.
/// 
/// /// Supports OnceCallbacks as well, useful to pass placeholder arguments: /// ///
///   void bar(int& ignore, const std::string& s) { cout << s << endl }
///
///   OnceClosure bar_callback = BindOnce(&bar, OwnedRef(0), "Hello");
///
///   std::move(bar_callback).Run(); // Prints "Hello"
/// 
/// /// Without OwnedRef() it would not be possible to pass a mutable reference to /// an object owned by the callback. /// template internal::OwnedRefWrapper> OwnedRef(T&& t) { return internal::OwnedRefWrapper>(std::forward(t)); } /// /// Passed() is for transferring movable-but-not-copyable types (eg. unique_ptr) /// through a RepeatingCallback. Logically, this signifies a destructive /// transfer of the state of the argument into the target function. Invoking /// RepeatingCallback::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 arg) { }
///   std::unique_ptr CreateFoo() { return std::make_unique();
///   }
///
///   auto f = std::make_unique();
///
///   // |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.
///   RepeatingClosure cb = BindRepeating(&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 = BindRepeating(&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 ::value>* = nullptr> inline internal::PassedWrapper Passed(T&& scoper) { return internal::PassedWrapper(std::move(scoper)); } template inline internal::PassedWrapper Passed(T* scoper) { return internal::PassedWrapper(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.
///   OnceCallback cb = BindOnce(IgnoreResult(&DoSomething));
///   std::move(cb).Run(1);  // Prints "1".
///
///   // Prints "2" on |ml|.
///   ml->PostTask(FROM_HERE, BindOnce(IgnoreResult(&DoSomething), 2);
/// 
/// template inline internal::IgnoreResultHelper IgnoreResult(T data) { return internal::IgnoreResultHelper(std::move(data)); } #if defined(OS_APPLE) && !HAS_FEATURE(objc_arc) /// /// RetainBlock() is used to adapt an Objective-C block when Automated Reference /// Counting (ARC) is disabled. This is unnecessary when ARC is enabled, as the /// BindOnce and BindRepeating already support blocks then. /// /// EXAMPLE OF RetainBlock(): /// ///
///   // Wrap the block and bind it to a callback.
///   OnceCallback cb =
///       BindOnce(RetainBlock(^(int n) { NSLog(@"%d", n); }));
///   std::move(cb).Run(1);  // Logs "1".
/// 
/// template base::mac::ScopedBlock RetainBlock(R (^block)(Args...)) { return base::mac::ScopedBlock(block, base::scoped_policy::RETAIN); } #endif // defined(OS_APPLE) && !HAS_FEATURE(objc_arc) } // namespace base #endif // !USING_CHROMIUM_INCLUDES #endif // CEF_INCLUDE_BASE_CEF_BIND_H_