Always use TaskScheduler::InitParams to initialize a TaskScheduler.

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 157 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());
+    scheduler_ = TaskSchedulerImpl::Create(
+        "Test", {{StandbyThreadPolicy::LAZY, kMaxNumBackgroundThreads,
+                  kSuggestedReclaimTime},
+                 {StandbyThreadPolicy::LAZY, kMaxNumBackgroundBlockingThreads,
+                  kSuggestedReclaimTime},
+                 {StandbyThreadPolicy::LAZY, kMaxNumForegroundThreads,
+                  kSuggestedReclaimTime},
+                 {StandbyThreadPolicy::LAZY, kMaxNumForegroundBlockingThreads,
+                  kSuggestedReclaimTime}});
 
-    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));
     ASSERT_TRUE(scheduler_);
   }
 
   void TearDown() override { scheduler_->JoinForTesting(); }
 
   std::unique_ptr<TaskSchedulerImpl> scheduler_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerImplTest);
 };
@@ skipping 57 matching lines @@
 // 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_F(TaskSchedulerImplTest, MultipleTraitsExecutionModePairs) {
   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();
+    threads_posting_tasks.back()->WaitForAllTasksToRun();
+    threads_posting_tasks.back()->Join();
   }
-
-  for (const auto& thread : threads_posting_tasks) {
-    thread->WaitForAllTasksToRun();
-    thread->Join();
-  }
+  /*
+    for (const auto& thread : threads_posting_tasks) {
+      //thread->WaitForAllTasksToRun();
+      //thread->Join();
+    }*/

[gab, 2017/04/12 18:46:24]

Fix temp code?

[fdoray, 2017/04/12 20:00:23]

Done.

 }
 
 TEST_F(TaskSchedulerImplTest, GetMaxConcurrentTasksWithTraitsDeprecated) {
   EXPECT_EQ(1, scheduler_->GetMaxConcurrentTasksWithTraitsDeprecated(
                    TaskTraits().WithPriority(TaskPriority::BACKGROUND)));
   EXPECT_EQ(
       3, scheduler_->GetMaxConcurrentTasksWithTraitsDeprecated(
              TaskTraits().WithPriority(TaskPriority::BACKGROUND).MayBlock()));
   EXPECT_EQ(4, scheduler_->GetMaxConcurrentTasksWithTraitsDeprecated(
                    TaskTraits().WithPriority(TaskPriority::USER_VISIBLE)));
@@ skipping 72 matching lines @@
             }
             task_ran->Signal();
           },
           com_sta_task_runner, Unretained(&task_ran)));
   task_ran.Wait();
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace internal
 }  // namespace base