TaskScheduler: Make the worker pools of TaskSchedulerImpl configurable

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 20 matching lines @@
 
 struct TraitsExecutionModePair {
   TraitsExecutionModePair(const TaskTraits& traits,
                           ExecutionMode execution_mode)
       : traits(traits), execution_mode(execution_mode) {}
 
   TaskTraits traits;
   ExecutionMode execution_mode;
 };
 
+class TestTaskSchedulerImplDelegate : public TaskSchedulerImpl::Delegate {
+ public:
+  using ThreadPoolCreationArgs =
+      TaskSchedulerImpl::Delegate::ThreadPoolCreationArgs;
+
+  TestTaskSchedulerImplDelegate() = default;
+  ~TestTaskSchedulerImplDelegate() = default;
+
+  size_t GetNumThreadPools() override { return 4; }
+
+  ThreadPoolCreationArgs GetCreationArgsForThreadPool(size_t pool_index) {
+    switch (pool_index) {
+      case 0:
+        return ThreadPoolCreationArgs{
+            std::string("Background"), ThreadPriority::BACKGROUND,
+            SchedulerThreadPoolImpl::IORestriction::DISALLOWED, 1U};
+      case 1:
+        return ThreadPoolCreationArgs{
+            "BackgroundFileIO", ThreadPriority::BACKGROUND,
+            SchedulerThreadPoolImpl::IORestriction::ALLOWED, 3U};
+      case 2:
+        return ThreadPoolCreationArgs{
+            "Foreground", ThreadPriority::NORMAL,
+            SchedulerThreadPoolImpl::IORestriction::DISALLOWED, 4U};
+      case 3:
+        return ThreadPoolCreationArgs{
+            "ForegroundFileIO", ThreadPriority::NORMAL,
+            SchedulerThreadPoolImpl::IORestriction::ALLOWED, 12U};
+      default:
+        ADD_FAILURE() << "Requested creation args for invalid pool index.";
+        return ThreadPoolCreationArgs{};
+    }
+  }
+
+  size_t GetThreadPoolIndexForTraits(const TaskTraits& traits) override {
+    if (traits.with_file_io())
+      return traits.priority() == TaskPriority::BACKGROUND ? 1U : 3U;
+    return traits.priority() == TaskPriority::BACKGROUND ? 0U : 2U;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestTaskSchedulerImplDelegate);
+};
+
 class TaskSchedulerImplTest
     : public testing::TestWithParam<TraitsExecutionModePair> {
  protected:
   TaskSchedulerImplTest() = default;
 
   void SetUp() override {
-    scheduler_ = TaskSchedulerImpl::Create();
+    scheduler_ = TaskSchedulerImpl::Create(
+        WrapUnique(new TestTaskSchedulerImplDelegate));
     EXPECT_TRUE(scheduler_);
   }
   void TearDown() override { scheduler_->JoinForTesting(); }
 
   std::unique_ptr<TaskSchedulerImpl> scheduler_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerImplTest);
 };
 
@@ skipping 130 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(OneTraitsExecutionModePair,
                         TaskSchedulerImplTest,
                         ::testing::ValuesIn(GetTraitsExecutionModePairs()));
 
 // Spawns threads that simultaneously post Tasks to TaskRunners with various
 // TaskTraits and ExecutionModes. Verifies that each Task runs on a thread with
 // the expected priority and I/O restrictions and respects the characteristics
 // of its ExecutionMode.
 TEST(TaskSchedulerImplTest, MultipleTraitsExecutionModePairs) {
-  std::unique_ptr<TaskSchedulerImpl> scheduler = TaskSchedulerImpl::Create();
+  std::unique_ptr<TaskSchedulerImpl> scheduler =
+      TaskSchedulerImpl::Create(WrapUnique(new TestTaskSchedulerImplDelegate));
 
   std::vector<std::unique_ptr<ThreadPostingTasks>> threads_posting_tasks;
   for (const auto& traits_execution_mode_pair : GetTraitsExecutionModePairs()) {
     threads_posting_tasks.push_back(WrapUnique(new ThreadPostingTasks(
         scheduler.get(), traits_execution_mode_pair.traits,
         traits_execution_mode_pair.execution_mode)));
     threads_posting_tasks.back()->Start();
   }
 
   for (const auto& thread : threads_posting_tasks) {
     thread->WaitForAllTasksToRun();
     thread->Join();
   }
 
   scheduler->JoinForTesting();
 }
 
 // TODO(fdoray): Add tests with Sequences that move around thread pools once
 // child TaskRunners are supported.
 
 }  // namespace internal
 }  // namespace base