cc: Move task graph construction to RasterWorkerPool classes.

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 <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 12 matching lines @@
 namespace cc {
 class PicturePileImpl;
 class PixelBufferRasterWorkerPool;
 class Resource;
 
 namespace internal {
 
 class CC_EXPORT RasterWorkerPoolTask
     : public base::RefCounted<RasterWorkerPoolTask> {
  public:
-  typedef std::vector<scoped_refptr<RasterWorkerPoolTask> > TaskVector;
+  typedef std::vector<scoped_refptr<WorkerPoolTask> > TaskVector;
 
   // Returns true if |device| was written to. False indicate that
   // the content of |device| is undefined and the resource doesn't
   // need to be initialized.
   virtual bool RunOnThread(SkDevice* device, unsigned thread_index) = 0;
   virtual void DispatchCompletionCallback() = 0;
 
   void DidRun(bool was_canceled);
   bool HasFinishedRunning() const;
   bool WasCanceled() const;
   void DidComplete();
   bool HasCompleted() const;
 
   const Resource* resource() const { return resource_; }
-  const WorkerPoolTask::TaskVector& dependencies() const {
-    return dependencies_;
-  }
+  const TaskVector& dependencies() const { return dependencies_; }
 
  protected:
   friend class base::RefCounted<RasterWorkerPoolTask>;
 
-  RasterWorkerPoolTask(const Resource* resource,
-                       WorkerPoolTask::TaskVector* dependencies);
+  RasterWorkerPoolTask(const Resource* resource, TaskVector* dependencies);
   virtual ~RasterWorkerPoolTask();
 
  private:
   bool did_run_;
   bool did_complete_;
   bool was_canceled_;
   const Resource* resource_;
-  WorkerPoolTask::TaskVector dependencies_;
+  TaskVector dependencies_;
 };
 
 }  // namespace internal
 }  // namespace cc
 
 #if defined(COMPILER_GCC)
 namespace BASE_HASH_NAMESPACE {
 template <> struct hash<cc::internal::RasterWorkerPoolTask*> {
   size_t operator()(cc::internal::RasterWorkerPoolTask* ptr) const {
     return hash<size_t>()(reinterpret_cast<size_t>(ptr));
@@ skipping 46 matching lines @@
      public:
       Set();
       ~Set();
 
       void Insert(const Task& task);
 
      private:
       friend class RasterWorkerPool;
       friend class RasterWorkerPoolTest;
 
-      typedef internal::WorkerPoolTask::TaskVector TaskVector;
+      typedef internal::RasterWorkerPoolTask::TaskVector TaskVector;
       TaskVector tasks_;
     };
 
     Task();
     ~Task();
 
     // Returns true if Task is null (doesn't refer to anything).
     bool is_null() const { return !internal_.get(); }
 
     // Returns the Task into an uninitialized state.
     void Reset();
 
    protected:
     friend class RasterWorkerPool;
     friend class RasterWorkerPoolTest;
 
     explicit Task(internal::WorkerPoolTask* internal);
 
     scoped_refptr<internal::WorkerPoolTask> internal_;
   };
 
   class CC_EXPORT RasterTask {
    public:
     typedef base::Callback<void(const PicturePileImpl::Analysis& analysis,
                                 bool was_canceled)> Reply;
 
     class CC_EXPORT Queue {
      public:
-      typedef internal::RasterWorkerPoolTask::TaskVector TaskVector;
-
       Queue();
       ~Queue();
 
       void Append(const RasterTask& task, bool required_for_activation);
 
      private:
       friend class RasterWorkerPool;
 
+      typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
+          TaskVector;
       TaskVector tasks_;
       typedef base::hash_set<internal::RasterWorkerPoolTask*> TaskSet;
       TaskSet tasks_required_for_activation_;
     };
 
     RasterTask();
     ~RasterTask();
 
     // Returns true if Task is null (doesn't refer to anything).
     bool is_null() const { return !internal_.get(); }
 
     // Returns the Task into an uninitialized state.
     void Reset();
 
    protected:
-    friend class PixelBufferRasterWorkerPool;
     friend class RasterWorkerPool;
     friend class RasterWorkerPoolTest;
 
     explicit RasterTask(internal::RasterWorkerPoolTask* internal);
 
     scoped_refptr<internal::RasterWorkerPoolTask> internal_;
   };
 
   virtual ~RasterWorkerPool();
 
@@ skipping 14 matching lines @@
   static RasterTask CreateRasterTask(
       const Resource* resource,
       PicturePileImpl* picture_pile,
       gfx::Rect content_rect,
       float contents_scale,
       RasterMode raster_mode,
       bool use_color_estimator,
       const RasterTaskMetadata& metadata,
       RenderingStatsInstrumentation* rendering_stats,
       const RasterTask::Reply& reply,
-      Task::Set& dependencies);
+      Task::Set* dependencies);
 
   static Task CreateImageDecodeTask(
       skia::LazyPixelRef* pixel_ref,
       int layer_id,
       RenderingStatsInstrumentation* stats_instrumentation,
       const Task::Reply& reply);
 
  protected:
-  class RootTask {
-   public:
-    RootTask();
-    explicit RootTask(internal::WorkerPoolTask::TaskVector* dependencies);
-    RootTask(const base::Closure& callback,
-             internal::WorkerPoolTask::TaskVector* dependencies);
-    ~RootTask();
-
-   protected:
-    friend class RasterWorkerPool;
-
-    scoped_refptr<internal::WorkerPoolTask> internal_;
-  };
-
+  typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector;
+  typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
+      RasterTaskVector;
   typedef internal::RasterWorkerPoolTask* TaskMapKey;
   typedef base::hash_map<TaskMapKey,
                          scoped_refptr<internal::WorkerPoolTask> > TaskMap;
 
+  class CC_EXPORT RasterTaskGraph {
+   public:
+    RasterTaskGraph();
+    ~RasterTaskGraph();
+
+    void InsertRasterTask(internal::WorkerPoolTask* raster_task,
+                          const TaskVector& decode_tasks);
+
+   private:
+    friend class RasterWorkerPool;
+
+    TaskGraph graph_;
+    scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
+    scoped_ptr<GraphNode> raster_finished_node_;
+    unsigned next_priority_;
+
+    DISALLOW_COPY_AND_ASSIGN(RasterTaskGraph);
+  };
+
   RasterWorkerPool(ResourceProvider* resource_provider, size_t num_threads);
 
+  virtual void OnRasterTasksFinished() {}
+
   void SetRasterTasks(RasterTask::Queue* queue);
-  void ScheduleRasterTasks(const RootTask& root);
+  void SetRasterTaskGraph(RasterTaskGraph* graph);
   bool IsRasterTaskRequiredForActivation(
       internal::RasterWorkerPoolTask* task) const;
 
   RasterWorkerPoolClient* client() const { return client_; }
   ResourceProvider* resource_provider() const { return resource_provider_; }
   const RasterTask::Queue::TaskVector& raster_tasks() const {
     return raster_tasks_;
   }
 
  private:
+  void OnRasterFinished(int64 schedule_raster_tasks_count);
+
   RasterWorkerPoolClient* client_;
   ResourceProvider* resource_provider_;
   RasterTask::Queue::TaskVector raster_tasks_;
   RasterTask::Queue::TaskSet raster_tasks_required_for_activation_;
 
-  // The root task that is a dependent of all other tasks.
-  scoped_refptr<internal::WorkerPoolTask> root_;
+  base::WeakPtrFactory<RasterWorkerPool> weak_ptr_factory_;
+  scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
+  int64 schedule_raster_tasks_count_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RASTER_WORKER_POOL_H_