Separate the create and start phases in SchedulerSingleThreadTaskRunnerManager.

base/task_scheduler/scheduler_worker_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/task_scheduler/scheduler_worker.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
@@ skipping 59 matching lines @@
 class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
  protected:
   TaskSchedulerWorkerTest()
       : main_entry_called_(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED),
         num_get_work_cv_(lock_.CreateConditionVariable()),
         worker_set_(WaitableEvent::ResetPolicy::MANUAL,
                     WaitableEvent::InitialState::NOT_SIGNALED) {}
 
   void SetUp() override {
-    worker_ = SchedulerWorker::Create(
+    worker_ = make_scoped_refptr(new SchedulerWorker(
         ThreadPriority::NORMAL, MakeUnique<TestSchedulerWorkerDelegate>(this),
-        &task_tracker_, SchedulerWorker::InitialState::ALIVE);
+        &task_tracker_));
     ASSERT_TRUE(worker_);
+    worker_->Start();
     worker_set_.Signal();
     main_entry_called_.Wait();
   }
 
   void TearDown() override {
     worker_->JoinForTesting();
   }
 
   size_t TasksPerSequence() const { return GetParam(); }
 
@@ skipping 289 matching lines @@
     void UnblockCanDetach() { can_detach_block_.Signal(); }
 
     void WaitForWorkToRun() { work_processed_.Wait(); }
 
     void WaitForDetachRequest() { detach_requested_.Wait(); }
 
     void WaitForDetach() { detached_.Wait(); }
 
     void WaitForDelegateDestroy() { destroyed_.Wait(); }
 
+    void set_expect_get_work(bool expect_get_work) {
+      expect_get_work_ = expect_get_work;
+    }
+
     void ResetState() {
       work_running_.Signal();
       work_processed_.Reset();
       detach_requested_.Reset();
       can_detach_block_.Signal();
       work_requested_ = false;
     }
 
     void set_can_detach(bool can_detach) { can_detach_ = can_detach; }
 
    private:
     friend class ControllableDetachDelegate;
     friend class RefCountedThreadSafe<Controls>;
     ~Controls() = default;
 
     WaitableEvent work_running_;
     WaitableEvent work_processed_;
     WaitableEvent detach_requested_;
     WaitableEvent detached_;
     WaitableEvent can_detach_block_;
     WaitableEvent destroyed_;
 
