Rename SchedulerThreadPool* to SchedulerWorkerPool*

base/task_scheduler/scheduler_service_thread_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/scheduler_service_thread.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/delayed_task_manager.h"
-#include "base/task_scheduler/scheduler_thread_pool_impl.h"
+#include "base/task_scheduler/scheduler_worker_pool_impl.h"
 #include "base/task_scheduler/sequence.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_tracker.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 namespace {
@@ skipping 18 matching lines @@
 //    doesn't advance), some tests below may fail.
 // 3) Short waits sufficiently cover longer waits. Having tests run quickly is
 //    desirable. Since the tests can't change the behavior of timed waiting, the
 //    delay durations should be reasonably short on the order of hundreds of
 //    milliseconds.
 class TaskSchedulerServiceThreadTest : public testing::Test {
  protected:
   TaskSchedulerServiceThreadTest() : delayed_task_manager_(Bind(&DoNothing)) {}
 
   void SetUp() override {
-    scheduler_thread_pool_ = SchedulerThreadPoolImpl::Create(
-        "TestThreadPoolForSchedulerThread", ThreadPriority::BACKGROUND, 1u,
-        SchedulerThreadPoolImpl::IORestriction::DISALLOWED,
+    scheduler_worker_pool_ = SchedulerWorkerPoolImpl::Create(
+        "TestWorkerPoolForSchedulerServiceThread", ThreadPriority::BACKGROUND,
+        1u, SchedulerWorkerPoolImpl::IORestriction::DISALLOWED,
         Bind(&ReEnqueueSequenceCallback), &task_tracker_,
         &delayed_task_manager_);
-    ASSERT_TRUE(scheduler_thread_pool_);
+    ASSERT_TRUE(scheduler_worker_pool_);
     service_thread_ = SchedulerServiceThread::Create(
         &task_tracker_, &delayed_task_manager_);
     ASSERT_TRUE(service_thread_);
   }
 
   void TearDown() override {
-    scheduler_thread_pool_->JoinForTesting();
+    scheduler_worker_pool_->JoinForTesting();
     service_thread_->JoinForTesting();
   }
 
   SchedulerServiceThread* service_thread() {
     return service_thread_.get();
   }
 
   DelayedTaskManager& delayed_task_manager() {
     return delayed_task_manager_;
   }
 
-  SchedulerThreadPoolImpl* thread_pool() {
-    return scheduler_thread_pool_.get();
+  SchedulerWorkerPoolImpl* worker_pool() {
+    return scheduler_worker_pool_.get();
   }
 
  private:
   static void ReEnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
     ADD_FAILURE() << "This test only expects one task per sequence.";
   }
 
   DelayedTaskManager delayed_task_manager_;
   TaskTracker task_tracker_;
-  std::unique_ptr<SchedulerThreadPoolImpl> scheduler_thread_pool_;
+  std::unique_ptr<SchedulerWorkerPoolImpl> scheduler_worker_pool_;
   std::unique_ptr<SchedulerServiceThread> service_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerServiceThreadTest);
 };
 
 }  // namespace
 
 // Tests that the service thread can handle a single delayed task.
 TEST_F(TaskSchedulerServiceThreadTest, RunSingleDelayedTask) {
   WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
   delayed_task_manager().AddDelayedTask(
       WrapUnique(new Task(FROM_HERE,
                           Bind(&WaitableEvent::Signal, Unretained(&event)),
                           TaskTraits(), TimeDelta::FromMilliseconds(100))),
-      make_scoped_refptr(new Sequence), nullptr, thread_pool());
+      make_scoped_refptr(new Sequence), nullptr, worker_pool());
   // Waking the service thread shouldn't cause the task to be executed per its
   // delay not having expired (racy in theory, see test-fixture meta-comment).
   service_thread()->WakeUp();
   // Yield to increase the likelihood of catching a bug where these tasks would
   // be released before their delay is passed.
   PlatformThread::YieldCurrentThread();
   EXPECT_FALSE(event.IsSignaled());
   // When the delay expires, the delayed task is posted, signaling |event|.
   event.Wait();
 }
 
 // Tests that the service thread can handle more than one delayed task with
 // different delays.
 TEST_F(TaskSchedulerServiceThreadTest, RunMultipleDelayedTasks) {
   const TimeTicks test_begin_time = TimeTicks::Now();
   const TimeDelta delay1 = TimeDelta::FromMilliseconds(100);
   const TimeDelta delay2 = TimeDelta::FromMilliseconds(200);
 
   WaitableEvent event1(WaitableEvent::ResetPolicy::MANUAL,
                        WaitableEvent::InitialState::NOT_SIGNALED);
   delayed_task_manager().AddDelayedTask(
       WrapUnique(new Task(FROM_HERE,
                           Bind(&WaitableEvent::Signal, Unretained(&event1)),
                           TaskTraits(), delay1)),
-      make_scoped_refptr(new Sequence), nullptr, thread_pool());
+      make_scoped_refptr(new Sequence), nullptr, worker_pool());
 
   WaitableEvent event2(WaitableEvent::ResetPolicy::MANUAL,
                        WaitableEvent::InitialState::NOT_SIGNALED);
   delayed_task_manager().AddDelayedTask(
       WrapUnique(new Task(FROM_HERE,
                           Bind(&WaitableEvent::Signal, Unretained(&event2)),
                           TaskTraits(), delay2)),
-      make_scoped_refptr(new Sequence), nullptr, thread_pool());
+      make_scoped_refptr(new Sequence), nullptr, worker_pool());
 
   // Adding the task shouldn't have caused them to be executed.
   EXPECT_FALSE(event1.IsSignaled());
   EXPECT_FALSE(event2.IsSignaled());
 
   // Waking the service thread shouldn't cause the tasks to be executed per
   // their delays not having expired (note: this is racy if the delay somehow
   // expires before this runs but 100ms is a long time in a unittest...). It
   // should instead cause the service thread to schedule itself for wakeup when
   // |delay1| expires.
@@ skipping 23 matching lines @@
 
   // Now wait for the second task to be fired.
   event2.Wait();
 
   // Which should only have fired after |delay2| was expired.
   EXPECT_GE(TimeTicks::Now() - test_begin_time, delay2);
 }
 
 }  // namespace internal
 }  // namespace base