Allow PostTask() to take unique_ptr to classes derived of QueuedTask

webrtc/rtc_base/task_queue.h

Index: webrtc/rtc_base/task_queue.h
diff --git a/webrtc/rtc_base/task_queue.h b/webrtc/rtc_base/task_queue.h
index e7eac2f18535ac7030d8c810b11fbf7c1d777800..5c6ce66c9b2d8548e7c96cfdcd0dd8e6fa7c0661 100644
--- a/webrtc/rtc_base/task_queue.h
+++ b/webrtc/rtc_base/task_queue.h
@@ -22,6 +22,7 @@
 #include "webrtc/rtc_base/constructormagic.h"
 #include "webrtc/rtc_base/criticalsection.h"
 #include "webrtc/rtc_base/scoped_ref_ptr.h"
+#include "webrtc/rtc_base/type_traits.h"

[kwiberg-webrtc, 2017/08/31 10:45:33]

You should #include <type_traits> instead.

[eladalon, 2017/08/31 10:51:04]

Done.

 
 #if defined(WEBRTC_WIN)
 #include "webrtc/rtc_base/platform_thread.h"
@@ -189,7 +190,12 @@ class LOCKABLE TaskQueue {
   // more likely). This can be mitigated by limiting the use of delayed tasks.
   void PostDelayedTask(std::unique_ptr<QueuedTask> task, uint32_t milliseconds);
 
-  template <class Closure>
+  // std::enable_if is used here to make sure that calls to PostTask() with
+  // std::unique_ptr<SomeClassDerivedFromQueuedTask> would not end up being
+  // caught by this template.
+  template <class Closure,
+            typename std::enable_if<
+                std::is_copy_constructible<Closure>::value>::type* = nullptr>
   void PostTask(const Closure& closure) {

[nisse-webrtc, 2017/08/31 09:40:39]

One question: At some point, we'll move to C++17, and then we can have lambdas
doing capture-by-move, including by capturing unique_ptr. And we'd then want
Closure to be able to match such lambdas, which I imagine will *not* be
copy-constructible. I don't understand all the magic, but to me, it seems that
when we get there, we'd need to

1. Adjust the template, and maybe the ClosureTask class too, to accept a Closure
which isn't copy-constructible.

2. Add a more narrow exclusion, to exclude std::unique_ptr<T> it and only if
that's implicitly convertible to std::unique_ptr<QueuedTask>.

Is it possible to do any of that right away? Or will it be possible with C++17?

[kwiberg-webrtc, 2017/08/31 10:45:33]

Yes. (But it's C++14, not 17.)
Yes.
That's right.

(It's already possible to construct such objects in C++11---you just
can't do it with lambdas alone. You need to manually write a class, or
wrap a lambda in bind guck.)
Yes. We'd want to std::move it everywhere.
I don't know offhand how to test if a type is unique_ptr<T> for some
T. However, we do know that closure objects need to be callable, and
we also know that unique_ptrs aren't callable. C++17 has a type trait
called std::is_invocable that tests if a type can be called with a
given argument list, and we can implement something similar in C++11
if we wanted to---see rtc::HasDataAndSize for an example.

I don't have a strong opinion on whether it's best to just use
std::is_copy_constructible for now, or if we should define and use
rtc::IsCallable. The latter is prettier, because it expresses what we
really mean, but it's also more work since we have to write
rtc::IsCallable.

     PostTask(std::unique_ptr<QueuedTask>(new ClosureTask<Closure>(closure)));
   }