Introduce base::IsWeakReceiver for base::Bind to support external weak pointers

base/bind_helpers.h

 // 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().
@@ skipping 152 matching lines @@
 #include <stddef.h>
 
 #include <type_traits>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
 
 namespace base {
+
+template <typename T>
+struct IsWeakReceiver;
+
 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
@@ skipping 269 matching lines @@
 }
 
 // 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 IsMethod, typename... Args>
-struct IsWeakMethod : public std::false_type {};
+struct IsWeakMethod : std::false_type {};
 
 template <typename T, typename... Args>
-struct IsWeakMethod<true, WeakPtr<T>, Args...> : public std::true_type {};
-
-template <typename T, typename... Args>
-struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T>>, Args...>
-    : public std::true_type {};
-
+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.
@@ skipping 139 matching lines @@
   return internal::IgnoreResultHelper<Callback<T> >(data);
 }
 
 BASE_EXPORT void DoNothing();
 
 template<typename T>
 void DeletePointer(T* obj) {
   delete obj;
 }
 
+// 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 null.

[danakj, 2016/06/10 23:36:18]

"if the receiver is tested as false" may be more accurate. Or something similar.

[tzik, 2016/06/14 12:06:10]

Done.

+// 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<WeakPtr<T>> : std::true_type {};
+
+template <typename T>
+struct IsWeakReceiver<internal::ConstRefWrapper<T>> : IsWeakReceiver<T> {};

[danakj, 2016/06/10 23:36:17]

nit: Does it compile if you put this above the WeakPtr one? I'm guess you intend
to add other things to the list, so grouping them at the bottom of the set of
defns might be nice.

[tzik, 2016/06/14 12:06:10]

Done.

+
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_