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(ResourceProvider* resource_provider,
+                                 ContextProvider* context_provider) = 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_; }
   const TaskVector& dependencies() const { return dependencies_; }
+  bool use_gpu_rasterization() const { return use_gpu_rasterization_; }
 
  protected:
   friend class base::RefCounted<RasterWorkerPoolTask>;
 
-  RasterWorkerPoolTask(const Resource* resource, TaskVector* dependencies);
+  RasterWorkerPoolTask(const Resource* resource,
+                       TaskVector* dependencies,
+                       bool use_gpu_rasterization);
   virtual ~RasterWorkerPoolTask();
 
  private:
   bool did_run_;
   bool did_complete_;
   bool was_canceled_;
   const Resource* resource_;
   TaskVector dependencies_;
+  bool use_gpu_rasterization_;
 };
 
 }  // 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 92 matching lines @@
     explicit RasterTask(internal::RasterWorkerPoolTask* internal);
 
     scoped_refptr<internal::RasterWorkerPoolTask> internal_;
   };
 
   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.

[reveman, 2013/12/19 01:36:47]

Do you mind replacing this comment with "// Overridden from WorkerPool:" while
here? As any documentation needed for this function should be on the WorkerPool
interface, not here.

[alokp, 2013/12/19 06:25:42]

Done.

   virtual void Shutdown() OVERRIDE;
 
+  // Force a check for completed tasks.
+  // Runs reply callbacks for completed tasks.
+  virtual void CheckForCompletedTasks() OVERRIDE;

[reveman, 2013/12/19 01:36:47]

Hm, this will still result in raster task completion callbacks taking place
outside the scope of the CheckForCompletedTasks() call made by the tile manager
as PBRWP will call this periodically to kick off more uploads. Maybe have IRWP
implement this instead and add a protected RWP::CheckForCompletedGpuRasterTasks
function that PBRWP and IRWP can call.

[alokp, 2013/12/19 06:25:42]

Hm. It does not sound like the right thing to do. Could PBRWP use a different
function to periodically collect completed tasks instead? I can look into it as
a separate patch.

[reveman, 2013/12/19 17:52:03]

This doesn't have to be overridden by RWP implementations if RWP is implementing
a "Check" function. How about we rename this to CheckForCompletedRasterTasks.
And WorkerPool::CheckForCompletedTasks becomes a protected non-virtual method
that PBRWP can call as much as it likes without having to worry about triggering
completion of gpu raster tasks?

[alokp, 2013/12/19 21:37:51]

Good Idea! With this change we are moving away from inheritance to composition.
Is there any reason for RWP to inherit from WP? It could easily have WP as a
data member and IMO it would be cleaner.

[reveman, 2013/12/19 22:05:26]

Yes, I think we'll do that but I like to first land all changes needed to share
the thread pool across LTHIs (https://codereview.chromium.org/73923003). That
will likely result in the base WorkerPool class being removed completely and the
RasterWorkerPool having a TaskGraphRunner as data member.

+
   // 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(
       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 SetRasterTasks(RasterTask::Queue* queue);
   bool IsRasterTaskRequiredForActivation(
       internal::RasterWorkerPoolTask* task) const;
+  // Run raster tasks that use GPU on impl thread.

[reveman, 2013/12/19 01:36:47]

nit: s/impl/current/

[alokp, 2013/12/19 06:25:42]

Done.

+  void RunGpuRasterTasks(RasterTaskVector* tasks);
 
   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_;
+  RasterTaskVector 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_