Support FileDescriptorWatcher in TaskScheduler.

base/task_scheduler/scheduler_worker_pool_impl_unittest.cc

Index: base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
diff --git a/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc b/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
index fdfe41cd100e9b1d25109537dac2f3852f7c217f..cf82eda4dd551ed3f628e2060eb47c5f806261fe 100644
--- a/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
+++ b/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
@@ -17,6 +17,7 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
@@ -40,6 +41,7 @@
 #include "base/threading/thread_local_storage.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
@@ -79,23 +81,36 @@ class TaskSchedulerWorkerPoolImplTest
                             size_t num_workers) {
     ASSERT_FALSE(worker_pool_);
     ASSERT_FALSE(delayed_task_manager_);
-    service_thread_.Start();
+    constexpr MessageLoop::Type kServiceThreadMessageLoopType =
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+        MessageLoop::TYPE_IO;
+#else
+        MessageLoop::TYPE_DEFAULT;
+#endif
+    constexpr size_t kDefaultStackSize = 0;
+    ASSERT_TRUE(service_thread_.StartWithOptions(
+        Thread::Options(kServiceThreadMessageLoopType, kDefaultStackSize)));
+    task_tracker_ = MakeUnique<TaskTracker>(
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+        static_cast<MessageLoopForIO*>(service_thread_.message_loop())
+#endif
+            );
     delayed_task_manager_ =
-        base::MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
+        MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
     worker_pool_ = SchedulerWorkerPoolImpl::Create(
         SchedulerWorkerPoolParams("TestWorkerPool", ThreadPriority::NORMAL,
                                   IORestriction::ALLOWED, num_workers,
                                   suggested_reclaim_time),
         Bind(&TaskSchedulerWorkerPoolImplTest::ReEnqueueSequenceCallback,
              Unretained(this)),
-        &task_tracker_, delayed_task_manager_.get());
+        task_tracker_.get(), delayed_task_manager_.get());
     ASSERT_TRUE(worker_pool_);
   }
 
   std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool_;
 
-  TaskTracker task_tracker_;
   Thread service_thread_;
+  std::unique_ptr<TaskTracker> task_tracker_;
   std::unique_ptr<DelayedTaskManager> delayed_task_manager_;
 
  private:
@@ -298,7 +313,7 @@ TEST_P(TaskSchedulerWorkerPoolImplTest, Saturate) {
 TEST_P(TaskSchedulerWorkerPoolImplTest, PostTaskAfterShutdown) {
   auto task_runner =
       worker_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam());
-  task_tracker_.Shutdown();
+  task_tracker_->Shutdown();
   EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRunCallback)));
 }
 
@@ -404,9 +419,13 @@ class TaskSchedulerWorkerPoolImplIORestrictionTest
 }  // namespace
 
 TEST_P(TaskSchedulerWorkerPoolImplIORestrictionTest, IORestriction) {
-  TaskTracker task_tracker;
-  DelayedTaskManager delayed_task_manager(
-      make_scoped_refptr(new TestSimpleTaskRunner));
+  MessageLoopForIO service_message_loop;
+  TaskTracker task_tracker {
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+    &service_message_loop
+#endif
+  };
+  DelayedTaskManager delayed_task_manager(service_message_loop.task_runner());
 
   auto worker_pool = SchedulerWorkerPoolImpl::Create(
       SchedulerWorkerPoolParams("TestWorkerPoolWithParam",