Test dynamic priorities on android (1F + 1B)

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>
 
 #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
 // categories.
-class RasterWorkerPoolThread : public base::SimpleThread {
+class RasterWorkerPoolThread : public base::TestSimpleThread {
  public:
-  RasterWorkerPoolThread(const std::string& name_prefix,
+  RasterWorkerPoolThread(const TestSimpleThread::PrioritySet& priorities,
+                         const std::string& name_prefix,
                          const Options& options,
                          RasterWorkerPool* pool,
                          std::vector<cc::TaskCategory> categories,
                          base::ConditionVariable* has_ready_to_run_tasks_cv)
-      : SimpleThread(name_prefix, options),
+      : TestSimpleThread(priorities, 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_); }
+  void Run() override {
+    pool_->Run(this, categories_, has_ready_to_run_tasks_cv_);
+  }
 
  private:
   RasterWorkerPool* 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.
@@ skipping 81 matching lines @@
 
 void RasterWorkerPool::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);
 
+  base::TestSimpleThread::PrioritySet only_foreground(
+      base::ThreadPriority::NORMAL, base::ThreadPriority::NORMAL,
+      base::ThreadPriority::NORMAL);
+
+  base::TestSimpleThread::PrioritySet dynamic_background(
+      base::ThreadPriority::BACKGROUND, base::ThreadPriority::BACKGROUND,
+      base::ThreadPriority::NORMAL);
+
+  // Create N normal priority threads and 1 background priority dynamic thread.
   for (int i = 0; i < num_threads; i++) {
     scoped_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
+        only_foreground,
         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
 
   scoped_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
+      dynamic_background,
       base::StringPrintf("CompositorTileWorker%u",
                          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));
 }
 
 void RasterWorkerPool::Shutdown() {
@@ skipping 50 matching lines @@
 
   ScheduleTasksWithLockAcquired(namespace_token_, &graph_);
   completed_tasks_.clear();
   return true;
 }
 
 bool RasterWorkerPool::RunsTasksOnCurrentThread() const {
   return true;
 }
 
-void RasterWorkerPool::Run(const std::vector<cc::TaskCategory>& categories,
+void RasterWorkerPool::Run(base::TestSimpleThread* runner,
+                           const std::vector<cc::TaskCategory>& categories,
                            base::ConditionVariable* has_ready_to_run_tasks_cv) {
   base::AutoLock lock(lock_);
 
   while (true) {
-    if (!RunTaskWithLockAcquired(categories)) {
+    if (!RunTaskWithLockAcquired(runner, 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();
@@ skipping 67 matching lines @@
     // up another origin thread.
     has_namespaces_with_finished_running_tasks_cv_.Signal();
   }
 }
 
 void RasterWorkerPool::CollectCompletedTasks(
     cc::NamespaceToken token,
     cc::Task::Vector* completed_tasks) {
   TRACE_EVENT0("disabled-by-default-cc.debug",
                "RasterWorkerPool::CollectCompletedTasks");
-
   {
     base::AutoLock lock(lock_);
     CollectCompletedTasksWithLockAcquired(token, completed_tasks);
   }
 }
 
 void RasterWorkerPool::CollectCompletedTasksWithLockAcquired(
     cc::NamespaceToken token,
     cc::Task::Vector* completed_tasks) {
   DCHECK(token.IsValid());
   work_queue_.CollectCompletedTasks(token, completed_tasks);
 }
 
 bool RasterWorkerPool::RunTaskWithLockAcquired(
+    base::TestSimpleThread* runner,
     const std::vector<cc::TaskCategory>& categories) {
   for (const auto& category : categories) {
     if (ShouldRunTaskForCategoryWithLockAcquired(category)) {
-      RunTaskInCategoryWithLockAcquired(category);
+      RunTaskInCategoryWithLockAcquired(runner, category);
       return true;
     }
   }
   return false;
 }
 
 void RasterWorkerPool::RunTaskInCategoryWithLockAcquired(
+    base::TestSimpleThread* runner,
     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();
 
+  task->SetRunner(runner);
   // Call WillRun() before releasing |lock_| and running task.
   task->WillRun();
 
   {
     base::AutoUnlock unlock(lock_);
 
     task->RunOnWorkerThread();
   }
 
   // This will mark task as finished running.
   task->DidRun();
 
   work_queue_.CompleteTask(prioritized_task);
 
+  if (task->IsRasterTask())
+    runner->Restore();
+
+  task->SetRunner(nullptr);
+
   // 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(
     cc::TaskCategory category) {
   lock_.AssertAcquired();
 
@@ skipping 45 matching lines @@
 
 // Overridden from cc::Task:
 void RasterWorkerPool::ClosureTask::RunOnWorkerThread() {
   closure_.Run();
   closure_.Reset();
 }
 
 RasterWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content