+    bool expect_get_work_ = true;
     bool can_detach_ = false;
     bool work_requested_ = false;
 
     DISALLOW_COPY_AND_ASSIGN(Controls);
   };
 
   ControllableDetachDelegate(TaskTracker* task_tracker)
       : task_tracker_(task_tracker), controls_(new Controls()) {}
 
   ~ControllableDetachDelegate() override { controls_->destroyed_.Signal(); }
 
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker)
       override {
+    EXPECT_TRUE(controls_->expect_get_work_);
+
     // Sends one item of work to signal |work_processed_|. On subsequent calls,
     // sends nullptr to indicate there's no more work to be done.
     if (controls_->work_requested_)
       return nullptr;
 
     controls_->work_requested_ = true;
     scoped_refptr<Sequence> sequence(new Sequence);
     std::unique_ptr<Task> task(new Task(
         FROM_HERE,
         Bind(
@@ skipping 56 matching lines @@
 
 TEST(TaskSchedulerWorkerTest, WorkerDetaches) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   MockedControllableDetachDelegate* delegate =
       new StrictMock<MockedControllableDetachDelegate>(&task_tracker);
   scoped_refptr<ControllableDetachDelegate::Controls> controls =
       delegate->controls();
   controls->set_can_detach(true);
   EXPECT_CALL(*delegate, OnMainEntry(_));
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker));
+  worker->Start();
   worker->WakeUp();
   controls->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   controls->WaitForDetachRequest();
   controls->WaitForDetach();
   ASSERT_FALSE(worker->ThreadAliveForTesting());
 }
 
 TEST(TaskSchedulerWorkerTest, WorkerCleanupBeforeDetach) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   // No mock here as that's reasonably covered by other tests and the delegate
   // may destroy on a different thread. Mocks aren't designed with that in mind.
   std::unique_ptr<ControllableDetachDelegate> delegate =
       MakeUnique<ControllableDetachDelegate>(&task_tracker);
   scoped_refptr<ControllableDetachDelegate::Controls> controls =
       delegate->controls();
 
   controls->set_can_detach(true);
   controls->MakeCanDetachBlock();
 
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  worker->Start();
   worker->WakeUp();
 
   controls->WaitForDetachRequest();
   worker->Cleanup();
   worker = nullptr;
   controls->UnblockCanDetach();
   controls->WaitForDelegateDestroy();
 }
 
 TEST(TaskSchedulerWorkerTest, WorkerCleanupAfterDetach) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   // No mock here as that's reasonably covered by other tests and the delegate
   // may destroy on a different thread. Mocks aren't designed with that in mind.
   std::unique_ptr<ControllableDetachDelegate> delegate =
       MakeUnique<ControllableDetachDelegate>(&task_tracker);
   scoped_refptr<ControllableDetachDelegate::Controls> controls =
       delegate->controls();
 
   controls->set_can_detach(true);
 
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  worker->Start();
   worker->WakeUp();
 
   controls->WaitForDetach();
   worker->Cleanup();
   worker = nullptr;
   controls->WaitForDelegateDestroy();
 }
 
 TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringWork) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   // No mock here as that's reasonably covered by other tests and the delegate
   // may destroy on a different thread. Mocks aren't designed with that in mind.
   std::unique_ptr<ControllableDetachDelegate> delegate =
       MakeUnique<ControllableDetachDelegate>(&task_tracker);
   scoped_refptr<ControllableDetachDelegate::Controls> controls =
       delegate->controls();
 
   controls->HaveWorkBlock();
 
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  worker->Start();
   worker->WakeUp();
 
   controls->WaitForWorkToRun();
   worker->Cleanup();
   worker = nullptr;
   controls->UnblockWork();
   controls->WaitForDelegateDestroy();
 }
 
 TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringWait) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   // No mock here as that's reasonably covered by other tests and the delegate
   // may destroy on a different thread. Mocks aren't designed with that in mind.
   std::unique_ptr<ControllableDetachDelegate> delegate =
       MakeUnique<ControllableDetachDelegate>(&task_tracker);
   scoped_refptr<ControllableDetachDelegate::Controls> controls =
       delegate->controls();
 
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  worker->Start();
   worker->WakeUp();
 
   controls->WaitForDetachRequest();
   worker->Cleanup();
   worker = nullptr;
   controls->WaitForDelegateDestroy();
 }
 
 TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringShutdown) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   // No mock here as that's reasonably covered by other tests and the delegate
   // may destroy on a different thread. Mocks aren't designed with that in mind.
   std::unique_ptr<ControllableDetachDelegate> delegate =
       MakeUnique<ControllableDetachDelegate>(&task_tracker);
   scoped_refptr<ControllableDetachDelegate::Controls> controls =
       delegate->controls();
 
   controls->HaveWorkBlock();
 
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  worker->Start();
   worker->WakeUp();
 
   controls->WaitForWorkToRun();
   task_tracker.Shutdown();
   worker->Cleanup();
   worker = nullptr;
   controls->UnblockWork();
   controls->WaitForDelegateDestroy();
 }
 
