Support binding WeakPtr<> to methods with void return types.

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.
 //
 // The public functions are base::Unretained() and base::ConstRef().
 // Unretained() allows Bind() to bind a non-refcounted class.
@@ skipping 34 matching lines @@
 //
 // Note that because ConstRef() takes a reference on |n|, |n| must outlive all
 // its bound callbacks.
 //
 
 #ifndef BASE_BIND_HELPERS_H_
 #define BASE_BIND_HELPERS_H_
 #pragma once
 
 #include "base/basictypes.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
@@ skipping 143 matching lines @@
 T* Unwrap(UnretainedWrapper<T> unretained) { return unretained.get(); }
 
 template <typename T>
 const T& Unwrap(ConstRefWrapper<T> const_ref) {
   return const_ref.get();
 }
 
 
 // Utility for handling different refcounting semantics in the Bind()
 // function.
-template <typename ref, typename T>
+template <typename IsMethod, typename T>
 struct MaybeRefcount;
 
 template <typename T>
 struct MaybeRefcount<base::false_type, T> {
   static void AddRef(const T&) {}
   static void Release(const T&) {}
 };
 
 template <typename T, size_t n>
 struct MaybeRefcount<base::false_type, T[n]> {
@@ skipping 12 matching lines @@
   static void AddRef(T* o) { o->AddRef(); }
   static void Release(T* o) { o->Release(); }
 };
 
 template <typename T>
 struct MaybeRefcount<base::true_type, const T*> {
   static void AddRef(const T* o) { o->AddRef(); }
   static void Release(const T* o) { o->Release(); }
 };
 
+template <typename T>
+struct MaybeRefcount<base::true_type, WeakPtr<T> > {
+  static void AddRef(const WeakPtr<T>&) {}
+  static void Release(const WeakPtr<T>&) {}
+};
+
 }  // namespace internal
 
 template <typename T>
 inline internal::UnretainedWrapper<T> Unretained(T* o) {
   return internal::UnretainedWrapper<T>(o);
 }
 
 template <typename T>
 inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
   return internal::ConstRefWrapper<T>(o);
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_