Rename SchedulerWorkerThread* to SchedulerWorker*

base/task_scheduler/scheduler_worker_pool_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/scheduler_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <unordered_set>
@@ skipping 54 matching lines @@
     worker_pool_ = SchedulerWorkerPoolImpl::Create(
         "TestWorkerPoolWithFileIO", ThreadPriority::NORMAL,
         kNumWorkersInWorkerPool, IORestriction::ALLOWED,
         Bind(&TaskSchedulerWorkerPoolImplTest::ReEnqueueSequenceCallback,
              Unretained(this)),
         &task_tracker_, &delayed_task_manager_);
     ASSERT_TRUE(worker_pool_);
   }
 
   void TearDown() override {
-    worker_pool_->WaitForAllWorkerWorkersIdleForTesting();
+    worker_pool_->WaitForAllWorkersIdleForTesting();
     worker_pool_->JoinForTesting();
   }
 
   std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool_;
 
   TaskTracker task_tracker_;
   TestDelayedTaskManager delayed_task_manager_;
 
  private:
   void ReEnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
     // In production code, this callback would be implemented by the
     // TaskScheduler which would first determine which PriorityQueue the
     // sequence must be re-enqueued.
     const SequenceSortKey sort_key(sequence->GetSortKey());
     worker_pool_->ReEnqueueSequence(std::move(sequence), sort_key);
   }
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplTest);
 };
 
 using PostNestedTask = test::TestTaskFactory::PostNestedTask;
 
 class ThreadPostingTasks : public SimpleThread {
  public:
   enum class WaitBeforePostTask {
     NO_WAIT,
     WAIT_FOR_ALL_THREADS_IDLE,

[fdoray, 2016/06/20 15:08:40]

WAIT_FOR_ALL_WORKERS_IDLE

[robliao, 2016/06/20 17:50:09]

Done.

   };
 
   // Constructs a thread that posts tasks to |worker_pool| through an
   // |execution_mode| task runner. If |wait_before_post_task| is
-  // WAIT_FOR_ALL_THREADS_IDLE, the thread waits until all worker threads in
+  // WAIT_FOR_ALL_THREADS_IDLE, the thread waits until all workers in
   // |worker_pool| are idle before posting a new task. If |post_nested_task| is
   // YES, each task posted by this thread posts another task when it runs.
   ThreadPostingTasks(SchedulerWorkerPoolImpl* worker_pool,
                      ExecutionMode execution_mode,
                      WaitBeforePostTask wait_before_post_task,
                      PostNestedTask post_nested_task)
       : SimpleThread("ThreadPostingTasks"),
         worker_pool_(worker_pool),
         wait_before_post_task_(wait_before_post_task),
         post_nested_task_(post_nested_task),
         factory_(worker_pool_->CreateTaskRunnerWithTraits(TaskTraits(),
                                                           execution_mode),
                  execution_mode) {
     DCHECK(worker_pool_);
   }
 
   const test::TestTaskFactory* factory() const { return &factory_; }
 
  private:
   void Run() override {
     EXPECT_FALSE(factory_.task_runner()->RunsTasksOnCurrentThread());
 
     for (size_t i = 0; i < kNumTasksPostedPerThread; ++i) {
       if (wait_before_post_task_ ==
           WaitBeforePostTask::WAIT_FOR_ALL_THREADS_IDLE) {
-        worker_pool_->WaitForAllWorkerWorkersIdleForTesting();
+        worker_pool_->WaitForAllWorkersIdleForTesting();
       }
       EXPECT_TRUE(factory_.PostTask(post_nested_task_, Closure()));
     }
   }
 
   SchedulerWorkerPoolImpl* const worker_pool_;
   const scoped_refptr<TaskRunner> task_runner_;
   const WaitBeforePostTask wait_before_post_task_;
   const PostNestedTask post_nested_task_;
   test::TestTaskFactory factory_;
@@ skipping 18 matching lines @@
         PostNestedTask::NO)));
     threads_posting_tasks.back()->Start();
   }
 
   // Wait for all tasks to run.
   for (const auto& thread_posting_tasks : threads_posting_tasks) {
     thread_posting_tasks->Join();
     thread_posting_tasks->factory()->WaitForAllTasksToRun();
   }
 
