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 be8e1d91e3e66a94401a6fff47f0c65212ca12b5..25c512433d1a451d580f6c98cdcfa8a8bea8a0d5 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,
@@ -169,11 +171,12 @@ TileManager::TileManager(
     bool use_cheapness_estimator)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
-      raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads)),
+      raster_worker_pool_(RasterWorkerPool::Create(this, 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_set_pixels_(0),
       record_rendering_stats_(false),
       use_cheapness_estimator_(use_cheapness_estimator) {
   for (int i = 0; i < NUM_STATES; ++i) {
@@ -395,6 +398,23 @@ void TileManager::ManageTiles() {
   DispatchMoreTasks();
 }
 
+void TileManager::CheckForCompletedRasterTasks() {
+  int pending_upload_count = tiles_with_pending_set_pixels_.size();
+
+  // Check for completed tasks and dispatch replies.
+  raster_worker_pool_->CheckForCompletedTasks();
+
+  // Flush if we began new uploads.
+  if (tiles_with_pending_set_pixels_.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();
@@ -541,6 +561,10 @@ bool TileManager::HasPendingWorkScheduled(WhichTree tree) const {
   return false;
 }
 
+void TileManager::OnIdle() {
+  client_->DidDetectIdleRaster();
+}
+
 void TileManager::AssignGpuMemoryToTiles() {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
   // Some memory cannot be released. Figure out which.
@@ -632,11 +656,18 @@ 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_raster_ +
+      bytes_pending_set_pixels_;
+  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() {
@@ -710,7 +741,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;
@@ -732,6 +763,8 @@ void TileManager::DispatchOneImageDecodeTask(
                  base::Unretained(this),
                  tile,
                  pixel_ref_id));
+
+  client_->ScheduleCheckForCompletedRasterTasks();
 }
 
 void TileManager::OnImageDecodeTaskCompleted(
@@ -751,8 +784,6 @@ void TileManager::OnImageDecodeTaskCompleted(
       }
     }
   }
-
-  DispatchMoreTasks();
 }
 
 scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
@@ -788,6 +819,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) {
@@ -838,7 +872,6 @@ 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();
@@ -856,9 +889,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) {