base: Add RetainedRef for unwrapping scoped_refptrs.

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.
 //
 // It also defines a set of simple functions and utilities that people want
 // when using Callback<> and Bind().
@@ skipping 16 matching lines @@
 // Callback::Run() twice on a Callback that was created with a Passed()
 // argument will CHECK() because the first invocation would have already
 // transferred ownership to the target function.
 //
 // ConstRef() allows binding a constant reference to an argument rather
 // than a copy.
 //
 // IgnoreResult() is used to adapt a function or Callback with a return type to
 // one with a void return. This is most useful if you have a function with,
 // say, a pesky ignorable bool return that you want to use with PostTask or
 // something else that expect a Callback with a void return.

[Nico, 2016/03/18 14:16:36]

explain this new qualifier here...

[vmpstr, 2016/03/18 18:02:46]

Done.

 //
 // EXAMPLE OF Unretained():
 //
 //   class Foo {
 //    public:
 //     void func() { cout << "Foo:f" << endl; }
 //   };
 //
 //   // In some function somewhere.
 //   Foo foo;
@@ skipping 75 matching lines @@
 //
 //   // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
 //   // no longer owns Foo() and, if reset, would not delete Foo().
 //   cb.Run();  // Foo() is now transferred to |arg| and deleted.
 //   cb.Run();  // This CHECK()s since Foo() already been used once.
 //
 // Passed() is particularly useful with PostTask() when you are transferring
 // ownership of an argument into a task, but don't necessarily know if the
 // task will always be executed. This can happen if the task is cancellable
 // or if it is posted to a TaskRunner.
 //

[Nico, 2016/03/18 14:16:36]

...and here

[vmpstr, 2016/03/18 18:02:46]

Done.

 //
 // SIMPLE FUNCTIONS AND UTILITIES.
 //
 //   DoNothing() - Useful for creating a Closure that does nothing when called.
 //   DeletePointer<T>() - Useful for creating a Closure that will delete a
 //                        pointer when invoked. Only use this when necessary.
 //                        In most cases MessageLoop::DeleteSoon() is a better
 //                        fit.
 
 #ifndef BASE_BIND_HELPERS_H_
@@ skipping 161 matching lines @@
 template <typename T>
 class ConstRefWrapper {
  public:
   explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
   const T& get() const { return *ptr_; }
  private:
   const T* ptr_;
 };
 
 template <typename T>
+class RetainedRefWrapper {
+ public:
+  explicit RetainedRefWrapper(T* o) : ptr_(o) {}
+  explicit RetainedRefWrapper(scoped_refptr<T> o) : ptr_(std::move(o)) {}
+  T* get() const { return ptr_.get(); }
+ private:
+  scoped_refptr<T> ptr_;
+};
+
+template <typename T>
 struct IgnoreResultHelper {
   explicit IgnoreResultHelper(T functor) : functor_(functor) {}
 
   T functor_;
 };
 
 template <typename T>
 struct IgnoreResultHelper<Callback<T> > {
   explicit IgnoreResultHelper(const Callback<T>& functor) : functor_(functor) {}
 
@@ skipping 78 matching lines @@
 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>
+T* Unwrap(const RetainedRefWrapper<T>& o) {
+  return o.get();
+}
+
+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();
 }
 
 template <typename T>
@@ skipping 115 matching lines @@
 using ExtractArgs = typename ExtractArgsImpl<Signature>::Type;
 
 }  // namespace internal
 
 template <typename T>
 static inline internal::UnretainedWrapper<T> Unretained(T* o) {
   return internal::UnretainedWrapper<T>(o);
 }
 
 template <typename T>
+static inline internal::RetainedRefWrapper<T> RetainedRef(T* o) {
+  return internal::RetainedRefWrapper<T>(o);
+}
+
+template <typename T>
+static inline internal::RetainedRefWrapper<T> RetainedRef(scoped_refptr<T> o) {
+  return internal::RetainedRefWrapper<T>(std::move(o));
+}
+
+template <typename T>
 static inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
   return internal::ConstRefWrapper<T>(o);
 }
 
 template <typename T>
 static inline internal::OwnedWrapper<T> Owned(T* o) {
   return internal::OwnedWrapper<T>(o);
 }
 
 // We offer 2 syntaxes for calling Passed().  The first takes an rvalue and
@@ skipping 28 matching lines @@
 BASE_EXPORT void DoNothing();
 
 template<typename T>
 void DeletePointer(T* obj) {
   delete obj;
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_