cc: Refactor WorkerPoolTaskClient::AcquireBufferForRaster

cc/resources/pixel_buffer_raster_worker_pool.cc

 // 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.
 
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 
 #include "base/containers/stack_container.h"
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/debug/traced_value.h"
@@ skipping 198 matching lines @@
     raster_task_states_.erase(task);
 
     task->RunReplyOnOriginThread();
 
     completed_raster_tasks_.pop_front();
   }
 
   CheckForCompletedGpuRasterTasks();
 }
 
-void* PixelBufferRasterWorkerPool::AcquireBufferForRaster(
-    internal::RasterWorkerPoolTask* task,
-    int* stride) {
-  // Request a pixel buffer. This will reserve shared memory.
-  resource_provider()->AcquirePixelBuffer(task->resource()->id());
-
-  *stride = 0;
-  return resource_provider()->MapPixelBuffer(task->resource()->id());
+SkCanvas* PixelBufferRasterWorkerPool::AcquireCanvasForRaster(
+    internal::RasterWorkerPoolTask* task) {
+  if (task->use_gpu_rasterization())
+    return RasterWorkerPool::AcquireCanvasForRaster(task);
+  resource_provider()->AcquirePixelRasterBuffer(task->resource()->id());
+  return resource_provider()->MapPixelRasterBuffer(task->resource()->id());
 }
 
 void PixelBufferRasterWorkerPool::OnRasterCompleted(
     internal::RasterWorkerPoolTask* task,
     const PicturePileImpl::Analysis& analysis) {
+  if (task->use_gpu_rasterization()) {
+    RasterWorkerPool::OnRasterCompleted(task, analysis);
+    return;
+  }
+
   TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc"),
                "PixelBufferRasterWorkerPool::OnRasterCompleted",
                "was_canceled",
                !task->HasFinishedRunning(),
                "needs_upload",
                task->HasFinishedRunning() && !analysis.is_solid_color);
 
   DCHECK(raster_task_states_.find(task) != raster_task_states_.end());
   DCHECK_EQ(SCHEDULED, raster_task_states_[task]);
 
-  // Balanced with MapPixelBuffer() call in AcquireBufferForRaster().
-  resource_provider()->UnmapPixelBuffer(task->resource()->id());
+  // Balanced with MapPixelRasterBuffer() call in AcquireCanvasForRaster().
+  resource_provider()->UnmapPixelRasterBuffer(task->resource()->id());
 
   if (!task->HasFinishedRunning() || analysis.is_solid_color) {
-    resource_provider()->ReleasePixelBuffer(task->resource()->id());
+    resource_provider()->ReleasePixelRasterBuffer(task->resource()->id());
 
     if (!task->HasFinishedRunning()) {
       // When priorites change, a raster task can be canceled as a result of
       // no longer being of high enough priority to fit in our throttled
       // raster task budget. The task has not yet completed in this case.
       RasterTaskVector::const_iterator it =
           std::find(raster_tasks().begin(), raster_tasks().end(), task);
       if (it != raster_tasks().end()) {
         raster_task_states_[task] = UNSCHEDULED;
         return;
@@ skipping 112 matching lines @@
     }
   }
 
   // Release shared memory and move tasks with completed uploads
   // to |completed_raster_tasks_|.
   while (!tasks_with_completed_uploads.empty()) {
     internal::RasterWorkerPoolTask* task =
         tasks_with_completed_uploads.front().get();
 
     // It's now safe to release the pixel buffer and the shared memory.
-    resource_provider()->ReleasePixelBuffer(task->resource()->id());
+    resource_provider()->ReleasePixelRasterBuffer(task->resource()->id());
 
     bytes_pending_upload_ -= task->resource()->bytes();
 
     DCHECK(std::find(completed_raster_tasks_.begin(),
                      completed_raster_tasks_.end(),
                      task) == completed_raster_tasks_.end());
     completed_raster_tasks_.push_back(task);
     raster_task_states_[task] = COMPLETED;
 
     raster_tasks_required_for_activation_.erase(task);
@@ skipping 267 matching lines @@
 
   throttle_state->SetInteger("bytes_available_for_upload",
                              max_bytes_pending_upload_ - bytes_pending_upload_);
   throttle_state->SetInteger("bytes_pending_upload", bytes_pending_upload_);
   throttle_state->SetInteger("scheduled_raster_task_count",
                              scheduled_raster_task_count_);
   return throttle_state.PassAs<base::Value>();
 }
 
 }  // namespace cc