cc: Generalize raster task notifications

cc/resources/raster_worker_pool.cc

Index: cc/resources/raster_worker_pool.cc
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index d175141f3f6308c688637857702b0ab9d9e10275..552b615620e423ed37861eeb3abdadc16c6b11a1 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -18,9 +18,7 @@ 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 =
@@ -39,10 +37,6 @@ class RasterTaskGraphRunner : public TaskGraphRunner,
 
   virtual ~RasterTaskGraphRunner() { NOTREACHED(); }
 
-  base::debug::TraceEventSyntheticDelay* synthetic_delay() {
-    return synthetic_delay_;
-  }
-
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
   virtual void Run() OVERRIDE {
@@ -50,7 +44,6 @@ class RasterTaskGraphRunner : public TaskGraphRunner,
   }
 
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
-  base::debug::TraceEventSyntheticDelay* synthetic_delay_;
 };
 
 base::LazyInstance<RasterTaskGraphRunner>::Leaky g_task_graph_runner =
@@ -64,13 +57,21 @@ 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();
   }
 
@@ -89,45 +90,10 @@ class RasterFinishedTaskImpl : public RasterizerTask {
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   const base::Closure on_raster_finished_callback_;
-
-  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::debug::TraceEventSyntheticDelay* synthetic_delay_;
   base::TimeTicks activation_delay_end_time_;
-  const size_t tasks_required_for_activation_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(RasterRequiredForActivationFinishedTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(RasterFinishedTaskImpl);
 };
 
 }  // namespace
@@ -143,6 +109,7 @@ unsigned RasterWorkerPool::kBenchmarkRasterTaskPriority = 0u;
 unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 2u;
 unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority =

[reveman, 2014/09/05 08:38:59]

remove

[ernstm, 2014/09/05 21:36:11]

Done.

     1u;
+unsigned RasterWorkerPool::kRasterTaskSetFinishedTaskPriority = 1u;
 unsigned RasterWorkerPool::kRasterTaskPriorityBase = 3u;
 
 RasterWorkerPool::RasterWorkerPool() {}
@@ -173,21 +140,10 @@ TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
 // 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));
-}
-
-// 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));
+    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