cc: Remove tile ref counting in tile manager.

Instead of increasing a ref count on a tile when passing a task
into raster worker pool, use a unique id and a hash map. This allows
tiles to be deleted even when raster task is working on rasterizing
a resource.

BUG=256777

Review URL: https://chromiumcodereview.appspot.com/18581004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@210713 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 191 insertions, 165 deletions

diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index c9bc7b3..f4433a5 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -49,8 +49,6 @@ PictureLayerTiling::PictureLayerTiling(float contents_scale,
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
-  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    client_->DestroyTile(it->second.get());
 }
 
 void PictureLayerTiling::SetClient(PictureLayerTilingClient* client) {
@@ -337,8 +335,6 @@ gfx::Size PictureLayerTiling::CoverageIterator::texture_size() const {
 
 void PictureLayerTiling::Reset() {
   live_tiles_rect_ = gfx::Rect();
-  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    client_->DestroyTile(it->second.get());
   tiles_.clear();
 }
 
@@ -508,10 +504,8 @@ void PictureLayerTiling::SetLiveTilesRect(
     TileMap::iterator found = tiles_.find(key);
     // If the tile was outside of the recorded region, it won't exist even
     // though it was in the live rect.
-    if (found == tiles_.end())
-      continue;
-    client_->DestroyTile(found->second.get());
-    tiles_.erase(found);
+    if (found != tiles_.end())
+      tiles_.erase(found);
   }
 
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index 63b9301..973fa50 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -29,7 +29,6 @@ class CC_EXPORT PictureLayerTilingClient {
   virtual scoped_refptr<Tile> CreateTile(
     PictureLayerTiling* tiling,
     gfx::Rect content_rect) = 0;
-  virtual void DestroyTile(Tile* tile) = 0;
   virtual void UpdatePile(Tile* tile) = 0;
   virtual gfx::Size CalculateTileSize(
     gfx::Size content_bounds) const = 0;
diff --git a/cc/resources/tile.cc b/cc/resources/tile.cc
index 6d557fe..d6a50e6 100644
--- a/cc/resources/tile.cc
+++ b/cc/resources/tile.cc
@@ -10,6 +10,8 @@
 
 namespace cc {
 
+Tile::Id Tile::s_next_id_ = 0;
+
 Tile::Tile(TileManager* tile_manager,
            PicturePileImpl* picture_pile,
            gfx::Size tile_size,
@@ -26,7 +28,8 @@ Tile::Tile(TileManager* tile_manager,
     opaque_rect_(opaque_rect),
     layer_id_(layer_id),
     source_frame_number_(source_frame_number),
-    can_use_lcd_text_(can_use_lcd_text) {
+    can_use_lcd_text_(can_use_lcd_text),
+    id_(s_next_id_++) {
   set_picture_pile(picture_pile);
   tile_manager_->RegisterTile(this);
 }
diff --git a/cc/resources/tile.h b/cc/resources/tile.h
index 449ca46..408d4b1 100644
--- a/cc/resources/tile.h
+++ b/cc/resources/tile.h
@@ -17,10 +17,11 @@
 namespace cc {
 
 class PicturePileImpl;
-class Tile;
 
 class CC_EXPORT Tile : public base::RefCounted<Tile> {
  public:
+  typedef uint64 Id;
+
   Tile(TileManager* tile_manager,
        PicturePileImpl* picture_pile,
        gfx::Size tile_size,
@@ -31,6 +32,10 @@ class CC_EXPORT Tile : public base::RefCounted<Tile> {
        int source_frame_number,
        bool can_use_lcd_text);
 
+  Id id() const {
+    return id_;
+  }
+
   PicturePileImpl* picture_pile() {
     return picture_pile_.get();
   }
@@ -141,6 +146,9 @@ class CC_EXPORT Tile : public base::RefCounted<Tile> {
   int source_frame_number_;
   bool can_use_lcd_text_;
 
+  Id id_;
+  static Id s_next_id_;
+
   DISALLOW_COPY_AND_ASSIGN(Tile);
 };
 
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index f707573c..65643b3 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -86,6 +86,8 @@ TileManager::TileManager(
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(raster_worker_pool.Pass()),
+      all_tiles_required_for_activation_have_been_initialized_(true),
+      all_tiles_required_for_activation_have_memory_(true),
       ever_exceeded_memory_budget_(false),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       did_initialize_visible_tile_(false),
@@ -97,13 +99,18 @@ TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
-  AssignGpuMemoryToTiles();
-  CleanUpUnusedImageDecodeTasks();
+
+  // Clear |sorted_tiles_| so that tiles kept alive by it can be freed.
+  sorted_tiles_.clear();
+  DCHECK_EQ(0u, tiles_.size());
+
+  TileVector empty;
+  ScheduleTasks(empty);
+
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_->Shutdown();
   raster_worker_pool_->CheckForCompletedTasks();
-  DCHECK_EQ(0u, tiles_.size());
 }
 
 void TileManager::SetGlobalState(
@@ -115,25 +122,17 @@ void TileManager::SetGlobalState(
 }
 
 void TileManager::RegisterTile(Tile* tile) {
-  DCHECK(std::find(tiles_.begin(), tiles_.end(), tile) == tiles_.end());
   DCHECK(!tile->required_for_activation());
-  tiles_.push_back(tile);
+  DCHECK(tiles_.find(tile->id()) == tiles_.end());
+
+  tiles_[tile->id()] = tile;
 }
 
 void TileManager::UnregisterTile(Tile* tile) {
-  TileVector::iterator raster_iter =
-      std::find(tiles_that_need_to_be_rasterized_.begin(),
-                tiles_that_need_to_be_rasterized_.end(),
-                tile);
-  if (raster_iter != tiles_that_need_to_be_rasterized_.end())
-    tiles_that_need_to_be_rasterized_.erase(raster_iter);
-
-  tiles_that_need_to_be_initialized_for_activation_.erase(tile);
-  oom_tiles_that_need_to_be_initialized_for_activation_.erase(tile);
-
-  DCHECK(std::find(tiles_.begin(), tiles_.end(), tile) != tiles_.end());
   FreeResourcesForTile(tile);
-  tiles_.erase(std::remove(tiles_.begin(), tiles_.end(), tile));
+
+  DCHECK(tiles_.find(tile->id()) != tiles_.end());
+  tiles_.erase(tile->id());
 }
 
 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
@@ -141,6 +140,8 @@ bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
 }
 
 void TileManager::DidFinishedRunningTasks() {
+  TRACE_EVENT0("cc", "TileManager::DidFinishedRunningTasks");
+
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.
   if (!memory_stats_from_last_assign_.bytes_over)
@@ -148,31 +149,39 @@ void TileManager::DidFinishedRunningTasks() {
 
   raster_worker_pool_->CheckForCompletedTasks();
 
-  AssignGpuMemoryToTiles();
-
-  if (!oom_tiles_that_need_to_be_initialized_for_activation_.empty())
-    ReassignGpuMemoryToOOMTilesRequiredForActivation();
+  TileVector tiles_that_need_to_be_rasterized;
+  TileSet oom_tiles_required_for_activation;
+  AssignGpuMemoryToTiles(sorted_tiles_,
+                         &tiles_that_need_to_be_rasterized,
+                         &oom_tiles_required_for_activation);
+
+  if (!oom_tiles_required_for_activation.empty()) {
+    ReassignGpuMemoryToOOMTilesRequiredForActivation(
+        sorted_tiles_,
+        &tiles_that_need_to_be_rasterized,
+        &oom_tiles_required_for_activation);
+  }
+  all_tiles_required_for_activation_have_memory_ =
+      oom_tiles_required_for_activation.empty();
 
-  // |tiles_that_need_to_be_rasterized_| will be empty when we reach a
+  // |tiles_that_need_to_be_rasterized| will be empty when we reach a
   // steady memory state. Keep scheduling tasks until we reach this state.
-  if (!tiles_that_need_to_be_rasterized_.empty()) {
-    ScheduleTasks();
+  if (!tiles_that_need_to_be_rasterized.empty()) {
+    ScheduleTasks(tiles_that_need_to_be_rasterized);
     return;
   }
 
   // Use on-demand raster for any tiles that have not been been assigned
   // memory after reaching a steady memory state.
-  for (TileSet::iterator it =
-           oom_tiles_that_need_to_be_initialized_for_activation_.begin();
-       it != oom_tiles_that_need_to_be_initialized_for_activation_.end();
+  for (TileSet::iterator it = oom_tiles_required_for_activation.begin();
+       it != oom_tiles_required_for_activation.end();
        ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
     mts.tile_versions[mts.raster_mode].set_rasterize_on_demand();
   }
-  oom_tiles_that_need_to_be_initialized_for_activation_.clear();
 
-  DCHECK_EQ(0u, tiles_that_need_to_be_initialized_for_activation_.size());
+  DCHECK(all_tiles_required_for_activation_have_been_initialized_);
   client_->NotifyReadyToActivate();
 }
 
@@ -182,7 +191,7 @@ void TileManager::DidFinishedRunningTasksRequiredForActivation() {
   // wait for DidFinishRunningTasks() to be called, try to re-assign
   // memory and in worst case use on-demand raster when tiles
   // required for activation are OOM.
-  if (!oom_tiles_that_need_to_be_initialized_for_activation_.empty())
+  if (!all_tiles_required_for_activation_have_memory_)
     return;
 
   client_->NotifyReadyToActivate();
@@ -190,7 +199,8 @@ void TileManager::DidFinishedRunningTasksRequiredForActivation() {
 
 class BinComparator {
  public:
-  bool operator() (const Tile* a, const Tile* b) const {
+  bool operator()(const scoped_refptr<Tile> a,
+                  const scoped_refptr<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])
@@ -222,7 +232,7 @@ class BinComparator {
   }
 };
 
-void TileManager::AssignBinsToTiles() {
+void TileManager::AssignBinsToTiles(TileRefVector* tiles) {
   const TreePriority tree_priority = global_state_.tree_priority;
 
   // Memory limit policy works by mapping some bin states to the NEVER bin.
@@ -250,10 +260,8 @@ void TileManager::AssignBinsToTiles() {
   }
 
   // For each tree, bin into different categories of tiles.
-  for (TileVector::iterator it = tiles_.begin();
-       it != tiles_.end();
-       ++it) {
-    Tile* tile = *it;
+  for (TileRefVector::iterator it = tiles->begin(); it != tiles->end(); ++it) {
+    Tile* tile = it->get();
     ManagedTileState& mts = tile->managed_state();
 
     TilePriority prio[NUM_BIN_PRIORITIES];
@@ -286,32 +294,51 @@ void TileManager::AssignBinsToTiles() {
     mts.gpu_memmgr_stats_bin =
         BinFromTilePriority(tile->combined_priority(), tree_priority);
 
-    DidTileTreeBinChange(tile,
-                         bin_map[BinFromTilePriority(
-                             tile->priority(ACTIVE_TREE), tree_priority)],
-                         ACTIVE_TREE);
-    DidTileTreeBinChange(tile,
-                         bin_map[BinFromTilePriority(
-                             tile->priority(PENDING_TREE), tree_priority)],
-                         PENDING_TREE);
+    mts.tree_bin[ACTIVE_TREE] = bin_map[
+        BinFromTilePriority(tile->priority(ACTIVE_TREE), tree_priority)];
+    mts.tree_bin[PENDING_TREE] = bin_map[
+        BinFromTilePriority(tile->priority(PENDING_TREE), tree_priority)];
 
     for (int i = 0; i < NUM_BIN_PRIORITIES; ++i)
       mts.bin[i] = bin_map[mts.bin[i]];
   }
 }
 
-void TileManager::SortTiles() {
+void TileManager::SortTiles(TileRefVector* tiles) {
   TRACE_EVENT0("cc", "TileManager::SortTiles");
 
   // Sort by bin, resolution and time until needed.
-  std::sort(tiles_.begin(), tiles_.end(), BinComparator());
+  std::sort(tiles->begin(), tiles->end(), BinComparator());
+}
+
+void TileManager::GetSortedTiles(TileRefVector* tiles) {
+  TRACE_EVENT0("cc", "TileManager::GetSortedTiles");
+
+  DCHECK_EQ(0u, tiles->size());
+
+  tiles->reserve(tiles_.size());
+  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
+    tiles->push_back(make_scoped_refptr(it->second));
+
+  AssignBinsToTiles(tiles);
+  SortTiles(tiles);
 }
 
 void TileManager::ManageTiles() {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
-  AssignBinsToTiles();
-  SortTiles();
-  AssignGpuMemoryToTiles();
+
+  // Clear |sorted_tiles_| so that tiles kept alive by it can be freed.
+  sorted_tiles_.clear();
+
+  GetSortedTiles(&sorted_tiles_);
+
+  TileVector tiles_that_need_to_be_rasterized;
+  TileSet oom_tiles_required_for_activation;
+  AssignGpuMemoryToTiles(sorted_tiles_,
+                         &tiles_that_need_to_be_rasterized,
+                         &oom_tiles_required_for_activation);
+  all_tiles_required_for_activation_have_memory_ =
+      oom_tiles_required_for_activation.empty();
   CleanUpUnusedImageDecodeTasks();
 
   TRACE_EVENT_INSTANT1(
@@ -319,7 +346,7 @@ void TileManager::ManageTiles() {
       "state", TracedValue::FromValue(BasicStateAsValue().release()));
 
   // Finally, schedule rasterizer tasks.
-  ScheduleTasks();
+  ScheduleTasks(tiles_that_need_to_be_rasterized);
 }
 
 void TileManager::CheckForCompletedTileUploads() {
@@ -338,10 +365,10 @@ void TileManager::GetMemoryStats(
   *memory_required_bytes = 0;
   *memory_nice_to_have_bytes = 0;
   *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes();
-  for (TileVector::const_iterator it = tiles_.begin();
+  for (TileMap::const_iterator it = tiles_.begin();
        it != tiles_.end();
        ++it) {
-    const Tile* tile = *it;
+    const Tile* tile = it->second;
     const ManagedTileState& mts = tile->managed_state();
 
     const ManagedTileState::TileVersion& tile_version =
@@ -368,10 +395,10 @@ scoped_ptr<base::Value> TileManager::BasicStateAsValue() const {
 
 scoped_ptr<base::Value> TileManager::AllTilesAsValue() const {
   scoped_ptr<base::ListValue> state(new base::ListValue());
-  for (TileVector::const_iterator it = tiles_.begin();
+  for (TileMap::const_iterator it = tiles_.begin();
        it != tiles_.end();
        it++) {
-    state->Append((*it)->AsValue().release());
+    state->Append(it->second->AsValue().release());
   }
   return state.PassAs<base::Value>();
 }
@@ -393,14 +420,6 @@ scoped_ptr<base::Value> TileManager::GetMemoryRequirementsAsValue() const {
   return requirements.PassAs<base::Value>();
 }
 
-void TileManager::AddRequiredTileForActivation(Tile* tile) {
-  DCHECK(std::find(tiles_that_need_to_be_initialized_for_activation_.begin(),
-                   tiles_that_need_to_be_initialized_for_activation_.end(),
-                   tile) ==
-         tiles_that_need_to_be_initialized_for_activation_.end());
-  tiles_that_need_to_be_initialized_for_activation_.insert(tile);
-}
-
 RasterMode TileManager::DetermineRasterMode(const Tile* tile) const {
   DCHECK(tile);
   DCHECK(tile->picture_pile());
@@ -420,20 +439,23 @@ RasterMode TileManager::DetermineRasterMode(const Tile* tile) const {
   return std::min(raster_mode, current_mode);
 }
 
-void TileManager::AssignGpuMemoryToTiles() {
+void TileManager::AssignGpuMemoryToTiles(
+    const TileRefVector& sorted_tiles,
+    TileVector* tiles_that_need_to_be_rasterized,
+    TileSet* oom_tiles_required_for_activation) {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
 
+  // Reset activation tiles flag, to ensure we can activate
+  // if we don't have any required-for-activation tiles here.
+  all_tiles_required_for_activation_have_been_initialized_ = true;
+
   // 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_.clear();
-  tiles_that_need_to_be_initialized_for_activation_.clear();
-  oom_tiles_that_need_to_be_initialized_for_activation_.clear();
-
   size_t bytes_releasable = 0;
-  for (TileVector::const_iterator it = tiles_.begin();
-       it != tiles_.end();
+  for (TileRefVector::const_iterator it = sorted_tiles.begin();
+       it != sorted_tiles.end();
        ++it) {
-    const Tile* tile = *it;
+    const Tile* tile = it->get();
     const ManagedTileState& mts = tile->managed_state();
     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
       if (mts.tile_versions[mode].resource_)
@@ -454,10 +476,10 @@ void TileManager::AssignGpuMemoryToTiles() {
   size_t bytes_left = bytes_allocatable;
   size_t bytes_oom_tiles_that_need_to_be_initialized_for_activation = 0;
   bool higher_priority_tile_oomed = false;
-  for (TileVector::iterator it = tiles_.begin();
-       it != tiles_.end();
+  for (TileRefVector::const_iterator it = sorted_tiles.begin();
+       it != sorted_tiles.end();
        ++it) {
-    Tile* tile = *it;
+    Tile* tile = it->get();
     ManagedTileState& mts = tile->managed_state();
 
     mts.raster_mode = DetermineRasterMode(tile);
@@ -496,7 +518,7 @@ void TileManager::AssignGpuMemoryToTiles() {
         // memory limit.
         if (bytes_oom_tiles_that_need_to_be_initialized_for_activation <
             global_state_.memory_limit_in_bytes) {
-          oom_tiles_that_need_to_be_initialized_for_activation_.insert(tile);
+          oom_tiles_required_for_activation->insert(tile);
           bytes_oom_tiles_that_need_to_be_initialized_for_activation +=
               tile_bytes;
         } else {
@@ -522,11 +544,11 @@ void TileManager::AssignGpuMemoryToTiles() {
       continue;
 
     if (!tile_version.resource_)
-      tiles_that_need_to_be_rasterized_.push_back(tile);
+      tiles_that_need_to_be_rasterized->push_back(tile);
 
     if (!tile->IsReadyToDraw() &&
         tile->required_for_activation()) {
-      AddRequiredTileForActivation(tile);
+      all_tiles_required_for_activation_have_been_initialized_ = false;
     }
   }
 
@@ -546,16 +568,21 @@ void TileManager::AssignGpuMemoryToTiles() {
       bytes_that_exceeded_memory_budget;
 }
 
-void TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation() {
+void TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation(
+    const TileRefVector& sorted_tiles,
+    TileVector* tiles_that_need_to_be_rasterized,
+    TileSet* oom_tiles_required_for_activation) {
   TRACE_EVENT0(
       "cc", "TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation");
 
   size_t bytes_oom_for_required_tiles = 0;
   TileVector tiles_requiring_memory_but_oomed;
-  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    Tile* tile = *it;
-    if (oom_tiles_that_need_to_be_initialized_for_activation_.find(tile) ==
-        oom_tiles_that_need_to_be_initialized_for_activation_.end())
+  for (TileRefVector::const_iterator it = sorted_tiles.begin();
+       it != sorted_tiles.end();
+       ++it) {
+    Tile* tile = it->get();
+    if (oom_tiles_required_for_activation->find(tile) ==
+        oom_tiles_required_for_activation->end())
       continue;
 
     tiles_requiring_memory_but_oomed.push_back(tile);
@@ -565,12 +592,13 @@ void TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation() {
   if (tiles_requiring_memory_but_oomed.empty())
     return;
 
-  // In OOM situation, we iterate tiles_, remove the memory for active tree
-  // and not the now bin. And give them to bytes_oom_for_required_tiles
+  // In OOM situation, we iterate sorted_tiles, remove the memory for active
+  // tree and not the now bin. And give them to bytes_oom_for_required_tiles
   size_t bytes_freed = 0;
-  for (TileVector::reverse_iterator it = tiles_.rbegin();
-       it != tiles_.rend(); ++it) {
-    Tile* tile = *it;
+  for (TileRefVector::const_reverse_iterator it = sorted_tiles.rbegin();
+       it != sorted_tiles.rend();
+       ++it) {
+    Tile* tile = it->get();
     ManagedTileState& mts = tile->managed_state();
     if (mts.tree_bin[PENDING_TREE] == NEVER_BIN &&
         mts.tree_bin[ACTIVE_TREE] != NOW_BIN) {
@@ -580,13 +608,13 @@ void TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation() {
       // If the tile is in the to-rasterize list, but it has no task,
       // then it means that we have assigned memory for it.
       TileVector::iterator raster_it =
-          std::find(tiles_that_need_to_be_rasterized_.begin(),
-                    tiles_that_need_to_be_rasterized_.end(),
+          std::find(tiles_that_need_to_be_rasterized->begin(),
+                    tiles_that_need_to_be_rasterized->end(),
                     tile);
-      if (raster_it != tiles_that_need_to_be_rasterized_.end() &&
+      if (raster_it != tiles_that_need_to_be_rasterized->end() &&
           tile_version.raster_task_.is_null()) {
         bytes_freed += tile->bytes_consumed_if_allocated();
-        tiles_that_need_to_be_rasterized_.erase(raster_it);
+        tiles_that_need_to_be_rasterized->erase(raster_it);
       }
 
       // Also consider all of the completed resources for freeing.
@@ -613,18 +641,18 @@ void TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation() {
       continue;
     mts.tile_versions[mts.raster_mode].set_use_resource();
     bytes_freed -= bytes_needed;
-    tiles_that_need_to_be_rasterized_.push_back(tile);
+    tiles_that_need_to_be_rasterized->push_back(tile);
     DCHECK(tile->required_for_activation());
-    AddRequiredTileForActivation(tile);
-    oom_tiles_that_need_to_be_initialized_for_activation_.erase(tile);
+    all_tiles_required_for_activation_have_been_initialized_ = false;
+    oom_tiles_required_for_activation->erase(tile);
   }
 }
 
 void TileManager::CleanUpUnusedImageDecodeTasks() {
   // Calculate a set of layers that are used by at least one tile.
   base::hash_set<int> used_layers;
-  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    used_layers.insert((*it)->layer_id());
+  for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it)
+    used_layers.insert(it->second->layer_id());
 
   // Now calculate the set of layers in |image_decode_tasks_| that are not used
   // by any tile.
@@ -675,15 +703,16 @@ void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
   }
 }
 
-void TileManager::ScheduleTasks() {
+void TileManager::ScheduleTasks(
+    const TileVector& tiles_that_need_to_be_rasterized) {
   TRACE_EVENT1("cc", "TileManager::ScheduleTasks",
-               "count", tiles_that_need_to_be_rasterized_.size());
+               "count", tiles_that_need_to_be_rasterized.size());
   RasterWorkerPool::RasterTask::Queue tasks;
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
-  for (TileVector::iterator it = tiles_that_need_to_be_rasterized_.begin();
-       it != tiles_that_need_to_be_rasterized_.end();
+  for (TileVector::const_iterator it = tiles_that_need_to_be_rasterized.begin();
+       it != tiles_that_need_to_be_rasterized.end();
        ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
@@ -763,7 +792,7 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
-                 make_scoped_refptr(tile),
+                 tile->id(),
                  base::Passed(&resource),
                  mts.raster_mode),
       &decode_tasks);
@@ -793,7 +822,7 @@ void TileManager::OnImageDecodeTaskCompleted(
 }
 
 void TileManager::OnRasterTaskCompleted(
-    scoped_refptr<Tile> tile,
+    Tile::Id tile_id,
     scoped_ptr<ResourcePool::Resource> resource,
     RasterMode raster_mode,
     const PicturePileImpl::Analysis& analysis,
@@ -801,6 +830,13 @@ void TileManager::OnRasterTaskCompleted(
   TRACE_EVENT1("cc", "TileManager::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
 
+  TileMap::iterator it = tiles_.find(tile_id);
+  if (it == tiles_.end()) {
+    resource_pool_->ReleaseResource(resource.Pass());
+    return;
+  }
+
+  Tile* tile = it->second;
   ManagedTileState& mts = tile->managed_state();
   ManagedTileState::TileVersion& tile_version =
       mts.tile_versions[raster_mode];
@@ -820,26 +856,9 @@ void TileManager::OnRasterTaskCompleted(
     tile_version.resource_ = resource.Pass();
   }
 
-  FreeUnusedResourcesForTile(tile.get());
-  DidFinishTileInitialization(tile.get());
-}
-
-void TileManager::DidFinishTileInitialization(Tile* tile) {
+  FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
-  if (tile->required_for_activation()) {
-    // It's possible that a tile required for activation is not in this list
-    // if it was marked as being required after being dispatched for
-    // rasterization but before AssignGPUMemory was called again.
-    tiles_that_need_to_be_initialized_for_activation_.erase(tile);
-  }
-}
-
-void TileManager::DidTileTreeBinChange(Tile* tile,
-                                       ManagedTileBin new_tree_bin,
-                                       WhichTree tree) {
-  ManagedTileState& mts = tile->managed_state();
-  mts.tree_bin[tree] = new_tree_bin;
 }
 
 }  // namespace cc
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index ab724fe..de98a4a 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -18,11 +18,10 @@
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "cc/resources/resource_pool.h"
+#include "cc/resources/tile.h"
 
 namespace cc {
 class ResourceProvider;
-class Tile;
-class TileVersion;
 
 class CC_EXPORT TileManagerClient {
  public:
@@ -66,8 +65,8 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
   }
 
   bool AreTilesRequiredForActivationReady() const {
-    return tiles_that_need_to_be_initialized_for_activation_.empty() &&
-        oom_tiles_that_need_to_be_initialized_for_activation_.empty();
+    return all_tiles_required_for_activation_have_been_initialized_ &&
+        all_tiles_required_for_activation_have_memory_;
   }
 
  protected:
@@ -89,14 +88,25 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
   virtual void DidFinishedRunningTasks() OVERRIDE;
   virtual void DidFinishedRunningTasksRequiredForActivation() OVERRIDE;
 
-  // Virtual for test
-  virtual void ScheduleTasks();
-
-  const std::vector<Tile*>& tiles_that_need_to_be_rasterized() const {
-    return tiles_that_need_to_be_rasterized_;
-  }
+  typedef std::vector<Tile*> TileVector;
+  typedef std::vector<scoped_refptr<Tile> > TileRefVector;
+  typedef std::set<Tile*> TileSet;
 
-  void ReassignGpuMemoryToOOMTilesRequiredForActivation();
+  // Virtual for test
+  virtual void ScheduleTasks(
+      const TileVector& tiles_that_need_to_be_rasterized);
+
+  void ReassignGpuMemoryToOOMTilesRequiredForActivation(
+      const TileRefVector& sorted_tiles,
+      TileVector* tiles_that_need_to_be_rasterized,
+      TileSet* oom_tiles_required_for_activation);
+  void AssignGpuMemoryToTiles(
+      const TileRefVector& sorted_tiles,
+      TileVector* tiles_that_need_to_be_rasterized,
+      TileSet* oom_tiles_required_for_activation);
+  void AssignBinsToTiles(TileRefVector* tiles);
+  void SortTiles(TileRefVector* tiles);
+  void GetSortedTiles(TileRefVector* tiles);
 
  private:
   void OnImageDecodeTaskCompleted(
@@ -104,41 +114,34 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
       skia::LazyPixelRef* pixel_ref,
       bool was_canceled);
   void OnRasterTaskCompleted(
-      scoped_refptr<Tile> tile,
+      Tile::Id tile,
       scoped_ptr<ResourcePool::Resource> resource,
       RasterMode raster_mode,
       const PicturePileImpl::Analysis& analysis,
       bool was_canceled);
 
-  void AssignBinsToTiles();
-  void SortTiles();
   RasterMode DetermineRasterMode(const Tile* tile) const;
   void CleanUpUnusedImageDecodeTasks();
-  void AssignGpuMemoryToTiles();
   void FreeResourceForTile(Tile* tile, RasterMode mode);
   void FreeResourcesForTile(Tile* tile);
   void FreeUnusedResourcesForTile(Tile* tile);
   RasterWorkerPool::Task CreateImageDecodeTask(
       Tile* tile, skia::LazyPixelRef* pixel_ref);
   RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile);
-  void DidFinishTileInitialization(Tile* tile);
-  void DidTileTreeBinChange(Tile* tile,
-                            ManagedTileBin new_tree_bin,
-                            WhichTree tree);
   scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
-  void AddRequiredTileForActivation(Tile* tile);
 
   TileManagerClient* client_;
   scoped_ptr<ResourcePool> resource_pool_;
   scoped_ptr<RasterWorkerPool> raster_worker_pool_;
   GlobalStateThatImpactsTilePriority global_state_;
 
-  typedef std::vector<Tile*> TileVector;
-  TileVector tiles_;
-  TileVector tiles_that_need_to_be_rasterized_;
-  typedef std::set<Tile*> TileSet;
-  TileSet tiles_that_need_to_be_initialized_for_activation_;
-  TileSet oom_tiles_that_need_to_be_initialized_for_activation_;
+  typedef base::hash_map<Tile::Id, Tile*> TileMap;
+  TileMap tiles_;
+
+  TileRefVector sorted_tiles_;
+
+  bool all_tiles_required_for_activation_have_been_initialized_;
+  bool all_tiles_required_for_activation_have_memory_;
 
   bool ever_exceeded_memory_budget_;
   MemoryHistory::Entry memory_stats_from_last_assign_;
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index 628324b..b87ac69 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -158,7 +158,7 @@ TEST_F(TileManagerTest, EnoughMemoryAllowAnything) {
       3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
-  tile_manager()->ManageTiles();
+  tile_manager()->AssignMemoryToTiles();
 
   EXPECT_EQ(3, AssignedMemoryCount(active_now));
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
@@ -179,7 +179,7 @@ TEST_F(TileManagerTest, EnoughMemoryAllowPrepaintOnly) {
       3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
-  tile_manager()->ManageTiles();
+  tile_manager()->AssignMemoryToTiles();
 
   EXPECT_EQ(3, AssignedMemoryCount(active_now));
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
@@ -200,7 +200,7 @@ TEST_F(TileManagerTest, EnoughMemoryAllowAbsoluteMinimum) {
       3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
-  tile_manager()->ManageTiles();
+  tile_manager()->AssignMemoryToTiles();
 
   EXPECT_EQ(3, AssignedMemoryCount(active_now));
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
@@ -221,7 +221,7 @@ TEST_F(TileManagerTest, EnoughMemoryAllowNothing) {
       3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
-  tile_manager()->ManageTiles();
+  tile_manager()->AssignMemoryToTiles();
 
   EXPECT_EQ(0, AssignedMemoryCount(active_now));
   EXPECT_EQ(0, AssignedMemoryCount(pending_now));
@@ -241,7 +241,7 @@ TEST_F(TileManagerTest, PartialOOMMemoryToPending) {
   TileVector pending_tree_tiles =
       CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
 
-  tile_manager()->ManageTiles();
+  tile_manager()->AssignMemoryToTiles();
 
   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
@@ -263,7 +263,7 @@ TEST_F(TileManagerTest, PartialOOMMemoryToActive) {
   TileVector pending_tree_tiles =
       CreateTiles(5, TilePriority(), TilePriorityForNowBin());
 
-  tile_manager()->ManageTiles();
+  tile_manager()->AssignMemoryToTiles();
 
   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
@@ -281,7 +281,7 @@ TEST_F(TileManagerTest, TotalOOMMemoryToPending) {
   TileVector pending_tree_tiles =
       CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
 
-  tile_manager()->ManageTiles();
+  tile_manager()->AssignMemoryToTiles();
 
   EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
@@ -304,7 +304,7 @@ TEST_F(TileManagerTest, TotalOOMActiveSoonMemoryToPending) {
   TileVector pending_tree_tiles =
       CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
 
-  tile_manager()->ManageTiles();
+  tile_manager()->AssignMemoryToTiles();
 
   EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
@@ -326,7 +326,7 @@ TEST_F(TileManagerTest, TotalOOMMemoryToActive) {
   TileVector pending_tree_tiles =
       CreateTiles(5, TilePriority(), TilePriorityForNowBin());
 
-  tile_manager()->ManageTiles();
+  tile_manager()->AssignMemoryToTiles();
 
   EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));