[reference - do not submit] Always create four pools in TaskSchedulerImpl.

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 153 matching lines @@
       params.push_back(TraitsExecutionModePair(
           TaskTraits().WithPriority(priority), execution_mode));
       params.push_back(TraitsExecutionModePair(
           TaskTraits().WithPriority(priority).MayBlock(), execution_mode));
     }
   }
 
   return params;
 }
 
-enum WorkerPoolType {
-  BACKGROUND_WORKER_POOL = 0,
-  BACKGROUND_BLOCKING_WORKER_POOL,
-  FOREGROUND_WORKER_POOL,
-  FOREGROUND_BLOCKING_WORKER_POOL,
-};
-
-size_t GetThreadPoolIndexForTraits(const TaskTraits& traits) {
-  if (traits.may_block()) {
-    return traits.priority() == TaskPriority::BACKGROUND
-               ? BACKGROUND_BLOCKING_WORKER_POOL
-               : FOREGROUND_BLOCKING_WORKER_POOL;
-  }
-  return traits.priority() == TaskPriority::BACKGROUND ? BACKGROUND_WORKER_POOL
-                                                       : FOREGROUND_WORKER_POOL;
-}
-
 class TaskSchedulerImplTest
     : public testing::TestWithParam<TraitsExecutionModePair> {
  protected:
   TaskSchedulerImplTest() = default;
 
   void SetUp() override {
     using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy;
 
-    std::vector<SchedulerWorkerPoolParams> params_vector;
+    constexpr TimeDelta kSuggestedReclaimTime = TimeDelta::FromSeconds(30);
+    constexpr int kMaxNumBackgroundThreads = 1;
+    constexpr int kMaxNumBackgroundBlockingThreads = 3;
+    constexpr int kMaxNumForegroundThreads = 4;
+    constexpr int kMaxNumForegroundBlockingThreads = 12;
 
-    ASSERT_EQ(BACKGROUND_WORKER_POOL, params_vector.size());
-    params_vector.emplace_back("Background", ThreadPriority::BACKGROUND,
-                               StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max());
-
-    ASSERT_EQ(BACKGROUND_BLOCKING_WORKER_POOL, params_vector.size());
-    params_vector.emplace_back("BackgroundBlocking", ThreadPriority::BACKGROUND,
-                               StandbyThreadPolicy::LAZY, 3U, TimeDelta::Max());
-
-    ASSERT_EQ(FOREGROUND_WORKER_POOL, params_vector.size());
-    params_vector.emplace_back("Foreground", ThreadPriority::NORMAL,
-                               StandbyThreadPolicy::LAZY, 4U, TimeDelta::Max());
-
-    ASSERT_EQ(FOREGROUND_BLOCKING_WORKER_POOL, params_vector.size());
-    params_vector.emplace_back("ForegroundBlocking", ThreadPriority::NORMAL,
-                               StandbyThreadPolicy::LAZY, 12U,
-                               TimeDelta::Max());
-
-    scheduler_ = TaskSchedulerImpl::Create(params_vector,
-                                           Bind(&GetThreadPoolIndexForTraits));
+    scheduler_ = TaskSchedulerImpl::Create(
+        "Test", {{StandbyThreadPolicy::LAZY, kMaxNumBackgroundThreads,
+                  kSuggestedReclaimTime},
+                 {StandbyThreadPolicy::LAZY, kMaxNumBackgroundBlockingThreads,
+                  kSuggestedReclaimTime},
+                 {StandbyThreadPolicy::LAZY, kMaxNumForegroundThreads,
+                  kSuggestedReclaimTime},
+                 {StandbyThreadPolicy::LAZY, kMaxNumForegroundBlockingThreads,
+                  kSuggestedReclaimTime}});
     ASSERT_TRUE(scheduler_);
   }
 
   void TearDown() override { scheduler_->JoinForTesting(); }
 
   std::unique_ptr<TaskSchedulerImpl> scheduler_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerImplTest);
 };
@@ skipping 131 matching lines @@
              WaitableEvent* task_ran) {
             EXPECT_FALSE(single_thread_task_runner->RunsTasksOnCurrentThread());
             task_ran->Signal();
           },
           single_thread_task_runner, Unretained(&task_ran)));
   task_ran.Wait();
 }
 
 }  // namespace internal
 }  // namespace base