Change ProcessThread's task type to be the one from TaskQueue.

ProcessThread will eventually be replaced by TaskQueue, so this is the first little step.

BUG=
R=magjed@webrtc.org

Review URL: https://codereview.webrtc.org/2016043003 .

Cr-Commit-Position: refs/heads/master@{#12952}

webrtc/modules/utility/BUILD.gn

@@ -41,6 +41,7 @@ source_set("utility") {
 
   deps = [
     "../..:webrtc_common",
+    "../../base:rtc_task_queue",
     "../../common_audio",
     "../../system_wrappers",
     "../audio_coding",

webrtc/modules/utility/include/mock/mock_process_thread.h

@@ -28,14 +28,14 @@ class MockProcessThread : public ProcessThread {
   MOCK_METHOD0(Start, void());
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD1(WakeUp, void(Module* module));
-  MOCK_METHOD1(PostTask, void(ProcessTask* task));
+  MOCK_METHOD1(PostTask, void(rtc::QueuedTask* task));
   MOCK_METHOD1(RegisterModule, void(Module* module));
   MOCK_METHOD1(DeRegisterModule, void(Module* module));
 
   // MOCK_METHOD1 gets confused with mocking this method, so we work around it
   // by overriding the method from the interface and forwarding the call to a
   // mocked, simpler method.
-  void PostTask(std::unique_ptr<ProcessTask> task) /* override */ {
+  void PostTask(std::unique_ptr<rtc::QueuedTask> task) /*override*/ {
     PostTask(task.get());
   }
 };

webrtc/modules/utility/include/process_thread.h

@@ -15,17 +15,23 @@
 
 #include "webrtc/typedefs.h"
 
+#if defined(WEBRTC_WIN)
+// Due to a bug in the std::unique_ptr implementation that ships with MSVS,
+// we need the full definition of QueuedTask, on Windows.
+#include "webrtc/base/task_queue.h"
+#else
+namespace rtc {
+class QueuedTask;
+}
+#endif
+
 namespace webrtc {
 class Module;
 
-class ProcessTask {
- public:
-  ProcessTask() {}
-  virtual ~ProcessTask() {}
-
-  virtual void Run() = 0;
-};
-
+// TODO(tommi): ProcessThread probably doesn't need to be a virtual
+// interface.  There exists one override besides ProcessThreadImpl,
+// MockProcessThread, but when looking at how it is used, it seems
+// a nullptr might suffice (or simply an actual ProcessThread instance).
 class ProcessThread {
  public:
   virtual ~ProcessThread();
@@ -51,7 +57,7 @@ class ProcessThread {
   // construction thread of the ProcessThread instance, if the task did not
   // get a chance to run (e.g. posting the task while shutting down or when
   // the thread never runs).
-  virtual void PostTask(std::unique_ptr<ProcessTask> task) = 0;
+  virtual void PostTask(std::unique_ptr<rtc::QueuedTask> task) = 0;
 
   // Adds a module that will start to receive callbacks on the worker thread.
   // Can be called from any thread.

webrtc/modules/utility/source/process_thread_impl.cc

@@ -11,6 +11,7 @@
 #include "webrtc/modules/utility/source/process_thread_impl.h"
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/task_queue.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/modules/include/module.h"
 #include "webrtc/system_wrappers/include/logging.h"
@@ -119,7 +120,7 @@ void ProcessThreadImpl::WakeUp(Module* module) {
   wake_up_->Set();
 }
 
-void ProcessThreadImpl::PostTask(std::unique_ptr<ProcessTask> task) {
+void ProcessThreadImpl::PostTask(std::unique_ptr<rtc::QueuedTask> task) {
   // Allowed to be called on any thread.
   {
     rtc::CritScope lock(&lock_);
@@ -218,7 +219,7 @@ bool ProcessThreadImpl::Process() {
     }
 
     while (!queue_.empty()) {
-      ProcessTask* task = queue_.front();
+      rtc::QueuedTask* task = queue_.front();
       queue_.pop();
       lock_.Leave();
       task->Run();

webrtc/modules/utility/source/process_thread_impl.h

@@ -33,7 +33,7 @@ class ProcessThreadImpl : public ProcessThread {
   void Stop() override;
 
   void WakeUp(Module* module) override;
-  void PostTask(std::unique_ptr<ProcessTask> task) override;
+  void PostTask(std::unique_ptr<rtc::QueuedTask> task) override;
 
   void RegisterModule(Module* module) override;
   void DeRegisterModule(Module* module) override;
@@ -75,8 +75,7 @@ class ProcessThreadImpl : public ProcessThread {
   std::unique_ptr<rtc::PlatformThread> thread_;
 
   ModuleList modules_;
-  // TODO(tommi): Support delayed tasks.
-  std::queue<ProcessTask*> queue_;
+  std::queue<rtc::QueuedTask*> queue_;
   bool stop_;
   const char* thread_name_;
 };

webrtc/modules/utility/source/process_thread_impl_unittest.cc

@@ -13,6 +13,7 @@
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/task_queue.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/modules/include/module.h"
 #include "webrtc/modules/utility/source/process_thread_impl.h"
@@ -33,10 +34,13 @@ class MockModule : public Module {
   MOCK_METHOD1(ProcessThreadAttached, void(ProcessThread*));
 };
 
-class RaiseEventTask : public ProcessTask {
+class RaiseEventTask : public rtc::QueuedTask {
  public:
   RaiseEventTask(EventWrapper* event) : event_(event) {}
-  void Run() override { event_->Set(); }
+  bool Run() override {
+    event_->Set();
+    return true;
+  }
 
  private:
   EventWrapper* event_;

webrtc/modules/utility/utility.gypi

@@ -14,6 +14,7 @@
       'dependencies': [
         'audio_coding_module',
         'media_file',
+        '<(webrtc_root)/base/base.gyp:rtc_task_queue',
         '<(webrtc_root)/common_audio/common_audio.gyp:common_audio',
         '<(webrtc_root)/system_wrappers/system_wrappers.gyp:system_wrappers',
       ],

webrtc/modules/video_coding/jitter_buffer_unittest.cc

@@ -195,7 +195,7 @@ class ProcessThreadMock : public ProcessThread {
   MOCK_METHOD1(WakeUp, void(Module* module));
   MOCK_METHOD1(RegisterModule, void(Module* module));
   MOCK_METHOD1(DeRegisterModule, void(Module* module));
-  void PostTask(std::unique_ptr<ProcessTask> task) {}
+  void PostTask(std::unique_ptr<rtc::QueuedTask> task) /*override*/ {}
 };
 
 class TestBasicJitterBuffer : public ::testing::TestWithParam<std::string>,