Add preliminary support for hw-accelerated tile rasterization.

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 18 matching lines @@
  public:
   typedef std::vector<scoped_refptr<WorkerPoolTask> > TaskVector;
 
   // Returns true if |buffer| was written to. False indicate that
   // the content of |buffer| is undefined and the resource doesn't
   // need to be initialized.
   virtual bool RunOnWorkerThread(unsigned thread_index,
                                  void* buffer,
                                  gfx::Size size,
                                  int stride) = 0;
+  virtual void RunOnOriginThread() = 0;
   virtual void CompleteOnOriginThread() = 0;
 
   void DidRun(bool was_canceled);
   bool HasFinishedRunning() const;
   bool WasCanceled() const;
   void WillComplete();
   void DidComplete();
   bool HasCompleted() const;
 
   const Resource* resource() const { return resource_; }
@@ skipping 88 matching lines @@
       Queue();
       ~Queue();
 
       void Append(const RasterTask& task, bool required_for_activation);
 
      private:
       friend class RasterWorkerPool;
 
       typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
           TaskVector;
+      typedef base::hash_set<internal::RasterWorkerPoolTask*> TaskSet;
+      TaskVector origin_thread_tasks_;

[reveman, 2013/12/17 00:28:48]

Maybe we should put all tasks in |tasks_| for now and pull them out and run them
on the origin thread more as an implementation detail of the RasterWorkerPool.
Wdyt?

[alokp, 2013/12/17 22:12:15]

Done.

+      // Worker thread tasks.
       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 RasterWorkerPool;
     friend class RasterWorkerPoolTest;
 
-    explicit RasterTask(internal::RasterWorkerPoolTask* internal);
+    explicit RasterTask(internal::RasterWorkerPoolTask* internal,
+                        bool must_run_on_origin_thread);
 
     scoped_refptr<internal::RasterWorkerPoolTask> internal_;
+    // True if this task must be run on origin thread,
+    // not on a worker thread.
+    bool must_run_on_origin_thread_;

[reveman, 2013/12/17 00:28:48]

Why must_run_on_origin_thread here but use_gpu_rasterization when passed to
CreateRasterTask? Also, could this be a internal::RasterWorkerPoolTask member
instead?

[alokp, 2013/12/17 22:12:15]

Done.

   };
 
   virtual ~RasterWorkerPool();
 
   void SetClient(RasterWorkerPoolClient* client);
 
   // Tells the worker pool to shutdown after canceling all previously
   // scheduled tasks. Reply callbacks are still guaranteed to run.
   virtual void Shutdown() OVERRIDE;
 
   // Schedule running of raster tasks in |queue| and all dependencies.
   // Previously scheduled tasks that are no longer needed to run
   // raster tasks in |queue| will be canceled unless already running.
   // Once scheduled, reply callbacks are guaranteed to run for all tasks
   // even if they later get canceled by another call to ScheduleTasks().
   virtual void ScheduleTasks(RasterTask::Queue* queue) = 0;
 
   // Returns the target that needs to be used for raster task resources.
   virtual GLenum GetResourceTarget() const = 0;
 
   // Returns the format that needs to be used for raster task resources.
   virtual ResourceFormat GetResourceFormat() const = 0;
 
   // TODO(vmpstr): Figure out an elegant way to not pass this many parameters.
-  static RasterTask CreateRasterTask(
+  RasterTask CreateRasterTask(
       const Resource* resource,
       PicturePileImpl* picture_pile,
       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);
 
   static Task CreateImageDecodeTask(
       skia::LazyPixelRef* pixel_ref,
       int layer_id,
       RenderingStatsInstrumentation* stats_instrumentation,
       const Task::Reply& reply);
 
  protected:
   typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector;
   typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
       RasterTaskVector;
   typedef base::hash_set<internal::RasterWorkerPoolTask*> RasterTaskSet;
   typedef internal::RasterWorkerPoolTask* TaskMapKey;
   typedef base::hash_map<TaskMapKey,
                          scoped_refptr<internal::WorkerPoolTask> > TaskMap;
 
-  RasterWorkerPool(ResourceProvider* resource_provider, size_t num_threads);
+  RasterWorkerPool(ResourceProvider* resource_provider,
+                   ContextProvider* context_provider,
+                   size_t num_threads);
 
   virtual void OnRasterTasksFinished() = 0;
   virtual void OnRasterTasksRequiredForActivationFinished() = 0;
 
+  void CompleteOriginThreadTasks(RasterTask::Queue* queue);

[reveman, 2013/12/17 00:28:48]

Do you have to pass a RasterTask::Queue* to this function? Could you instead
pass a TaskVector?

[alokp, 2013/12/17 22:12:15]

Done.

   void SetRasterTasks(RasterTask::Queue* queue);
   bool IsRasterTaskRequiredForActivation(
       internal::RasterWorkerPoolTask* task) const;
 
   RasterWorkerPoolClient* client() const { return client_; }
   ResourceProvider* resource_provider() const { return resource_provider_; }
+  ContextProvider* context_provider() const { return context_provider_; }
   const RasterTaskVector& raster_tasks() const { return raster_tasks_; }
   const RasterTaskSet& raster_tasks_required_for_activation() const {
     return raster_tasks_required_for_activation_;
   }
   void set_raster_finished_task(
       scoped_refptr<internal::WorkerPoolTask> raster_finished_task) {
     raster_finished_task_ = raster_finished_task;
   }
   void set_raster_required_for_activation_finished_task(
       scoped_refptr<internal::WorkerPoolTask>
@@ skipping 19 matching lines @@
       unsigned priority,
       TaskGraph* graph);
 
  private:
   void OnRasterFinished(const internal::WorkerPoolTask* source);
   void OnRasterRequiredForActivationFinished(
       const internal::WorkerPoolTask* source);
 
   RasterWorkerPoolClient* client_;
   ResourceProvider* resource_provider_;
+  ContextProvider* context_provider_;
   RasterTask::Queue::TaskVector raster_tasks_;
   RasterTask::Queue::TaskSet raster_tasks_required_for_activation_;
 
   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_