Move PostTaskAndReplyWithStatus into task_runner_helpers.h

base/task_runner.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_TASK_RUNNER_H_
 #define BASE_TASK_RUNNER_H_
 #pragma once
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
-#include "base/callback_forward.h"
+#include "base/bind.h"

[willchan no longer on Chromium, 2012/04/04 17:35:49]

I have a problem with all these new headers. I see why you added them, but
TaskRunner is used very very widely in chrome code, due to MessageLoop
inheriting from it. That means we should be careful about what we include. I'm
torn, but sorta leaning towards moving this into a utility header and making it
a non-member function that takes a TaskRunner as a parameter, rather than being
a member function of TaskRunner.

I'd love to hear thoughts on this.

[battre, 2012/04/04 19:47:41]

Either way is fine with me. I'll follow your decision.

[willchan no longer on Chromium, 2012/04/05 16:53:03]

darin/akalin, feel free to chime in, but otherwise I'm going to ask for a
task_runner_util.h. I figure that in the future, we may have more of these
helpers anyway, so I'd like to defer to a helper file and reduce #includes for
the common case.

battre: please give them another day, and if there's no NACK, proceed.

[battre, 2012/04/12 06:46:33]

Done.

+#include "base/bind_helpers.h"
+#include "base/callback.h"
+#include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/time.h"
 
 namespace tracked_objects {
 class Location;
 } // namespace tracked_objects
 
 namespace base {
 
+namespace internal {
+
+// Helper class for TaskRunner::PostTaskAndReplyWithResult.
+template <typename ReturnType>
+void ReturnAsParamAdapter(const Callback<ReturnType(void)>& func,
+                          ReturnType* result) {
+  if (!func.is_null())
+    *result = func.Run();
+}
+
+// Helper class for TaskRunner::PostTaskAndReplyWithResult.
+template <typename ReturnType>
+Closure ReturnAsParam(const Callback<ReturnType(void)>& func,
+                      ReturnType* result) {
+  DCHECK(result);
+  return Bind(&ReturnAsParamAdapter<ReturnType>, func, result);
+}
+
+// Helper class for TaskRunner::PostTaskAndReplyWithResult.
+template <typename ReturnType>
+void ReplyAdapter(const Callback<void(ReturnType)>& callback,
+                  ReturnType* result) {
+  DCHECK(result);
+  if(!callback.is_null())
+    callback.Run(*result);
+}
+
+// Helper class for TaskRunner::PostTaskAndReplyWithResult.
+template <typename ReturnType, typename OWNED>

[willchan no longer on Chromium, 2012/04/04 17:35:49]

s/OWNED/OwnedType/

[battre, 2012/04/12 06:46:33]

Done.

+Closure ReplyHelper(const Callback<void(ReturnType)>& callback, OWNED result) {
+  return Bind(&ReplyAdapter<ReturnType>, callback, result);
+}
+
+}  // namespace internal
+
 struct TaskRunnerTraits;
 
 // A TaskRunner is an object that runs posted tasks (in the form of
 // Closure objects).  The TaskRunner interface provides a way of
 // decoupling task posting from the mechanics of how each task will be
 // run.  TaskRunner provides very weak guarantees as to how posted
 // tasks are run (or if they're run at all).  In particular, it only
 // guarantees:
 //
 //   - Posting a task will not run it synchronously.  That is, no
@@ skipping 96 matching lines @@
   //   * Results of |task| are shared with |reply| by binding a shared argument
   //     (a DataBuffer instance).
   //   * The DataLoader object has no special thread safety.
   //   * The DataLoader object can be deleted while |task| is still running,
   //     and the reply will cancel itself safely because it is bound to a
   //     WeakPtr<>.
   bool PostTaskAndReply(const tracked_objects::Location& from_here,
                         const Closure& task,
                         const Closure& reply);
 
+  // When you have these methods
+  //
+  //   R DoWorkAndReturn();
+  //   void Callback(const R& result);
+  //
+  // and want to call them in a PostTaskAndReply kind of fashion where the
+  // result of DoWorkAndReturn is passed to the Callback, you can use
+  // PostTaskAndReplyWithResult as in this example:
+  //
+  // target_thread_.message_loop_proxy()->PostTaskAndReplyWithResult(
+  //     FROM_HERE,
+  //     Bind(&DoWorkAndReturn),
+  //     Bind(&Callback));
+  template <typename ReturnType>
+  bool PostTaskAndReplyWithResult(
+      const tracked_objects::Location& from_here,
+      const Callback<ReturnType(void)>& task,
+      const Callback<void(ReturnType)>& reply) {
+    ReturnType* result = new ReturnType;
+    return PostTaskAndReply(
+        from_here,
+        internal::ReturnAsParam<ReturnType>(task, result),
+        internal::ReplyHelper(reply, Owned(result)));
+  }
+
  protected:
   friend struct TaskRunnerTraits;
 
   // Only the Windows debug build seems to need this: see
   // http://crbug.com/112250.
   friend class RefCountedThreadSafe<TaskRunner, TaskRunnerTraits>;
 
   TaskRunner();
   virtual ~TaskRunner();
 
   // Called when this object should be destroyed.  By default simply
   // deletes |this|, but can be overridden to do something else, like
   // delete on a certain thread.
   virtual void OnDestruct() const;
 };
 
 struct BASE_EXPORT TaskRunnerTraits {
   static void Destruct(const TaskRunner* task_runner);
 };
 
 }  // namespace base
 
 #endif  // BASE_TASK_RUNNER_H_