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..e71f8041a2e46580c3a4d5b64f78f61e728d8d93 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,
@@ -172,7 +174,9 @@ TileManager::TileManager(
       raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
+      bytes_pending_raster_(0),
       bytes_pending_set_pixels_(0),
+      need_shallow_flush_(false),
       ever_exceeded_memory_budget_(false),
       record_rendering_stats_(false),
       use_cheapness_estimator_(use_cheapness_estimator) {
@@ -632,14 +636,27 @@ 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_bytes_pending = bytes_pending_set_pixels_;
-  new_bytes_pending += tile->bytes_consumed_if_allocated();
-  return new_bytes_pending <= kMaxPendingUploadBytes;
+
+  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;
+
+  return true;
 }
 
 void TileManager::DispatchMoreTasks() {
+  // If a flush is needed, do it now before we start dispatching more tasks.
+  if (need_shallow_flush_) {

[nduca, 2013/02/13 08:29:32]

hmmm the position of this group surprised me, I was sort of hoping to see this
on the raster task callback... whys it not called after we get the raster task
and do the upload?

[reveman, 2013/02/13 08:46:38]

this is just common code that is always executed after task completion and it
shouldn't hurt to have it here if DispatchMoreTasks is called for a different
reason. But I can move this to OnImageDecodeTaskCompleted and
OnRasterTaskCompleted if you prefer that?

+    resource_pool_->resource_provider()->shallowFlushIfSupported();
+    need_shallow_flush_ = false;
+  }
+
   // Because tiles in the image decoding list have higher priorities, we
   // need to process those tiles first before we start to handle the tiles
   // in the need_to_be_rasterized queue.
@@ -710,7 +727,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;
@@ -735,7 +752,9 @@ void TileManager::DispatchOneImageDecodeTask(
 }
 
 void TileManager::OnImageDecodeTaskCompleted(
-    scoped_refptr<Tile> tile, uint32_t pixel_ref_id) {
+    scoped_refptr<Tile> tile,
+    uint32_t pixel_ref_id,
+    bool more_tasks_completed) {
   TRACE_EVENT0("cc", "TileManager::OnImageDecodeTaskCompleted");
   pending_decode_tasks_.erase(pixel_ref_id);
 
@@ -752,7 +771,8 @@ void TileManager::OnImageDecodeTaskCompleted(
     }
   }
 
-  DispatchMoreTasks();
+  if (!more_tasks_completed)
+    DispatchMoreTasks();
 }
 
 scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
@@ -788,6 +808,8 @@ void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
                  tile,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
+
+  bytes_pending_raster_ += tile->bytes_consumed_if_allocated();
 }
 
 void TileManager::PerformOneRaster(Tile* tile) {
@@ -838,7 +860,8 @@ void TileManager::OnRasterCompleted(
     managed_tile_state.can_be_freed = false;
 
     resource_pool_->resource_provider()->beginSetPixels(resource->id());
-    resource_pool_->resource_provider()->shallowFlushIfSupported();
+    need_shallow_flush_ = true;
+
     managed_tile_state.resource = resource.Pass();
 
     bytes_pending_set_pixels_ += tile->bytes_consumed_if_allocated();
@@ -855,10 +878,13 @@ void TileManager::OnRasterCompleted(
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
-    int manage_tiles_call_count_when_dispatched) {
+    int manage_tiles_call_count_when_dispatched,
+    bool more_tasks_completed) {
+  bytes_pending_raster_ -= tile->bytes_consumed_if_allocated();
   OnRasterCompleted(tile, resource.Pass(),
                     manage_tiles_call_count_when_dispatched);
-  DispatchMoreTasks();
+  if (!more_tasks_completed)
+    DispatchMoreTasks();
 }
 
 void TileManager::DidFinishTileInitialization(Tile* tile) {