cc: Refactor WorkerPoolTaskClient::AcquireBufferForRaster

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 13 matching lines @@
 class Resource;
 class ResourceProvider;
 
 namespace internal {
 
 class WorkerPoolTask;
 class RasterWorkerPoolTask;
 
 class CC_EXPORT WorkerPoolTaskClient {
  public:
-  virtual void* AcquireBufferForRaster(RasterWorkerPoolTask* task,
-                                       int* stride) = 0;
+  virtual SkCanvas* AcquireCanvasForRaster(RasterWorkerPoolTask* task) = 0;

[reveman, 2014/02/11 02:00:44]

I'd like to see this take a basic WorkerPoolTask* in the future and eliminate
the need for both a RasterWorkerPoolTask and a WorkerPoolTask class. You don't
have to change that in this patch but it would be nice if it lined up with that
idea.

The result is that the WorkerPoolTaskClient doesn't know much about the task.
ie. it can't call use_gpu_rasterization(). The decision to use gpu raster would
instead have to be driven by the task.

So maybe we could make this:

virtual SkCanvas* AcquireCanvasForRaster(const WorkerPoolTask* task,
                                         const Resource* resource,
                                         bool use_gpu_rasterization);

And I think OnRasterCompleted should be removed altogether but we could keep it
as:

virtual void OnRasterCompleted(internal::WorkerPoolTask* task,
                               const Resource* resource,
                               const PicturePileImpl::Analysis&,
                               bool use_gpu_rasterization);

for now.

[alokp, 2014/02/11 07:05:21]

Sure. This can be easily done when you decide to actually change
RasterWorkerPoolTask to WorkerPoolTask.

   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:
@@ skipping 165 matching lines @@
       RenderingStatsInstrumentation* rendering_stats,
       const RasterTask::Reply& reply,
       Task::Set* dependencies);
 
   static Task CreateImageDecodeTask(
       SkPixelRef* pixel_ref,
       int layer_id,
       RenderingStatsInstrumentation* rendering_stats,
       const Task::Reply& reply);
 
+  // Overridden from internal::WorkerPoolTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(internal::RasterWorkerPoolTask* task)
+      OVERRIDE;
+  virtual void OnRasterCompleted(internal::RasterWorkerPoolTask* task,
+                                 const PicturePileImpl::Analysis& analysis)
+      OVERRIDE;
+
   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();
 
   // 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
@@ skipping 86 matching lines @@
 
   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_