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

cc/tile_manager.cc

Index: cc/tile_manager.cc
diff --git a/cc/tile_manager.cc b/cc/tile_manager.cc
index a80f1dd8380c04320c67fa1c4aa218efc86bd5bb..06aa08bd4238b1142f07952e248aa09153c4eabe 100644
--- a/cc/tile_manager.cc
+++ b/cc/tile_manager.cc
@@ -57,6 +57,15 @@ ManagedTileState::~ManagedTileState() {
   DCHECK(!resource_is_being_initialized);
 }
 
+PendingSetPixels::PendingSetPixels(

[nduca, 2012/12/04 23:59:26]

I think this is overkill. Just do what I told you originally --

managedResource {
  resource  -- set when its allocated
  state { rasterizing, uploading, ready }

Tile::resource_id accessor -- returns resource id only when ready

Pending queue is just a queue of tiles. Done.

[reveman, 2012/12/05 23:21:19]

Done.

+    Tile* tile, scoped_ptr<ResourcePool::Resource> resource)
+    : tile_(tile),
+      resource_(resource.Pass()) {
+}
+
+PendingSetPixels::~PendingSetPixels() {
+}
+
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
@@ -65,6 +74,7 @@ TileManager::TileManager(
       resource_pool_(ResourcePool::Create(resource_provider,
                                           Renderer::ImplPool)),
       manage_tiles_pending_(false),
+      in_prepare_to_draw_(false),
       pending_raster_tasks_(0),
       num_raster_threads_(num_raster_threads),
       worker_pool_(new base::SequencedWorkerPool(num_raster_threads,
@@ -222,6 +232,12 @@ void TileManager::ManageTiles() {
   DispatchMoreRasterTasks();
 }
 
+void TileManager::PrepareToDraw() {

[nduca, 2012/12/04 23:59:26]

Lets call this CheckForCompletedUploads() so its obvious what its doing.

[reveman, 2012/12/05 23:21:19]

Done. Now CheckForCompletedSetPixels().

+  in_prepare_to_draw_ = true;
+  CheckForPendingSetPixelsCompletion();
+  in_prepare_to_draw_ = false;
+}
+
 void TileManager::renderingStats(RenderingStats* stats) {
   stats->totalRasterizeTimeInSeconds =
     rendering_stats_.totalRasterizeTimeInSeconds;
@@ -294,6 +310,8 @@ void TileManager::DispatchMoreRasterTasks() {
     DispatchOneRasterTask(tiles_that_need_to_be_rasterized_.back());
     tiles_that_need_to_be_rasterized_.pop_back();
   }
+
+  CheckForPendingSetPixelsCompletion();
 }
 
 void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
@@ -360,16 +378,18 @@ void TileManager::OnRasterTaskCompleted(
 
   // 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());
+    pending_set_pixels_.append(
+        make_scoped_ptr(new PendingSetPixels(tile, resource.Pass())));
   } else {
     resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
@@ -379,14 +399,33 @@ void TileManager::OnRasterTaskCompleted(
   DispatchMoreRasterTasks();
 }
 
+void TileManager::CheckForPendingSetPixelsCompletion() {
+  while (!pending_set_pixels_.isEmpty()) {
+    // Set pixel tasks complete in the order they are posted.
+    if (!resource_pool_->resource_provider()->didSetPixelsComplete(
+            pending_set_pixels_.first()->resource()->id()))
+      break;
+
+    scoped_ptr<PendingSetPixels> set_pixels = pending_set_pixels_.takeFirst();
+    scoped_ptr<ResourcePool::Resource> resource = set_pixels->takeResource();
+
+    // It's now safe to release the pixel buffer.
+    resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
+
+    DidFinishTileInitialization(set_pixels->tile(), resource.Pass());
+  }
+}
+
 void TileManager::DidFinishTileInitialization(
     Tile* tile, scoped_ptr<ResourcePool::Resource> resource) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(!managed_tile_state.resource);
   managed_tile_state.resource = resource.Pass();
   managed_tile_state.resource_is_being_initialized = false;
+  managed_tile_state.can_be_freed = true;
   // TODO(qinmin): Make this conditional on managed_tile_state.bin == NOW_BIN.
-  client_->ScheduleRedraw();
+  if (!in_prepare_to_draw_)
+    client_->ScheduleRedraw();
 }
 
 }