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 39 matching lines @@
       can_be_freed(true),
       resource_is_being_initialized(false),
       contents_swizzled(false) {
 }
 
 ManagedTileState::~ManagedTileState() {
   DCHECK(!resource);
   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,
     size_t num_raster_threads)
     : client_(client),
       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,
                                                  kRasterThreadNamePrefix)) {
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
@@ skipping 137 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::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;
   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 52 matching lines @@
     int max_pending_tasks = kNumPendingRasterTasksPerThread *
         num_raster_threads_;
 
     // Stop dispatching raster tasks when too many are pending.
     if (pending_raster_tasks_ >= max_pending_tasks)
       break;
 
     DispatchOneRasterTask(tiles_that_need_to_be_rasterized_.back());
     tiles_that_need_to_be_rasterized_.pop_back();
   }
+
+  CheckForPendingSetPixelsCompletion();
 }
 
 void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
   scoped_refptr<PicturePileImpl> cloned_picture_pile =
       tile->picture_pile()->CloneForDrawing();
 
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_use_gpu_memory);
   scoped_ptr<ResourcePool::Resource> resource =
@@ skipping 46 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());
+    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());
     managed_tile_state.resource_is_being_initialized = false;
   }
 
   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();
 }
 
 }