cc: Improve tile deletion and general tile manager performance.

cc/tile_manager.cc

Index: cc/tile_manager.cc
diff --git a/cc/tile_manager.cc b/cc/tile_manager.cc
index 9935de5d2e84e1a130b685ac8ef0864213a46ae0..00d1268ad7dbbdaf5210f472dae78a08efc297aa 100644
--- a/cc/tile_manager.cc
+++ b/cc/tile_manager.cc
@@ -94,19 +94,26 @@ scoped_ptr<base::Value> TileManagerBinAsValue(TileManagerBin bin) {
   }
 }
 
-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);
 }
@@ -118,7 +125,8 @@ TileManager::TileManager(
     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),
@@ -133,16 +141,18 @@ TileManager::TileManager(
 }
 
 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(
@@ -153,62 +163,48 @@ void TileManager::SetGlobalState(
 }
 
 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();
@@ -219,7 +215,7 @@ 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() {
@@ -230,16 +226,25 @@ void TileManager::ManageTiles() {
   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);
@@ -251,21 +256,35 @@ void TileManager::ManageTiles() {
         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());
-
-    DidTileBinChange(tile,
+    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(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) {
@@ -289,14 +308,13 @@ void TileManager::ManageTiles() {
     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();
@@ -312,27 +330,26 @@ void TileManager::ManageTiles() {
 
 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();
   }
 
@@ -340,48 +357,47 @@ void TileManager::CheckForCompletedTileUploads() {
 }
 
 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());
-
-  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);
+  scoped_ptr<base::DictionaryValue> requirements(new base::DictionaryValue());
+
+  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>();
 }
 
@@ -424,10 +440,11 @@ 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
@@ -446,45 +463,46 @@ void TileManager::AssignGpuMemoryToTiles() {
   // 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);
   }
@@ -494,25 +512,24 @@ void TileManager::AssignGpuMemoryToTiles() {
   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;
 }
 
@@ -522,12 +539,12 @@ void TileManager::DispatchMoreTasks() {
   // 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;
@@ -537,32 +554,30 @@ void TileManager::DispatchMoreTasks() {
   // 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 +=
@@ -571,10 +586,9 @@ void TileManager::GatherPixelRefsForTile(Tile* tile) {
   }
 }
 
-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(
@@ -589,14 +603,14 @@ void TileManager::DispatchImageDecodeTasksForTile(Tile* tile) {
     } 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() ==
@@ -607,19 +621,18 @@ void TileManager::DispatchOneImageDecodeTask(
       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()) {
@@ -632,37 +645,36 @@ void TileManager::OnImageDecodeTaskCompleted(
   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");
@@ -670,8 +682,7 @@ void 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
@@ -683,69 +694,66 @@ void TileManager::OnRasterTaskCompleted(
     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