+// Verify that Start() is a no-op after Cleanup().
+TEST(TaskSchedulerWorkerTest, CleanupBeforeStart) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorker.
+  // No mock here as that's reasonably covered by other tests and the delegate
+  // may destroy on a different thread. Mocks aren't designed with that in mind.
+  std::unique_ptr<ControllableDetachDelegate> delegate =
+      MakeUnique<ControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+  controls->set_expect_get_work(false);
+
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+
+  worker->Cleanup();
+
+  worker->Start();
+  worker->WakeUp();
+
+  EXPECT_FALSE(worker->ThreadAliveForTesting());
+}
+
+// Verify that Start() is a no-op after JoinForTesting().
+TEST(TaskSchedulerWorkerTest, JoinForTestingBeforeStart) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorker.
+  // No mock here as that's reasonably covered by other tests and the delegate
+  // may destroy on a different thread. Mocks aren't designed with that in mind.
+  std::unique_ptr<ControllableDetachDelegate> delegate =
+      MakeUnique<ControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+  controls->set_expect_get_work(false);
+
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+
+  worker->JoinForTesting();
+
+  worker->Start();
+  worker->WakeUp();
+
+  EXPECT_FALSE(worker->ThreadAliveForTesting());
+}
+
 namespace {
 
 class CallJoinFromDifferentThread : public SimpleThread {
  public:
   CallJoinFromDifferentThread(SchedulerWorker* worker_to_join)
       : SimpleThread("SchedulerWorkerJoinThread"),
         worker_to_join_(worker_to_join),
         run_started_event_(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED) {}
 
@@ skipping 20 matching lines @@
   // No mock here as that's reasonably covered by other tests and the
   // delegate may destroy on a different thread. Mocks aren't designed with that
   // in mind.
   std::unique_ptr<ControllableDetachDelegate> delegate =
       MakeUnique<ControllableDetachDelegate>(&task_tracker);
   scoped_refptr<ControllableDetachDelegate::Controls> controls =
       delegate->controls();
 
   controls->HaveWorkBlock();
 
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  worker->Start();
   worker->WakeUp();
 
   controls->WaitForWorkToRun();
   CallJoinFromDifferentThread join_from_different_thread(worker.get());
   join_from_different_thread.Start();
   join_from_different_thread.WaitForRunToStart();
   // Sleep here to give the other thread a chance to call JoinForTesting().
   // Receiving a signal that Run() was called doesn't mean JoinForTesting() was
   // necessarily called, and we can't signal after JoinForTesting() as
   // JoinForTesting() blocks until we call UnblockWork().
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   worker->Cleanup();
   worker = nullptr;
   controls->UnblockWork();
   controls->WaitForDelegateDestroy();
   join_from_different_thread.Join();
 }
 
 TEST(TaskSchedulerWorkerTest, WorkerDetachesAndWakes) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   MockedControllableDetachDelegate* delegate =
       new StrictMock<MockedControllableDetachDelegate>(&task_tracker);
   scoped_refptr<ControllableDetachDelegate::Controls> controls =
       delegate->controls();
 
   controls->set_can_detach(true);
   EXPECT_CALL(*delegate, OnMainEntry(_));
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker));
+  worker->Start();
   worker->WakeUp();
   controls->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   controls->WaitForDetachRequest();
   controls->WaitForDetach();
   ASSERT_FALSE(worker->ThreadAliveForTesting());
 
   controls->ResetState();
   controls->set_can_detach(false);
   // Expect OnMainEntry() to be called when SchedulerWorker recreates its
   // thread.
   EXPECT_CALL(*delegate, OnMainEntry(worker.get()));
   worker->WakeUp();
   controls->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   controls->WaitForDetachRequest();
   controls->WaitForDetach();
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   worker->JoinForTesting();
 }
 
-TEST(TaskSchedulerWorkerTest, CreateDetached) {
+TEST(TaskSchedulerWorkerTest, StartDetached) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   MockedControllableDetachDelegate* delegate =
       new StrictMock<MockedControllableDetachDelegate>(&task_tracker);
   scoped_refptr<ControllableDetachDelegate::Controls> controls =
       delegate->controls();
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
-      SchedulerWorker::InitialState::DETACHED);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker));
+  worker->Start(SchedulerWorker::InitialState::DETACHED);
   ASSERT_FALSE(worker->ThreadAliveForTesting());
   EXPECT_CALL(*delegate, OnMainEntry(worker.get()));
   worker->WakeUp();
   controls->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   controls->WaitForDetachRequest();
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   worker->JoinForTesting();
 }
 
