The Tor Browser / file revision

 // 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.

 // This defines a set of argument wrappers and related factory methods that

 // can be used specify the refcounting and reference semantics of arguments

 // that are bound by the Bind() function in base/bind.h.

 //

 // It also defines a set of simple functions and utilities that people want

 // when using Callback<> and Bind().

 //

 //

 // ARGUMENT BINDING WRAPPERS

 //

 // The wrapper functions are base::Unretained(), base::Owned(), bass::Passed(),

 // base::ConstRef(), and base::IgnoreResult().

 //

 // Unretained() allows Bind() to bind a non-refcounted class, and to disable

 // refcounting on arguments that are refcounted objects.

 //

 // Owned() transfers ownership of an object to the Callback resulting from

 // bind; the object will be deleted when the Callback is deleted.

 //

 // Passed() is for transferring movable-but-not-copyable types (eg. scoped_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.

 //

 // ConstRef() allows binding a constant reference to an argument rather

 // than a copy.

 //

 // 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 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.

 //

 //

 // 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.

 //

 //

 // 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.

 //

 //

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

 //

 //

 // EXAMPLE OF Passed():

 //

 //   void TakesOwnership(scoped_ptr<Foo> arg) { }

 //   scoped_ptr<Foo> CreateFoo() { return scoped_ptr<Foo>(new Foo()); }

 //

 //   scoped_ptr<Foo> f(new Foo());

 //

 //   // |cb| is given ownership of Foo(). |f| is now NULL.

 //   // You can use f.Pass() 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.

 //

 // Passed() is particularly useful with PostTask() when you are transferring

 // ownership of an argument into a task, but don't necessarily know if the

 // task will always be executed. This can happen if the task is cancellable

 // or if it is posted to a MessageLoopProxy.

 //

 //

 // SIMPLE FUNCTIONS AND UTILITIES.

 //

 //   DoNothing() - Useful for creating a Closure that does nothing when called.

 //   DeletePointer<T>() - Useful for creating a Closure that will delete a

 //                        pointer when invoked. Only use this when necessary.

 //                        In most cases MessageLoop::DeleteSoon() is a better

 //                        fit.

 #ifndef BASE_BIND_HELPERS_H_

 #define BASE_BIND_HELPERS_H_

 #include "base/basictypes.h"

 #include "base/callback.h"

 #include "base/memory/weak_ptr.h"

 #include "base/template_util.h"

 namespace base {

 namespace internal {

 // Use the Substitution Failure Is Not An Error (SFINAE) trick to inspect T

 // for the existence of AddRef() and Release() functions of the correct

 // signature.

 //

 // http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error

 // http://stackoverflow.com/questions/257288/is-it-possible-to-write-a-c-template-to-check-for-a-functions-existence

 // http://stackoverflow.com/questions/4358584/sfinae-approach-comparison

 // http://stackoverflow.com/questions/1966362/sfinae-to-check-for-inherited-member-functions

 //

 // The last link in particular show the method used below.

 //

 // For SFINAE to work with inherited methods, we need to pull some extra tricks

 // with multiple inheritance.  In the more standard formulation, the overloads

 // of Check would be:

 //

 //   template <typename C>

 //   Yes NotTheCheckWeWant(Helper<&C::TargetFunc>*);

 //

 //   template <typename C>

 //   No NotTheCheckWeWant(...);

 //

 //   static const bool value = sizeof(NotTheCheckWeWant<T>(0)) == sizeof(Yes);

 //

 // The problem here is that template resolution will not match

 // C::TargetFunc if TargetFunc does not exist directly in C.  That is, if

 // TargetFunc in inherited from an ancestor, &C::TargetFunc will not match,

 // |value| will be false.  This formulation only checks for whether or

 // not TargetFunc exist directly in the class being introspected.

 //

 // To get around this, we play a dirty trick with multiple inheritance.

 // First, We create a class BaseMixin that declares each function that we

 // want to probe for.  Then we create a class Base that inherits from both T

 // (the class we wish to probe) and BaseMixin.  Note that the function

 // signature in BaseMixin does not need to match the signature of the function

 // we are probing for; thus it's easiest to just use void(void).

 //

 // Now, if TargetFunc exists somewhere in T, then &Base::TargetFunc has an

 // ambiguous resolution between BaseMixin and T.  This lets us write the

 // following:

 //

 //   template <typename C>

 //   No GoodCheck(Helper<&C::TargetFunc>*);

 //

 //   template <typename C>

 //   Yes GoodCheck(...);

 //

 //   static const bool value = sizeof(GoodCheck<Base>(0)) == sizeof(Yes);

 //

 // Notice here that the variadic version of GoodCheck() returns Yes here

 // instead of No like the previous one. Also notice that we calculate |value|

 // by specializing GoodCheck() on Base instead of T.

 //

 // We've reversed the roles of the variadic, and Helper overloads.

 // GoodCheck(Helper<&C::TargetFunc>*), when C = Base, fails to be a valid

 // substitution if T::TargetFunc exists. Thus GoodCheck<Base>(0) will resolve

 // to the variadic version if T has TargetFunc.  If T::TargetFunc does not

 // exist, then &C::TargetFunc is not ambiguous, and the overload resolution

 // will prefer GoodCheck(Helper<&C::TargetFunc>*).

 //

 // This method of SFINAE will correctly probe for inherited names, but it cannot

 // typecheck those names.  It's still a good enough sanity check though.

 //

 // Works on gcc-4.2, gcc-4.4, and Visual Studio 2008.

 //

 // TODO(ajwong): Move to ref_counted.h or template_util.h when we've vetted

 // this works well.

 //

 // TODO(ajwong): Make this check for Release() as well.

 // See http://crbug.com/82038.

 template <typename T>

 class SupportsAddRefAndRelease {

   typedef char Yes[1];

   typedef char No[2];

   struct BaseMixin {

     void AddRef();

   };

 // MSVC warns when you try to use Base if T has a private destructor, the

 // common pattern for refcounted types. It does this even though no attempt to

 // instantiate Base is made.  We disable the warning for this definition.

 #if defined(OS_WIN)

 #pragma warning(push)

 #pragma warning(disable:4624)

 #endif

   struct Base : public T, public BaseMixin {

   };

 #if defined(OS_WIN)

 #pragma warning(pop)

 #endif

   template <void(BaseMixin::*)(void)> struct Helper {};

   template <typename C>

   static No& Check(Helper<&C::AddRef>*);

   template <typename >

   static Yes& Check(...);

  public:

   static const bool value = sizeof(Check<Base>(0)) == sizeof(Yes);

 };

 // Helpers to assert that arguments of a recounted type are bound with a

 // scoped_refptr.

 template <bool IsClasstype, typename T>

 struct UnsafeBindtoRefCountedArgHelper : false_type {

 };

 template <typename T>

 struct UnsafeBindtoRefCountedArgHelper<true, T>

     : integral_constant<bool, SupportsAddRefAndRelease<T>::value> {

 };

 template <typename T>

 struct UnsafeBindtoRefCountedArg : false_type {

 };

 template <typename T>

 struct UnsafeBindtoRefCountedArg<T*>

     : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {

 };

 template <typename T>

 class HasIsMethodTag {

   typedef char Yes[1];

   typedef char No[2];

   template <typename U>

   static Yes& Check(typename U::IsMethod*);

   template <typename U>

   static No& Check(...);

  public:

   static const bool value = sizeof(Check<T>(0)) == sizeof(Yes);

 };

 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>

 struct IgnoreResultHelper {

   explicit IgnoreResultHelper(T functor) : functor_(functor) {}

   T functor_;

 };

 template <typename T>

 struct IgnoreResultHelper<Callback<T> > {

   explicit IgnoreResultHelper(const Callback<T>& functor) : functor_(functor) {}

   const Callback<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 scoped_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(const 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 "Pass()" function.

 //     This is intentional. The whitelisting of which specific types we

 //     support is maintained by CallbackParamTraits<>.

 //  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_(scoper.Pass()) {}

   PassedWrapper(const PassedWrapper& other)

       : is_valid_(other.is_valid_), scoper_(other.scoper_.Pass()) {

   }

   T Pass() const {

     CHECK(is_valid_);

     is_valid_ = false;

     return scoper_.Pass();

   }

  private:

   mutable bool is_valid_;

   mutable T scoper_;

 };

 // Unwrap the stored parameters for the wrappers above.

 template <typename T>

 struct UnwrapTraits {

   typedef const T& ForwardType;

   static ForwardType Unwrap(const T& o) { return o; }

 };

 template <typename T>

 struct UnwrapTraits<UnretainedWrapper<T> > {

   typedef T* ForwardType;

   static ForwardType Unwrap(UnretainedWrapper<T> unretained) {

     return unretained.get();

   }

 };

 template <typename T>

 struct UnwrapTraits<ConstRefWrapper<T> > {

   typedef const T& ForwardType;

   static ForwardType Unwrap(ConstRefWrapper<T> const_ref) {

     return const_ref.get();

   }

 };

 template <typename T>

 struct UnwrapTraits<scoped_refptr<T> > {

   typedef T* ForwardType;

   static ForwardType Unwrap(const scoped_refptr<T>& o) { return o.get(); }

 };

 template <typename T>

 struct UnwrapTraits<WeakPtr<T> > {

   typedef const WeakPtr<T>& ForwardType;

   static ForwardType Unwrap(const WeakPtr<T>& o) { return o; }

 };

 template <typename T>

 struct UnwrapTraits<OwnedWrapper<T> > {

   typedef T* ForwardType;

   static ForwardType Unwrap(const OwnedWrapper<T>& o) {

     return o.get();

   }

 };

 template <typename T>

 struct UnwrapTraits<PassedWrapper<T> > {

   typedef T ForwardType;

   static T Unwrap(PassedWrapper<T>& o) {

     return o.Pass();

   }

 };

 // Utility for handling different refcounting semantics in the Bind()

 // function.

 template <bool is_method, typename T>

 struct MaybeRefcount;

 template <typename T>

 struct MaybeRefcount<false, T> {

   static void AddRef(const T&) {}

   static void Release(const T&) {}

 };

 template <typename T, size_t n>

 struct MaybeRefcount<false, T[n]> {

   static void AddRef(const T*) {}

   static void Release(const T*) {}

 };

 template <typename T>

 struct MaybeRefcount<true, T> {

   static void AddRef(const T&) {}

   static void Release(const T&) {}

 };

 template <typename T>

 struct MaybeRefcount<true, T*> {

   static void AddRef(T* o) { o->AddRef(); }

   static void Release(T* o) { o->Release(); }

 };

 // No need to additionally AddRef() and Release() since we are storing a

 // scoped_refptr<> inside the storage object already.

 template <typename T>

 struct MaybeRefcount<true, scoped_refptr<T> > {

   static void AddRef(const scoped_refptr<T>& o) {}

   static void Release(const scoped_refptr<T>& o) {}

 };

 template <typename T>

 struct MaybeRefcount<true, const T*> {

   static void AddRef(const T* o) { o->AddRef(); }

   static void Release(const T* o) { o->Release(); }

 };

 // 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.

 //

 // P1 should be the type of the object that will be received of the method.

 template <bool IsMethod, typename P1>

 struct IsWeakMethod : public false_type {};

 template <typename T>

 struct IsWeakMethod<true, WeakPtr<T> > : public true_type {};

 template <typename T>

 struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T> > > : public true_type {};

 }  // namespace internal

 template <typename T>

 static inline internal::UnretainedWrapper<T> Unretained(T* o) {

   return internal::UnretainedWrapper<T>(o);

 }

 template <typename T>

 static inline internal::ConstRefWrapper<T> ConstRef(const T& o) {

   return internal::ConstRefWrapper<T>(o);

 }

 template <typename T>

 static inline internal::OwnedWrapper<T> Owned(T* o) {

   return internal::OwnedWrapper<T>(o);

 }

 // We offer 2 syntaxes for calling Passed().  The first takes a temporary and

 // is best suited for use with the return value of a function. The second

 // takes a pointer to the scoper and is just syntactic sugar to avoid having

 // to write Passed(scoper.Pass()).

 template <typename T>

 static inline internal::PassedWrapper<T> Passed(T scoper) {

   return internal::PassedWrapper<T>(scoper.Pass());

 }

 template <typename T>

 static inline internal::PassedWrapper<T> Passed(T* scoper) {

   return internal::PassedWrapper<T>(scoper->Pass());

 }

 template <typename T>

 static inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {

   return internal::IgnoreResultHelper<T>(data);

 }

 template <typename T>

 static inline internal::IgnoreResultHelper<Callback<T> >

 IgnoreResult(const Callback<T>& data) {

   return internal::IgnoreResultHelper<Callback<T> >(data);

 }

 BASE_EXPORT void DoNothing();

 template<typename T>

 void DeletePointer(T* obj) {

   delete obj;

 }

 }  // namespace base

 #endif  // BASE_BIND_HELPERS_H_