TaskScheduler: Remove base::ExecutionMode.

base/task_scheduler/task_scheduler_impl_unittest.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 <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 16 matching lines @@
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
 struct TraitsExecutionModePair {
   TraitsExecutionModePair(const TaskTraits& traits,
-                          ExecutionMode execution_mode)
+                          test::ExecutionMode execution_mode)
       : traits(traits), execution_mode(execution_mode) {}
 
   TaskTraits traits;
-  ExecutionMode execution_mode;
+  test::ExecutionMode execution_mode;
 };
 
 #if DCHECK_IS_ON()
 // Returns whether I/O calls are allowed on the current thread.
 bool GetIOAllowed() {
   const bool previous_value = ThreadRestrictions::SetIOAllowed(true);
   ThreadRestrictions::SetIOAllowed(previous_value);
   return previous_value;
 }
 #endif
@@ skipping 29 matching lines @@
             current_thread_name.find("FileIO") != std::string::npos);
 }
 
 void VerifyTaskEnvironementAndSignalEvent(const TaskTraits& traits,
                                           WaitableEvent* event) {
   DCHECK(event);
   VerifyTaskEnvironement(traits);
   event->Signal();
 }
 
+scoped_refptr<TaskRunner> CreateTaskRunnerWithTraitsAndExecutionMode(
+    TaskScheduler* scheduler,
+    const TaskTraits& traits,
+    test::ExecutionMode execution_mode) {
+  switch (execution_mode) {
+    case test::ExecutionMode::PARALLEL:
+      return scheduler->CreateTaskRunnerWithTraits(traits);
+    case test::ExecutionMode::SEQUENCED:
+      return scheduler->CreateSequencedTaskRunnerWithTraits(traits);
+    case test::ExecutionMode::SINGLE_THREADED:
+      return scheduler->CreateSingleThreadTaskRunnerWithTraits(traits);
+  }
+  ADD_FAILURE() << "Unknown ExecutionMode";
+  return nullptr;
+}
+
 class ThreadPostingTasks : public SimpleThread {
  public:
   // Creates a thread that posts Tasks to |scheduler| with |traits| and
   // |execution_mode|.
   ThreadPostingTasks(TaskSchedulerImpl* scheduler,
                      const TaskTraits& traits,
-                     ExecutionMode execution_mode)
+                     test::ExecutionMode execution_mode)
       : SimpleThread("ThreadPostingTasks"),
         traits_(traits),
-        factory_(scheduler->CreateTaskRunnerWithTraits(traits, execution_mode),
+        factory_(CreateTaskRunnerWithTraitsAndExecutionMode(scheduler,
+                                                            traits,
+                                                            execution_mode),
                  execution_mode) {}
 
   void WaitForAllTasksToRun() { factory_.WaitForAllTasksToRun(); }
 
  private:
   void Run() override {
     EXPECT_FALSE(factory_.task_runner()->RunsTasksOnCurrentThread());
 
     const size_t kNumTasksPerThread = 150;
     for (size_t i = 0; i < kNumTasksPerThread; ++i) {
       factory_.PostTask(test::TestTaskFactory::PostNestedTask::NO,
                         Bind(&VerifyTaskEnvironement, traits_));
     }
   }
 
   const TaskTraits traits_;
   test::TestTaskFactory factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasks);
 };
 
 // Returns a vector with a TraitsExecutionModePair for each valid
 // combination of {ExecutionMode, TaskPriority, WithFileIO()}.
 std::vector<TraitsExecutionModePair> GetTraitsExecutionModePairs() {
   std::vector<TraitsExecutionModePair> params;
 
-  const ExecutionMode execution_modes[] = {ExecutionMode::PARALLEL,
-                                           ExecutionMode::SEQUENCED,
-                                           ExecutionMode::SINGLE_THREADED};
+  const test::ExecutionMode execution_modes[] = {
+      test::ExecutionMode::PARALLEL, test::ExecutionMode::SEQUENCED,
+      test::ExecutionMode::SINGLE_THREADED};
 
-  for (ExecutionMode execution_mode : execution_modes) {
+  for (test::ExecutionMode execution_mode : execution_modes) {
     for (size_t priority_index = static_cast<size_t>(TaskPriority::LOWEST);
          priority_index <= static_cast<size_t>(TaskPriority::HIGHEST);
          ++priority_index) {
       const TaskPriority priority = static_cast<TaskPriority>(priority_index);
       params.push_back(TraitsExecutionModePair(
           TaskTraits().WithPriority(priority), execution_mode));
       params.push_back(TraitsExecutionModePair(
           TaskTraits().WithPriority(priority).WithFileIO(), execution_mode));
     }
   }
@@ skipping 70 matching lines @@
       Bind(&VerifyTaskEnvironementAndSignalEvent, GetParam().traits,
            Unretained(&task_ran)));
   task_ran.Wait();
 }
 
 // Verifies that Tasks posted via a TaskRunner with parameterized TaskTraits and
 // ExecutionMode run on a thread with the expected priority and I/O restrictions
 // and respect the characteristics of their ExecutionMode.
 TEST_P(TaskSchedulerImplTest, PostTasksViaTaskRunner) {
   test::TestTaskFactory factory(
-      scheduler_->CreateTaskRunnerWithTraits(GetParam().traits,
-                                             GetParam().execution_mode),
+      CreateTaskRunnerWithTraitsAndExecutionMode(
+          scheduler_.get(), GetParam().traits, GetParam().execution_mode),
       GetParam().execution_mode);
   EXPECT_FALSE(factory.task_runner()->RunsTasksOnCurrentThread());
 
   const size_t kNumTasksPerTest = 150;
   for (size_t i = 0; i < kNumTasksPerTest; ++i) {
     factory.PostTask(test::TestTaskFactory::PostNestedTask::NO,
                      Bind(&VerifyTaskEnvironement, GetParam().traits));
   }
 
   factory.WaitForAllTasksToRun();
@@ skipping 20 matching lines @@
     thread->WaitForAllTasksToRun();
     thread->Join();
   }
 }
 
 // TODO(fdoray): Add tests with Sequences that move around worker pools once
 // child TaskRunners are supported.
 
 }  // namespace internal
 }  // namespace base