Support scoped_refptr<> as the object for a method call in base::Bind(). Reduce useless copies.

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(), base::ConstRef(), and
 // base::IgnoreReturn().
@@ skipping 209 matching lines @@
 T Unwrap(T o) { return o; }
 
 template <typename T>
 T* Unwrap(UnretainedWrapper<T> unretained) { return unretained.get(); }
 
 template <typename T>
 const T& Unwrap(ConstRefWrapper<T> const_ref) {
   return const_ref.get();
 }
 
+template <typename T>
+T* Unwrap(const scoped_refptr<T>& o) { return o.get(); }
+
+template <typename T>
+const WeakPtr<T>& Unwrap(const WeakPtr<T>& o) { return o; }
 
 // Utility for handling different refcounting semantics in the Bind()
 // function.
 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&) {}
@@ skipping 10 matching lines @@
   static void AddRef(const UnretainedWrapper<T>&) {}
   static void Release(const UnretainedWrapper<T>&) {}
 };
 
 template <typename T>
 struct MaybeRefcount<base::true_type, 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<base::true_type, scoped_refptr<T> > {
+  static void AddRef(const scoped_refptr<T>& o) {}
+  static void Release(const scoped_refptr<T>& o) {}
+};
+
 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>&) {}
@@ skipping 17 matching lines @@
 }
 
 template <typename R>
 Closure IgnoreReturn(Callback<R(void)> callback) {
   return Bind(&internal::VoidReturnAdapter<R>, callback);
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_