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

base/bind_internal.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.
 
 #ifndef BASE_BIND_INTERNAL_H_
 #define BASE_BIND_INTERNAL_H_
 
 #include <stddef.h>
 
 #include <tuple>
@@ skipping 301 matching lines @@
     std::forward<Runnable>(runnable).Run(std::forward<RunArgs>(args)...);
   }
 };
 
 template <>
 struct InvokeHelper<true, void> {
   template <typename Runnable, typename BoundWeakPtr, typename... RunArgs>
   static void MakeItSo(Runnable&& runnable,
                        BoundWeakPtr weak_ptr,
                        RunArgs&&... args) {
-    if (!weak_ptr.get()) {
+    if (!weak_ptr) {
       return;
     }
     std::forward<Runnable>(runnable).Run(
-        weak_ptr.get(), std::forward<RunArgs>(args)...);
+        weak_ptr, std::forward<RunArgs>(args)...);

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

I had to look at a bunch of places to understand why weak_ptr didn't need to be
moved here. Run takes a Receiver&&, but BoundWeakPtr will actually be a const&
since that is what Unwrap returns, IIUC.

It might be more obvious/less hidden, if you make |weak_ptr| be a forwarding
reference like the other arguments to this method with a &&, and forward it
here?

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

Done.

   }
 };
 
 #if !defined(_MSC_VER)
 
 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.
@@ skipping 100 matching lines @@
 
   static void Destroy(BindStateBase* self) {
     delete static_cast<BindState*>(self);
   }
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_