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 391 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) {
-      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;
-        }
+    if (!raster_task->HasFinishedRunning()) {

[reveman, 2014/08/15 11:54:31]

Should we release the raster buffer in this case?

[auygun, 2014/08/15 12:24:19]

Buffer is relased in RasterTaskImpl::CompleteOnOriginThread(). It's either
called here or later in CheckForCompletedUploads().

[reveman, 2014/08/15 13:59:34]

Acknowledged.

+      // 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()) {
+        raster_task->WillComplete();
+        raster_task->CompleteOnOriginThread(this);
+        raster_task->DidComplete();

[reveman, 2014/08/15 11:54:31]

These functions need to be called even if the conditional above is not true.

[auygun, 2014/08/15 12:24:20]

Aren't they called later in CheckForCompletedUploads() as the task gets pushed
to raster_tasks_with_pending_upload_ right after BeginSetPixels() call?

[reveman, 2014/08/15 13:59:34]

Acknowledged.

+        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;

[reveman, 2014/08/15 11:54:31]

We still need this code in case the task is no longer in |raster_tasks_|.

[auygun, 2014/08/15 12:24:20]

Now the task is pushed into raster_tasks_with_pending_upload_ and later
processed in CheckForCompletedUploads() even when BeginSetPixel() doesn't result
in an upload. Are you sure we still need this code?

[reveman, 2014/08/15 13:59:34]

It seemed a bit awkward to attempt an upload when the raster task was cancelled
but I think you're right, it's better to always call BeginSetPixels in this
case. You can can keep the code as is. 

[auygun, 2014/08/15 15:08:23]

Ok. I think it's better to not to attempt an upload here. I'm changing this.

-      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