-  // Wait until all worker threads are idle to be sure that no task accesses
+  // Wait until all workers are idle to be sure that no task accesses
   // its TestTaskFactory after |thread_posting_tasks| is destroyed.
-  worker_pool_->WaitForAllWorkerWorkersIdleForTesting();
+  worker_pool_->WaitForAllWorkersIdleForTesting();
 }
 
 TEST_P(TaskSchedulerWorkerPoolImplTest, PostTasksWaitAllThreadsIdle) {

[fdoray, 2016/06/20 15:08:40]

WaitAllWorkersIdle

[robliao, 2016/06/20 17:50:09]

Done.

-  // Create threads to post tasks. To verify that worker threads can sleep and
-  // be woken up when new tasks are posted, wait for all threads to become idle
-  // before posting a new task.
+  // Create threads to post tasks. To verify that workers can sleep and be woken
+  // up when new tasks are posted, wait for all threads to become idle before

[fdoray, 2016/06/20 15:08:40]

for all *workers* to become

[robliao, 2016/06/20 17:50:09]

Done.

+  // posting a new task.
   std::vector<std::unique_ptr<ThreadPostingTasks>> threads_posting_tasks;
   for (size_t i = 0; i < kNumThreadsPostingTasks; ++i) {
     threads_posting_tasks.push_back(WrapUnique(new ThreadPostingTasks(
         worker_pool_.get(), GetParam(),
         WaitBeforePostTask::WAIT_FOR_ALL_THREADS_IDLE, PostNestedTask::NO)));
     threads_posting_tasks.back()->Start();
   }
 
   // Wait for all tasks to run.
   for (const auto& thread_posting_tasks : threads_posting_tasks) {
     thread_posting_tasks->Join();
     thread_posting_tasks->factory()->WaitForAllTasksToRun();
   }
 
-  // Wait until all worker threads are idle to be sure that no task accesses
-  // its TestTaskFactory after |thread_posting_tasks| is destroyed.
-  worker_pool_->WaitForAllWorkerWorkersIdleForTesting();
+  // Wait until all workers are idle to be sure that no task accesses its
+  // TestTaskFactory after |thread_posting_tasks| is destroyed.
+  worker_pool_->WaitForAllWorkersIdleForTesting();
 }
 
 TEST_P(TaskSchedulerWorkerPoolImplTest, NestedPostTasks) {
   // Create threads to post tasks. Each task posted by these threads will post
   // another task when it runs.
   std::vector<std::unique_ptr<ThreadPostingTasks>> threads_posting_tasks;
   for (size_t i = 0; i < kNumThreadsPostingTasks; ++i) {
     threads_posting_tasks.push_back(WrapUnique(new ThreadPostingTasks(
         worker_pool_.get(), GetParam(), WaitBeforePostTask::NO_WAIT,
         PostNestedTask::YES)));
     threads_posting_tasks.back()->Start();
   }
 
   // Wait for all tasks to run.
   for (const auto& thread_posting_tasks : threads_posting_tasks) {
     thread_posting_tasks->Join();
     thread_posting_tasks->factory()->WaitForAllTasksToRun();
   }
 
-  // Wait until all worker threads are idle to be sure that no task accesses
-  // its TestTaskFactory after |thread_posting_tasks| is destroyed.
-  worker_pool_->WaitForAllWorkerWorkersIdleForTesting();
+  // Wait until all workers are idle to be sure that no task accesses its
+  // TestTaskFactory after |thread_posting_tasks| is destroyed.
+  worker_pool_->WaitForAllWorkersIdleForTesting();
 }
 
 TEST_P(TaskSchedulerWorkerPoolImplTest, PostTasksWithOneAvailableThread) {

[fdoray, 2016/06/20 15:08:40]

OneAvailableWorker

[robliao, 2016/06/20 17:50:09]

Done.

   // Post blocking tasks to keep all threads busy except one until |event| is

[fdoray, 2016/06/20 15:08:40]

all *workers* busy

[robliao, 2016/06/20 17:50:09]

Done.

   // signaled. Use different factories so that tasks are added to different
   // sequences and can run simultaneously when the execution mode is SEQUENCED.
   WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
   std::vector<std::unique_ptr<test::TestTaskFactory>> blocked_task_factories;
   for (size_t i = 0; i < (kNumWorkersInWorkerPool - 1); ++i) {
     blocked_task_factories.push_back(WrapUnique(new test::TestTaskFactory(
         worker_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam()),
         GetParam())));
     EXPECT_TRUE(blocked_task_factories.back()->PostTask(
         PostNestedTask::NO, Bind(&WaitableEvent::Wait, Unretained(&event))));
     blocked_task_factories.back()->WaitForAllTasksToRun();
   }
 
   // Post |kNumTasksPostedPerThread| tasks that should all run despite the fact
   // that only one thread in |worker_pool_| isn't busy.

