cc: Generalize raster task notifications

cc/resources/raster_worker_pool.h

 // 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.
 
 #ifndef CC_RESOURCES_RASTER_WORKER_POOL_H_
 #define CC_RESOURCES_RASTER_WORKER_POOL_H_
 
 #include "cc/resources/rasterizer.h"
 
 namespace base {
 class SequencedTaskRunner;
 }
 
 namespace cc {
 
 class CC_EXPORT RasterWorkerPool {
  public:
   static unsigned kOnDemandRasterTaskPriority;
   static unsigned kBenchmarkRasterTaskPriority;
   static unsigned kRasterFinishedTaskPriority;
-  static unsigned kRasterRequiredForActivationFinishedTaskPriority;
   static unsigned kRasterTaskPriorityBase;
 
+  class TaskSetSizes {

[reveman, 2014/09/12 16:33:51]

While convenient, I find the use of this class with its overloaded operators a
bit hard to read. It's fine for PBRWP as I don't see a better way to keep track
of all these counts there. However, I'd like it to be constrained to that class
(PixelBufferRasterWorkerPool) and simply use "size_t
task_count[kNumberOfTaskSets]" elsewhere.

The reasoning would be that all this counting will go away as we remove/refactor
synthetic delays, except for PBRWP where we still need it (and PBRWP might just
go away completely if 1-copy works out as expected). I'd rather not have it
exposed through the Rasterizer API if not needed long term. I've been wanting to
remove the existing count from the Rasterizer API for some time and adding
something more complicated there would be sad..

[ernstm, 2014/09/13 01:26:51]

Done.

+   public:
+    TaskSetSizes();
+    explicit TaskSetSizes(const RasterTaskQueue* queue);

[reveman, 2014/09/12 16:33:51]

nit: blank line between ctor/dtor and other functions.

[ernstm, 2014/09/13 01:26:51]

Done.

+    TaskSetCollection ToTaskSetCollection() const;
+    size_t& operator[](TaskSet task_set);
+    const size_t& operator[](TaskSet task_set) const;
+    bool operator==(const TaskSetSizes& other) const;
+    void operator+=(const TaskSetCollection& task_set_collection);
+    void operator-=(const TaskSetCollection& task_set_collection);
+
+   private:
+    size_t sizes_[kNumberOfTaskSets];
+  };
+
   RasterWorkerPool();
   virtual ~RasterWorkerPool();
 
   // Set the number of threads to use for the global TaskGraphRunner instance.
   // This can only be called once and must be called prior to
   // GetNumRasterThreads().
   static void SetNumRasterThreads(int num_threads);
 
   // Returns the number of threads used for the global TaskGraphRunner instance.
   static int GetNumRasterThreads();
 
   // Returns a pointer to the global TaskGraphRunner instance.
   static TaskGraphRunner* GetTaskGraphRunner();
 
   // Utility function that can be used to create a "raster finished" task that
   // posts |callback| to |task_runner| when run.
   static scoped_refptr<RasterizerTask> CreateRasterFinishedTask(
       base::SequencedTaskRunner* task_runner,
-      const base::Closure& callback);
-
-  // Utility function that can be used to create a "raster required for
-  // activation finished" task that posts |callback| to |task_runner| when run.
-  static scoped_refptr<RasterizerTask>
-      CreateRasterRequiredForActivationFinishedTask(
-          size_t tasks_required_for_activation_count,
-          base::SequencedTaskRunner* task_runner,
-          const base::Closure& callback);
+      const base::Closure& callback,
+      base::debug::TraceEventSyntheticDelay* synthetic_delay);
 
   // Utility function that can be used to call ::ScheduleOnOriginThread() for
   // each task in |graph|.
   static void ScheduleTasksOnOriginThread(RasterizerTaskClient* client,
                                           TaskGraph* graph);
 
   // Utility function that can be used to build a task graph. Inserts a node
   // that represents |task| in |graph|. See TaskGraph definition for valid
   // |priority| values.
   static void InsertNodeForTask(TaskGraph* graph,
                                 RasterizerTask* task,
                                 unsigned priority,
                                 size_t dependencies);
 
   // Utility function that can be used to build a task graph. Inserts nodes that
   // represent |task| and all its image decode dependencies in |graph|.
   static void InsertNodesForRasterTask(
       TaskGraph* graph,
       RasterTask* task,
       const ImageDecodeTask::Vector& decode_tasks,
       unsigned priority);
 
   // Type-checking downcast routine.
   virtual Rasterizer* AsRasterizer() = 0;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RASTER_WORKER_POOL_H_