cc: Move GPU raster to DirectRasterWorkerPool.

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 <deque>
 #include <vector>
 
@@ skipping 23 matching lines @@
   virtual void OnRasterCompleted(RasterWorkerPoolTask* task,
                                  const PicturePileImpl::Analysis& analysis) = 0;
   virtual void OnImageDecodeCompleted(WorkerPoolTask* task) = 0;
 
  protected:
   virtual ~WorkerPoolTaskClient() {}
 };
 
 class CC_EXPORT WorkerPoolTask : public Task {
  public:
+  typedef std::vector<scoped_refptr<WorkerPoolTask> > Vector;
+
   virtual void ScheduleOnOriginThread(WorkerPoolTaskClient* client) = 0;
+  virtual void RunOnOriginThread() = 0;
   virtual void CompleteOnOriginThread(WorkerPoolTaskClient* client) = 0;
   virtual void RunReplyOnOriginThread() = 0;
 
   void WillSchedule();
   void DidSchedule();
   bool HasBeenScheduled() const;
 
   void WillComplete();
   void DidComplete();
   bool HasCompleted() const;
 
  protected:
   WorkerPoolTask();
   virtual ~WorkerPoolTask();
 
   bool did_schedule_;
   bool did_complete_;
 };
 
 class CC_EXPORT RasterWorkerPoolTask : public WorkerPoolTask {
  public:
-  virtual void RunOnOriginThread(ResourceProvider* resource_provider,
-                                 ContextProvider* context_provider) = 0;
-
   const Resource* resource() const { return resource_; }
-  const internal::Task::Vector& dependencies() const { return dependencies_; }
-  bool use_gpu_rasterization() const { return use_gpu_rasterization_; }
+  const internal::WorkerPoolTask::Vector& dependencies() const {
+    return dependencies_;
+  }
 
  protected:
   RasterWorkerPoolTask(const Resource* resource,
-                       internal::Task::Vector* dependencies,
-                       bool use_gpu_rasterization);
+                       internal::WorkerPoolTask::Vector* dependencies);
   virtual ~RasterWorkerPoolTask();
 
  private:
   const Resource* resource_;
-  Task::Vector dependencies_;
-  bool use_gpu_rasterization_;
+  WorkerPoolTask::Vector dependencies_;
 };
 
 }  // namespace internal
 
 class CC_EXPORT RasterWorkerPoolClient {
  public:
   virtual bool ShouldForceTasksRequiredForActivationToComplete() const = 0;
   virtual void DidFinishRunningTasks() = 0;
   virtual void DidFinishRunningTasksRequiredForActivation() = 0;
 
@@ skipping 11 matching lines @@
     class CC_EXPORT Set {
      public:
       Set();
       ~Set();
 
       void Insert(const Task& task);
 
      private:
       friend class RasterWorkerPool;
 
-      internal::Task::Vector tasks_;
+      internal::WorkerPoolTask::Vector 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();
@@ skipping 20 matching lines @@
       void Append(const RasterTask& task, bool required_for_activation);
       void Swap(Queue* other);
 
       size_t count() const { return tasks_.size(); }
       size_t required_for_activation_count() const {
         return required_for_activation_count_;
       }
 
      private:
       friend class RasterWorkerPool;
+      friend class DirectRasterWorkerPool;
 
       struct QueuedTask {
+        class TaskComparator {
+         public:
+          explicit TaskComparator(const internal::RasterWorkerPoolTask* task)
+              : task_(task) {}
+
+          bool operator()(const QueuedTask& queued_task) const {
+            return queued_task.task == task_;
+          }
+
+         private:
+          const internal::RasterWorkerPoolTask* task_;
+        };
+
         typedef std::vector<QueuedTask> Vector;
 
         QueuedTask(internal::RasterWorkerPoolTask* task,
                    bool required_for_activation);
         ~QueuedTask();
 
         scoped_refptr<internal::RasterWorkerPoolTask> task;
         bool required_for_activation;
       };
 
@@ skipping 14 matching lines @@
     friend class RasterWorkerPool;
 
     explicit RasterTask(internal::RasterWorkerPoolTask* internal);
 
     scoped_refptr<internal::RasterWorkerPoolTask> internal_;
   };
 
   virtual ~RasterWorkerPool();
 
   static void SetNumRasterThreads(int num_threads);
-
   static int GetNumRasterThreads();
 
   static internal::TaskGraphRunner* GetTaskGraphRunner();
 
   static unsigned kOnDemandRasterTaskPriority;
   static unsigned kRasterFinishedTaskPriority;
   static unsigned kRasterRequiredForActivationFinishedTaskPriority;
   static unsigned kRasterTaskPriorityBase;
 
   // TODO(vmpstr): Figure out an elegant way to not pass this many parameters.
   static RasterTask CreateRasterTask(
       const Resource* resource,
       PicturePileImpl* picture_pile,
       const gfx::Rect& content_rect,
       float contents_scale,
       RasterMode raster_mode,
       TileResolution tile_resolution,
       int layer_id,
       const void* tile_id,
       int source_frame_number,
-      bool use_gpu_rasterization,
       RenderingStatsInstrumentation* rendering_stats,
       const RasterTask::Reply& reply,
-      Task::Set* dependencies);
+      Task::Set* dependencies,
+      ContextProvider* context_provider);
 
   static Task CreateImageDecodeTask(
       SkPixelRef* pixel_ref,
       int layer_id,
       RenderingStatsInstrumentation* rendering_stats,
       const Task::Reply& reply);
 
   void SetClient(RasterWorkerPoolClient* client);
 
   // Tells the worker pool to shutdown after canceling all previously
