cc: Check for completed raster tasks at interval.

cc/tile_manager.cc

Index: cc/tile_manager.cc
diff --git a/cc/tile_manager.cc b/cc/tile_manager.cc
index 16d82d46a8a885052d1549bf4749c73e9d1e50f9..f893dbfd5bc34fe3def240bac4aa39d8c4d01f8a 100644
--- a/cc/tile_manager.cc
+++ b/cc/tile_manager.cc
@@ -30,8 +30,10 @@ namespace {
 // For reference, the Nexus10 can upload 1MB in about 2.5ms.
 // Assuming a three frame deep pipeline this implies ~20MB.
 const int kMaxPendingUploadBytes = 20 * 1024 * 1024;
+const int kMaxPendingRasterBytes = 2 * 1024 * 1024;
 #else
 const int kMaxPendingUploadBytes = 100 * 1024 * 1024;
+const int kMaxPendingRasterBytes = 10 * 1024 * 1024;
 #endif
 
 // Determine bin based on three categories of tiles: things we need now,
@@ -122,8 +124,9 @@ TileManager::TileManager(
       raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
-      bytes_pending_set_pixels_(0),
       ever_exceeded_memory_budget_(false),
+      bytes_pending_raster_(0),
+      bytes_pending_upload_(0),
       record_rendering_stats_(false),
       use_cheapness_estimator_(use_cheapness_estimator) {
   for (int i = 0; i < NUM_STATES; ++i) {
@@ -143,7 +146,7 @@ TileManager::~TileManager() {
   // resources.
   raster_worker_pool_.reset();
   CheckForCompletedTileUploads();
-  DCHECK(tiles_with_pending_set_pixels_.size() == 0);
+  DCHECK(tiles_with_pending_upload_.size() == 0);
   DCHECK(tiles_.size() == 0);
 }
 
@@ -344,9 +347,26 @@ void TileManager::ManageTiles() {
   DispatchMoreTasks();
 }
 
+void TileManager::CheckForCompletedRasterTasks() {
+  int pending_upload_count = tiles_with_pending_upload_.size();
+
+  // Check for completed tasks and dispatch replies.
+  raster_worker_pool_->CheckForCompletedTasks();
+
+  // Flush if we began new uploads.
+  if (tiles_with_pending_upload_.size() != pending_upload_count)
+    resource_pool_->resource_provider()->shallowFlushIfSupported();
+
+  DispatchMoreTasks();
+
+  // Schedule another check if we still have pending raster tasks.
+  if (bytes_pending_raster_)
+    client_->ScheduleCheckForCompletedRasterTasks();
+}
+
 void TileManager::CheckForCompletedTileUploads() {
-  while (!tiles_with_pending_set_pixels_.empty()) {
-    Tile* tile = tiles_with_pending_set_pixels_.front();
+  while (!tiles_with_pending_upload_.empty()) {
+    Tile* tile = tiles_with_pending_upload_.front();
     DCHECK(tile->managed_state().resource);
 
     // Set pixel tasks complete in the order they are posted.
@@ -365,9 +385,9 @@ void TileManager::CheckForCompletedTileUploads() {
 
     DidFinishTileInitialization(tile);
 
-    bytes_pending_set_pixels_ -= tile->bytes_consumed_if_allocated();
+    bytes_pending_upload_ -= tile->bytes_consumed_if_allocated();
     DidTileRasterStateChange(tile, IDLE_STATE);
-    tiles_with_pending_set_pixels_.pop();
+    tiles_with_pending_upload_.pop();
   }
 
   DispatchMoreTasks();
@@ -446,7 +466,7 @@ bool TileManager::HasPendingWorkScheduled(WhichTree tree) const {
     switch (i) {
       case WAITING_FOR_RASTER_STATE:
       case RASTER_STATE:
-      case SET_PIXELS_STATE:
+      case UPLOAD_STATE:
         for (int j = 0; j < NEVER_BIN; ++j) {
           if (raster_state_count_[i][tree][j])
             return true;
@@ -553,11 +573,17 @@ void TileManager::FreeResourcesForTile(Tile* tile) {
 }
 
 bool TileManager::CanDispatchRasterTask(Tile* tile) {
-  if (raster_worker_pool_->IsBusy())
+  size_t new_raster_bytes_pending = bytes_pending_raster_;
+  new_raster_bytes_pending += tile->bytes_consumed_if_allocated();
+  if (new_raster_bytes_pending > kMaxPendingRasterBytes)
+    return false;
+
+  size_t new_upload_bytes_pending = bytes_pending_upload_;

[brianderson, 2013/02/12 01:44:31]

Shouldn't this be:
size_t new_upload_bytes_pending = bytes_pending_upload_ + bytes_pending_raster_;

[reveman, 2013/02/12 02:29:52]

makes sense.

+  new_upload_bytes_pending += tile->bytes_consumed_if_allocated();
+  if (new_upload_bytes_pending > kMaxPendingUploadBytes)
     return false;
-  size_t new_bytes_pending = bytes_pending_set_pixels_;
-  new_bytes_pending += tile->bytes_consumed_if_allocated();
-  return new_bytes_pending <= kMaxPendingUploadBytes;
+
+  return true;
 }
 
 void TileManager::DispatchMoreTasks() {
@@ -631,7 +657,7 @@ void TileManager::DispatchImageDecodeTasksForTile(Tile* tile) {
       rendering_stats_.totalDeferredImageCacheHitCount++;
       pending_pixel_refs.erase(it++);
     } else {
-      if (raster_worker_pool_->IsBusy())
+      if (!CanDispatchRasterTask(tile))
         return;
       DispatchOneImageDecodeTask(tile, *it);
       ++it;
@@ -653,6 +679,8 @@ void TileManager::DispatchOneImageDecodeTask(
                  base::Unretained(this),
                  tile,
                  pixel_ref_id));
+
+  client_->ScheduleCheckForCompletedRasterTasks();
 }
 
 void TileManager::OnImageDecodeTaskCompleted(
@@ -672,8 +700,6 @@ void TileManager::OnImageDecodeTaskCompleted(
       }
     }
   }
-
-  DispatchMoreTasks();
 }
 
 scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
@@ -709,6 +735,9 @@ void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
                  tile,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
+
+  bytes_pending_raster_ += tile->bytes_consumed_if_allocated();
+  client_->ScheduleCheckForCompletedRasterTasks();
 }
 
 void TileManager::PerformOneRaster(Tile* tile) {
@@ -759,12 +788,11 @@ void TileManager::OnRasterCompleted(
     managed_tile_state.can_be_freed = false;
 
     resource_pool_->resource_provider()->beginSetPixels(resource->id());
-    resource_pool_->resource_provider()->shallowFlushIfSupported();
     managed_tile_state.resource = resource.Pass();
 
-    bytes_pending_set_pixels_ += tile->bytes_consumed_if_allocated();
-    DidTileRasterStateChange(tile, SET_PIXELS_STATE);
-    tiles_with_pending_set_pixels_.push(tile);
+    bytes_pending_upload_ += tile->bytes_consumed_if_allocated();
+    DidTileRasterStateChange(tile, UPLOAD_STATE);
+    tiles_with_pending_upload_.push(tile);
   } else {
     resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
@@ -777,9 +805,9 @@ void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
+  bytes_pending_raster_ -= tile->bytes_consumed_if_allocated();
   OnRasterCompleted(tile, resource.Pass(),
                     manage_tiles_call_count_when_dispatched);
-  DispatchMoreTasks();
 }
 
 void TileManager::DidFinishTileInitialization(Tile* tile) {