Add new helper that can adapt Callbacks with return values for Closures.

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().
+// The public functions are base::Unretained(), base::ConstRef(), and
+// base::IgnoreReturn().
+//
 // Unretained() allows Bind() to bind a non-refcounted class.
 // ConstRef() allows binding a constant reference to an argument rather
 // than a copy.
+// IgnoreReturn() is used to adapt a 0-argument Callback with a return type to
+// a Closure. This is useful if you need to PostTask with a function that has
+// a return value that you don't care about.
 //
 //
 // EXAMPLE OF Unretained():
 //
 //   class Foo {
 //    public:
-//     void func() { cout << "Foo:f" << endl;
+//     void func() { cout << "Foo:f" << endl; }
 //   };
 //
 //   // In some function somewhere.
 //   Foo foo;
 //   Callback<void(void)> foo_callback =
 //       Bind(&Foo::func, Unretained(&foo));
 //   foo_callback.Run();  // Prints "Foo:f".
 //
 // Without the Unretained() wrapper on |&foo|, the above call would fail
 // to compile because Foo does not support the AddRef() and Release() methods.
 //
 //
-// EXAMPLE OF ConstRef();
+// EXAMPLE OF ConstRef():
 //   void foo(int arg) { cout << arg << endl }
 //
 //   int n = 1;
 //   Callback<void(void)> no_ref = Bind(&foo, n);
 //   Callback<void(void)> has_ref = Bind(&foo, ConstRef(n));
 //
 //   no_ref.Run();  // Prints "1"
 //   has_ref.Run();  // Prints "1"
 //
 //   n = 2;
 //   no_ref.Run();  // Prints "1"
 //   has_ref.Run();  // Prints "2"
 //
 // Note that because ConstRef() takes a reference on |n|, |n| must outlive all
 // its bound callbacks.
 //
+//
+// EXAMPLE OF IgnoreReturn():
+//   int DoSomething(int arg) { cout << arg << endl; }
+//   Callback<int(void)> cb = Bind(&DoSomething, 1);
+//   Closure c = IgnoreReturn(cb);  // Prints "1"
+//       or
+//   ml->PostTask(FROM_HERE, IgnoreReturn(cb));  // Prints "1" on |ml|
 
 #ifndef BASE_BIND_HELPERS_H_
 #define BASE_BIND_HELPERS_H_
 #pragma once
 
 #include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/callback.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.
 //
@@ skipping 183 matching lines @@
   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>&) {}
 };
 
+template <typename R>
+void VoidReturnAdapter(Callback<R(void)> callback) {
+  callback.Run();
+}
+
 }  // 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);
 }
 
+template <typename R>
+Closure IgnoreReturn(Callback<R(void)> callback) {
+  return Bind(&internal::VoidReturnAdapter<R>, callback);
+}
+
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_