TaskScheduler: Make SchedulerWorkerThread own its delegate.

base/task_scheduler/scheduler_worker_thread_unittest.cc

Index: base/task_scheduler/scheduler_worker_thread_unittest.cc
diff --git a/base/task_scheduler/scheduler_worker_thread_unittest.cc b/base/task_scheduler/scheduler_worker_thread_unittest.cc
index dd414d0a6426ad0f9e6f9a3484c8910cc6cdf5bd..9e9e28862572ead1422520821f43215291440082 100644
--- a/base/task_scheduler/scheduler_worker_thread_unittest.cc
+++ b/base/task_scheduler/scheduler_worker_thread_unittest.cc
@@ -27,16 +27,17 @@ namespace {
 const size_t kNumSequencesPerTest = 150;
 
 // The test parameter is the number of Tasks per Sequence returned by GetWork().
-class TaskSchedulerWorkerThreadTest : public testing::TestWithParam<size_t>,
-                                      public SchedulerWorkerThread::Delegate {
+class TaskSchedulerWorkerThreadTest : public testing::TestWithParam<size_t> {
  protected:
   TaskSchedulerWorkerThreadTest()
       : main_entry_called_(true, false),
         num_get_work_cv_(lock_.CreateConditionVariable()) {}
 
   void SetUp() override {
-    worker_thread_ = SchedulerWorkerThread::CreateSchedulerWorkerThread(
-        ThreadPriority::NORMAL, this, &task_tracker_);
+    worker_thread_ = SchedulerWorkerThread::Create(
+        ThreadPriority::NORMAL,
+        WrapUnique(new TestSchedulerWorkerThreadDelegate(this)),
+        &task_tracker_);
     ASSERT_TRUE(worker_thread_);
     main_entry_called_.Wait();
   }
@@ -83,74 +84,85 @@ class TaskSchedulerWorkerThreadTest : public testing::TestWithParam<size_t>,
   std::unique_ptr<SchedulerWorkerThread> worker_thread_;
 
  private:
-  // SchedulerWorkerThread::Delegate:
-  void OnMainEntry() override {
-    // Without this |auto_lock|, OnMainEntry() could be called twice without
-    // generating an error.
-    AutoSchedulerLock auto_lock(lock_);
-    EXPECT_FALSE(main_entry_called_.IsSignaled());
-    main_entry_called_.Signal();
-  }
-
-  scoped_refptr<Sequence> GetWork(
-      SchedulerWorkerThread* worker_thread) override {
-    EXPECT_EQ(worker_thread_.get(), worker_thread);
-
-    {
-      AutoSchedulerLock auto_lock(lock_);
-
-      // Increment the number of times that this method has been called.
-      ++num_get_work_;
-      num_get_work_cv_->Signal();
-
-      // Verify that this method isn't called more times than expected.
-      EXPECT_LE(num_get_work_, max_get_work_);
-
-      // Check if a Sequence should be returned.
-      if (num_sequences_to_create_ == 0)
-        return nullptr;
-      --num_sequences_to_create_;
+  class TestSchedulerWorkerThreadDelegate
+      : public SchedulerWorkerThread::Delegate {
+   public:
+    TestSchedulerWorkerThreadDelegate(TaskSchedulerWorkerThreadTest* outer)
+        : outer_(outer) {}
+
+    // SchedulerWorkerThread::Delegate:
+    void OnMainEntry() override {
+      // Without synchronization, OnMainEntry() could be called twice without
+      // generating an error.
+      AutoSchedulerLock auto_lock(outer_->lock_);
+      EXPECT_FALSE(outer_->main_entry_called_.IsSignaled());
+      outer_->main_entry_called_.Signal();
     }
 
-    // Create a Sequence with TasksPerSequence() Tasks.
-    scoped_refptr<Sequence> sequence(new Sequence);
-    for (size_t i = 0; i < TasksPerSequence(); ++i) {
-      std::unique_ptr<Task> task(new Task(
-          FROM_HERE, Bind(&TaskSchedulerWorkerThreadTest::RunTaskCallback,
-                          Unretained(this)),
-          TaskTraits(), TimeTicks()));
-      EXPECT_TRUE(task_tracker_.WillPostTask(task.get()));
-      sequence->PushTask(std::move(task));
+    scoped_refptr<Sequence> GetWork(
+        SchedulerWorkerThread* worker_thread) override {
+      EXPECT_EQ(outer_->worker_thread_.get(), worker_thread);
+
+      {
+        AutoSchedulerLock auto_lock(outer_->lock_);
+
+        // Increment the number of times that this method has been called.
+        ++outer_->num_get_work_;
+        outer_->num_get_work_cv_->Signal();
+
+        // Verify that this method isn't called more times than expected.
+        EXPECT_LE(outer_->num_get_work_, outer_->max_get_work_);
+
+        // Check if a Sequence should be returned.
+        if (outer_->num_sequences_to_create_ == 0)
+          return nullptr;
+        --outer_->num_sequences_to_create_;
+      }
+
+      // Create a Sequence with TasksPerSequence() Tasks.
+      scoped_refptr<Sequence> sequence(new Sequence);
+      for (size_t i = 0; i < outer_->TasksPerSequence(); ++i) {
+        std::unique_ptr<Task> task(new Task(
+            FROM_HERE, Bind(&TaskSchedulerWorkerThreadTest::RunTaskCallback,
+                            Unretained(outer_)),
+            TaskTraits(), TimeTicks()));
+        EXPECT_TRUE(outer_->task_tracker_.WillPostTask(task.get()));
+        sequence->PushTask(std::move(task));
+      }
+
+      {
+        // Add the Sequence to the vector of created Sequences.
+        AutoSchedulerLock auto_lock(outer_->lock_);
+        outer_->created_sequences_.push_back(sequence);
+      }
+
+      return sequence;
     }
 
-    {
-      // Add the Sequence to the vector of created Sequences.
-      AutoSchedulerLock auto_lock(lock_);
-      created_sequences_.push_back(sequence);
+    // This override verifies that |sequence| contains the expected number of
+    // Tasks and adds it to |enqueued_sequences_|. Unlike a normal
+    // EnqueueSequence implementation, it doesn't reinsert |sequence| into a
+    // queue for further execution.
+    void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
+      EXPECT_GT(outer_->TasksPerSequence(), 1U);
+
+      // Verify that |sequence| contains TasksPerSequence() - 1 Tasks.
+      for (size_t i = 0; i < outer_->TasksPerSequence() - 1; ++i) {
+        EXPECT_TRUE(sequence->PeekTask());
+        sequence->PopTask();
+      }
+      EXPECT_FALSE(sequence->PeekTask());
+
+      // Add |sequence| to |re_enqueued_sequences_|.
+      AutoSchedulerLock auto_lock(outer_->lock_);
+      outer_->re_enqueued_sequences_.push_back(std::move(sequence));
+      EXPECT_LE(outer_->re_enqueued_sequences_.size(),
+                outer_->created_sequences_.size());
     }
 
-    return sequence;
-  }
-
-  // This override verifies that |sequence| contains the expected number of
-  // Tasks and adds it to |re_enqueued_sequences_|. Unlike a normal
-  // ReEnqueueSequence implementation, it doesn't reinsert |sequence| into a
-  // queue for further execution.
-  void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
-    EXPECT_GT(TasksPerSequence(), 1U);
-
-    // Verify that |sequence| contains TasksPerSequence() - 1 Tasks.
-    for (size_t i = 0; i < TasksPerSequence() - 1; ++i) {
-      EXPECT_TRUE(sequence->PeekTask());
-      sequence->PopTask();
-    }
-    EXPECT_FALSE(sequence->PeekTask());
-
-    // Add |sequence| to |re_enqueued_sequences_|.
-    AutoSchedulerLock auto_lock(lock_);
-    re_enqueued_sequences_.push_back(std::move(sequence));
-    EXPECT_LE(re_enqueued_sequences_.size(), created_sequences_.size());
-  }
+   private:
+    TaskSchedulerWorkerThreadTest* outer_;
+  };
 
   void RunTaskCallback() {
     AutoSchedulerLock auto_lock(lock_);