Creates a live_tile_ list that manages live tiles.

cc/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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 124 matching lines @@
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
   AssignGpuMemoryToTiles();
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_.reset();
   CheckForCompletedTileUploads();
-  DCHECK(tiles_with_pending_set_pixels_.size() == 0);
-  DCHECK(tiles_.size() == 0);
+  DCHECK_EQ(tiles_with_pending_set_pixels_.size(), 0);
+  DCHECK_EQ(all_tiles_.size(), 0);
+  DCHECK_EQ(live_tiles_.size(), 0);
 }
 
 void TileManager::SetGlobalState(
     const GlobalStateThatImpactsTilePriority& global_state) {
   global_state_ = global_state;
   resource_pool_->SetMaxMemoryUsageBytes(global_state_.memory_limit_in_bytes);
   ScheduleManageTiles();
 }
 
 void TileManager::RegisterTile(Tile* tile) {
-  tiles_.push_back(tile);
+  all_tiles_.push_back(tile);
 
   const ManagedTileState& mts = tile->managed_state();
   for (int i = 0; i < NUM_TREES; ++i)
     ++raster_state_count_[mts.raster_state][i][mts.tree_bin[i]];
 
   ScheduleManageTiles();
 }
 
 void TileManager::UnregisterTile(Tile* tile) {
   for (TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
        it != tiles_with_image_decoding_tasks_.end(); it++) {
     if (*it == tile) {
       tiles_with_image_decoding_tasks_.erase(it);
       break;
     }
   }
   for (TileVector::iterator it = tiles_that_need_to_be_rasterized_.begin();
        it != tiles_that_need_to_be_rasterized_.end(); it++) {
     if (*it == tile) {
       tiles_that_need_to_be_rasterized_.erase(it);
       break;
     }
   }
-  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); it++) {
+  for (TileVector::iterator it = live_tiles_.begin();
+      it != live_tiles_.end(); it++) {

[reveman, 2013/02/06 03:20:24]

nit: test statement should be vertically aligned with init statement instead of
having 4 space indent

+    if (*it == tile) {
+      live_tiles_.erase(it);
+      break;
+    }
+  }
+  for (TileVector::iterator it = all_tiles_.begin();
+      it != all_tiles_.end(); it++) {

[reveman, 2013/02/06 03:20:24]

nit: vertical alignment wrong here too

     if (*it == tile) {
       const ManagedTileState& mts = tile->managed_state();
       for (int i = 0; i < NUM_TREES; ++i)
         --raster_state_count_[mts.raster_state][i][mts.tree_bin[i]];
       FreeResourcesForTile(tile);
-      tiles_.erase(it);
+      all_tiles_.erase(it);
       return;
     }
   }
   DCHECK(false) << "Could not find tile version.";
 }
 
 class BinComparator {
 public:
   bool operator() (const Tile* a, const Tile* b) const {
     const ManagedTileState& ams = a->managed_state();
@@ skipping 15 matching lines @@
     if (a_rect.y() != b_rect.y())
       return a_rect.y() < b_rect.y();
     return a_rect.x() < b_rect.x();
   }
 };
 
 void TileManager::SortTiles() {
   TRACE_EVENT0("cc", "TileManager::SortTiles");
 
   // Sort by bin, resolution and time until needed.
-  std::sort(tiles_.begin(), tiles_.end(), BinComparator());
+  std::sort(live_tiles_.begin(), live_tiles_.end(), BinComparator());
 }
 
 void TileManager::ManageTiles() {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
   manage_tiles_pending_ = false;
   ++manage_tiles_call_count_;
 
   const TreePriority tree_priority = global_state_.tree_priority;
-  TRACE_COUNTER_ID1("cc", "TileCount", this, tiles_.size());
+  TRACE_COUNTER_ID1("cc", "AllTileCount", this, all_tiles_.size());
+
+  live_tiles_.clear();
+  for (TileVector::iterator it = all_tiles_.begin();
+      it != all_tiles_.end(); ++it) {

[reveman, 2013/02/06 03:20:24]

nit: vertical alignment

+    if ((*it)->priority( ACTIVE_TREE).is_live ||
+        (*it)->priority(PENDING_TREE).is_live)
+      live_tiles_.push_back(*it);
+  }
+
+  TRACE_COUNTER_ID1("cc", "LiveTileCount", this, live_tiles_.size());
 
   // For each tree, bin into different categories of tiles.
-  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+  for (TileVector::iterator it = live_tiles_.begin();
+      it != live_tiles_.end(); ++it) {

[reveman, 2013/02/06 03:20:24]

nit: vertical alignment

     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
 
     TilePriority prio[NUM_BIN_PRIORITIES];
     switch (tree_priority) {
       case SAME_PRIORITY_FOR_BOTH_TREES:
         prio[HIGH_PRIORITY_BIN] = prio[LOW_PRIORITY_BIN] =
             tile->combined_priority();
         break;
       case SMOOTHNESS_TAKES_PRIORITY:
@@ skipping 37 matching lines @@
     bin_map[NOW_BIN] = NOW_BIN;
     bin_map[SOON_BIN] = SOON_BIN;
     bin_map[EVENTUALLY_BIN] = NEVER_BIN;
     bin_map[NEVER_BIN] = NEVER_BIN;
   } else {
     bin_map[NOW_BIN] = NOW_BIN;
     bin_map[SOON_BIN] = SOON_BIN;
     bin_map[EVENTUALLY_BIN] = EVENTUALLY_BIN;
     bin_map[NEVER_BIN] = NEVER_BIN;
   }
-  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+  for (TileVector::iterator it = live_tiles_.begin();
+      it != live_tiles_.end(); ++it) {

[reveman, 2013/02/06 03:20:24]

nit: vertical alignment

     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
     for (int i = 0; i < NUM_BIN_PRIORITIES; ++i)
       mts.bin[i] = bin_map[mts.bin[i]];
 
     DidTileBinChange(tile, bin_map[mts.tree_bin[ACTIVE_TREE]], ACTIVE_TREE);
     DidTileBinChange(tile, bin_map[mts.tree_bin[PENDING_TREE]], PENDING_TREE);
   }
 
   SortTiles();
@@ skipping 36 matching lines @@
   DispatchMoreTasks();
 }
 
 void TileManager::GetMemoryStats(
     size_t* memoryRequiredBytes,
     size_t* memoryNiceToHaveBytes,
     size_t* memoryUsedBytes) const {
   *memoryRequiredBytes = 0;
   *memoryNiceToHaveBytes = 0;
   *memoryUsedBytes = 0;
-  for(size_t i = 0; i < tiles_.size(); i++) {
-    const Tile* tile = tiles_[i];
+  for(size_t i = 0; i < all_tiles_.size(); i++) {

[reveman, 2013/02/06 03:20:24]

nit: missing space before ( in for(

+    const Tile* tile = all_tiles_[i];
     const ManagedTileState& mts = tile->managed_state();
     size_t tile_bytes = tile->bytes_consumed_if_allocated();
     if (mts.gpu_memmgr_stats_bin == NOW_BIN)
       *memoryRequiredBytes += tile_bytes;
     if (mts.gpu_memmgr_stats_bin != NEVER_BIN)
       *memoryNiceToHaveBytes += tile_bytes;
     if (mts.can_use_gpu_memory)
       *memoryUsedBytes += tile_bytes;
   }
 }
 
 scoped_ptr<base::Value> TileManager::AsValue() const {
     scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
-    state->SetInteger("tile_count", tiles_.size());
+    state->SetInteger("all_tile_count", all_tiles_.size());
+    state->SetInteger("live_tile_count", live_tiles_.size());
 
     state->Set("global_state", global_state_.AsValue().release());
 
     state->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
     return state.PassAs<base::Value>();
 }
 
 scoped_ptr<base::Value> TileManager::GetMemoryRequirementsAsValue() const {
   scoped_ptr<base::DictionaryValue> requirements(
       new base::DictionaryValue());
@@ skipping 42 matching lines @@
     }
   }
 
   return false;
 }
 
 void TileManager::AssignGpuMemoryToTiles() {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
   // Some memory cannot be released. Figure out which.
   size_t unreleasable_bytes = 0;
-  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+  for (TileVector::iterator it = all_tiles_.begin();
+      it != all_tiles_.end(); ++it) {

[reveman, 2013/02/06 03:20:24]

nit: vertical alignment

     Tile* tile = *it;
     if (!tile->managed_state().can_be_freed)
       unreleasable_bytes += tile->bytes_consumed_if_allocated();
   }
 
   // Now give memory out to the tiles until we're out, and build
   // the needs-to-be-rasterized queue.
-  tiles_that_need_to_be_rasterized_.erase(
-      tiles_that_need_to_be_rasterized_.begin(),
-      tiles_that_need_to_be_rasterized_.end());
+  tiles_that_need_to_be_rasterized_.clear();
 
   // Reset the image decoding list so that we don't mess up with tile
   // priorities. Tiles will be added to the image decoding list again
   // when DispatchMoreTasks() is called.
   tiles_with_image_decoding_tasks_.clear();
 
   // By clearing the tiles_that_need_to_be_rasterized_ vector and
   // tiles_with_image_decoding_tasks_ list above we move all tiles
   // currently waiting for raster to idle state.
   // Call DidTileRasterStateChange() for each of these tiles to
   // have this state change take effect.
-  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+  for (TileVector::iterator it = all_tiles_.begin();
+      it != all_tiles_.end(); ++it) {

[reveman, 2013/02/06 03:20:24]

nit: vertical alignment

     Tile* tile = *it;
     if (tile->managed_state().raster_state == WAITING_FOR_RASTER_STATE)
       DidTileRasterStateChange(tile, IDLE_STATE);
   }
 
+  for (TileVector::iterator it = all_tiles_.begin();
+      it != all_tiles_.end(); ++it) {

[reveman, 2013/02/06 03:20:24]

nit: vertical alignment

+    Tile* tile = *it;
+    ManagedTileState& managed_tile_state = tile->managed_state();
+    if (!managed_tile_state.can_be_freed)
+      continue;
+    managed_tile_state.can_use_gpu_memory = false;
+  }
+
   size_t bytes_allocatable = global_state_.memory_limit_in_bytes - unreleasable_bytes;
   size_t bytes_that_exceeded_memory_budget = 0;
   size_t bytes_left = bytes_allocatable;
-  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+  for (TileVector::iterator it = live_tiles_.begin();
+      it != live_tiles_.end(); ++it) {

[reveman, 2013/02/06 03:20:24]

nit: vertical alignment

     Tile* tile = *it;
     size_t tile_bytes = tile->bytes_consumed_if_allocated();
     ManagedTileState& managed_tile_state = tile->managed_state();
     if (!managed_tile_state.can_be_freed)
       continue;
     if (managed_tile_state.bin[HIGH_PRIORITY_BIN] == NEVER_BIN &&
         managed_tile_state.bin[LOW_PRIORITY_BIN] == NEVER_BIN) {
-      managed_tile_state.can_use_gpu_memory = false;
-      FreeResourcesForTile(tile);
       continue;
     }
     if (tile_bytes > bytes_left) {
-      managed_tile_state.can_use_gpu_memory = false;
       bytes_that_exceeded_memory_budget += tile_bytes;
-      FreeResourcesForTile(tile);
       continue;
     }
     bytes_left -= tile_bytes;
     managed_tile_state.can_use_gpu_memory = true;
     if (!managed_tile_state.resource &&
         !managed_tile_state.resource_is_being_initialized) {
       tiles_that_need_to_be_rasterized_.push_back(tile);
       DidTileRasterStateChange(tile, WAITING_FOR_RASTER_STATE);
     }
   }
 
+  for (TileVector::iterator it = all_tiles_.begin();
+      it != all_tiles_.end(); ++it) {

[reveman, 2013/02/06 03:20:24]

nit: vertical alignment

+    Tile* tile = *it;
+    ManagedTileState& managed_tile_state = tile->managed_state();
+    if (!managed_tile_state.can_be_freed)
+      continue;
+    if (!managed_tile_state.can_use_gpu_memory)
+      FreeResourcesForTile(tile);
+  }
+
+

[reveman, 2013/02/06 03:20:24]

nit: extra blank line

   ever_exceeded_memory_budget_ |= bytes_that_exceeded_memory_budget > 0;
   if (ever_exceeded_memory_budget_) {
       TRACE_COUNTER_ID2("cc", "over_memory_budget", this,
                         "budget", global_state_.memory_limit_in_bytes,
                         "over", bytes_that_exceeded_memory_budget);
   }
   memory_stats_from_last_assign_.bytes_allocated =
       bytes_allocatable - bytes_left;
   memory_stats_from_last_assign_.bytes_unreleasable = unreleasable_bytes;
   memory_stats_from_last_assign_.bytes_over =
@@ skipping 295 matching lines @@
     decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::Now() - decode_begin_time;
   }
 }
 
 }  // namespace cc