Support FileDescriptorWatcher in TaskScheduler.

base/task_scheduler/task_tracker.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/task_tracker.h"
 
 #include <limits>
 
 #include "base/callback.h"
 #include "base/debug/task_annotator.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequence_token.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+#include "base/files/file_descriptor_watcher_posix.h"
+#endif
+
 namespace base {
 namespace internal {
 
 namespace {
 
 // An immutable copy of a scheduler task's info required by tracing.
 class TaskTracingInfo : public trace_event::ConvertableToTraceFormat {
  public:
   TaskTracingInfo(const TaskTraits& task_traits,
                   ExecutionMode execution_mode,
@@ skipping 127 matching lines @@
   // modify-write) semantics however. For example, if two threads are racing to
   // call IncrementNumTasksBlockingShutdown() and StartShutdown() respectively,
   // either the first thread will win and the StartShutdown() call will see the
   // blocking task or the second thread will win and
   // IncrementNumTasksBlockingShutdown() will know that shutdown has started.
   subtle::Atomic32 bits_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(State);
 };
 
-TaskTracker::TaskTracker()
+TaskTracker::TaskTracker(
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+    MessageLoopForIO* watch_file_descriptor_message_loop
+#endif
+    )
     : state_(new State),
       flush_cv_(flush_lock_.CreateConditionVariable()),
-      shutdown_lock_(&flush_lock_) {}
+      shutdown_lock_(&flush_lock_)
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+      ,
+      watch_file_descriptor_message_loop_(watch_file_descriptor_message_loop)
+#endif
+{
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+  DCHECK(watch_file_descriptor_message_loop_);
+#endif
+}
 TaskTracker::~TaskTracker() = default;
 
 void TaskTracker::Shutdown() {
   PerformShutdown();
   DCHECK(IsShutdownComplete());
 
   // Unblock Flush() when shutdown completes.
   AutoSchedulerLock auto_lock(flush_lock_);
   flush_cv_->Signal();
 }
@@ skipping 32 matching lines @@
 
   if (can_run_task) {
     // All tasks run through here and the scheduler itself doesn't use
     // singletons. Therefore, it isn't necessary to reset the singleton allowed
     // bit after running the task.
     ThreadRestrictions::SetSingletonAllowed(
         task->traits.shutdown_behavior() !=
         TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);
 
     {
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
+      // Support FileDescriptorWatcher for the scope of the task.
+      FileDescriptorWatcher file_descriptor_watcher(
+          watch_file_descriptor_message_loop_);
+#endif
+
       // Set up SequenceToken as expected for the scope of the task.
       ScopedSetSequenceTokenForCurrentThread
           scoped_set_sequence_token_for_current_thread(sequence_token);
 
       // Set up TaskRunnerHandle as expected for the scope of the task.
       std::unique_ptr<SequencedTaskRunnerHandle> sequenced_task_runner_handle;
       std::unique_ptr<ThreadTaskRunnerHandle> single_thread_task_runner_handle;
       DCHECK(!task->sequenced_task_runner_ref ||
              !task->single_thread_task_runner_ref);
       if (task->sequenced_task_runner_ref) {
@@ skipping 199 matching lines @@
       subtle::NoBarrier_AtomicIncrement(&num_pending_undelayed_tasks_, -1);
   DCHECK_GE(new_num_pending_undelayed_tasks, 0);
   if (new_num_pending_undelayed_tasks == 0) {
     AutoSchedulerLock auto_lock(flush_lock_);
     flush_cv_->Signal();
   }
 }
 
 }  // namespace internal
 }  // namespace base