cc: Remove tile ref counting in tile manager.

cc/resources/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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 136 matching lines @@
     const GlobalStateThatImpactsTilePriority& global_state) {
   global_state_ = global_state;
   resource_pool_->SetMaxMemoryUsageBytes(
       global_state_.memory_limit_in_bytes,
       global_state_.unused_memory_limit_in_bytes);
 }
 
 void TileManager::RegisterTile(Tile* tile) {
   DCHECK(std::find(tiles_.begin(), tiles_.end(), tile) == tiles_.end());
   DCHECK(!tile->required_for_activation());
+  DCHECK(managed_tile_map_.find(tile->id()) == managed_tile_map_.end());
+
   tiles_.push_back(tile);
+  managed_tile_map_[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);
 
   DCHECK(std::find(tiles_.begin(), tiles_.end(), tile) != tiles_.end());
   FreeResourcesForTile(tile);
   tiles_.erase(std::remove(tiles_.begin(), tiles_.end(), tile));
+
+  ManagedTileMap::iterator managed_iter = managed_tile_map_.find(tile->id());
+  DCHECK(managed_iter != managed_tile_map_.end());
+  managed_tile_map_.erase(managed_iter);
 }
 
 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
   return GlobalState().tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 }
 
 class BinComparator {
  public:
   bool operator() (const Tile* a, const Tile* b) const {
     const ManagedTileState& ams = a->managed_state();
@@ skipping 546 matching lines @@
   return RasterWorkerPool::CreateRasterTask(
       const_resource,
       tile->picture_pile(),
       tile->content_rect(),
       tile->contents_scale(),
       mts.raster_mode,
       metadata,
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
-                 make_scoped_refptr(tile),
+                 tile->id(),
                  base::Passed(&resource),
                  mts.raster_mode),
       &decode_tasks);
 }
 
 void TileManager::OnImageDecodeTaskCompleted(
     int layer_id,
     skia::LazyPixelRef* pixel_ref,
     bool was_canceled) {
   // If the task was canceled, we need to clean it up
   // from |image_decode_tasks_|.
   if (!was_canceled)
     return;
 
   LayerPixelRefTaskMap::iterator layer_it =
       image_decode_tasks_.find(layer_id);
 
   if (layer_it == image_decode_tasks_.end())
     return;
 
   PixelRefTaskMap& pixel_ref_tasks = layer_it->second;
   PixelRefTaskMap::iterator task_it =
       pixel_ref_tasks.find(pixel_ref->getGenerationID());
 
   if (task_it != pixel_ref_tasks.end())
     pixel_ref_tasks.erase(task_it);
 }
 
 void TileManager::OnRasterTaskCompleted(
-    scoped_refptr<Tile> tile,
+    ManagedTileId managed_id,

[reveman, 2013/07/03 00:32:47]

Lets use the same type name for the Id everywhere. Preferably Tile::TileId.

     scoped_ptr<ResourcePool::Resource> resource,
     RasterMode raster_mode,
     const PicturePileImpl::Analysis& analysis,
     bool was_canceled) {
   TRACE_EVENT1("cc", "TileManager::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
 
+  ManagedTileMap::iterator managed_iter = managed_tile_map_.find(managed_id);
+  if (managed_iter == managed_tile_map_.end()) {
+    resource_pool_->ReleaseResource(resource.Pass());
+    return;
+  }
+
+  Tile* tile = managed_iter->second;
   ManagedTileState& mts = tile->managed_state();
   ManagedTileState::TileVersion& tile_version =
       mts.tile_versions[raster_mode];
   DCHECK(!tile_version.raster_task_.is_null());
   tile_version.raster_task_.Reset();
 
   if (was_canceled) {
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
 
   tile_version.set_has_text(analysis.has_text);
   if (analysis.is_solid_color) {
     tile_version.set_solid_color(analysis.solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     tile_version.resource_ = resource.Pass();
   }
 
-  FreeUnusedResourcesForTile(tile.get());
+  FreeUnusedResourcesForTile(tile);
 
-  DidFinishTileInitialization(tile.get());
+  DidFinishTileInitialization(tile);
 }
 
 void TileManager::DidFinishTileInitialization(Tile* 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);
 
     if (AreTilesRequiredForActivationReady())
       client_->NotifyReadyToActivate();
   }
 }
 
 void TileManager::DidTileTreeBinChange(Tile* tile,
                                        TileManagerBin new_tree_bin,
                                        WhichTree tree) {
   ManagedTileState& mts = tile->managed_state();
   mts.tree_bin[tree] = new_tree_bin;
 }
 
 }  // namespace cc