TaskScheduler: Add TaskRunnerHandle support to TaskScheduler tasks

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 "base/callback.h"
 #include "base/debug/task_annotator.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
 const char kQueueFunctionName[] = "base::PostTask";
 
 // Upper bound for the
 // TaskScheduler.BlockShutdownTasksPostedDuringShutdown histogram.
@@ skipping 51 matching lines @@
 }
 
 void TaskTracker::RunTask(const Task* task) {
   DCHECK(task);
 
   const TaskShutdownBehavior shutdown_behavior =
       task->traits.shutdown_behavior();
   if (!BeforeRunTask(shutdown_behavior))
     return;
 
-  debug::TaskAnnotator task_annotator;
-  task_annotator.RunTask(kQueueFunctionName, *task);
+  {
+    // Set up TaskRunnerHandle as expected for the scope of the task.
+    std::unique_ptr<SequencedTaskRunnerHandle> sequenced_trh;
+    std::unique_ptr<ThreadTaskRunnerHandle> single_thread_trh;
+    DCHECK(!task->sequenced_task_runner_ref ||

[robliao, 2016/04/28 17:16:42]

Alternatively, you can have an else clause below with NOTREACHED() which would
accomplish the same thing.

[gab, 2016/04/28 17:55:07]

An else clause below would be a

DCHECK(task->sequenced_task_runner_ref || 
       task->single_thread_task_runner_ref);

which is not what I want (it's okay to have no task_runner_ref).

What this is checking is that |task| has either 1 or 0 (not 2) task_runner_refs
set.

It's equivalent to this (which I could use if it's clearer):

DCHECK(!(task->sequenced_task_runner_ref && 
         task->single_thread_task_runner_ref));

[robliao, 2016/04/28 18:06:47]

Ah yes, my misreading. I think Chrome tends to prefer the nongrouped
demorganized form, so it's fine as is.
Alternatively then you could distribute the DCHECK.
if (task->sequenced_task_runner_ref) {
  DCHECK(!task->single_Thread_task_runner_ref)
} ...
(The else if doesn't need the DCHECK as sequenced_task_runner_ref must be false)
Your choice.

[gab, 2016/04/28 18:50:15]

I prefer the current one as it reads more as "the two of them can't be set at
same time; if the first is do X; if the second is do Y" which I prefer to "if
the first is, confirm that the second isn't, do X; if the second is do Y".

+           !task->single_thread_task_runner_ref);
+    if (task->sequenced_task_runner_ref) {
+      sequenced_trh.reset(
+          new SequencedTaskRunnerHandle(task->sequenced_task_runner_ref));
+    } else if (task->single_thread_task_runner_ref) {
+      single_thread_trh.reset(
+          new ThreadTaskRunnerHandle(task->single_thread_task_runner_ref));
+    }
+
+    debug::TaskAnnotator task_annotator;
+    task_annotator.RunTask(kQueueFunctionName, *task);
+  }
 
   AfterRunTask(shutdown_behavior);
 }
 
 bool TaskTracker::IsShuttingDownForTesting() const {
   AutoSchedulerLock auto_lock(lock_);
   return !!shutdown_cv_;
 }
 
 bool TaskTracker::BeforePostTask(TaskShutdownBehavior shutdown_behavior) {
@@ skipping 78 matching lines @@
     AutoSchedulerLock auto_lock(lock_);
     DCHECK_GT(num_tasks_blocking_shutdown_, 0U);
     --num_tasks_blocking_shutdown_;
     if (num_tasks_blocking_shutdown_ == 0 && shutdown_cv_)
       shutdown_cv_->Signal();
   }
 }
 
 }  // namespace internal
 }  // namespace base