cc: Improve tile deletion and general tile manager performance.

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 76 matching lines @@
   case NEVER_BIN:
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "NEVER_BIN"));
   default:
       DCHECK(false) << "Unrecognized TileManagerBin value";
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "<unknown TileManagerBin value>"));
   }
 }
 
-ManagedTileState::ManagedTileState()
-    : can_use_gpu_memory(false),
+ManagedTileState::ManagedTileState(TileManager* tile_manager)
+    : tile_manager(tile_manager),
+      can_use_gpu_memory(false),
       can_be_freed(true),
       resource_is_being_initialized(false),
       contents_swizzled(false),
       need_to_gather_pixel_refs(true),
       gpu_memmgr_stats_bin(NEVER_BIN),
-      raster_state(IDLE_STATE) {
+      raster_state(IDLE_STATE),
+      bytes_consumed_if_allocated(0),

[nduca, 2013/02/05 06:50:01]

I'm worried about the duplication of state here. This code is hard to follow as
it is. What necessitates this?

[reveman, 2013/02/05 18:04:51]

With this patch ManagedTileState can now outlive a Tile so all state that the
tile manager uses needs to be duplicated. This is how the deletion problem is
solved. Destroying a tile just drops its managed state ref while the tile
manager can keep running. The managed state will be deleted when ManageTiles is
called.

Before this patch some state is computed/duplicated in ManageTiles and some tile
state can change without ManageTiles being called. I think that having one place
where the tile manager updates its knowledge of tiles helps.  E.g. without this
patch a tile can be visible and high res when ManagedTiles is called and
prioritized as such but suddenly when the upload completes it's considered
visible and high res. I've found that very hard to follow when debugging this
code.

+      visible_high_resolution(false),
+      contents_scale(1),
+      format(GL_RGBA) {
   for (int i = 0; i < NUM_TREES; ++i)
     tree_bin[i] = NEVER_BIN;
+  tile_manager->RegisterManagedTile(this);
 }
 
 ManagedTileState::~ManagedTileState() {
+  tile_manager->UnregisterManagedTile(this);
   DCHECK(!resource);
   DCHECK(!resource_is_being_initialized);
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
     bool record_rendering_stats)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
-      raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads, record_rendering_stats)),
+      raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads,
+                                                   record_rendering_stats)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       bytes_pending_set_pixels_(0),
       ever_exceeded_memory_budget_(false),
       record_rendering_stats_(record_rendering_stats) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
         raster_state_count_[i][j][k] = 0;
     }
   }
 }
 
 TileManager::~TileManager() {
+  DCHECK_EQ(tiles_.size(), 0);
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
-  AssignGpuMemoryToTiles();
+  ManageTiles();
   // 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_that_need_to_be_rasterized_.size(), 0);
+  DCHECK_EQ(tiles_with_pending_set_pixels_.size(), 0);
+  DCHECK_EQ(managed_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);
-
-  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]];
-
+  DCHECK(tiles_.find(tile) == tiles_.end());
+  scoped_refptr<ManagedTileState> mts(new ManagedTileState(this));
+  tile->set_managed_state(mts);
+  tiles_.insert(tile);
   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++) {
-    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);
-      return;
-    }
-  }
-  DCHECK(false) << "Could not find tile version.";
+  DCHECK(tiles_.find(tile) != tiles_.end());
+  tiles_.erase(tile);
+  ScheduleManageTiles();
+}
+
+void TileManager::RegisterManagedTile(ManagedTileState* mts) {
+  for (int i = 0; i < NUM_TREES; ++i)
+    ++raster_state_count_[mts->raster_state][i][mts->tree_bin[i]];
+}
+
+void TileManager::UnregisterManagedTile(ManagedTileState* mts) {
+  FreeResourcesForTile(mts);
+  for (int i = 0; i < NUM_TREES; ++i)
+    --raster_state_count_[mts->raster_state][i][mts->tree_bin[i]];
 }
 
 class BinComparator {
 public:
-  bool operator() (const Tile* a, const Tile* b) const {
-    const ManagedTileState& ams = a->managed_state();
-    const ManagedTileState& bms = b->managed_state();
-    if (ams.bin[HIGH_PRIORITY_BIN] != bms.bin[HIGH_PRIORITY_BIN])
-      return ams.bin[HIGH_PRIORITY_BIN] < bms.bin[HIGH_PRIORITY_BIN];
+  bool operator() (const ManagedTileState* a,
+                   const ManagedTileState* b) const {
+    if (a->bin[HIGH_PRIORITY_BIN] != b->bin[HIGH_PRIORITY_BIN])
+      return a->bin[HIGH_PRIORITY_BIN] < b->bin[HIGH_PRIORITY_BIN];
 
-    if (ams.bin[LOW_PRIORITY_BIN] != bms.bin[LOW_PRIORITY_BIN])
-      return ams.bin[LOW_PRIORITY_BIN] < bms.bin[LOW_PRIORITY_BIN];
+    if (a->bin[LOW_PRIORITY_BIN] != b->bin[LOW_PRIORITY_BIN])
+      return a->bin[LOW_PRIORITY_BIN] < b->bin[LOW_PRIORITY_BIN];
 
-    if (ams.resolution != bms.resolution)
-      return ams.resolution < bms.resolution;
+    if (a->resolution != b->resolution)
+      return a->resolution < b->resolution;
 
-    if (ams.time_to_needed_in_seconds !=  bms.time_to_needed_in_seconds)
-      return ams.time_to_needed_in_seconds < bms.time_to_needed_in_seconds;
+    if (a->time_to_needed_in_seconds != b->time_to_needed_in_seconds)
+      return a->time_to_needed_in_seconds < b->time_to_needed_in_seconds;
 
-    gfx::Rect a_rect = a->content_rect();
-    gfx::Rect b_rect = b->content_rect();
+    gfx::Rect a_rect = a->content_rect;
+    gfx::Rect b_rect = b->content_rect;
     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(managed_tiles_.begin(), managed_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());
 
+  // Determine tiles that should be managed by rebuilding managed_tiles_
+  // vector.
+  managed_tiles_.erase(managed_tiles_.begin(), managed_tiles_.end());
+
   // For each tree, bin into different categories of tiles.
-  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+  for (TileSet::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = *it;
-    ManagedTileState& mts = tile->managed_state();
+
+    TilePriority combined_priority = tile->combined_priority();
+    if (!combined_priority.is_live) {
+      if (tile->managed_state()->can_be_freed)
+        FreeResourcesForTile(tile->managed_state());
+      continue;
+    }
 
     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();
+        prio[HIGH_PRIORITY_BIN] = prio[LOW_PRIORITY_BIN] = combined_priority;
         break;
       case SMOOTHNESS_TAKES_PRIORITY:
         prio[HIGH_PRIORITY_BIN] = tile->priority(ACTIVE_TREE);
         prio[LOW_PRIORITY_BIN] = tile->priority(PENDING_TREE);
         break;
       case NEW_CONTENT_TAKES_PRIORITY:
         prio[HIGH_PRIORITY_BIN] = tile->priority(PENDING_TREE);
         prio[LOW_PRIORITY_BIN] = tile->priority(ACTIVE_TREE);
         break;
     }
 
-    mts.resolution = prio[HIGH_PRIORITY_BIN].resolution;
-    mts.time_to_needed_in_seconds =
+    ManagedTileState* mts = tile->managed_state();
+    mts->resolution = prio[HIGH_PRIORITY_BIN].resolution;
+    mts->time_to_needed_in_seconds =
         prio[HIGH_PRIORITY_BIN].time_to_visible_in_seconds;
-    mts.bin[HIGH_PRIORITY_BIN] = BinFromTilePriority(prio[HIGH_PRIORITY_BIN]);
-    mts.bin[LOW_PRIORITY_BIN] = BinFromTilePriority(prio[LOW_PRIORITY_BIN]);
-    mts.gpu_memmgr_stats_bin = BinFromTilePriority(tile->combined_priority());
+    mts->bin[HIGH_PRIORITY_BIN] = BinFromTilePriority(prio[HIGH_PRIORITY_BIN]);
+    mts->bin[LOW_PRIORITY_BIN] = BinFromTilePriority(prio[LOW_PRIORITY_BIN]);
+    mts->gpu_memmgr_stats_bin = BinFromTilePriority(combined_priority);
+    mts->bytes_consumed_if_allocated = tile->bytes_consumed_if_allocated();
+    mts->visible_high_resolution =
+        tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0 &&
+        tile->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION;
+    mts->picture_pile = tile->picture_pile();
+    mts->content_rect = tile->content_rect_;
+    mts->contents_scale = tile->contents_scale_;
+    mts->tile_size = tile->tile_size_.size();
+    mts->format = tile->format_;
 
-    DidTileBinChange(tile,
+    DidTileBinChange(mts,
                      BinFromTilePriority(tile->priority(ACTIVE_TREE)),
                      ACTIVE_TREE);
-    DidTileBinChange(tile,
+    DidTileBinChange(mts,
                      BinFromTilePriority(tile->priority(PENDING_TREE)),
                      PENDING_TREE);
+
+    managed_tiles_.push_back(mts);
   }
 
+  TRACE_COUNTER_ID1("cc", "ManagedTileCount", this, managed_tiles_.size());
+
   // Memory limit policy works by mapping some bin states to the NEVER bin.
   TileManagerBin bin_map[NUM_BINS];
   if (global_state_.memory_limit_policy == ALLOW_NOTHING) {
     bin_map[NOW_BIN] = NEVER_BIN;
     bin_map[SOON_BIN] = NEVER_BIN;
     bin_map[EVENTUALLY_BIN] = NEVER_BIN;
     bin_map[NEVER_BIN] = NEVER_BIN;
   } else if (global_state_.memory_limit_policy == ALLOW_ABSOLUTE_MINIMUM) {
     bin_map[NOW_BIN] = NOW_BIN;
     bin_map[SOON_BIN] = NEVER_BIN;
     bin_map[EVENTUALLY_BIN] = NEVER_BIN;
     bin_map[NEVER_BIN] = NEVER_BIN;
   } else if (global_state_.memory_limit_policy == ALLOW_PREPAINT_ONLY) {
     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) {
-    Tile* tile = *it;
-    ManagedTileState& mts = tile->managed_state();
+  for (ManagedTileVector::iterator it = managed_tiles_.begin();
+       it != managed_tiles_.end(); ++it) {
+    ManagedTileState* mts = *it;
     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);
+      mts->bin[i] = bin_map[mts->bin[i]];
+    DidTileBinChange(mts, bin_map[mts->tree_bin[ACTIVE_TREE]], ACTIVE_TREE);
+    DidTileBinChange(mts, bin_map[mts->tree_bin[PENDING_TREE]], PENDING_TREE);
   }
 
   SortTiles();
 
   // Assign gpu memory and determine what tiles need to be rasterized.
   AssignGpuMemoryToTiles();
 
   TRACE_EVENT_INSTANT1("cc", "DidManage", "state", ValueToString(AsValue()));
 
   // Finally, kick the rasterizer.
   DispatchMoreTasks();
 }
 
 void TileManager::CheckForCompletedTileUploads() {
   while (!tiles_with_pending_set_pixels_.empty()) {
-    Tile* tile = tiles_with_pending_set_pixels_.front();
-    DCHECK(tile->managed_state().resource);
+    ManagedTileState* mts = tiles_with_pending_set_pixels_.front();
+    DCHECK(mts->resource);
 
     // Set pixel tasks complete in the order they are posted.
     if (!resource_pool_->resource_provider()->didSetPixelsComplete(
-          tile->managed_state().resource->id())) {
+          mts->resource->id())) {
       break;
     }
 
-    if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0 &&
-        tile->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION)
+    if (mts->visible_high_resolution)
       client_->DidUploadVisibleHighResolutionTile();
 
     // It's now safe to release the pixel buffer.
     resource_pool_->resource_provider()->releasePixelBuffer(
-        tile->managed_state().resource->id());
+        mts->resource->id());
 
-    DidFinishTileInitialization(tile);
+    DidFinishTileInitialization(mts);
 
-    bytes_pending_set_pixels_ -= tile->bytes_consumed_if_allocated();
-    DidTileRasterStateChange(tile, IDLE_STATE);
+    bytes_pending_set_pixels_ -= mts->bytes_consumed_if_allocated;
+    DidTileRasterStateChange(mts, IDLE_STATE);
     tiles_with_pending_set_pixels_.pop();
   }
 
   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];
