cc: Do bitmap conversion for RasterBuffer in the worker thread.

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 <algorithm>
 
 #include "base/containers/stack_container.h"
 #include "base/debug/trace_event.h"
@@ skipping 243 matching lines @@
     DCHECK_EQ(RasterTaskState::COMPLETED, state_it->type);
 
     std::swap(*state_it, raster_task_states_.back());
     raster_task_states_.pop_back();
 
     task->RunReplyOnOriginThread();
   }
   completed_raster_tasks_.clear();
 }
 
-SkCanvas* PixelBufferRasterWorkerPool::AcquireCanvasForRaster(
+RasterBuffer* PixelBufferRasterWorkerPool::AcquireBufferForRaster(
     RasterTask* task) {
   DCHECK(std::find_if(raster_task_states_.begin(),
                       raster_task_states_.end(),
                       RasterTaskState::TaskComparator(task)) !=
          raster_task_states_.end());
-  resource_provider_->AcquirePixelRasterBuffer(task->resource()->id());
-  return resource_provider_->MapPixelRasterBuffer(task->resource()->id());
+  return resource_provider_->AcquirePixelRasterBuffer(task->resource()->id());
 }
 
-void PixelBufferRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) {
+void PixelBufferRasterWorkerPool::ReleaseBufferForRaster(RasterTask* task) {
   DCHECK(std::find_if(raster_task_states_.begin(),
                       raster_task_states_.end(),
                       RasterTaskState::TaskComparator(task)) !=
          raster_task_states_.end());
   resource_provider_->ReleasePixelRasterBuffer(task->resource()->id());
 }
 
 void PixelBufferRasterWorkerPool::OnRasterFinished() {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::OnRasterFinished");
 
@@ skipping 394 matching lines @@
 
     RasterTaskState::Vector::iterator state_it =
         std::find_if(raster_task_states_.begin(),
                      raster_task_states_.end(),
                      RasterTaskState::TaskComparator(raster_task));
     DCHECK(state_it != raster_task_states_.end());
 
     RasterTaskState& state = *state_it;
     DCHECK_EQ(RasterTaskState::SCHEDULED, state.type);
 
-    // Balanced with MapPixelRasterBuffer() call in AcquireCanvasForRaster().
-    bool content_has_changed = resource_provider_->UnmapPixelRasterBuffer(
-        raster_task->resource()->id());
-
-    // |content_has_changed| can be false as result of task being canceled or
-    // task implementation deciding not to modify bitmap (ie. analysis of raster
-    // commands detected content as a solid color).
-    if (!content_has_changed) {
+    if (!raster_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.
       raster_task->WillComplete();
       raster_task->CompleteOnOriginThread(this);
       raster_task->DidComplete();
 
-      if (!raster_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.
-        RasterTaskQueue::Item::Vector::const_iterator item_it =
-            std::find_if(raster_tasks_.items.begin(),
-                         raster_tasks_.items.end(),
-                         RasterTaskQueue::Item::TaskComparator(raster_task));
-        if (item_it != raster_tasks_.items.end()) {
-          state.type = RasterTaskState::UNSCHEDULED;
-          continue;
-        }
+      RasterTaskQueue::Item::Vector::const_iterator item_it =
+          std::find_if(raster_tasks_.items.begin(),
+                       raster_tasks_.items.end(),
+                       RasterTaskQueue::Item::TaskComparator(raster_task));
+      if (item_it != raster_tasks_.items.end()) {
+        state.type = RasterTaskState::UNSCHEDULED;
+        continue;
       }
 
       DCHECK(std::find(completed_raster_tasks_.begin(),
                        completed_raster_tasks_.end(),
                        raster_task) == completed_raster_tasks_.end());
       completed_raster_tasks_.push_back(raster_task);
       state.type = RasterTaskState::COMPLETED;
       DCHECK_LE(static_cast<size_t>(state.required_for_activation),
                 raster_tasks_required_for_activation_count_);
       raster_tasks_required_for_activation_count_ -=
           state.required_for_activation;
       continue;
     }
 
-    DCHECK(raster_task->HasFinishedRunning());
-
     resource_provider_->BeginSetPixels(raster_task->resource()->id());
     has_performed_uploads_since_last_flush_ = true;
 
     bytes_pending_upload_ += raster_task->resource()->bytes();
     raster_tasks_with_pending_upload_.push_back(raster_task);
     state.type = RasterTaskState::UPLOADING;
   }
   completed_tasks_.clear();
 }
 
@@ skipping 16 matching lines @@
 void PixelBufferRasterWorkerPool::ThrottleStateAsValueInto(
     base::debug::TracedValue* throttle_state) const {
   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_);
 }
 
 }  // namespace cc