Disassociate argument type from return type in PostTaskAndReplyWithResult template.

base/task_runner_util.h

Index: base/task_runner_util.h
diff --git a/base/task_runner_util.h b/base/task_runner_util.h
index d1b9f62fcd6b25abf788324e118979421c738e03..caeeddc66b3668548f6299b4dd201df76ad2b990 100644
--- a/base/task_runner_util.h
+++ b/base/task_runner_util.h
@@ -32,19 +32,19 @@ Closure ReturnAsParam(const Callback<ReturnType(void)>& func,
 }
 
 // Helper class for TaskRunner::PostTaskAndReplyWithResult.
-template <typename ReturnType>
+template <typename ReturnType, typename ResultType>

[Jeffrey Yasskin, 2012/11/05 22:13:22]

Could you give these template arguments the same names as you're using in
PostTaskAndReplyWithResult?

[awong, 2012/11/19 05:57:09]

Done.

 void ReplyAdapter(const Callback<void(ReturnType)>& callback,
-                  ReturnType* result) {
+                  ResultType* result) {
   DCHECK(result);
   if(!callback.is_null())
     callback.Run(CallbackForward(*result));
 }
 
 // Helper class for TaskRunner::PostTaskAndReplyWithResult.
-template <typename ReturnType, typename OwnedType>
+template <typename ReturnType, typename ResultType>

[Jeffrey Yasskin, 2012/11/05 22:13:22]

Ditto here.

[awong, 2012/11/19 05:57:09]

Done.

[awong, 2012/11/19 05:57:09]

Done.

 Closure ReplyHelper(const Callback<void(ReturnType)>& callback,
-                    OwnedType result) {
-  return Bind(&ReplyAdapter<ReturnType>, callback, result);
+                    ResultType* result) {
+  return Bind(&ReplyAdapter<ReturnType, ResultType>, callback, Owned(result));
 }
 
 }  // namespace internal
@@ -63,17 +63,17 @@ Closure ReplyHelper(const Callback<void(ReturnType)>& callback,
 //     FROM_HERE,
 //     Bind(&DoWorkAndReturn),
 //     Bind(&Callback));
-template <typename ReturnType>
+template <typename TaskReturnType, typename ReplyArgType>
 bool PostTaskAndReplyWithResult(
     TaskRunner* task_runner,
     const tracked_objects::Location& from_here,
-    const Callback<ReturnType(void)>& task,
-    const Callback<void(ReturnType)>& reply) {
-  ReturnType* result = new ReturnType;
+    const Callback<TaskReturnType(void)>& task,
+    const Callback<void(ReplyArgType)>& reply) {

[Jeffrey Yasskin, 2012/11/05 22:13:22]

Could you double-check that users get a sensible error message when
TaskReturnType isn't convertible to ReplyArgType?

[awong, 2012/11/19 05:57:09]

Define sensible :)

It looks good enough to me. The compile error happens at the CallbackForward()
inside the adapter function below and the conversion shows up first on the error
list which is a bonus.

In file included from ../../base/task_runner_util_unittest.cc:5:
../../base/task_runner_util.h:30:16: error: reference to type 'const double'
could not bind to an lvalue of type 'char *'
  callback.Run(CallbackForward(*result));
               ^~~~~~~~~~~~~~~~~~~~~~~~
../../base/task_runner_util.h:61:18: note: in instantiation of function template
specialization 'base::internal::ReplyAdapter<char *, double>' requested here
      base::Bind(&internal::ReplyAdapter<TaskReturnType, ReplyArgType>, reply,
                 ^
../../base/task_runner_util_unittest.cc:90:3: note: in instantiation of function
template specialization 'base::PostTaskAndReplyWithResult<char *, double>'
requested here
  PostTaskAndReplyWithResult(
  ^
../../base/callback.h:427:65: note: passing argument to parameter 'a1' here
  R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1) const {
                                                                ^
2 errors generated.
ninja: build stopped: subcommand failed.

[Jeffrey Yasskin, 2012/11/19 10:33:46]

LGTM

+  TaskReturnType* result = new TaskReturnType;
   return task_runner->PostTaskAndReply(
       from_here,
-      internal::ReturnAsParam<ReturnType>(task, result),
-      internal::ReplyHelper(reply, Owned(result)));
+      internal::ReturnAsParam<TaskReturnType>(task, result),
+      internal::ReplyHelper(reply, result));
 }
 
 }  // namespace base