Support FileDescriptorWatcher in TaskScheduler.

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>
 
 #include "base/bind.h"
 #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"
 #include "base/task_scheduler/sequence.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_tracker.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 28 matching lines @@
     ADD_FAILURE() << "Unexpected call to ReEnqueueSequence()";
   }
   TimeDelta GetSleepTimeout() override { return TimeDelta::Max(); }
   bool CanDetach(SchedulerWorker* worker) override { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerDefaultDelegate);
 };
 
 // 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(
         ThreadPriority::NORMAL, MakeUnique<TestSchedulerWorkerDelegate>(this),
         &task_tracker_, SchedulerWorker::InitialState::ALIVE);
     ASSERT_TRUE(worker_);
     worker_set_.Signal();
     main_entry_called_.Wait();
   }
 
@@ skipping 34 matching lines @@
   std::vector<scoped_refptr<Sequence>> EnqueuedSequences() {
     AutoSchedulerLock auto_lock(lock_);
     return re_enqueued_sequences_;
   }
 
   std::unique_ptr<SchedulerWorker> worker_;
 
  private:
   class TestSchedulerWorkerDelegate : public SchedulerWorkerDefaultDelegate {
    public:
-    TestSchedulerWorkerDelegate(TaskSchedulerWorkerTest* outer)
+    TestSchedulerWorkerDelegate(TaskSchedulerWorkerDoWorkTest* outer)
         : outer_(outer) {}
 
     ~TestSchedulerWorkerDelegate() override {
       EXPECT_FALSE(IsCallToDidRunTaskWithPriorityExpected());
     }
 
     // SchedulerWorker::Delegate:
     void OnMainEntry(SchedulerWorker* worker,
                      const TimeDelta& detach_duration) override {
       outer_->worker_set_.Wait();
@@ skipping 24 matching lines @@
         // 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(&TaskSchedulerWorkerTest::RunTaskCallback,
+            FROM_HERE, Bind(&TaskSchedulerWorkerDoWorkTest::RunTaskCallback,
                             Unretained(outer_)),
             TaskTraits(), TimeDelta()));
         EXPECT_TRUE(outer_->task_tracker_.WillPostTask(task.get()));
         sequence->PushTask(std::move(task));
       }
 
       ExpectCallToDidRunTaskWithPriority(sequence->PeekTaskTraits().priority());
 
       {
         // Add the Sequence to the vector of created Sequences.
@@ skipping 41 matching lines @@
       AutoSchedulerLock auto_lock(expect_did_run_task_with_priority_lock_);
       expect_did_run_task_with_priority_ = true;
       expected_task_priority_ = task_priority;
     }
 
     bool IsCallToDidRunTaskWithPriorityExpected() const {
       AutoSchedulerLock auto_lock(expect_did_run_task_with_priority_lock_);
       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_|.
     mutable SchedulerLock expect_did_run_task_with_priority_lock_;
 
     // Whether the next method called on this delegate should be
     // DidRunTaskWithPriority().
     bool expect_did_run_task_with_priority_ = false;
 
     // Expected priority for the next call to DidRunTaskWithPriority().
     TaskPriority expected_task_priority_ = TaskPriority::BACKGROUND;
   };
 
   void RunTaskCallback() {
     AutoSchedulerLock auto_lock(lock_);
     ++num_run_tasks_;
     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.
   mutable SchedulerLock lock_;
 
   // Signaled once OnMainEntry() has been called.
   WaitableEvent main_entry_called_;
 
   // Number of Sequences that should be created by GetWork(). When this
   // is 0, GetWork() returns nullptr.
@@ skipping 13 matching lines @@
 
   // Sequences passed to EnqueueSequence().
   std::vector<scoped_refptr<Sequence>> re_enqueued_sequences_;
 
   // Number of times that RunTaskCallback() has been called.
   size_t num_run_tasks_ = 0;
 
   // 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);
 
   // Expect |kNumSequencesPerTest| calls to GetWork() in which it returns a
   // Sequence and one call in which its returns nullptr.
   const size_t kExpectedNumGetWork = kNumSequencesPerTest + 1;
   SetMaxGetWork(kExpectedNumGetWork);
 
   // Wake up |worker_| and wait until GetWork() has been invoked the
   // expected amount of times.
   worker_->WakeUp();
   WaitForNumGetWork(kExpectedNumGetWork);
 
   // All tasks should have run.
   EXPECT_EQ(kNumSequencesPerTest, NumRunTasks());
 
   // If Sequences returned by GetWork() contain more than one Task, they aren't
   // empty after the worker pops Tasks from them and thus should be returned to
   // EnqueueSequence().
   if (TasksPerSequence() > 1)
     EXPECT_EQ(CreatedSequences(), EnqueuedSequences());
   else
     EXPECT_TRUE(EnqueuedSequences().empty());
 }
 
 // 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.
     SetNumSequencesToCreate(1);
 
     // Expect |i + 1| calls to GetWork() in which it returns a Sequence and
     // |i + 1| calls in which it returns nullptr.
     const size_t expected_num_get_work = 2 * (i + 1);
     SetMaxGetWork(expected_num_get_work);
 
     // Wake up |worker_| and wait until GetWork() has been invoked
     // the expected amount of times.
     worker_->WakeUp();
     WaitForNumGetWork(expected_num_get_work);
 
     // The Task should have run
     EXPECT_EQ(i + 1, NumRunTasks());
 
     // If Sequences returned by GetWork() contain more than one Task, they
     // aren't empty after the worker pops Tasks from them and thus should be
     // returned to EnqueueSequence().
     if (TasksPerSequence() > 1)
       EXPECT_EQ(CreatedSequences(), EnqueuedSequences());
     else
       EXPECT_TRUE(EnqueuedSequences().empty());
   }
 }
 
 INSTANTIATE_TEST_CASE_P(OneTaskPerSequence,
-                        TaskSchedulerWorkerTest,
+                        TaskSchedulerWorkerDoWorkTest,
                         ::testing::Values(1));
 INSTANTIATE_TEST_CASE_P(TwoTasksPerSequence,
-                        TaskSchedulerWorkerTest,
+                        TaskSchedulerWorkerDoWorkTest,
                         ::testing::Values(2));
 
 namespace {
 
 class ControllableDetachDelegate : public SchedulerWorkerDefaultDelegate {
  public:
   ControllableDetachDelegate(TaskTracker* task_tracker)
       : task_tracker_(task_tracker),
         work_processed_(WaitableEvent::ResetPolicy::MANUAL,
                         WaitableEvent::InitialState::NOT_SIGNALED),
@@ skipping 52 matching lines @@
  private:
   TaskTracker* const task_tracker_;
   bool work_requested_ = false;
   bool can_detach_ = false;
   WaitableEvent work_processed_;
   WaitableEvent detach_requested_;
 
   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);
   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->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);
   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->ThreadAliveForTesting());
 
   delegate->ResetState();
   delegate->set_can_detach(false);
   // When SchedulerWorker recreates its thread, expect OnMainEntry() to be
   // called with a detach duration which is not TimeDelta::Max().
   EXPECT_CALL(*delegate, OnMainEntry(worker.get(), Ne(TimeDelta::Max())));
   worker->WakeUp();
   delegate->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   delegate->WaitForDetachRequest();
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   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();
   delegate->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   delegate->WaitForDetachRequest();
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   worker->JoinForTesting();
 }
 
@@ skipping 40 matching lines @@
   SchedulerLock expected_thread_priority_lock_;
 
   // Expected thread priority for the next call to OnMainEntry() or GetWork().
   ThreadPriority expected_thread_priority_;
 
   DISALLOW_COPY_AND_ASSIGN(ExpectThreadPriorityDelegate);
 };
 
 }  // namespace
 
-TEST(TaskSchedulerWorkerTest, BumpPriorityOfAliveThreadDuringShutdown) {
-  TaskTracker task_tracker;
-
+TEST_F(TaskSchedulerWorkerTest, BumpPriorityOfAliveThreadDuringShutdown) {
   std::unique_ptr<ExpectThreadPriorityDelegate> delegate(
       new ExpectThreadPriorityDelegate);
   ExpectThreadPriorityDelegate* delegate_raw = delegate.get();
   delegate_raw->SetExpectedThreadPriority(
       PlatformThread::CanIncreaseCurrentThreadPriority()
           ? ThreadPriority::BACKGROUND
           : 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
   // 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();
+  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();
   delegate_raw->SetExpectedThreadPriority(ThreadPriority::NORMAL);
 
   // 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.
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   worker->JoinForTesting();
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace base