Move code that sets up the environment to run a task to TaskTracker::PerformRunTask().

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 <string>
 
 #include "base/callback.h"
@@ skipping 228 matching lines @@
                           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) {
-    RecordTaskLatencyHistogram(task.get());
-
-    const bool previous_singleton_allowed =
-        ThreadRestrictions::SetSingletonAllowed(
-            task->traits.shutdown_behavior() !=
-            TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);
-    const bool previous_io_allowed =
-        ThreadRestrictions::SetIOAllowed(task->traits.may_block());
-    const bool previous_wait_allowed = ThreadRestrictions::SetWaitAllowed(
-        task->traits.with_base_sync_primitives());
-
-    {
-      ScopedSetSequenceTokenForCurrentThread
-          scoped_set_sequence_token_for_current_thread(sequence_token);
-      ScopedSetTaskPriorityForCurrentThread
-          scoped_set_task_priority_for_current_thread(task->traits.priority());
-
-      // 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) {
-        sequenced_task_runner_handle.reset(
-            new SequencedTaskRunnerHandle(task->sequenced_task_runner_ref));
-      } else if (task->single_thread_task_runner_ref) {
-        single_thread_task_runner_handle.reset(
-            new ThreadTaskRunnerHandle(task->single_thread_task_runner_ref));
-      }
-
-      TRACE_TASK_EXECUTION(kRunFunctionName, *task);
-
-      const char* const execution_mode =
-          task->single_thread_task_runner_ref
-              ? kSingleThreadExecutionMode
-              : (task->sequenced_task_runner_ref ? kSequencedExecutionMode
-                                                 : kParallelExecutionMode);
-      // 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));
-
-      PerformRunTask(std::move(task));
-    }
-
-    ThreadRestrictions::SetWaitAllowed(previous_wait_allowed);
-    ThreadRestrictions::SetIOAllowed(previous_io_allowed);
-    ThreadRestrictions::SetSingletonAllowed(previous_singleton_allowed);
-
+    PerformRunTask(std::move(task), sequence_token);
     AfterRunTask(shutdown_behavior);
   }
 
   if (!is_delayed)
     DecrementNumPendingUndelayedTasks();
 
   return can_run_task;
 }
 
 bool TaskTracker::HasShutdownStarted() const {
@@ skipping 10 matching lines @@
 
   // Create a dummy |shutdown_event_| to satisfy TaskTracker's expectation of
   // its existence during shutdown (e.g. in OnBlockingShutdownTasksComplete()).
   shutdown_event_.reset(
       new WaitableEvent(WaitableEvent::ResetPolicy::MANUAL,
                         WaitableEvent::InitialState::NOT_SIGNALED));
 
   state_->StartShutdown();
 }
 
-void TaskTracker::PerformRunTask(std::unique_ptr<Task> task) {
-  debug::TaskAnnotator().RunTask(kQueueFunctionName, task.get());
+void TaskTracker::PerformRunTask(std::unique_ptr<Task> task,
+                                 const SequenceToken& sequence_token) {
+  RecordTaskLatencyHistogram(task.get());
+
+  const bool previous_singleton_allowed =
+      ThreadRestrictions::SetSingletonAllowed(
+          task->traits.shutdown_behavior() !=
+          TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);
+  const bool previous_io_allowed =
+      ThreadRestrictions::SetIOAllowed(task->traits.may_block());
+  const bool previous_wait_allowed = ThreadRestrictions::SetWaitAllowed(
+      task->traits.with_base_sync_primitives());
+
+  {
+    ScopedSetSequenceTokenForCurrentThread
+        scoped_set_sequence_token_for_current_thread(sequence_token);
+    ScopedSetTaskPriorityForCurrentThread
+        scoped_set_task_priority_for_current_thread(task->traits.priority());
+
+    // 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) {
+      sequenced_task_runner_handle.reset(
+          new SequencedTaskRunnerHandle(task->sequenced_task_runner_ref));
+    } else if (task->single_thread_task_runner_ref) {
+      single_thread_task_runner_handle.reset(
+          new ThreadTaskRunnerHandle(task->single_thread_task_runner_ref));
+    }
+
+    TRACE_TASK_EXECUTION(kRunFunctionName, *task);
+
+    const char* const execution_mode =
+        task->single_thread_task_runner_ref
+            ? kSingleThreadExecutionMode
+            : (task->sequenced_task_runner_ref ? kSequencedExecutionMode
+                                               : kParallelExecutionMode);
+    // 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().RunTask(kQueueFunctionName, task.get());
+  }
+
+  ThreadRestrictions::SetWaitAllowed(previous_wait_allowed);
+  ThreadRestrictions::SetIOAllowed(previous_io_allowed);
+  ThreadRestrictions::SetSingletonAllowed(previous_singleton_allowed);
 }
 
 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());
@@ skipping 170 matching lines @@
   task_latency_histograms_[static_cast<int>(task->traits.priority())]
                           [task->traits.may_block() ||
                                    task->traits.with_base_sync_primitives()
                                ? 1
                                : 0]
                               ->Add(task_latency.InMicroseconds());
 }
 
 }  // namespace internal
 }  // namespace base