content: Improve thread priority for raster threads.

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 102 matching lines @@
   // tasks.
   cc::Task::Vector completed_tasks_;
 };
 
 RasterWorkerPool::RasterWorkerPool()
     : namespace_token_(GetNamespaceToken()),
       has_ready_to_run_tasks_cv_(&lock_),
       has_namespaces_with_finished_running_tasks_cv_(&lock_),
       shutdown_(false) {}
 
-void RasterWorkerPool::Start(
-    int num_threads,
-    const base::SimpleThread::Options& thread_options) {
+void RasterWorkerPool::Start(int num_foreground_threads) {
   DCHECK(threads_.empty());
-  while (threads_.size() < static_cast<size_t>(num_threads)) {
-    // Determine the categories that each thread can run.
+
+  while (threads_.size() < static_cast<size_t>(num_foreground_threads)) {
+    // Determine the categories that each foreground thread can run.
     std::vector<cc::TaskCategory> task_categories;
 
     // The first thread can run nonconcurrent tasks.
-    if (threads_.size() == 0) {
+    if (!threads_.size()) {
       task_categories.push_back(cc::TASK_CATEGORY_NONCONCURRENT_FOREGROUND);
     }
 
     // All threads can run foreground tasks.
     task_categories.push_back(cc::TASK_CATEGORY_FOREGROUND);
 
-    // The last thread can run background tasks.
-    if (threads_.size() == (static_cast<size_t>(num_threads) - 1)) {
-      task_categories.push_back(cc::TASK_CATEGORY_BACKGROUND);
-    }
-
-    scoped_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
+    scoped_ptr<base::SimpleThread> foreground_thread(new RasterWorkerPoolThread(
         base::StringPrintf("CompositorTileWorker%u",
                            static_cast<unsigned>(threads_.size() + 1))
             .c_str(),
-        thread_options, this, task_categories));
-    thread->Start();
-    threads_.push_back(std::move(thread));
+        base::SimpleThread::Options(), this, task_categories));
+    foreground_thread->Start();
+    threads_.push_back(std::move(foreground_thread));
   }
+
+  // Background thread can only run background tasks.

[ericrk, 2016/01/26 22:39:56]

I like this idea in general, but a few questions:
 - What happens when a low priority task running on a background thread is
suddenly promoted to high priority (due to a view change / rescheduling). Are we
OK with it continuing to run to completion on the lower priority thread? Maybe
this is ok as it's only ever one task at most?
 - This change allows background work to run at all times, even when FG work is
still pending. We have a lower priority here, so maybe it's fine?

+  std::vector<cc::TaskCategory> background_task_categories;
+  background_task_categories.push_back(cc::TASK_CATEGORY_BACKGROUND);
+
+  // Use background priority for background thread.
+  base::SimpleThread::Options thread_options;
+  thread_options.set_priority(base::ThreadPriority::BACKGROUND);
+
+  scoped_ptr<base::SimpleThread> background_thread(new RasterWorkerPoolThread(
+      base::StringPrintf("CompositorTileWorker%u",
+                         static_cast<unsigned>(threads_.size() + 1))
+          .c_str(),
+      thread_options, this, background_task_categories));
+  background_thread->Start();
+  threads_.push_back(std::move(background_thread));
 }
 
 void RasterWorkerPool::Shutdown() {
   WaitForTasksToFinishRunning(namespace_token_);
   CollectCompletedTasks(namespace_token_, &completed_tasks_);
   // Shutdown raster threads.
   {
     base::AutoLock lock(lock_);
 
     DCHECK(!work_queue_.HasReadyToRunTasks());
@@ skipping 194 matching lines @@
 
 // Overridden from cc::Task:
 void RasterWorkerPool::ClosureTask::RunOnWorkerThread() {
   closure_.Run();
   closure_.Reset();
 }
 
 RasterWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content