content: Depict priority in raster worker thread's name.

content/renderer/raster_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 <string>
 #include <utility>
 #include <vector>
 
@@ skipping 106 matching lines @@
   cc::Task::Vector completed_tasks_;
 };
 
 RasterWorkerPool::RasterWorkerPool()
     : 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::CreateAndStartRasterWorkerPoolThread(
+    const base::SimpleThread::Options& thread_options,
+    const std::vector<cc::TaskCategory>& categories,
+    base::ConditionVariable* has_ready_to_run_tasks_cv) {
+  scoped_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
+      base::StringPrintf(
+          "CompositorTileWorker%u(%s)",
+          static_cast<unsigned>(threads_.size() + 1),
+          base::GetThreadPriorityAbbr(thread_options.priority()).c_str())
+          .c_str(),
+      thread_options, this, categories, has_ready_to_run_tasks_cv));
+  thread->Start();
+  threads_.push_back(std::move(thread));
+}
+
 void RasterWorkerPool::Start(int num_threads) {
   DCHECK(threads_.empty());
 
+  base::SimpleThread::Options thread_options;
+
   // 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++) {
-    scoped_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
-        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));
+    CreateAndStartRasterWorkerPoolThread(
+        thread_options, foreground_categories,
+        &has_ready_to_run_foreground_tasks_cv_);
   }
 
+  // Use background priority for background thread.
+#if !defined(OS_MACOSX)
+  thread_options.set_priority(base::ThreadPriority::BACKGROUND);
+#endif
   // 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
-
-  scoped_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
-      base::StringPrintf("CompositorTileWorker%u",

[reveman, 2016/03/24 15:40:46]

Can we reduce this patch to a one line change here at l.158 that simply
s/CompositorTileWorker/CompositorBackgroundTileWorker/ ?

[prashant.n, 2016/03/24 17:13:29]

Okay. I'll reduce the patch. May be later we can add if we have many priorities
for different task workers.

-                         static_cast<unsigned>(threads_.size() + 1))
-          .c_str(),
-      thread_options, this, background_categories,
-      &has_ready_to_run_background_tasks_cv_));
-  thread->Start();
-  threads_.push_back(std::move(thread));
+  CreateAndStartRasterWorkerPoolThread(thread_options, background_categories,
+                                       &has_ready_to_run_background_tasks_cv_);
 }
 
 void RasterWorkerPool::Shutdown() {
   WaitForTasksToFinishRunning(namespace_token_);
   CollectCompletedTasks(namespace_token_, &completed_tasks_);
   // Shutdown raster threads.
   {
     base::AutoLock lock(lock_);
 
     DCHECK(!work_queue_.HasReadyToRunTasks());
@@ skipping 252 matching lines @@
 
 // Overridden from cc::Task:
 void RasterWorkerPool::ClosureTask::RunOnWorkerThread() {
   closure_.Run();
   closure_.Reset();
 }
 
 RasterWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content