Add OnceCallback support to PostTaskAndReplyWithResult

base/task_runner_util.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_UTIL_H_
 #define BASE_TASK_RUNNER_UTIL_H_
 
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 //   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:
 //
 // PostTaskAndReplyWithResult(
 //     target_thread_.task_runner(),
 //     FROM_HERE,
-//     Bind(&DoWorkAndReturn),
-//     Bind(&Callback));
+//     BindOnce(&DoWorkAndReturn),
+//     BindOnce(&Callback));
+template <typename TaskReturnType, typename ReplyArgType>
+bool PostTaskAndReplyWithResult(TaskRunner* task_runner,
+                                const tracked_objects::Location& from_here,
+                                OnceCallback<TaskReturnType()> task,
+                                OnceCallback<void(ReplyArgType)> reply) {
+  DCHECK(task);
+  DCHECK(reply);
+  TaskReturnType* result = new TaskReturnType();
+  return task_runner->PostTaskAndReply(
+      from_here,
+      BindOnce(&internal::ReturnAsParamAdapter<TaskReturnType>, std::move(task),
+               result),
+      BindOnce(&internal::ReplyAdapter<TaskReturnType, ReplyArgType>,
+               std::move(reply), Owned(result)));
+}
+
+// Callback version of PostTaskAndReplyWithResult above.
+// Though RepeatingCallback is convertible to OnceCallback, we need this since
+// we can not use template deduction and object conversion at once on the
+// overload resolution.
+// TODO(tzik): Update all callers of the Callback version to use OnceCallback.
 template <typename TaskReturnType, typename ReplyArgType>
 bool PostTaskAndReplyWithResult(TaskRunner* task_runner,
                                 const tracked_objects::Location& from_here,
                                 Callback<TaskReturnType()> task,
                                 Callback<void(ReplyArgType)> reply) {
-  DCHECK(task);
-  DCHECK(reply);
-  TaskReturnType* result = new TaskReturnType();
-  return task_runner->PostTaskAndReply(
-      from_here,
-      base::BindOnce(&internal::ReturnAsParamAdapter<TaskReturnType>,
-                     std::move(task), result),
-      base::BindOnce(&internal::ReplyAdapter<TaskReturnType, ReplyArgType>,
-                     std::move(reply), base::Owned(result)));
+  return PostTaskAndReplyWithResult(
+      task_runner, from_here,
+      static_cast<OnceCallback<TaskReturnType()>>(std::move(task)),
+      static_cast<OnceCallback<void(ReplyArgType)>>(std::move(reply)));
 }
 
 }  // namespace base
 
 #endif  // BASE_TASK_RUNNER_UTIL_H_