TaskScheduler: Remove base::ExecutionMode.

base/task_scheduler/scheduler_worker_pool_impl.cc

Index: base/task_scheduler/scheduler_worker_pool_impl.cc
diff --git a/base/task_scheduler/scheduler_worker_pool_impl.cc b/base/task_scheduler/scheduler_worker_pool_impl.cc
index af6e92ff053b5b5fe6a7af7800bd110114b1791f..34de2ac586c1e49f66f8edb31ec764ae85ab0659 100644
--- a/base/task_scheduler/scheduler_worker_pool_impl.cc
+++ b/base/task_scheduler/scheduler_worker_pool_impl.cc
@@ -16,8 +16,6 @@
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/sequence_token.h"
-#include "base/sequenced_task_runner.h"
-#include "base/single_thread_task_runner.h"

[gab, 2016/10/31 19:10:11]

(but here you'll want to keep them since you're using it beyond just the
overrides -- tricky details of IWYU ;-))

[robliao, 2016/10/31 19:19:59]

Not sure I follow here. The style guide permits use of headers from the main
header.

https://google.github.io/styleguide/cppguide.html#Names_and_Order_of_Includes
However, any includes present in the related header do not need to be included
again in the related cc (i.e., foo.cc can rely on foo.h's includes).

[gab, 2016/10/31 19:28:45]

Right but my other comment asks to remove from header per only being used in the
overrides (which can be assumed to be included by parent class).

[robliao, 2016/10/31 19:31:48]

Gotcha. That other comment makes a lot more sense now. +1 to that.

[fdoray, 2016/10/31 19:44:51]

Done.

 #include "base/strings/stringprintf.h"
 #include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/task_tracker.h"
@@ -341,33 +339,31 @@ void SchedulerWorkerPoolImpl::DisallowWorkerDetachmentForTesting() {
 }
 
 scoped_refptr<TaskRunner> SchedulerWorkerPoolImpl::CreateTaskRunnerWithTraits(
-    const TaskTraits& traits,
-    ExecutionMode execution_mode) {
-  switch (execution_mode) {
-    case ExecutionMode::PARALLEL:
-      return make_scoped_refptr(new SchedulerParallelTaskRunner(traits, this));
-
-    case ExecutionMode::SEQUENCED:
-      return make_scoped_refptr(new SchedulerSequencedTaskRunner(traits, this));
-
-    case ExecutionMode::SINGLE_THREADED: {
-      // TODO(fdoray): Find a way to take load into account when assigning a
-      // SchedulerWorker to a SingleThreadTaskRunner. Also, this code
-      // assumes that all SchedulerWorkers are alive. Eventually, we might
-      // decide to tear down threads that haven't run tasks for a long time.
-      size_t worker_index;
-      {
-        AutoSchedulerLock auto_lock(next_worker_index_lock_);
-        worker_index = next_worker_index_;
-        next_worker_index_ = (next_worker_index_ + 1) % workers_.size();
-      }
-      return make_scoped_refptr(new SchedulerSingleThreadTaskRunner(
-          traits, this, workers_[worker_index].get()));
-    }
-  }
+    const TaskTraits& traits) {
+  return make_scoped_refptr(new SchedulerParallelTaskRunner(traits, this));
+}
 
-  NOTREACHED();
-  return nullptr;
+scoped_refptr<SequencedTaskRunner>
+SchedulerWorkerPoolImpl::CreateSequencedTaskRunnerWithTraits(
+    const TaskTraits& traits) {
+  return make_scoped_refptr(new SchedulerSequencedTaskRunner(traits, this));
+}
+
+scoped_refptr<SingleThreadTaskRunner>
+SchedulerWorkerPoolImpl::CreateSingleThreadTaskRunnerWithTraits(
+    const TaskTraits& traits) {
+  // TODO(fdoray): Find a way to take load into account when assigning a
+  // SchedulerWorker to a SingleThreadTaskRunner. Also, this code assumes that
+  // all SchedulerWorkers are alive. Eventually, we might decide to tear down
+  // threads that haven't run tasks for a long time.

[gab, 2016/10/31 19:10:11]

The second half of this comment is wrong with detach now (i.e. it's still fine
in practice but "alive" has been redefined)

[fdoray, 2016/10/31 19:44:51]

Removed second part of the comment since I don't believe that we'll take the
detach state into account. We'll decide what the best algorithm is when we
address this TODO.

+  size_t worker_index;
+  {
+    AutoSchedulerLock auto_lock(next_worker_index_lock_);
+    worker_index = next_worker_index_;
+    next_worker_index_ = (next_worker_index_ + 1) % workers_.size();
+  }
+  return make_scoped_refptr(new SchedulerSingleThreadTaskRunner(
+      traits, this, workers_[worker_index].get()));
 }
 
 void SchedulerWorkerPoolImpl::ReEnqueueSequence(