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 304 matching lines @@
   typedef T* ForwardType;
   static ForwardType Unwrap(const scoped_refptr<T>& o) { return o.get(); }
 };
 
 template <typename T>
 struct UnwrapTraits<WeakPtr<T> > {
   typedef const WeakPtr<T>& ForwardType;
   static ForwardType Unwrap(const WeakPtr<T>& o) { return o; }
 };
 
+/*
+template <typename T>
+struct UnwrapTraits<subtle::PassScopedPtrAnchor<T> > {
+  typedef PassScopedPtr<T> ForwardType;
+  static PassScopedPtr<T> Unwrap(subtle::PassScopedPtrAnchor<T>& o) {
+    return &o;
+  }
+};
+*/
+
+template <typename T>
+struct UnwrapTraits<subtle::PassScopedPtrAnchor<T> > {
+  typedef subtle::PassScopedPtrAnchor<T>* ForwardType;
+  static subtle::PassScopedPtrAnchor<T>*
+      Unwrap(subtle::PassScopedPtrAnchor<T>& o) {
+    return &o;
+  }
+};
+
 template <typename T>
 struct UnwrapTraits<OwnedWrapper<T> > {
   typedef T* ForwardType;
   static ForwardType Unwrap(const OwnedWrapper<T>& o) {
     return o.get();
   }
 };
 
 // Utility for handling different refcounting semantics in the Bind()
 // function.
 template <bool, typename T>
 struct MaybeRefcount;
 
 template <typename T>
 struct MaybeRefcount<false, T> {
   static void AddRef(const T&) {}
   static void Release(const T&) {}
 };
 
 template <typename T, size_t n>
 struct MaybeRefcount<false, T[n]> {
   static void AddRef(const T*) {}
   static void Release(const T*) {}
 };
 
 template <typename T>
+struct MaybeRefcount<false, PassScopedPtr<T> > {
+  static void AddRef(const subtle::PassScopedPtrAnchor<T>&) {}
+  static void Release(const subtle::PassScopedPtrAnchor<T>&) {}
+};
+
+template <typename T>
 struct MaybeRefcount<true, T*> {
   static void AddRef(T* o) { o->AddRef(); }
   static void Release(T* o) { o->Release(); }
 };
 
 template <typename T>
 struct MaybeRefcount<true, 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<true, const T*> {
   static void AddRef(const T* o) { o->AddRef(); }
   static void Release(const T* o) { o->Release(); }
 };
 
 template <typename T>
+struct MaybeRefcount<true, PassScopedPtr<T> > {
+  static void AddRef(const subtle::PassScopedPtrAnchor<T>&) {}
+  static void Release(const subtle::PassScopedPtrAnchor<T>&) {}
+};
+
+template <typename T>
 struct MaybeRefcount<true, 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 42 matching lines @@
 template <typename T>
 static inline internal::IgnoreResultHelper<Callback<T> >
 IgnoreResult(const Callback<T>& data) {
   return internal::IgnoreResultHelper<Callback<T> >(data);
 }
 
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_