FOR REFERENCE ONLY Task Scheduler COM Task Runner

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 223 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();
+  const bool is_normal_task = task->task_type == Task::TaskType::NORMAL;
 
   if (can_run_task) {
-    RecordTaskLatencyHistogram(task.get());
+    if (is_normal_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);
+      if (is_normal_task) {
+        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));
+        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));
+        PerformRunTask(std::move(task));
+      } else {
+        // To avoid polluting Chrome traces with internal tasks, we simply just
+        // execute the task here.
+        std::move(task->task).Run();
+      }
     }
 
     ThreadRestrictions::SetWaitAllowed(previous_wait_allowed);
     ThreadRestrictions::SetIOAllowed(previous_io_allowed);
     ThreadRestrictions::SetSingletonAllowed(previous_singleton_allowed);
 
     AfterRunTask(shutdown_behavior);
   }
 
-  if (!is_delayed)
+  if (!is_delayed && is_normal_task)
     DecrementNumPendingUndelayedTasks();
 
   return can_run_task;
 }
 
 bool TaskTracker::HasShutdownStarted() const {
   return state_->HasShutdownStarted();
 }
 
 bool TaskTracker::IsShutdownComplete() const {
@@ skipping 182 matching lines @@
   task_latency_histograms_[static_cast<int>(task->traits.priority())]
                           [task->traits.may_block() ||
                                    task->traits.with_base_sync_primitives()
                                ? 1
                                : 0]
                               ->AddTime(task_latency);
 }
 
 }  // namespace internal
 }  // namespace base