TaskScheduler: Add TaskRunnerHandle support to TaskScheduler tasks

base/task_scheduler/scheduler_thread_pool_impl.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/scheduler_thread_pool_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 60 matching lines @@
   // so long as |thread_pool| is alive.
   // TODO(robliao): Find a concrete way to manage |thread_pool|'s memory.
   SchedulerSequencedTaskRunner(const TaskTraits& traits,
                                SchedulerThreadPool* thread_pool)
       : traits_(traits), thread_pool_(thread_pool) {}
 
   // SequencedTaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const Closure& closure,
                        TimeDelta delay) override {
+    std::unique_ptr<Task> task(new Task(from_here, closure, traits_, delay));
+    task->sequenced_task_runner_ref = this;
+
     // Post the task as part of |sequence_|.
-    return thread_pool_->PostTaskWithSequence(
-        WrapUnique(new Task(from_here, closure, traits_, delay)), sequence_,
-        nullptr);
+    return thread_pool_->PostTaskWithSequence(std::move(task), sequence_,
+                                              nullptr);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const Closure& closure,
                                   base::TimeDelta delay) override {
     // Tasks are never nested within the task scheduler.
     return PostDelayedTask(from_here, closure, delay);
   }
 
   bool RunsTasksOnCurrentThread() const override {
@@ skipping 23 matching lines @@
                                   SchedulerThreadPool* thread_pool,
                                   SchedulerWorkerThread* worker_thread)
       : traits_(traits),
         thread_pool_(thread_pool),
         worker_thread_(worker_thread) {}
 
   // SingleThreadTaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const Closure& closure,
                        TimeDelta delay) override {
+    std::unique_ptr<Task> task(new Task(from_here, closure, traits_, delay));
+    task->single_thread_task_runner_ref = this;
+
     // Post the task to be executed by |worker_thread_| as part of |sequence_|.
-    return thread_pool_->PostTaskWithSequence(
-        WrapUnique(new Task(from_here, closure, traits_, delay)), sequence_,
-        worker_thread_);
+    return thread_pool_->PostTaskWithSequence(std::move(task), sequence_,
+                                              worker_thread_);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const Closure& closure,
                                   base::TimeDelta delay) override {
     // Tasks are never nested within the task scheduler.
     return PostDelayedTask(from_here, closure, delay);
   }
 
   bool RunsTasksOnCurrentThread() const override {
@@ skipping 386 matching lines @@
 }
 
 void SchedulerThreadPoolImpl::RemoveFromIdleWorkerThreadsStack(
     SchedulerWorkerThread* worker_thread) {
   AutoSchedulerLock auto_lock(idle_worker_threads_stack_lock_);
   idle_worker_threads_stack_.Remove(worker_thread);
 }
 
 }  // namespace internal
 }  // namespace base