Support FileDescriptorWatcher in TaskScheduler.

base/task_scheduler/scheduler_worker_unittest.cc

Index: base/task_scheduler/scheduler_worker_unittest.cc
diff --git a/base/task_scheduler/scheduler_worker_unittest.cc b/base/task_scheduler/scheduler_worker_unittest.cc
index 0d29bcd16c5bd46215e41eb2e9004fbe6db0267c..2838999ce768e0af19f4f82b46582a7f59f09d41 100644
--- a/base/task_scheduler/scheduler_worker_unittest.cc
+++ b/base/task_scheduler/scheduler_worker_unittest.cc
@@ -13,6 +13,7 @@
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/scheduler_lock.h"
@@ -61,14 +62,19 @@ class SchedulerWorkerDefaultDelegate : public SchedulerWorker::Delegate {
 };
 
 // The test parameter is the number of Tasks per Sequence returned by GetWork().
-class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
+class TaskSchedulerWorkerDoWorkTest : public testing::TestWithParam<size_t> {
  protected:
-  TaskSchedulerWorkerTest()
-      : main_entry_called_(WaitableEvent::ResetPolicy::MANUAL,
+  TaskSchedulerWorkerDoWorkTest()
+      :
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+        task_tracker_(&watch_file_descriptor_message_loop_),
+#endif
+        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) {}
+                    WaitableEvent::InitialState::NOT_SIGNALED) {
+  }
 
   void SetUp() override {
     worker_ = SchedulerWorker::Create(
@@ -123,7 +129,7 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
  private:
   class TestSchedulerWorkerDelegate : public SchedulerWorkerDefaultDelegate {
    public:
-    TestSchedulerWorkerDelegate(TaskSchedulerWorkerTest* outer)
+    TestSchedulerWorkerDelegate(TaskSchedulerWorkerDoWorkTest* outer)
         : outer_(outer) {}
 
     ~TestSchedulerWorkerDelegate() override {
@@ -168,7 +174,7 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
       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(&TaskSchedulerWorkerTest::RunTaskCallback,
+            FROM_HERE, Bind(&TaskSchedulerWorkerDoWorkTest::RunTaskCallback,
                             Unretained(outer_)),
             TaskTraits(), TimeDelta()));
         EXPECT_TRUE(outer_->task_tracker_.WillPostTask(task.get()));
@@ -230,7 +236,7 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
       return expect_did_run_task_with_priority_;
     }
 
-    TaskSchedulerWorkerTest* outer_;
+    TaskSchedulerWorkerDoWorkTest* const outer_;
 
     // Synchronizes access to |expect_did_run_task_with_priority_| and
     // |expected_task_priority_|.
@@ -250,6 +256,12 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
     EXPECT_LE(num_run_tasks_, created_sequences_.size());
   }
 
+ private:
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+  MessageLoopForIO watch_file_descriptor_message_loop_;
+#endif
+
+ protected:
   TaskTracker task_tracker_;
 
   // Synchronizes access to all members below.
@@ -283,12 +295,12 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
   // Signaled after |worker_| is set.
   WaitableEvent worker_set_;
 
-  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerTest);
+  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerDoWorkTest);
 };
 
 // Verify that when GetWork() continuously returns Sequences, all Tasks in these
 // Sequences run successfully. The test wakes up the SchedulerWorker once.
