content: Rename RasterWorkerPool -> CategorizedWorkerPool.

content/renderer/categorized_worker_pool.cc

 // Copyright 2015 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 "content/renderer/raster_worker_pool.h"
+#include "content/renderer/categorized_worker_pool.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/raster/task_category.h"
 
 namespace content {
 namespace {
 
-// A thread which forwards to RasterWorkerPool::Run with the runnable
+// A thread which forwards to CategorizedWorkerPool::Run with the runnable
 // categories.
-class RasterWorkerPoolThread : public base::SimpleThread {
+class CategorizedWorkerPoolThread : public base::SimpleThread {
  public:
-  RasterWorkerPoolThread(const std::string& name_prefix,
-                         const Options& options,
-                         RasterWorkerPool* pool,
-                         std::vector<cc::TaskCategory> categories,
-                         base::ConditionVariable* has_ready_to_run_tasks_cv)
+  CategorizedWorkerPoolThread(
+      const std::string& name_prefix,
+      const Options& options,
+      CategorizedWorkerPool* pool,
+      std::vector<cc::TaskCategory> categories,
+      base::ConditionVariable* has_ready_to_run_tasks_cv)
       : SimpleThread(name_prefix, options),
         pool_(pool),
         categories_(categories),
         has_ready_to_run_tasks_cv_(has_ready_to_run_tasks_cv) {}
 
   void Run() override { pool_->Run(categories_, has_ready_to_run_tasks_cv_); }
 
  private:
-  RasterWorkerPool* const pool_;
+  CategorizedWorkerPool* const pool_;
   const std::vector<cc::TaskCategory> categories_;
   base::ConditionVariable* const has_ready_to_run_tasks_cv_;
 };
 
 }  // namespace
 
-// A sequenced task runner which posts tasks to a RasterWorkerPool.
-class RasterWorkerPool::RasterWorkerPoolSequencedTaskRunner
+// A sequenced task runner which posts tasks to a CategorizedWorkerPool.
+class CategorizedWorkerPool::CategorizedWorkerPoolSequencedTaskRunner
     : public base::SequencedTaskRunner {
  public:
-  explicit RasterWorkerPoolSequencedTaskRunner(
+  explicit CategorizedWorkerPoolSequencedTaskRunner(
       cc::TaskGraphRunner* task_graph_runner)
       : task_graph_runner_(task_graph_runner),
         namespace_token_(task_graph_runner->GetNamespaceToken()) {}
 
   // Overridden from base::TaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override {
     return PostNonNestableDelayedTask(from_here, task, delay);
   }
@@ skipping 29 matching lines @@
             cc::TaskGraph::Edge(graph_.nodes.back().task, node.task));
       }
       graph_.nodes.push_back(node);
     }
     task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
     completed_tasks_.clear();
     return true;
   }
 
  private:
-  ~RasterWorkerPoolSequencedTaskRunner() override {
+  ~CategorizedWorkerPoolSequencedTaskRunner() override {
     task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
     task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                               &completed_tasks_);
   };
 
   // Lock to exclusively access all the following members that are used to
   // implement the SequencedTaskRunner interfaces.
   base::Lock lock_;
 
   cc::TaskGraphRunner* task_graph_runner_;
   // Namespace used to schedule tasks in the task graph runner.
   cc::NamespaceToken namespace_token_;
   // List of tasks currently queued up for execution.
   cc::Task::Vector tasks_;
   // Graph object used for scheduling tasks.
   cc::TaskGraph graph_;
   // Cached vector to avoid allocation when getting the list of complete
   // tasks.
   cc::Task::Vector completed_tasks_;
 };
 
-RasterWorkerPool::RasterWorkerPool()
+CategorizedWorkerPool::CategorizedWorkerPool()
     : namespace_token_(GetNamespaceToken()),
       has_ready_to_run_foreground_tasks_cv_(&lock_),
       has_ready_to_run_background_tasks_cv_(&lock_),
       has_namespaces_with_finished_running_tasks_cv_(&lock_),
       shutdown_(false) {}
 
