cc: Use asynchronous set pixels API for impl-side painting.

cc/tile_manager.cc

 // Copyright 2012 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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 98 matching lines @@
   DCHECK(!resource_is_being_initialized);
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider,
                                           Renderer::ImplPool)),
-      manage_tiles_pending_(false) {
+      manage_tiles_pending_(false),
+      check_for_completed_set_pixels_pending_(false) {
   // Initialize all threads.
   const std::string thread_name_prefix = kRasterThreadNamePrefix;
   while (raster_threads_.size() < num_raster_threads) {
     int thread_number = raster_threads_.size() + 1;
     scoped_ptr<RasterThread> thread = make_scoped_ptr(
         new RasterThread(thread_name_prefix +
                          StringPrintf("Worker%d", thread_number).c_str()));
     raster_threads_.append(thread.Pass());
   }
 }
@@ skipping 38 matching lines @@
   ScheduleManageTiles();
 }
 
 void TileManager::ScheduleManageTiles() {
   if (manage_tiles_pending_)
     return;
   client_->ScheduleManageTiles();
   manage_tiles_pending_ = true;
 }
 
+void TileManager::ScheduleCheckForCompletedSetPixels() {
+  if (check_for_completed_set_pixels_pending_)
+    return;
+  client_->ScheduleCheckForCompletedSetPixels();
+  check_for_completed_set_pixels_pending_ = true;
+}
+
 class BinComparator {
 public:
   bool operator() (const Tile* a, const Tile* b) const {
     const ManagedTileState& ams = a->managed_state();
     const ManagedTileState& bms = b->managed_state();
     if (ams.bin != bms.bin)
       return ams.bin < bms.bin;
 
     if (ams.resolution != bms.resolution)
       return ams.resolution < ams.resolution;
@@ skipping 84 matching lines @@
   // Sort by bin.
   std::sort(tiles_.begin(), tiles_.end(), BinComparator());
 
   // Assign gpu memory and determine what tiles need to be rasterized.
   AssignGpuMemoryToTiles();
 
   // Finally, kick the rasterizer.
   DispatchMoreRasterTasks();
 }
 
+void TileManager::CheckForCompletedSetPixels() {
+  check_for_completed_set_pixels_pending_ = false;
+
+  while (!tiles_with_pending_set_pixels_.empty()) {
+    Tile* tile = tiles_with_pending_set_pixels_.front();
+    DCHECK(tile->managed_state().resource);
+
+    // Set pixel tasks complete in the order they are posted.
+    if (!resource_pool_->resource_provider()->didSetPixelsComplete(
+          tile->managed_state().resource->id())) {
+      ScheduleCheckForCompletedSetPixels();
+      break;
+    }
+
+    // It's now safe to release the pixel buffer.
+    resource_pool_->resource_provider()->releasePixelBuffer(
+        tile->managed_state().resource->id());
+
+    DidFinishTileInitialization(tile);
+    tiles_with_pending_set_pixels_.pop();
+  }
+}
+
 void TileManager::renderingStats(RenderingStats* stats) {
   stats->totalRasterizeTimeInSeconds =
     rendering_stats_.totalRasterizeTimeInSeconds;
   stats->totalPixelsRasterized = rendering_stats_.totalPixelsRasterized;
 }
 
 void TileManager::AssignGpuMemoryToTiles() {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
   // Some memory cannot be released. Figure out which.
   size_t unreleasable_bytes = 0;
@@ skipping 121 matching lines @@
   // Tile can be freed after the completion of the raster task. Call
   // AssignGpuMemoryToTiles() to re-assign gpu memory to highest priority
   // tiles. The result of this could be that this tile is no longer
   // allowed to use gpu memory and in that case we need to abort
   // initialization and free all associated resources before calling
   // DispatchMoreRasterTasks().
   AssignGpuMemoryToTiles();
 
   // Finish resource initialization if |can_use_gpu_memory| is true.
   if (managed_tile_state.can_use_gpu_memory) {
-    resource_pool_->resource_provider()->setPixelsFromBuffer(resource->id());
-    resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
-
-    // The component order may be bgra if we uploaded bgra pixels to rgba
+    // The component order may be bgra if we're uploading bgra pixels to rgba
     // texture. Mark contents as swizzled if image component order is
     // different than texture format.
     managed_tile_state.contents_swizzled =
         !PlatformColor::sameComponentOrder(tile->format_);
 
-    DidFinishTileInitialization(tile, resource.Pass());
+    // Tile resources can't be freed until upload has completed.
+    managed_tile_state.can_be_freed = false;
+
+    resource_pool_->resource_provider()->beginSetPixels(resource->id());
+    managed_tile_state.resource = resource.Pass();
+    tiles_with_pending_set_pixels_.push(tile);
+
+    ScheduleCheckForCompletedSetPixels();
   } else {
     resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
     managed_tile_state.resource_is_being_initialized = false;
   }
 
   DispatchMoreRasterTasks();
 }
 
-void TileManager::DidFinishTileInitialization(
-    Tile* tile, scoped_ptr<ResourcePool::Resource> resource) {
+void TileManager::DidFinishTileInitialization(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
-  DCHECK(!managed_tile_state.resource);
-  managed_tile_state.resource = resource.Pass();
+  DCHECK(managed_tile_state.resource);
   managed_tile_state.resource_is_being_initialized = false;
-  // TODO(qinmin): Make this conditional on managed_tile_state.bin == NOW_BIN.
-  client_->ScheduleRedraw();
+  managed_tile_state.can_be_freed = true;
 }
 
 }