-    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;
+    size_t* memory_required_bytes,
+    size_t* memory_nice_to_have_bytes,
+    size_t* memory_used_bytes) const {
+  *memory_required_bytes = 0;
+  *memory_nice_to_have_bytes = 0;
+  *memory_used_bytes = 0;
+  for (ManagedTileVector::const_iterator it = managed_tiles_.begin();
+       it != managed_tiles_.end(); ++it) {
+    const ManagedTileState* mts = *it;
+    size_t tile_bytes = mts->bytes_consumed_if_allocated;
+    if (mts->gpu_memmgr_stats_bin == NOW_BIN)
+      *memory_required_bytes += tile_bytes;
+    if (mts->gpu_memmgr_stats_bin != NEVER_BIN)
+      *memory_nice_to_have_bytes += tile_bytes;
+    if (mts->can_use_gpu_memory)
+      *memory_used_bytes += tile_bytes;
   }
 }
 
 scoped_ptr<base::Value> TileManager::AsValue() const {
-    scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
-    state->SetInteger("tile_count", tiles_.size());
-
-    state->Set("global_state", global_state_.AsValue().release());
-
-    state->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
-    return state.PassAs<base::Value>();
+  scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
+  state->SetInteger("tile_count", tiles_.size());
+  state->SetInteger("managed_tile_count", managed_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());
+  scoped_ptr<base::DictionaryValue> requirements(new base::DictionaryValue());
 
-  size_t memoryRequiredBytes;
-  size_t memoryNiceToHaveBytes;
-  size_t memoryUsedBytes;
-  GetMemoryStats(&memoryRequiredBytes,
-                 &memoryNiceToHaveBytes,
-                 &memoryUsedBytes);
-  requirements->SetInteger("memory_required_bytes", memoryRequiredBytes);
-  requirements->SetInteger("memory_nice_to_have_bytes", memoryNiceToHaveBytes);
-  requirements->SetInteger("memory_used_bytes", memoryUsedBytes);
+  size_t memory_required_bytes;
+  size_t memory_nice_to_have_bytes;
+  size_t memory_used_bytes;
+  GetMemoryStats(&memory_required_bytes,
+                 &memory_nice_to_have_bytes,
+                 &memory_used_bytes);
+  requirements->SetInteger("memory_required_bytes", memory_required_bytes);
+  requirements->SetInteger("memory_nice_to_have_bytes",
+                           memory_nice_to_have_bytes);
+  requirements->SetInteger("memory_used_bytes", memory_used_bytes);
   return requirements.PassAs<base::Value>();
 }
 
 void TileManager::GetRenderingStats(RenderingStats* stats) {
   CHECK(record_rendering_stats_);
   raster_worker_pool_->GetRenderingStats(stats);
   stats->totalDeferredImageCacheHitCount =
       rendering_stats_.totalDeferredImageCacheHitCount;
   stats->totalImageGatheringCount = rendering_stats_.totalImageGatheringCount;
   stats->totalImageGatheringTime =
@@ skipping 22 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) {
-    Tile* tile = *it;
-    if (!tile->managed_state().can_be_freed)
-      unreleasable_bytes += tile->bytes_consumed_if_allocated();
+  for (ManagedTileVector::iterator it = managed_tiles_.begin();
+       it != managed_tiles_.end(); ++it) {
+    ManagedTileState* mts = *it;
+    if (!mts->can_be_freed)
+      unreleasable_bytes += mts->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) {
-    Tile* tile = *it;
-    if (tile->managed_state().raster_state == WAITING_FOR_RASTER_STATE)
-      DidTileRasterStateChange(tile, IDLE_STATE);
+  for (ManagedTileVector::iterator it = managed_tiles_.begin();
+       it != managed_tiles_.end(); ++it) {
+    ManagedTileState* mts = *it;
+    if (mts->raster_state == WAITING_FOR_RASTER_STATE)
+      DidTileRasterStateChange(mts, IDLE_STATE);
   }
 
-  size_t bytes_allocatable = global_state_.memory_limit_in_bytes - unreleasable_bytes;
+  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) {
-    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)
+  for (ManagedTileVector::iterator it = managed_tiles_.begin();
+       it != managed_tiles_.end(); ++it) {
+    ManagedTileState* mts = *it;
+    if (!mts->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);
+    if (mts->bin[HIGH_PRIORITY_BIN] == NEVER_BIN &&
+        mts->bin[LOW_PRIORITY_BIN] == NEVER_BIN) {
+      mts->can_use_gpu_memory = false;
+      FreeResourcesForTile(mts);
       continue;
     }
+    size_t tile_bytes = mts->bytes_consumed_if_allocated;
     if (tile_bytes > bytes_left) {
-      managed_tile_state.can_use_gpu_memory = false;
+      mts->can_use_gpu_memory = false;
       bytes_that_exceeded_memory_budget += tile_bytes;
-      FreeResourcesForTile(tile);
+      FreeResourcesForTile(mts);
       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);
+    mts->can_use_gpu_memory = true;
+    if (!mts->resource && !mts->resource_is_being_initialized) {
+      tiles_that_need_to_be_rasterized_.push_back(mts);
+      DidTileRasterStateChange(mts, WAITING_FOR_RASTER_STATE);
     }
   }
 
   ever_exceeded_memory_budget_ |= bytes_that_exceeded_memory_budget > 0;
   if (ever_exceeded_memory_budget_) {
-      TRACE_COUNTER_ID2("cc", "over_memory_budget", this,
+      TRACE_COUNTER_ID2("cc", "OverMemoryBudget", 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 =
       bytes_that_exceeded_memory_budget;
 
-  // Reverse two tiles_that_need_* vectors such that pop_back gets
-  // the highest priority tile.
+  // Reverse the tiles_that_need_to_be_rasterized_ vector such that pop_back
+  // gets the highest priority tile.
   std::reverse(
       tiles_that_need_to_be_rasterized_.begin(),
       tiles_that_need_to_be_rasterized_.end());
 }
 
-void TileManager::FreeResourcesForTile(Tile* tile) {
-  ManagedTileState& managed_tile_state = tile->managed_state();
-  DCHECK(managed_tile_state.can_be_freed);
-  if (managed_tile_state.resource)
-    resource_pool_->ReleaseResource(managed_tile_state.resource.Pass());
+void TileManager::FreeResourcesForTile(ManagedTileState* mts) {
+  DCHECK(mts->can_be_freed);
+  if (mts->resource)
+    resource_pool_->ReleaseResource(mts->resource.Pass());
 }
 
-bool TileManager::CanDispatchRasterTask(Tile* tile) {
+bool TileManager::CanDispatchRasterTask(ManagedTileState* mts) {
   if (raster_worker_pool_->IsBusy())
     return false;
   size_t new_bytes_pending = bytes_pending_set_pixels_;
-  new_bytes_pending += tile->bytes_consumed_if_allocated();
+  new_bytes_pending += mts->bytes_consumed_if_allocated;
   return new_bytes_pending <= kMaxPendingUploadBytes;
 }
 
 void TileManager::DispatchMoreTasks() {
   // 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.
   for(TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
       it != tiles_with_image_decoding_tasks_.end(); ) {
-    DispatchImageDecodeTasksForTile(*it);
-    ManagedTileState& managed_state = (*it)->managed_state();
-    if (managed_state.pending_pixel_refs.empty()) {
-      if (!CanDispatchRasterTask(*it))
+    ManagedTileState* mts = *it;
+    DispatchImageDecodeTasksForTile(mts);
+    if (mts->pending_pixel_refs.empty()) {
+      if (!CanDispatchRasterTask(mts))
         return;
-      DispatchOneRasterTask(*it);
+      DispatchOneRasterTask(mts);
       tiles_with_image_decoding_tasks_.erase(it++);
     } else {
       ++it;
     }
   }
 
   // Process all tiles in the need_to_be_rasterized queue. If a tile has
   // image decoding tasks, put it to the back of the image decoding list.
   while (!tiles_that_need_to_be_rasterized_.empty()) {
-    Tile* tile = tiles_that_need_to_be_rasterized_.back();
-    DispatchImageDecodeTasksForTile(tile);
-    ManagedTileState& managed_state = tile->managed_state();
-    if (!managed_state.pending_pixel_refs.empty()) {
-      tiles_with_image_decoding_tasks_.push_back(tile);
+    ManagedTileState* mts = tiles_that_need_to_be_rasterized_.back();
+    DispatchImageDecodeTasksForTile(mts);
+    if (!mts->pending_pixel_refs.empty()) {
+      tiles_with_image_decoding_tasks_.push_back(mts);
     } else {
-      if (!CanDispatchRasterTask(tile))
+      if (!CanDispatchRasterTask(mts))
         return;
-      DispatchOneRasterTask(tile);
+      DispatchOneRasterTask(mts);
     }
     tiles_that_need_to_be_rasterized_.pop_back();
   }
 }
 
-void TileManager::GatherPixelRefsForTile(Tile* tile) {
+void TileManager::GatherPixelRefsForTile(ManagedTileState* mts) {
   TRACE_EVENT0("cc", "TileManager::GatherPixelRefsForTile");
-  ManagedTileState& managed_state = tile->managed_state();
-  if (managed_state.need_to_gather_pixel_refs) {
+  if (mts->need_to_gather_pixel_refs) {
     base::TimeTicks gather_begin_time;
     if (record_rendering_stats_)
       gather_begin_time = base::TimeTicks::Now();
-    tile->picture_pile()->GatherPixelRefs(
-        tile->content_rect_,
-        tile->contents_scale_,
-        managed_state.pending_pixel_refs);
-    managed_state.need_to_gather_pixel_refs = false;
+    mts->picture_pile->GatherPixelRefs(
+        mts->content_rect,
+        mts->contents_scale,
+        mts->pending_pixel_refs);
+    mts->need_to_gather_pixel_refs = false;
     if (record_rendering_stats_) {
       rendering_stats_.totalImageGatheringCount++;
       rendering_stats_.totalImageGatheringTime +=
           base::TimeTicks::Now() - gather_begin_time;
     }
   }
 }
 
-void TileManager::DispatchImageDecodeTasksForTile(Tile* tile) {
-  GatherPixelRefsForTile(tile);
-  std::list<skia::LazyPixelRef*>& pending_pixel_refs =
-      tile->managed_state().pending_pixel_refs;
+void TileManager::DispatchImageDecodeTasksForTile(ManagedTileState* mts) {
+  GatherPixelRefsForTile(mts);
+  std::list<skia::LazyPixelRef*>& pending_pixel_refs = mts->pending_pixel_refs;
   std::list<skia::LazyPixelRef*>::iterator it = pending_pixel_refs.begin();
   while (it != pending_pixel_refs.end()) {
     if (pending_decode_tasks_.end() != pending_decode_tasks_.find(
         (*it)->getGenerationID())) {
       ++it;
       continue;
     }
     // TODO(qinmin): passing correct image size to PrepareToDecode().
     if ((*it)->PrepareToDecode(skia::LazyPixelRef::PrepareParams())) {
       rendering_stats_.totalDeferredImageCacheHitCount++;
       pending_pixel_refs.erase(it++);
     } else {
       if (raster_worker_pool_->IsBusy())
         return;
-      DispatchOneImageDecodeTask(tile, *it);
+      DispatchOneImageDecodeTask(mts, *it);
       ++it;
     }
   }
 }
 
 void TileManager::DispatchOneImageDecodeTask(
-    scoped_refptr<Tile> tile, skia::LazyPixelRef* pixel_ref) {
+    scoped_refptr<ManagedTileState> mts, skia::LazyPixelRef* pixel_ref) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneImageDecodeTask");
   uint32_t pixel_ref_id = pixel_ref->getGenerationID();
   DCHECK(pending_decode_tasks_.end() ==
       pending_decode_tasks_.find(pixel_ref_id));
   pending_decode_tasks_[pixel_ref_id] = pixel_ref;
 
   raster_worker_pool_->PostTaskAndReply(
       base::Bind(&TileManager::RunImageDecodeTask, pixel_ref),
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
-                 tile,
+                 mts,
                  pixel_ref_id));
 }
 
 void TileManager::OnImageDecodeTaskCompleted(
-    scoped_refptr<Tile> tile, uint32_t pixel_ref_id) {
+    scoped_refptr<ManagedTileState> mts, uint32_t pixel_ref_id) {
   TRACE_EVENT0("cc", "TileManager::OnImageDecodeTaskCompleted");
   pending_decode_tasks_.erase(pixel_ref_id);
 
   for (TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
       it != tiles_with_image_decoding_tasks_.end(); ++it) {
-    std::list<skia::LazyPixelRef*>& pixel_refs =
-        (*it)->managed_state().pending_pixel_refs;
+    std::list<skia::LazyPixelRef*>& pixel_refs = (*it)->pending_pixel_refs;
     for (std::list<skia::LazyPixelRef*>::iterator pixel_it =
         pixel_refs.begin(); pixel_it != pixel_refs.end(); ++pixel_it) {
       if (pixel_ref_id == (*pixel_it)->getGenerationID()) {
         pixel_refs.erase(pixel_it);
         break;
       }
     }
   }
 
   DispatchMoreTasks();
 }
 
-void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
+void TileManager::DispatchOneRasterTask(scoped_refptr<ManagedTileState> mts) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
-  ManagedTileState& managed_tile_state = tile->managed_state();
-  DCHECK(managed_tile_state.can_use_gpu_memory);
+  DCHECK(mts->can_use_gpu_memory);
   scoped_ptr<ResourcePool::Resource> resource =
-      resource_pool_->AcquireResource(tile->tile_size_.size(), tile->format_);
+      resource_pool_->AcquireResource(mts->tile_size, mts->format);
   resource_pool_->resource_provider()->acquirePixelBuffer(resource->id());
 
-  managed_tile_state.resource_is_being_initialized = true;
-  managed_tile_state.can_be_freed = false;
+  mts->resource_is_being_initialized = true;
+  mts->can_be_freed = false;
 
-  DidTileRasterStateChange(tile, RASTER_STATE);
+  DidTileRasterStateChange(mts, RASTER_STATE);
 
   ResourceProvider::ResourceId resource_id = resource->id();
 
   raster_worker_pool_->PostRasterTaskAndReply(
-      tile->picture_pile(),
+      mts->picture_pile,
       base::Bind(&TileManager::RunRasterTask,
                  resource_pool_->resource_provider()->mapPixelBuffer(
                      resource_id),
-                 tile->content_rect_,
-                 tile->contents_scale()),
+                 mts->content_rect,
+                 mts->contents_scale),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
-                 tile,
+                 mts,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
 }
 
 void TileManager::OnRasterTaskCompleted(
-    scoped_refptr<Tile> tile,
+    scoped_refptr<ManagedTileState> mts,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
   TRACE_EVENT0("cc", "TileManager::OnRasterTaskCompleted");
 
   // Release raster resources.
   resource_pool_->resource_provider()->unmapPixelBuffer(resource->id());
 
-  ManagedTileState& managed_tile_state = tile->managed_state();
-  managed_tile_state.can_be_freed = true;
+  mts->can_be_freed = true;
 
   // Tile can be freed after the completion of the raster task. Call
   // AssignGpuMemoryToTiles() to re-assign gpu memory to highest priority
   // tiles if ManageTiles() was called since task was dispatched. The result
   // of this could be that this tile is no longer allowed to use gpu
   // memory and in that case we need to abort initialization and free all
   // associated resources before calling DispatchMoreTasks().
   if (manage_tiles_call_count_when_dispatched != manage_tiles_call_count_)
     AssignGpuMemoryToTiles();
 
   // Finish resource initialization if |can_use_gpu_memory| is true.
-  if (managed_tile_state.can_use_gpu_memory) {
+  if (mts->can_use_gpu_memory) {
     // The component order may be bgra if we're uploading bgra pixels to rgba
     // texture. Mark contents as swizzled if image component order is
     // different than texture format.
-    managed_tile_state.contents_swizzled =
-        !PlatformColor::sameComponentOrder(tile->format_);
+    mts->contents_swizzled = !PlatformColor::sameComponentOrder(mts->format);
 
     // Tile resources can't be freed until upload has completed.
-    managed_tile_state.can_be_freed = false;
+    mts->can_be_freed = false;
 
     resource_pool_->resource_provider()->beginSetPixels(resource->id());
     resource_pool_->resource_provider()->shallowFlushIfSupported();
-    managed_tile_state.resource = resource.Pass();
+    mts->resource = resource.Pass();
 
-    bytes_pending_set_pixels_ += tile->bytes_consumed_if_allocated();
-    DidTileRasterStateChange(tile, SET_PIXELS_STATE);
-    tiles_with_pending_set_pixels_.push(tile);
+    bytes_pending_set_pixels_ += mts->bytes_consumed_if_allocated;
+    DidTileRasterStateChange(mts, SET_PIXELS_STATE);
+    tiles_with_pending_set_pixels_.push(mts);
   } else {
     resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
-    managed_tile_state.resource_is_being_initialized = false;
-    DidTileRasterStateChange(tile, IDLE_STATE);
+    mts->resource_is_being_initialized = false;
+    DidTileRasterStateChange(mts, IDLE_STATE);
   }
 
   DispatchMoreTasks();
 }
 
-void TileManager::DidFinishTileInitialization(Tile* tile) {
-  ManagedTileState& managed_tile_state = tile->managed_state();
-  DCHECK(managed_tile_state.resource);
-  managed_tile_state.resource_is_being_initialized = false;
-  managed_tile_state.can_be_freed = true;
+void TileManager::DidFinishTileInitialization(ManagedTileState* mts) {
+  DCHECK(mts->resource);
+  mts->resource_is_being_initialized = false;
+  mts->can_be_freed = true;
 }
 
-void TileManager::DidTileRasterStateChange(Tile* tile, TileRasterState state) {
-  ManagedTileState& mts = tile->managed_state();
+void TileManager::DidTileRasterStateChange(
+    ManagedTileState* mts, TileRasterState state) {
   DCHECK_LT(state, NUM_STATES);
 
   for (int i = 0; i < NUM_TREES; ++i) {
     // Decrement count for current state.
-    --raster_state_count_[mts.raster_state][i][mts.tree_bin[i]];
-    DCHECK_GE(raster_state_count_[mts.raster_state][i][mts.tree_bin[i]], 0);
+    --raster_state_count_[mts->raster_state][i][mts->tree_bin[i]];
+    DCHECK_GE(raster_state_count_[mts->raster_state][i][mts->tree_bin[i]], 0);
 
     // Increment count for new state.
-    ++raster_state_count_[state][i][mts.tree_bin[i]];
+    ++raster_state_count_[state][i][mts->tree_bin[i]];
   }
 
-  mts.raster_state = state;
+  mts->raster_state = state;
 }
 
-void TileManager::DidTileBinChange(Tile* tile,
+void TileManager::DidTileBinChange(ManagedTileState* mts,
                                    TileManagerBin bin,
                                    WhichTree tree) {
-  ManagedTileState& mts = tile->managed_state();
-
   // Decrement count for current bin.
-  --raster_state_count_[mts.raster_state][tree][mts.tree_bin[tree]];
-  DCHECK_GE(raster_state_count_[mts.raster_state][tree][mts.tree_bin[tree]], 0);
+  --raster_state_count_[mts->raster_state][tree][mts->tree_bin[tree]];
+  DCHECK_GE(
+      raster_state_count_[mts->raster_state][tree][mts->tree_bin[tree]], 0);
 
   // Increment count for new bin.
-  ++raster_state_count_[mts.raster_state][tree][bin];
+  ++raster_state_count_[mts->raster_state][tree][bin];
 
-  mts.tree_bin[tree] = bin;
+  mts->tree_bin[tree] = bin;
 }
 
 // static
 void TileManager::RunRasterTask(uint8* buffer,
                                 const gfx::Rect& rect,
                                 float contents_scale,
                                 PicturePileImpl* picture_pile,
                                 RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::RunRasterTask");
   DCHECK(picture_pile);
@@ skipping 15 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