cc: Change required_for_activation bookkeeping.

cc/resources/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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 657 matching lines @@
     mts.required_for_activation = tile_priority.required_for_activation;
 
     mts.visible_and_ready_to_draw =
         tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
 
     // If the tile is in NEVER_BIN and it does not have an active task, then we
     // can release the resources early. If it does have the task however, we
     // 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;
     }
 
     // Insert the tile into a priority set.
     tiles->InsertTile(tile, mts.bin);
   }
 }
 
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
@@ skipping 144 matching lines @@
   bool have_hit_soft_memory = false;  // Soft memory comes after hard.
 
   // Memory we assign to raster tasks now will be deducted from our memory
   // in future iterations if priorities change. By assigning at most half
   // the raster limit, we will always have another 50% left even if priorities
   // change completely (assuming we check for completed/cancelled rasters
   // between each call to this function).
   size_t max_raster_bytes = max_raster_usage_bytes_ / 2;
   size_t raster_bytes = 0;
 
+  size_t processed_required_for_activation_tile_count = 0u;
   unsigned schedule_priority = 1u;
   for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
 
     mts.scheduled_priority = schedule_priority++;
 
     mts.raster_mode = tile->DetermineOverallRasterMode();
 
     ManagedTileState::TileVersion& tile_version =
         mts.tile_versions[mts.raster_mode];
 
     // If this tile doesn't need a resource, then nothing to do.
     if (!tile_version.requires_resource())
       continue;
 
     // 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;
     }
 
     const bool tile_uses_hard_limit = mts.bin <= NOW_BIN;
     const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile);
     const size_t raster_bytes_if_rastered = raster_bytes + bytes_if_allocated;
     const size_t tile_bytes_left =
         (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left;
 
     // Hard-limit is reserved for tiles that would cause a calamity
@@ skipping 38 matching lines @@
       oomed_soft = true;
       if (tile_uses_hard_limit) {
         oomed_hard = true;
         bytes_that_exceeded_memory_budget += tile_bytes;
       }
     } else {
       resources_left -= tile_resources;
       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_);
 
     // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized|
     // has reached it's limit or we've failed to assign gpu memory to this
     // or any higher priority tile. Preventing tiles that fit into memory
     // budget to be rasterized when higher priority tile is oom is
     // important for two reasons:
     // 1. Tile size should not impact raster priority.
     // 2. Tiles with existing raster task could otherwise incorrectly
     //    be added as they are not affected by |bytes_allocatable|.
     bool can_schedule_tile =
         !oomed_soft && raster_bytes_if_rastered <= max_raster_bytes &&
         tiles_that_need_to_be_rasterized->size() < kScheduledRasterTasksLimit;
 
     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;
   }
 
+  size_t total_required_for_activation_tile_count = 0;
+  for (std::vector<PictureLayerImpl*>::const_iterator it = layers_.begin();
+       it != layers_.end();
+       ++it) {
+    if ((*it)->IsOnActiveOrPendingTree()) {
+      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_) {
     TRACE_COUNTER_ID2("cc",
                       "over_memory_budget",
                       this,
                       "budget",
                       global_state_.hard_memory_limit_in_bytes,
                       "over",
                       bytes_that_exceeded_memory_budget);
@@ skipping 232 matching lines @@
     tile_version.set_solid_color(analysis.solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     tile_version.set_use_resource();
     tile_version.resource_ = resource.Pass();
 
     bytes_releasable_ += BytesConsumedIfAllocated(tile);
     ++resources_releasable_;
   }
 
+  client_->NotifyTileInitialized(tile);
+
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f)
     did_initialize_visible_tile_ = true;
 }
 
 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                             const gfx::Size& tile_size,
                                             const gfx::Rect& content_rect,
                                             const gfx::Rect& opaque_rect,
                                             float contents_scale,
@@ skipping 412 matching lines @@
 
   if (b_priority.resolution != a_priority.resolution) {
     return (prioritize_low_res && b_priority.resolution == LOW_RESOLUTION) ||
            (!prioritize_low_res && b_priority.resolution == HIGH_RESOLUTION) ||
            (a_priority.resolution == NON_IDEAL_RESOLUTION);
   }
   return a_priority.IsHigherPriorityThan(b_priority);
 }
 
 }  // namespace cc