cc: Change required_for_activation bookkeeping.

This patch changes the bookkeeping of whether required for activation
tiles all received memory during AssignGpuMemory. The new approach
doesn't rely on the fact that we process every tile in that loop, thus
allowing us to early out or use another approach at getting tiles that
does not guarantee that every tile will be visited.

The end goal is to evaluate if we can activate when the rasterizer
notifies us that all tasks given to it that are required for
activation are finished rather than trying to figure this out
when we schedule tasks.

R=reveman, enne

Review URL: https://codereview.chromium.org/257773009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@267400 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 24 insertions, 4 deletions

diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 38948c3..eb389c5 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -675,7 +675,8 @@ void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
     // should keep it in the prioritized tile set to ensure that AssignGpuMemory
     // can visit it.
     if (mts.bin == NEVER_BIN &&
-        !mts.tile_versions[mts.raster_mode].raster_task_) {
+        !mts.tile_versions[mts.raster_mode].raster_task_ &&
+        !tile->required_for_activation()) {
       FreeResourcesForTile(tile);
       continue;
     }
@@ -840,6 +841,7 @@ void TileManager::AssignGpuMemoryToTiles(
   size_t max_raster_bytes = max_raster_usage_bytes_ / 2;
   size_t raster_bytes = 0;
 
+  int processed_required_for_activation_tile_count = 0;
   unsigned schedule_priority = 1u;
   for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) {
     Tile* tile = *it;
@@ -859,6 +861,8 @@ void TileManager::AssignGpuMemoryToTiles(
     // If the tile is not needed, free it up.
     if (mts.bin == NEVER_BIN) {
       FreeResourcesForTile(tile);
+      if (tile->required_for_activation())
+        ++processed_required_for_activation_tile_count;
       continue;
     }
 
@@ -917,8 +921,10 @@ void TileManager::AssignGpuMemoryToTiles(
       hard_bytes_left -= tile_bytes;
       soft_bytes_left =
           (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0;
-      if (tile_version.resource_)
+      if (tile_version.resource_) {
+        DCHECK(tile->IsReadyToDraw());
         continue;
+      }
     }
 
     DCHECK(!tile_version.resource_);
@@ -937,16 +943,30 @@ void TileManager::AssignGpuMemoryToTiles(
 
     if (!can_schedule_tile) {
       all_tiles_that_need_to_be_rasterized_have_memory_ = false;
-      if (tile->required_for_activation())
-        all_tiles_required_for_activation_have_memory_ = false;
       it.DisablePriorityOrdering();
       continue;
     }
 
     raster_bytes = raster_bytes_if_rastered;
     tiles_that_need_to_be_rasterized->push_back(tile);
+    if (tile->required_for_activation())
+      ++processed_required_for_activation_tile_count;
+  }
+
+  int total_required_for_activation_tile_count = 0;
+  for (std::vector<PictureLayerImpl*>::const_iterator it = layers_.begin();
+       it != layers_.end();
+       ++it) {
+    if ((*it)->GetTree() == PENDING_TREE) {
+      total_required_for_activation_tile_count +=
+          (*it)->UninitializedTilesRequiredForActivationCount();
+    }
   }
 
+  all_tiles_required_for_activation_have_memory_ =
+      processed_required_for_activation_tile_count ==
+      total_required_for_activation_tile_count;
+
   // OOM reporting uses hard-limit, soft-OOM is normal depending on limit.
   ever_exceeded_memory_budget_ |= oomed_hard;
   if (ever_exceeded_memory_budget_) {