[fdoray, 2016/06/20 15:08:40]

one *worker*

[robliao, 2016/06/20 17:50:09]

Done.

   test::TestTaskFactory short_task_factory(
       worker_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam()),
       GetParam());
   for (size_t i = 0; i < kNumTasksPostedPerThread; ++i)
     EXPECT_TRUE(short_task_factory.PostTask(PostNestedTask::NO, Closure()));
   short_task_factory.WaitForAllTasksToRun();
 
   // Release tasks waiting on |event|.
   event.Signal();
 
-  // Wait until all worker threads are idle to be sure that no task accesses
+  // Wait until all workers are idle to be sure that no task accesses
   // its TestTaskFactory after it is destroyed.
-  worker_pool_->WaitForAllWorkerWorkersIdleForTesting();
+  worker_pool_->WaitForAllWorkersIdleForTesting();
 }
 
 TEST_P(TaskSchedulerWorkerPoolImplTest, Saturate) {
   // Verify that it is possible to have |kNumWorkersInWorkerPool|
   // tasks/sequences running simultaneously. Use different factories so that the
   // blocking tasks are added to different sequences and can run simultaneously
   // when the execution mode is SEQUENCED.
   WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
   std::vector<std::unique_ptr<test::TestTaskFactory>> factories;
   for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
     factories.push_back(WrapUnique(new test::TestTaskFactory(
         worker_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam()),
         GetParam())));
     EXPECT_TRUE(factories.back()->PostTask(
         PostNestedTask::NO, Bind(&WaitableEvent::Wait, Unretained(&event))));
     factories.back()->WaitForAllTasksToRun();
   }
 
   // Release tasks waiting on |event|.
   event.Signal();
 
-  // Wait until all worker threads are idle to be sure that no task accesses
+  // Wait until all workers are idle to be sure that no task accesses
   // its TestTaskFactory after it is destroyed.
-  worker_pool_->WaitForAllWorkerWorkersIdleForTesting();
+  worker_pool_->WaitForAllWorkersIdleForTesting();
 }
 
 // Verify that a Task can't be posted after shutdown.
 TEST_P(TaskSchedulerWorkerPoolImplTest, PostTaskAfterShutdown) {
   auto task_runner =
       worker_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam());
   task_tracker_.Shutdown();
   EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRunCallback)));
 }
 
@@ skipping 91 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(IOAllowed,
                         TaskSchedulerWorkerPoolImplIORestrictionTest,
                         ::testing::Values(IORestriction::ALLOWED));
 INSTANTIATE_TEST_CASE_P(IODisallowed,
                         TaskSchedulerWorkerPoolImplIORestrictionTest,
                         ::testing::Values(IORestriction::DISALLOWED));
 
 }  // namespace internal
 }  // namespace base