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 125 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(all_tiles_.size() == 0);
+  DCHECK(live_tiles_.size() == 0);

[reveman, 2013/02/05 19:31:09]

do you mind changing all these checks to DCHECK_EQ instead?

 }
 
 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++) {
+    if (*it == tile) {
+      live_tiles_.erase(it);
+      break;
+    }
+  }
+  for (TileVector::iterator it = all_tiles_.begin();
+      it != all_tiles_.end(); it++) {
     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_.resize(0);

[reveman, 2013/02/05 19:31:09]

nit: use live_tiles_.erase(live_tiles_.begin(), live_tiles_.end()) to be
consistent with how we reset vectors elsewhere in this file. if using resize(0)
is better then we should change it everywhere.

[whunt, 2013/02/05 22:00:00]

I believe that resize(0) is faster but probably not measurably so. (There's
likely a branch inside erase that checks to see if the iterator bound is equal
to end() and just calls resize in that case.)

I'll make this one consistent with the others regardless of efficiency because I
would rather touch less code for this patch.

[reveman, 2013/02/05 22:16:41]

sg, we can change all this to resize(0) later.

+  for (TileVector::iterator it = all_tiles_.begin();
+      it != all_tiles_.end(); ++it) {
+    if ((*it)->priority( ACTIVE_TREE).is_live ||

[reveman, 2013/02/05 19:31:09]

nit: I like when things align but not sure the coding style allows you to add a
space between "(" and ACTIVE_TREE like this.

[whunt, 2013/02/05 22:00:00]

If the system doesn't bounce it and you don't bounce it, we're all good =). 
Style is there to make things readable and maintainable.

+        (*it)->priority(PENDING_TREE).is_live)

[reveman, 2013/02/05 19:31:09]

should we be using (*it)->combined_priority().is_live here instead?

[whunt, 2013/02/05 22:00:00]

To be honest, I have no idea, should we?.  I'm happy to change it.  I did what I
believe is conservative.  I'm not well versed in why we even have more than one
priority.

[reveman, 2013/02/05 22:16:41]

the result is the same right now. look at "TilePriority(const TilePriority&
active, const TilePriority& pending)" constructor in tile_priority.h.

I think it's fine to leave it like this for now.

+      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) {
     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) {
     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/05 22:16:41]

nit: you didn't introduce this but I'd be happy if you fixed it while changing
this line: 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 = live_tiles_.begin();
+      it != live_tiles_.end(); ++it) {
     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());
 
   // 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 = live_tiles_.begin();
+      it != live_tiles_.end(); ++it) {
     Tile* tile = *it;
     if (tile->managed_state().raster_state == WAITING_FOR_RASTER_STATE)
       DidTileRasterStateChange(tile, IDLE_STATE);
   }
 
   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) {
     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;
@@ skipping 321 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