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

webrtc/rtc_base/task_queue.h

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_RTC_BASE_TASK_QUEUE_H_
 #define WEBRTC_RTC_BASE_TASK_QUEUE_H_
 
 #include <list>
 #include <memory>
 #include <queue>
 
 #if defined(WEBRTC_MAC)
 #include <dispatch/dispatch.h>
 #endif
 
 #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"
 #endif
 
 namespace rtc {
 
 // Base interface for asynchronously executed tasks.
 // The interface basically consists of a single function, Run(), that executes
 // on the target queue.  For more details see the Run() method and TaskQueue.
@@ skipping 147 matching lines @@
   void PostTaskAndReply(std::unique_ptr<QueuedTask> task,
                         std::unique_ptr<QueuedTask> reply);
 
   // Schedules a task to execute a specified number of milliseconds from when
   // the call is made. The precision should be considered as "best effort"
   // and in some cases, such as on Windows when all high precision timers have
   // been used up, can be off by as much as 15 millseconds (although 8 would be
   // 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)));
   }
 
   // See documentation above for performance expectations.
   template <class Closure>
   void PostDelayedTask(const Closure& closure, uint32_t milliseconds) {
     PostDelayedTask(
         std::unique_ptr<QueuedTask>(new ClosureTask<Closure>(closure)),
         milliseconds);
   }
@@ skipping 62 matching lines @@
   class Impl;
   const scoped_refptr<Impl> impl_;
 #endif
 
   RTC_DISALLOW_COPY_AND_ASSIGN(TaskQueue);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_RTC_BASE_TASK_QUEUE_H_