-void RasterWorkerPool::Start(int num_threads) {
+void CategorizedWorkerPool::Start(int num_threads) {
   DCHECK(threads_.empty());
 
   // Start |num_threads| threads for foreground work, including nonconcurrent
   // foreground work.
   std::vector<cc::TaskCategory> foreground_categories;
   foreground_categories.push_back(cc::TASK_CATEGORY_NONCONCURRENT_FOREGROUND);
   foreground_categories.push_back(cc::TASK_CATEGORY_FOREGROUND);
 
   for (int i = 0; i < num_threads; i++) {
-    std::unique_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
+    std::unique_ptr<base::SimpleThread> thread(new CategorizedWorkerPoolThread(
         base::StringPrintf("CompositorTileWorker%u",
                            static_cast<unsigned>(threads_.size() + 1))
             .c_str(),
         base::SimpleThread::Options(), this, foreground_categories,
         &has_ready_to_run_foreground_tasks_cv_));
     thread->Start();
     threads_.push_back(std::move(thread));
   }
 
   // Start a single thread for background work.
   std::vector<cc::TaskCategory> background_categories;
   background_categories.push_back(cc::TASK_CATEGORY_BACKGROUND);
 
   // Use background priority for background thread.
   base::SimpleThread::Options thread_options;
 #if !defined(OS_MACOSX)
   thread_options.set_priority(base::ThreadPriority::BACKGROUND);
 #endif
 
-  std::unique_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
+  std::unique_ptr<base::SimpleThread> thread(new CategorizedWorkerPoolThread(
       "CompositorTileWorkerBackground", thread_options, this,
       background_categories, &has_ready_to_run_background_tasks_cv_));
   thread->Start();
   threads_.push_back(std::move(thread));
 }
 
-void RasterWorkerPool::Shutdown() {
+void CategorizedWorkerPool::Shutdown() {
   WaitForTasksToFinishRunning(namespace_token_);
   CollectCompletedTasks(namespace_token_, &completed_tasks_);
   // Shutdown raster threads.
   {
     base::AutoLock lock(lock_);
 
     DCHECK(!work_queue_.HasReadyToRunTasks());
     DCHECK(!work_queue_.HasAnyNamespaces());
 
     DCHECK(!shutdown_);
     shutdown_ = true;
 
     // Wake up all workers so they exit.
     has_ready_to_run_foreground_tasks_cv_.Broadcast();
     has_ready_to_run_background_tasks_cv_.Broadcast();
   }
   while (!threads_.empty()) {
     threads_.back()->Join();
     threads_.pop_back();
   }
 }
 
 // Overridden from base::TaskRunner:
-bool RasterWorkerPool::PostDelayedTask(
+bool CategorizedWorkerPool::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeDelta delay) {
   base::AutoLock lock(lock_);
 
   // Remove completed tasks.
   DCHECK(completed_tasks_.empty());
   CollectCompletedTasksWithLockAcquired(namespace_token_, &completed_tasks_);
 
   cc::Task::Vector::iterator end = std::remove_if(
@@ skipping 12 matching lines @@
     graph_.nodes.push_back(
         cc::TaskGraph::Node(graph_task.get(), cc::TASK_CATEGORY_FOREGROUND,
                             0u /* priority */, 0u /* dependencies */));
   }
 
   ScheduleTasksWithLockAcquired(namespace_token_, &graph_);
   completed_tasks_.clear();
   return true;
 }
 
-bool RasterWorkerPool::RunsTasksOnCurrentThread() const {
+bool CategorizedWorkerPool::RunsTasksOnCurrentThread() const {
   return true;
 }
 
-void RasterWorkerPool::Run(const std::vector<cc::TaskCategory>& categories,
-                           base::ConditionVariable* has_ready_to_run_tasks_cv) {
+void CategorizedWorkerPool::Run(
+    const std::vector<cc::TaskCategory>& categories,
+    base::ConditionVariable* has_ready_to_run_tasks_cv) {
   base::AutoLock lock(lock_);
 
   while (true) {
     if (!RunTaskWithLockAcquired(categories)) {
       // We are no longer running tasks, which may allow another category to
       // start running. Signal other worker threads.
       SignalHasReadyToRunTasksWithLockAcquired();
 
       // Exit when shutdown is set and no more tasks are pending.
       if (shutdown_)
         break;
 
       // Wait for more tasks.
       has_ready_to_run_tasks_cv->Wait();
       continue;
     }
   }
 }
 
-void RasterWorkerPool::FlushForTesting() {
+void CategorizedWorkerPool::FlushForTesting() {
   base::AutoLock lock(lock_);
 
   while (!work_queue_.HasFinishedRunningTasksInAllNamespaces()) {
     has_namespaces_with_finished_running_tasks_cv_.Wait();
   }
 }
 
 scoped_refptr<base::SequencedTaskRunner>
-RasterWorkerPool::CreateSequencedTaskRunner() {
-  return new RasterWorkerPoolSequencedTaskRunner(this);
+CategorizedWorkerPool::CreateSequencedTaskRunner() {
+  return new CategorizedWorkerPoolSequencedTaskRunner(this);
 }
 
-RasterWorkerPool::~RasterWorkerPool() {}
+CategorizedWorkerPool::~CategorizedWorkerPool() {}
 
-cc::NamespaceToken RasterWorkerPool::GetNamespaceToken() {
+cc::NamespaceToken CategorizedWorkerPool::GetNamespaceToken() {
   base::AutoLock lock(lock_);
   return work_queue_.GetNamespaceToken();
 }
 
-void RasterWorkerPool::ScheduleTasks(cc::NamespaceToken token,
-                                     cc::TaskGraph* graph) {
+void CategorizedWorkerPool::ScheduleTasks(cc::NamespaceToken token,
+                                          cc::TaskGraph* graph) {
   TRACE_EVENT2("disabled-by-default-cc.debug",
-               "RasterWorkerPool::ScheduleTasks", "num_nodes",
+               "CategorizedWorkerPool::ScheduleTasks", "num_nodes",
                graph->nodes.size(), "num_edges", graph->edges.size());
   {
     base::AutoLock lock(lock_);
     ScheduleTasksWithLockAcquired(token, graph);
   }
 }
 
-void RasterWorkerPool::ScheduleTasksWithLockAcquired(cc::NamespaceToken token,
-                                                     cc::TaskGraph* graph) {
+void CategorizedWorkerPool::ScheduleTasksWithLockAcquired(
+    cc::NamespaceToken token,
+    cc::TaskGraph* graph) {
   DCHECK(token.IsValid());
   DCHECK(!cc::TaskGraphWorkQueue::DependencyMismatch(graph));
   DCHECK(!shutdown_);
 
   work_queue_.ScheduleTasks(token, graph);
 
   // There may be more work available, so wake up another worker thread.
   SignalHasReadyToRunTasksWithLockAcquired();
 }
 
-void RasterWorkerPool::WaitForTasksToFinishRunning(cc::NamespaceToken token) {
+void CategorizedWorkerPool::WaitForTasksToFinishRunning(
+    cc::NamespaceToken token) {
   TRACE_EVENT0("disabled-by-default-cc.debug",
-               "RasterWorkerPool::WaitForTasksToFinishRunning");
+               "CategorizedWorkerPool::WaitForTasksToFinishRunning");
 
   DCHECK(token.IsValid());
 
   {
     base::AutoLock lock(lock_);
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
 
     auto* task_namespace = work_queue_.GetNamespaceForToken(token);
 
     if (!task_namespace)
       return;
 
     while (!work_queue_.HasFinishedRunningTasksInNamespace(task_namespace))
       has_namespaces_with_finished_running_tasks_cv_.Wait();
 
     // There may be other namespaces that have finished running tasks, so wake
     // up another origin thread.
     has_namespaces_with_finished_running_tasks_cv_.Signal();
   }
 }
 
-void RasterWorkerPool::CollectCompletedTasks(
+void CategorizedWorkerPool::CollectCompletedTasks(
     cc::NamespaceToken token,
     cc::Task::Vector* completed_tasks) {
   TRACE_EVENT0("disabled-by-default-cc.debug",
-               "RasterWorkerPool::CollectCompletedTasks");
+               "CategorizedWorkerPool::CollectCompletedTasks");
 
   {
     base::AutoLock lock(lock_);
     CollectCompletedTasksWithLockAcquired(token, completed_tasks);
   }
 }
 
-void RasterWorkerPool::CollectCompletedTasksWithLockAcquired(
+void CategorizedWorkerPool::CollectCompletedTasksWithLockAcquired(
     cc::NamespaceToken token,
     cc::Task::Vector* completed_tasks) {
   DCHECK(token.IsValid());
   work_queue_.CollectCompletedTasks(token, completed_tasks);
 }
 
-bool RasterWorkerPool::RunTaskWithLockAcquired(
+bool CategorizedWorkerPool::RunTaskWithLockAcquired(
     const std::vector<cc::TaskCategory>& categories) {
   for (const auto& category : categories) {
     if (ShouldRunTaskForCategoryWithLockAcquired(category)) {
       RunTaskInCategoryWithLockAcquired(category);
       return true;
     }
   }
   return false;
 }
 
-void RasterWorkerPool::RunTaskInCategoryWithLockAcquired(
+void CategorizedWorkerPool::RunTaskInCategoryWithLockAcquired(
     cc::TaskCategory category) {
   TRACE_EVENT0("toplevel", "TaskGraphRunner::RunTask");
 
   lock_.AssertAcquired();
 
   auto prioritized_task = work_queue_.GetNextTaskToRun(category);
   cc::Task* task = prioritized_task.task;
 
   // There may be more work available, so wake up another worker thread.
   SignalHasReadyToRunTasksWithLockAcquired();
 
   {
     base::AutoUnlock unlock(lock_);
 
     task->RunOnWorkerThread();
   }
 
   work_queue_.CompleteTask(prioritized_task);
 
   // If namespace has finished running all tasks, wake up origin threads.
   if (work_queue_.HasFinishedRunningTasksInNamespace(
           prioritized_task.task_namespace))
     has_namespaces_with_finished_running_tasks_cv_.Signal();
 }
 
-bool RasterWorkerPool::ShouldRunTaskForCategoryWithLockAcquired(
+bool CategorizedWorkerPool::ShouldRunTaskForCategoryWithLockAcquired(
     cc::TaskCategory category) {
   lock_.AssertAcquired();
 
   if (!work_queue_.HasReadyToRunTasksForCategory(category))
     return false;
 
   if (category == cc::TASK_CATEGORY_BACKGROUND) {
     // Only run background tasks if there are no foreground tasks running or
     // ready to run.
     size_t num_running_foreground_tasks =
@@ skipping 12 matching lines @@
   // Enforce that only one nonconcurrent task runs at a time.
   if (category == cc::TASK_CATEGORY_NONCONCURRENT_FOREGROUND &&
       work_queue_.NumRunningTasksForCategory(
           cc::TASK_CATEGORY_NONCONCURRENT_FOREGROUND) > 0) {
     return false;
   }
 
   return true;
 }
 
-void RasterWorkerPool::SignalHasReadyToRunTasksWithLockAcquired() {
+void CategorizedWorkerPool::SignalHasReadyToRunTasksWithLockAcquired() {
   lock_.AssertAcquired();
 
   if (ShouldRunTaskForCategoryWithLockAcquired(cc::TASK_CATEGORY_FOREGROUND) ||
       ShouldRunTaskForCategoryWithLockAcquired(
           cc::TASK_CATEGORY_NONCONCURRENT_FOREGROUND)) {
     has_ready_to_run_foreground_tasks_cv_.Signal();
   }
 
   if (ShouldRunTaskForCategoryWithLockAcquired(cc::TASK_CATEGORY_BACKGROUND)) {
     has_ready_to_run_background_tasks_cv_.Signal();
   }
 }
 
-RasterWorkerPool::ClosureTask::ClosureTask(const base::Closure& closure)
+CategorizedWorkerPool::ClosureTask::ClosureTask(const base::Closure& closure)
     : closure_(closure) {}
 
 // Overridden from cc::Task:
-void RasterWorkerPool::ClosureTask::RunOnWorkerThread() {
+void CategorizedWorkerPool::ClosureTask::RunOnWorkerThread() {
   closure_.Run();
   closure_.Reset();
 }
 
-RasterWorkerPool::ClosureTask::~ClosureTask() {}
+CategorizedWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content