@@ skipping 49 matching lines @@
    private:
     const RasterTask::Queue::QueuedTask::Vector* tasks_;
     size_t current_index_;
   };
   typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector;
   typedef std::deque<scoped_refptr<internal::WorkerPoolTask> > TaskDeque;
   typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
       RasterTaskVector;
 
   RasterWorkerPool(internal::TaskGraphRunner* task_graph_runner,
-                   ResourceProvider* resource_provider,
-                   ContextProvider* context_provider);
+                   ResourceProvider* resource_provider);
 
   virtual void OnRasterTasksFinished() = 0;
   virtual void OnRasterTasksRequiredForActivationFinished() = 0;
 
   void SetTaskGraph(internal::TaskGraph* graph);
   void CollectCompletedWorkerPoolTasks(internal::Task::Vector* completed_tasks);
 
-  // Run raster tasks that use GPU on current thread.
-  void RunGpuRasterTasks(const RasterTaskVector& tasks);
-  void CheckForCompletedGpuRasterTasks();
-
   RasterWorkerPoolClient* client() const { return client_; }
   ResourceProvider* resource_provider() const { return resource_provider_; }
-  ContextProvider* context_provider() const { return context_provider_; }
 
   void set_raster_finished_task(
       internal::WorkerPoolTask* raster_finished_task) {
     raster_finished_task_ = raster_finished_task;
   }
+  internal::WorkerPoolTask* raster_finished_task() const {
+    return raster_finished_task_.get();
+  }
   void set_raster_required_for_activation_finished_task(
       internal::WorkerPoolTask* raster_required_for_activation_finished_task) {
     raster_required_for_activation_finished_task_ =
         raster_required_for_activation_finished_task;
   }
+  internal::WorkerPoolTask* raster_required_for_activation_finished_task()
+      const {
+    return raster_required_for_activation_finished_task_.get();
+  }
 
   scoped_refptr<internal::WorkerPoolTask> CreateRasterFinishedTask();
   scoped_refptr<internal::WorkerPoolTask>
       CreateRasterRequiredForActivationFinishedTask(
           size_t tasks_required_for_activation_count);
 
-  scoped_ptr<base::Value> ScheduledStateAsValue() const;
+  void RunTaskOnOriginThread(internal::WorkerPoolTask* task);
 
   static void InsertNodeForTask(internal::TaskGraph* graph,
                                 internal::WorkerPoolTask* task,
                                 unsigned priority,
                                 size_t dependencies);
 
   static void InsertNodeForRasterTask(
       internal::TaskGraph* graph,
       internal::WorkerPoolTask* task,
-      const internal::Task::Vector& decode_tasks,
+      const internal::WorkerPoolTask::Vector& decode_tasks,
       unsigned priority);
 
  private:
   void OnRasterFinished(const internal::WorkerPoolTask* source);
   void OnRasterRequiredForActivationFinished(
       const internal::WorkerPoolTask* source);
 
   internal::TaskGraphRunner* task_graph_runner_;
   internal::NamespaceToken namespace_token_;
   RasterWorkerPoolClient* client_;
   ResourceProvider* resource_provider_;
-  ContextProvider* context_provider_;
-  TaskDeque completed_gpu_raster_tasks_;
 
   scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
   scoped_refptr<internal::WorkerPoolTask>
       raster_required_for_activation_finished_task_;
   base::WeakPtrFactory<RasterWorkerPool> weak_ptr_factory_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RASTER_WORKER_POOL_H_