Add a PassScopedPtr into base/memory.

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::Owned(),
 // base::ConstRef(), and base::IgnoreReturn().
@@ skipping 259 matching lines @@
 
 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>
+PassScopedPtr<T> Unwrap(subtle::PassScopedPtrAnchor<T>& o) {
+  return PassScopedPtr<T>(&o);
+}
+
+template <typename T>
 const WeakPtr<T>& Unwrap(const WeakPtr<T>& o) { return o; }
 
 template <typename T>
 T* Unwrap(const OwnedWrapper<T>& o) {
   return o.get();
 }
 
 // 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&) {}
 };
 
 template <typename T, size_t n>
 struct MaybeRefcount<base::false_type, T[n]> {
   static void AddRef(const T*) {}
   static void Release(const T*) {}
 };
 
 template <typename T>
+struct MaybeRefcount<base::false_type, subtle::TransientPassScopedPtr<T> > {
+  static void AddRef(const subtle::PassScopedPtrAnchor<T>&) {}
+  static void Release(const subtle::PassScopedPtrAnchor<T>&) {}
+};
+
+template <typename T>
 struct MaybeRefcount<base::true_type, T*> {
   static void AddRef(T* o) { o->AddRef(); }
   static void Release(T* o) { o->Release(); }
 };
 
 template <typename T>
 struct MaybeRefcount<base::true_type, UnretainedWrapper<T> > {
   static void AddRef(const UnretainedWrapper<T>&) {}
   static void Release(const UnretainedWrapper<T>&) {}
 };
@@ skipping 12 matching lines @@
   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, subtle::TransientPassScopedPtr<T> > {
+  static void AddRef(const subtle::PassScopedPtrAnchor<T>&) {}
+  static void Release(const subtle::PassScopedPtrAnchor<T>&) {}
+};
+
+template <typename T>
 struct MaybeRefcount<base::true_type, WeakPtr<T> > {
   static void AddRef(const WeakPtr<T>&) {}
   static void Release(const WeakPtr<T>&) {}
 };
 
 template <typename R>
 void VoidReturnAdapter(Callback<R(void)> callback) {
   callback.Run();
 }
 
@@ skipping 15 matching lines @@
 }
 
 template <typename R>
 Closure IgnoreReturn(Callback<R(void)> callback) {
   return Bind(&internal::VoidReturnAdapter<R>, callback);
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_