Virtualize The Existence of a Scheduler Worker Thread

base/task_scheduler/scheduler_worker_thread_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_thread.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
@@ skipping 23 matching lines @@
       : main_entry_called_(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED),
         num_get_work_cv_(lock_.CreateConditionVariable()),
         worker_thread_set_(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED) {}
 
   void SetUp() override {
     worker_thread_ = SchedulerWorkerThread::Create(
         ThreadPriority::NORMAL,
         WrapUnique(new TestSchedulerWorkerThreadDelegate(this)),
-        &task_tracker_);
+        &task_tracker_,
+        SchedulerWorkerThread::InitialWorkerState::ALIVE);
     ASSERT_TRUE(worker_thread_);
     worker_thread_set_.Signal();
     main_entry_called_.Wait();
   }
 
   void TearDown() override {
     worker_thread_->JoinForTesting();
   }
 
   size_t TasksPerSequence() const { return GetParam(); }
@@ skipping 110 matching lines @@
       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());
     }
 
     TimeDelta GetSleepTimeout() override {
       return TimeDelta::Max();
     }
 
+    bool CanDetach(SchedulerWorkerThread* worker_thread) override {
+      return false;
+    }
+
    private:
     TaskSchedulerWorkerThreadTest* outer_;
   };
 
   void RunTaskCallback() {
     AutoSchedulerLock auto_lock(lock_);
     ++num_run_tasks_;
     EXPECT_LE(num_run_tasks_, created_sequences_.size());
   }
 
@@ skipping 94 matching lines @@
   }
 }
 
 INSTANTIATE_TEST_CASE_P(OneTaskPerSequence,
                         TaskSchedulerWorkerThreadTest,
                         ::testing::Values(1));
 INSTANTIATE_TEST_CASE_P(TwoTasksPerSequence,
                         TaskSchedulerWorkerThreadTest,
                         ::testing::Values(2));
 
+namespace {
+
+class ControllableDetachDelegate : public SchedulerWorkerThread::Delegate {
+ public:
+  ControllableDetachDelegate()
+      : work_requested_(false),
+        can_detach_(false),
+        work_processed_(WaitableEvent::ResetPolicy::MANUAL,
+                        WaitableEvent::InitialState::NOT_SIGNALED),
+        detach_requested_(WaitableEvent::ResetPolicy::MANUAL,
+                          WaitableEvent::InitialState::NOT_SIGNALED) {}
+
+  ~ControllableDetachDelegate() override = default;
+
+  // SchedulerWorkerThread::Delegate:
+  void OnMainEntry(SchedulerWorkerThread* worker_thread) override {}
+
+  scoped_refptr<Sequence> GetWork(SchedulerWorkerThread* worker_thread)
+      override {
+    if (work_requested_)
+      return nullptr;
+
+    work_requested_ = true;
+    scoped_refptr<Sequence> sequence(new Sequence);
+    std::unique_ptr<Task> task(new Task(
+        FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&work_processed_)),
+        TaskTraits(), TimeDelta()));
+    sequence->PushTask(std::move(task));
+    return sequence;
+  }
+
+  void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
+    NOTREACHED() <<
+        "GetWork() never returns a sequence so there's nothing to reenqueue.";
+  }
+
+  TimeDelta GetSleepTimeout() override {
+    return TimeDelta::Max();
+  }
+
+  bool CanDetach(SchedulerWorkerThread* worker_thread) override {
+    detach_requested_.Signal();
+    return can_detach_;
+  }
+
+  void WaitForWorkToRun() {
+    work_processed_.Wait();
+  }
+
+  void WaitForDetachRequest() {
+    detach_requested_.Wait();
+  }
+
+  void ResetAll() {
+    work_requested_ = false;
+    work_processed_.Reset();
+    detach_requested_.Reset();
+  }
+
+  void set_can_detach(bool can_detach) { can_detach_ = can_detach; }
+
+ private:
+  bool work_requested_;
+  bool can_detach_;
+  WaitableEvent work_processed_;
+  WaitableEvent detach_requested_;
+
+  DISALLOW_COPY_AND_ASSIGN(ControllableDetachDelegate);
+};
+
+}  // namespace
+
+TEST(TaskSchedulerWorkerThreadTest, WorkerDetaches) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorkerThread.
+  ControllableDetachDelegate* delegate = new ControllableDetachDelegate;
+  delegate->set_can_detach(true);
+  std::unique_ptr<SchedulerWorkerThread> worker_thread =
+      SchedulerWorkerThread::Create(
+          ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
+          SchedulerWorkerThread::InitialWorkerState::ALIVE);
+  worker_thread->WakeUp();
+  delegate->WaitForWorkToRun();
+  delegate->WaitForDetachRequest();
+  // Sleep to give a chance for the detach to happen. A yield is too short.
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
+  ASSERT_FALSE(worker_thread->WorkerAliveForTesting());
+}
+
+TEST(TaskSchedulerWorkerThreadTest, WorkerDetachesAndWakes) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorkerThread.
+  ControllableDetachDelegate* delegate = new ControllableDetachDelegate;
+  delegate->set_can_detach(true);
+  std::unique_ptr<SchedulerWorkerThread> worker_thread =
+      SchedulerWorkerThread::Create(
+          ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
+          SchedulerWorkerThread::InitialWorkerState::ALIVE);
+  worker_thread->WakeUp();
+  delegate->WaitForWorkToRun();
+  delegate->WaitForDetachRequest();
+  // Sleep to give a chance for the detach to happen. A yield is too short.
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
+  ASSERT_FALSE(worker_thread->WorkerAliveForTesting());
+
+  delegate->ResetAll();
+  delegate->set_can_detach(false);
+  worker_thread->WakeUp();
+  delegate->WaitForWorkToRun();
+  delegate->WaitForDetachRequest();
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
+  ASSERT_TRUE(worker_thread->WorkerAliveForTesting());
+  worker_thread->JoinForTesting();
+}
+
+TEST(TaskSchedulerWorkerThreadTest, CreateDetached) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorkerThread.
+  ControllableDetachDelegate* delegate = new ControllableDetachDelegate;
+  std::unique_ptr<SchedulerWorkerThread> worker_thread =
+      SchedulerWorkerThread::Create(
+          ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
+          SchedulerWorkerThread::InitialWorkerState::DETACHED);
+  ASSERT_FALSE(worker_thread->WorkerAliveForTesting());
+  worker_thread->WakeUp();
+  delegate->WaitForWorkToRun();
+  delegate->WaitForDetachRequest();
+  ASSERT_TRUE(worker_thread->WorkerAliveForTesting());
+  worker_thread->JoinForTesting();
+}
+
 }  // namespace
 }  // namespace internal
 }  // namespace base