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"
@@ skipping 195 matching lines @@
 }
 
 bool TaskTracker::RunTask(std::unique_ptr<Task> task,
                           const SequenceToken& sequence_token) {
   DCHECK(task);
   DCHECK(sequence_token.IsValid());
 
   const TaskShutdownBehavior shutdown_behavior =
       task->traits.shutdown_behavior();
   const bool can_run_task = BeforeRunTask(shutdown_behavior);
+  const bool is_delayed = !task->delayed_run_time.is_null();
 
   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);
 
     {
@@ skipping 21 matching lines @@
               ? ExecutionMode::SINGLE_THREADED
               : (task->sequenced_task_runner_ref ? ExecutionMode::SEQUENCED
                                                  : ExecutionMode::PARALLEL);
       // TODO(gab): In a better world this would be tacked on as an extra arg
       // to the trace event generated above. This is not possible however until
       // http://crbug.com/652692 is resolved.
       TRACE_EVENT1("task_scheduler", "TaskTracker::RunTask", "task_info",
                    MakeUnique<TaskTracingInfo>(task->traits, execution_mode,
                                                sequence_token));
 
-      debug::TaskAnnotator task_annotator;
-      task_annotator.RunTask(kQueueFunctionName, task.get());
+      PerformRunTask(std::move(task));
     }
 
     AfterRunTask(shutdown_behavior);
   }
 
-  if (task->delayed_run_time.is_null())
+  if (!is_delayed)
     DecrementNumPendingUndelayedTasks();
 
   return can_run_task;
 }
 
 bool TaskTracker::HasShutdownStarted() const {
   return state_->HasShutdownStarted();
 }
 
 bool TaskTracker::IsShutdownComplete() const {
   AutoSchedulerLock auto_lock(shutdown_lock_);
   return shutdown_event_ && shutdown_event_->IsSignaled();
 }
 
 void TaskTracker::SetHasShutdownStartedForTesting() {
   state_->StartShutdown();
 }
 
+void TaskTracker::PerformRunTask(std::unique_ptr<Task> task) {
+  debug::TaskAnnotator().RunTask(kQueueFunctionName, task.get());

[gab, 2016/10/21 16:10:48]

Actually this makes me realize that I'm not sure it is/was correct to
instantiates a new TaskAnnotator every time..

Not a blocker for this CL because this was already the case but worth looking
into.

[fdoray, 2016/10/27 13:06:50]

Yes, it's wrong to initialize a TaskAnnotator every time. I plan to fix this in
a separate CL.

+}
+
 void TaskTracker::PerformShutdown() {
   {
     AutoSchedulerLock auto_lock(shutdown_lock_);
 
     // This method can only be called once.
     DCHECK(!shutdown_event_);
     DCHECK(!num_block_shutdown_tasks_posted_during_shutdown_);
     DCHECK(!state_->HasShutdownStarted());
 
     shutdown_event_.reset(
@@ skipping 142 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