@@ skipping 48 matching lines @@
   TaskTracker task_tracker;
 
   std::unique_ptr<ExpectThreadPriorityDelegate> delegate(
       new ExpectThreadPriorityDelegate);
   ExpectThreadPriorityDelegate* delegate_raw = delegate.get();
   delegate_raw->SetExpectedThreadPriority(
       PlatformThread::CanIncreaseCurrentThreadPriority()
           ? ThreadPriority::BACKGROUND
           : ThreadPriority::NORMAL);
 
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker));
+  worker->Start();
 
   // Verify that the initial thread priority is BACKGROUND (or NORMAL if thread
   // priority can't be increased).
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   // Verify that the thread priority is bumped to NORMAL during shutdown.
   delegate_raw->SetExpectedThreadPriority(ThreadPriority::NORMAL);
   task_tracker.SetHasShutdownStartedForTesting();
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   worker->JoinForTesting();
 }
 
 TEST(TaskSchedulerWorkerTest, BumpPriorityOfDetachedThreadDuringShutdown) {
   TaskTracker task_tracker;
 
   std::unique_ptr<ExpectThreadPriorityDelegate> delegate(
       new ExpectThreadPriorityDelegate);
   ExpectThreadPriorityDelegate* delegate_raw = delegate.get();
   delegate_raw->SetExpectedThreadPriority(ThreadPriority::NORMAL);
 
   // Create a DETACHED thread.
-  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::DETACHED);
+  auto worker = make_scoped_refptr(new SchedulerWorker(
+      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker));
+  worker->Start(SchedulerWorker::InitialState::DETACHED);
 
   // Pretend that shutdown has started.
   task_tracker.SetHasShutdownStartedForTesting();
 
   // Wake up the thread and verify that its priority is NORMAL when
   // OnMainEntry() and GetWork() are called.
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   worker->JoinForTesting();
@@ skipping 34 matching lines @@
 
 }  // namespace
 
 TEST(TaskSchedulerWorkerTest, BackwardCompatibilityEnabled) {
   TaskTracker task_tracker;
   auto delegate = MakeUnique<CoInitializeDelegate>();
   CoInitializeDelegate* const delegate_raw = delegate.get();
 
   // Create a worker with backward compatibility ENABLED. Wake it up and wait
   // until GetWork() returns.
-  auto worker = SchedulerWorker::Create(
+  auto worker = make_scoped_refptr(new SchedulerWorker(
       ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE,
-      SchedulerBackwardCompatibility::INIT_COM_STA);
+      SchedulerBackwardCompatibility::INIT_COM_STA));
+  worker->Start();
   worker->WakeUp();
   delegate_raw->WaitUntilGetWorkReturned();
 
   // The call to CoInitializeEx() should have returned S_FALSE to indicate that
   // the COM library was already initialized on the thread.
   EXPECT_EQ(S_FALSE, delegate_raw->coinitialize_hresult());
 
   worker->JoinForTesting();
 }
 
 TEST(TaskSchedulerWorkerTest, BackwardCompatibilityDisabled) {
   TaskTracker task_tracker;
   auto delegate = MakeUnique<CoInitializeDelegate>();
   CoInitializeDelegate* const delegate_raw = delegate.get();
 
   // Create a worker with backward compatibility DISABLED. Wake it up and wait
   // until GetWork() returns.
-  auto worker = SchedulerWorker::Create(
+  auto worker = make_scoped_refptr(new SchedulerWorker(
       ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
-      SchedulerWorker::InitialState::ALIVE,
-      SchedulerBackwardCompatibility::DISABLED);
+      SchedulerBackwardCompatibility::DISABLED));
+  worker->Start();
   worker->WakeUp();
   delegate_raw->WaitUntilGetWorkReturned();
 
   // The call to CoInitializeEx() should have returned S_OK to indicate that the
   // COM library wasn't already initialized on the thread.
   EXPECT_EQ(S_OK, delegate_raw->coinitialize_hresult());
 
   worker->JoinForTesting();
 }
 
 #endif  // defined(OS_WIN)
 
 }  // namespace internal
 }  // namespace base