TaskScheduler: Make SchedulerWorkerThread own its delegate.

base/task_scheduler/scheduler_worker_thread.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_worker_thread.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/task_scheduler/task_tracker.h"
 
 namespace base {
 namespace internal {
 
 std::unique_ptr<SchedulerWorkerThread>
-SchedulerWorkerThread::CreateSchedulerWorkerThread(
-    ThreadPriority thread_priority,
-    Delegate* delegate,
-    TaskTracker* task_tracker) {
+SchedulerWorkerThread::CreateWorkerThread(ThreadPriority thread_priority,

[robliao, 2016/04/22 20:30:48]

While we're here, would Create(*) be sufficient as a name?

[fdoray, 2016/04/22 22:46:46]

Done. Also renamed SchedulerThreadPool::CreateThreadPool ->
SchedulerThreadPool::Create.

+                                          std::unique_ptr<Delegate> delegate,
+                                          TaskTracker* task_tracker) {
   std::unique_ptr<SchedulerWorkerThread> worker_thread(
-      new SchedulerWorkerThread(thread_priority, delegate, task_tracker));
+      new SchedulerWorkerThread(thread_priority, std::move(delegate),
+                                task_tracker));
 
   if (worker_thread->thread_handle_.is_null())
     return nullptr;
   return worker_thread;
 }
 
 SchedulerWorkerThread::~SchedulerWorkerThread() {
   DCHECK(ShouldExitForTesting());
 }
 
 void SchedulerWorkerThread::WakeUp() {
   wake_up_event_.Signal();
 }
 
 void SchedulerWorkerThread::JoinForTesting() {
   {
     AutoSchedulerLock auto_lock(should_exit_for_testing_lock_);
     should_exit_for_testing_ = true;
   }
   WakeUp();
   PlatformThread::Join(thread_handle_);
 }
 
 SchedulerWorkerThread::SchedulerWorkerThread(ThreadPriority thread_priority,
-                                             Delegate* delegate,
+                                             std::unique_ptr<Delegate> delegate,
                                              TaskTracker* task_tracker)
     : wake_up_event_(false, false),
-      delegate_(delegate),
+      delegate_(std::move(delegate)),
       task_tracker_(task_tracker) {
   DCHECK(delegate_);
   DCHECK(task_tracker_);
 
   const size_t kDefaultStackSize = 0;
   PlatformThread::CreateWithPriority(kDefaultStackSize, this, &thread_handle_,
                                      thread_priority);
 }
 
 void SchedulerWorkerThread::ThreadMain() {
@@ skipping 32 matching lines @@
   }
 }
 
 bool SchedulerWorkerThread::ShouldExitForTesting() const {
   AutoSchedulerLock auto_lock(should_exit_for_testing_lock_);
   return should_exit_for_testing_;
 }
 
 }  // namespace internal
 }  // namespace base