cc: Generalize raster task notifications

cc/resources/raster_worker_pool.cc

 // Copyright 2013 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 "cc/resources/raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event_synthetic_delay.h"
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/simple_thread.h"
 #include "cc/base/scoped_ptr_deque.h"
 
 namespace cc {
 namespace {
 
 class RasterTaskGraphRunner : public TaskGraphRunner,
                               public base::DelegateSimpleThread::Delegate {
  public:
-  RasterTaskGraphRunner()
-      : synthetic_delay_(base::debug::TraceEventSyntheticDelay::Lookup(
-            "cc.RasterRequiredForActivation")) {
+  RasterTaskGraphRunner() {
     size_t num_threads = RasterWorkerPool::GetNumRasterThreads();
     while (workers_.size() < num_threads) {
       scoped_ptr<base::DelegateSimpleThread> worker =
           make_scoped_ptr(new base::DelegateSimpleThread(
               this,
               base::StringPrintf("CompositorRasterWorker%u",
                                  static_cast<unsigned>(workers_.size() + 1))
                   .c_str()));
       worker->Start();
 #if defined(OS_ANDROID) || defined(OS_LINUX)
       worker->SetThreadPriority(base::kThreadPriority_Background);
 #endif
       workers_.push_back(worker.Pass());
     }
   }
 
   virtual ~RasterTaskGraphRunner() { NOTREACHED(); }
 
-  base::debug::TraceEventSyntheticDelay* synthetic_delay() {
-    return synthetic_delay_;
-  }
-
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
   virtual void Run() OVERRIDE {
     TaskGraphRunner::Run();
   }
 
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
-  base::debug::TraceEventSyntheticDelay* synthetic_delay_;
 };
 
 base::LazyInstance<RasterTaskGraphRunner>::Leaky g_task_graph_runner =
     LAZY_INSTANCE_INITIALIZER;
 
 const int kDefaultNumRasterThreads = 1;
 
 int g_num_raster_threads = 0;
 
 class RasterFinishedTaskImpl : public RasterizerTask {
  public:
   explicit RasterFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
-      const base::Closure& on_raster_finished_callback)
+      const base::Closure& on_raster_finished_callback,
+      base::debug::TraceEventSyntheticDelay* synthetic_delay)
       : task_runner_(task_runner),
-        on_raster_finished_callback_(on_raster_finished_callback) {}
+        on_raster_finished_callback_(on_raster_finished_callback),
+        synthetic_delay_(synthetic_delay) {
+    if (synthetic_delay_)
+      synthetic_delay_->BeginParallel(&activation_delay_end_time_);
+  }
 
   // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnWorkerThread");
+
+    if (synthetic_delay_)
+      synthetic_delay_->EndParallel(activation_delay_end_time_);
     RasterFinished();
   }
 
   // Overridden from RasterizerTask:
   virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
   virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
   virtual void RunReplyOnOriginThread() OVERRIDE {}
 
  protected:
   virtual ~RasterFinishedTaskImpl() {}
 
   void RasterFinished() {
     task_runner_->PostTask(FROM_HERE, on_raster_finished_callback_);
   }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   const base::Closure on_raster_finished_callback_;
+  base::debug::TraceEventSyntheticDelay* synthetic_delay_;
+  base::TimeTicks activation_delay_end_time_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterFinishedTaskImpl);
 };
 
-class RasterRequiredForActivationFinishedTaskImpl
-    : public RasterFinishedTaskImpl {
- public:
-  RasterRequiredForActivationFinishedTaskImpl(
-      base::SequencedTaskRunner* task_runner,
-      const base::Closure& on_raster_finished_callback,
-      size_t tasks_required_for_activation_count)
-      : RasterFinishedTaskImpl(task_runner, on_raster_finished_callback),
-        tasks_required_for_activation_count_(
-            tasks_required_for_activation_count) {
-    if (tasks_required_for_activation_count_) {
-      g_task_graph_runner.Get().synthetic_delay()->BeginParallel(
-          &activation_delay_end_time_);
-    }
-  }
-
-  // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {
-    TRACE_EVENT0(
-        "cc", "RasterRequiredForActivationFinishedTaskImpl::RunOnWorkerThread");
-
-    if (tasks_required_for_activation_count_) {
-      g_task_graph_runner.Get().synthetic_delay()->EndParallel(
-          activation_delay_end_time_);
-    }
-    RasterFinished();
-  }
-
- private:
-  virtual ~RasterRequiredForActivationFinishedTaskImpl() {}
-
-  base::TimeTicks activation_delay_end_time_;
-  const size_t tasks_required_for_activation_count_;
-
-  DISALLOW_COPY_AND_ASSIGN(RasterRequiredForActivationFinishedTaskImpl);
-};
-
 }  // namespace
 
 // This allows an external rasterize on-demand system to run raster tasks
 // with highest priority using the same task graph runner instance.
 unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u;
 // This allows a micro benchmark system to run tasks with highest priority,
 // since it should finish as quickly as possible.
 unsigned RasterWorkerPool::kBenchmarkRasterTaskPriority = 0u;
 // Task priorities that make sure raster finished tasks run before any
 // remaining raster tasks.
-unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 2u;
-unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority =
-    1u;
-unsigned RasterWorkerPool::kRasterTaskPriorityBase = 3u;
+unsigned RasterWorkerPool::kRasterTaskSetFinishedTaskPriority = 1u;
+unsigned RasterWorkerPool::kRasterTaskPriorityBase = 2u;
+
+RasterWorkerPool::TaskSetSizes::TaskSetSizes() {
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++)
+    sizes_[task_set] = 0;
+}
+
+RasterWorkerPool::TaskSetSizes::TaskSetSizes(const RasterTaskQueue* queue) {
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++)
+    sizes_[task_set] = 0;
+
+  for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+       it != queue->items.end();
+       ++it) {
+    *this += it->task_sets;
+  }
+}
+
+TaskSetCollection RasterWorkerPool::TaskSetSizes::ToTaskSetCollection() const {
+  TaskSetCollection task_set_collection;
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {
+    if (sizes_[task_set] > 0)
+      task_set_collection[task_set] = true;
+  }
+  return task_set_collection;
+}
+
+size_t& RasterWorkerPool::TaskSetSizes::operator[](TaskSet task_set) {
+  return sizes_[task_set];
+}
+
+const size_t& RasterWorkerPool::TaskSetSizes::operator[](
+    TaskSet task_set) const {
+  return sizes_[task_set];
+}
+
+bool RasterWorkerPool::TaskSetSizes::operator==(
+    const TaskSetSizes& other) const {
+  for (size_t i = 0; i < kNumberOfTaskSets; i++) {
+    if (sizes_[i] != other.sizes_[i])
+      return false;
+  }
+  return true;
+}
+
+void RasterWorkerPool::TaskSetSizes::operator+=(
+    const TaskSetCollection& task_set_collection) {
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {
+    if (task_set_collection[task_set])
+      sizes_[task_set]++;
+  }
+}
+
+void RasterWorkerPool::TaskSetSizes::operator-=(
+    const TaskSetCollection& task_set_collection) {
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {
+    if (task_set_collection[task_set])
+      sizes_[task_set]--;
+  }
+}
 
 RasterWorkerPool::RasterWorkerPool() {}
 
 RasterWorkerPool::~RasterWorkerPool() {}
 
 // static
 void RasterWorkerPool::SetNumRasterThreads(int num_threads) {
   DCHECK_LT(0, num_threads);
   DCHECK_EQ(0, g_num_raster_threads);
 
   g_num_raster_threads = num_threads;
 }
 
 // static
 int RasterWorkerPool::GetNumRasterThreads() {
   if (!g_num_raster_threads)
     g_num_raster_threads = kDefaultNumRasterThreads;
 
   return g_num_raster_threads;
 }
 
 // static
 TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
   return g_task_graph_runner.Pointer();
 }
 
 // static
 scoped_refptr<RasterizerTask> RasterWorkerPool::CreateRasterFinishedTask(
     base::SequencedTaskRunner* task_runner,
-    const base::Closure& on_raster_finished_callback) {
-  return make_scoped_refptr(
-      new RasterFinishedTaskImpl(task_runner, on_raster_finished_callback));
+    const base::Closure& on_raster_finished_callback,
+    base::debug::TraceEventSyntheticDelay* synthetic_delay) {
+  return make_scoped_refptr(new RasterFinishedTaskImpl(
+      task_runner, on_raster_finished_callback, synthetic_delay));
 }
 
 // static
-scoped_refptr<RasterizerTask>
-RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
-    size_t tasks_required_for_activation_count,
-    base::SequencedTaskRunner* task_runner,
-    const base::Closure& on_raster_finished_callback) {
-  return make_scoped_refptr(new RasterRequiredForActivationFinishedTaskImpl(
-      task_runner,
-      on_raster_finished_callback,
-      tasks_required_for_activation_count));
-}
-
-// static
 void RasterWorkerPool::ScheduleTasksOnOriginThread(RasterizerTaskClient* client,
                                                    TaskGraph* graph) {
   TRACE_EVENT0("cc", "Rasterizer::ScheduleTasksOnOriginThread");
 
   for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
        it != graph->nodes.end();
        ++it) {
     TaskGraph::Node& node = *it;
     RasterizerTask* task = static_cast<RasterizerTask*>(node.task);
 
@@ skipping 45 matching lines @@
     if (decode_it == graph->nodes.end())
       InsertNodeForTask(graph, decode_task, priority, 0u);
 
     graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, priority, dependencies);
 }
 
 }  // namespace cc