-TEST_P(TaskSchedulerWorkerTest, ContinuousWork) {
+TEST_P(TaskSchedulerWorkerDoWorkTest, ContinuousWork) {
   // Set GetWork() to return |kNumSequencesPerTest| Sequences before starting to
   // return nullptr.
   SetNumSequencesToCreate(kNumSequencesPerTest);
@@ -318,7 +330,7 @@ TEST_P(TaskSchedulerWorkerTest, ContinuousWork) {
 // Verify that when GetWork() alternates between returning a Sequence and
 // returning nullptr, all Tasks in the returned Sequences run successfully. The
 // test wakes up the SchedulerWorker once for each Sequence.
-TEST_P(TaskSchedulerWorkerTest, IntermittentWork) {
+TEST_P(TaskSchedulerWorkerDoWorkTest, IntermittentWork) {
   for (size_t i = 0; i < kNumSequencesPerTest; ++i) {
     // Set GetWork() to return 1 Sequence before starting to return
     // nullptr.
@@ -348,10 +360,10 @@ TEST_P(TaskSchedulerWorkerTest, IntermittentWork) {
 }
 
 INSTANTIATE_TEST_CASE_P(OneTaskPerSequence,
-                        TaskSchedulerWorkerTest,
+                        TaskSchedulerWorkerDoWorkTest,
                         ::testing::Values(1));
 INSTANTIATE_TEST_CASE_P(TwoTasksPerSequence,
-                        TaskSchedulerWorkerTest,
+                        TaskSchedulerWorkerDoWorkTest,
                         ::testing::Values(2));
 
 namespace {
@@ -424,19 +436,38 @@ class ControllableDetachDelegate : public SchedulerWorkerDefaultDelegate {
   DISALLOW_COPY_AND_ASSIGN(ControllableDetachDelegate);
 };
 
+class TaskSchedulerWorkerTest : public testing::Test {
+ public:
+  TaskSchedulerWorkerTest()
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+      : task_tracker_(&service_message_loop_)
+#endif
+  {
+  }
+
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+ private:
+  MessageLoopForIO service_message_loop_;
+#endif
+
+ protected:
+  TaskTracker task_tracker_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerTest);
+};
+
 }  // namespace
 
-TEST(TaskSchedulerWorkerTest, WorkerDetaches) {
-  TaskTracker task_tracker;
+TEST_F(TaskSchedulerWorkerTest, WorkerDetaches) {
   // Will be owned by SchedulerWorker.
   ControllableDetachDelegate* delegate =
-      new StrictMock<ControllableDetachDelegate>(&task_tracker);
+      new StrictMock<ControllableDetachDelegate>(&task_tracker_);
   delegate->set_can_detach(true);
   EXPECT_CALL(*delegate, OnMainEntry(_, TimeDelta::Max()));
-  std::unique_ptr<SchedulerWorker> worker =
-      SchedulerWorker::Create(
-          ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
-          SchedulerWorker::InitialState::ALIVE);
+  std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker_,
+      SchedulerWorker::InitialState::ALIVE);
   worker->WakeUp();
   delegate->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
@@ -446,17 +477,15 @@ TEST(TaskSchedulerWorkerTest, WorkerDetaches) {
   ASSERT_FALSE(worker->ThreadAliveForTesting());
 }
 
-TEST(TaskSchedulerWorkerTest, WorkerDetachesAndWakes) {
-  TaskTracker task_tracker;
+TEST_F(TaskSchedulerWorkerTest, WorkerDetachesAndWakes) {
   // Will be owned by SchedulerWorker.
   ControllableDetachDelegate* delegate =
-      new StrictMock<ControllableDetachDelegate>(&task_tracker);
+      new StrictMock<ControllableDetachDelegate>(&task_tracker_);
   delegate->set_can_detach(true);
   EXPECT_CALL(*delegate, OnMainEntry(_, TimeDelta::Max()));
-  std::unique_ptr<SchedulerWorker> worker =
-      SchedulerWorker::Create(
-          ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
-          SchedulerWorker::InitialState::ALIVE);
+  std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker_,
+      SchedulerWorker::InitialState::ALIVE);
   worker->WakeUp();
   delegate->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
@@ -479,15 +508,13 @@ TEST(TaskSchedulerWorkerTest, WorkerDetachesAndWakes) {
   worker->JoinForTesting();
 }
 
-TEST(TaskSchedulerWorkerTest, CreateDetached) {
-  TaskTracker task_tracker;
+TEST_F(TaskSchedulerWorkerTest, CreateDetached) {
   // Will be owned by SchedulerWorker.
   ControllableDetachDelegate* delegate =
-      new StrictMock<ControllableDetachDelegate>(&task_tracker);
-  std::unique_ptr<SchedulerWorker> worker =
-      SchedulerWorker::Create(
-          ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
-          SchedulerWorker::InitialState::DETACHED);
+      new StrictMock<ControllableDetachDelegate>(&task_tracker_);
+  std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker_,
+      SchedulerWorker::InitialState::DETACHED);
   ASSERT_FALSE(worker->ThreadAliveForTesting());
   EXPECT_CALL(*delegate, OnMainEntry(worker.get(), TimeDelta::Max()));
   worker->WakeUp();
@@ -548,9 +575,7 @@ class ExpectThreadPriorityDelegate : public SchedulerWorkerDefaultDelegate {
 
 }  // namespace
 
-TEST(TaskSchedulerWorkerTest, BumpPriorityOfAliveThreadDuringShutdown) {
-  TaskTracker task_tracker;
-
+TEST_F(TaskSchedulerWorkerTest, BumpPriorityOfAliveThreadDuringShutdown) {
   std::unique_ptr<ExpectThreadPriorityDelegate> delegate(
       new ExpectThreadPriorityDelegate);
   ExpectThreadPriorityDelegate* delegate_raw = delegate.get();
@@ -560,7 +585,7 @@ TEST(TaskSchedulerWorkerTest, BumpPriorityOfAliveThreadDuringShutdown) {
           : ThreadPriority::NORMAL);
 
   std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker,
+      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker_,
       SchedulerWorker::InitialState::ALIVE);
 
   // Verify that the initial thread priority is BACKGROUND (or NORMAL if thread
@@ -570,16 +595,14 @@ TEST(TaskSchedulerWorkerTest, BumpPriorityOfAliveThreadDuringShutdown) {
 
   // Verify that the thread priority is bumped to NORMAL during shutdown.
   delegate_raw->SetExpectedThreadPriority(ThreadPriority::NORMAL);
-  task_tracker.SetHasShutdownStartedForTesting();
+  task_tracker_.SetHasShutdownStartedForTesting();
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   worker->JoinForTesting();
 }
 
-TEST(TaskSchedulerWorkerTest, BumpPriorityOfDetachedThreadDuringShutdown) {
-  TaskTracker task_tracker;
-
+TEST_F(TaskSchedulerWorkerTest, BumpPriorityOfDetachedThreadDuringShutdown) {
   std::unique_ptr<ExpectThreadPriorityDelegate> delegate(
       new ExpectThreadPriorityDelegate);
   ExpectThreadPriorityDelegate* delegate_raw = delegate.get();
@@ -587,11 +610,11 @@ TEST(TaskSchedulerWorkerTest, BumpPriorityOfDetachedThreadDuringShutdown) {
 
   // Create a DETACHED thread.
   std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
-      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker,
+      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker_,
       SchedulerWorker::InitialState::DETACHED);
 
   // Pretend that shutdown has started.
-  task_tracker.SetHasShutdownStartedForTesting();
+  task_tracker_.SetHasShutdownStartedForTesting();
 
   // Wake up the thread and verify that its priority is NORMAL when
   // OnMainEntry() and GetWork() are called.