TaskScheduler: Nits in service thread and delayed tasks code.

base/task_scheduler/task_scheduler_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/task_scheduler_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 66 matching lines @@
     : service_thread_("TaskSchedulerServiceThread"),
       worker_pool_index_for_traits_callback_(
           worker_pool_index_for_traits_callback) {
   DCHECK(!worker_pool_index_for_traits_callback_.is_null());
 }
 
 void TaskSchedulerImpl::Initialize(
     const std::vector<SchedulerWorkerPoolParams>& worker_pool_params_vector) {
   DCHECK(!worker_pool_params_vector.empty());
 
-  // Start the service thread.
+  // Start the service thread. On POSIX, the service thread runs a
+  // MessageLoopForIO to support FileDescriptorWatcher.
   constexpr MessageLoop::Type kServiceThreadMessageLoopType =
 #if defined(OS_POSIX)
       MessageLoop::TYPE_IO;
 #else
       MessageLoop::TYPE_DEFAULT;
 #endif
   constexpr size_t kDefaultStackSize = 0;
   CHECK(service_thread_.StartWithOptions(
       Thread::Options(kServiceThreadMessageLoopType, kDefaultStackSize)));
 
-  const SchedulerWorkerPoolImpl::ReEnqueueSequenceCallback
-      re_enqueue_sequence_callback =
-          Bind(&TaskSchedulerImpl::ReEnqueueSequenceCallback, Unretained(this));
-
   // Instantiate the DelayedTaskManager. The service thread must be started
   // before its TaskRunner is available.
   delayed_task_manager_ =
       base::MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
 
+  const SchedulerWorkerPoolImpl::ReEnqueueSequenceCallback

[robliao, 2016/10/18 20:21:43]

What the motivation for this reordering?

[gab, 2016/10/18 20:50:40]

It's only required below and |delayed_task_manager| is related to
|service_thread_| created before it so both this being here makes sense and
|delayed_task_manager|'s init moving up.

+      re_enqueue_sequence_callback =
+          Bind(&TaskSchedulerImpl::ReEnqueueSequenceCallback, Unretained(this));
+
   // Start worker pools.
   for (const auto& worker_pool_params : worker_pool_params_vector) {
     // Passing pointers to objects owned by |this| to
     // SchedulerWorkerPoolImpl::Create() is safe because a TaskSchedulerImpl
     // can't be deleted before all its worker pools have been joined.
     worker_pools_.push_back(SchedulerWorkerPoolImpl::Create(
         worker_pool_params, re_enqueue_sequence_callback, &task_tracker_,
         delayed_task_manager_.get()));
     CHECK(worker_pools_.back());
   }
@@ skipping 17 matching lines @@
   // in |sequence|.
   const TaskTraits traits =
       sequence->PeekTaskTraits().WithPriority(sort_key.priority());
 
   GetWorkerPoolForTraits(traits)->ReEnqueueSequence(std::move(sequence),
                                                     sort_key);
 }
 
 }  // namespace internal
 }  // namespace base