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 116 matching lines @@
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       did_initialize_visible_tile_(false),
       texture_format_(texture_format) {
   raster_worker_pool_->SetClient(this);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
-  AssignGpuMemoryToTiles();
+  TileVector tiles_that_need_to_be_rasterized;
+  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
   CleanUpUnusedImageDecodeTasks();
   // 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(
     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_tiles_.find(tile->id()) == managed_tiles_.end());
+
   tiles_.push_back(tile);

[reveman, 2013/07/03 20:20:06]

I prefer if this becomes |sorted_tiles_| as that better represents what it is
and will help prevent us from using it when not valid.

in here we could just "sorted_tiles_need_update_ = true" or something like that

[vmpstr, 2013/07/03 23:47:51]

Done.

+  managed_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));

[reveman, 2013/07/03 20:20:06]

"sorted_tiles_need_update_ = true" or whatever we decide

[vmpstr, 2013/07/03 23:47:51]

Done.

+
+  TileMap::iterator managed_iter = managed_tiles_.find(tile->id());
+  DCHECK(managed_iter != managed_tiles_.end());
+  managed_tiles_.erase(managed_iter);

[reveman, 2013/07/03 20:20:06]

I prefer:
DCHECK(tiles_.find(tile->id()) != tiles_.end());
tiles_.erase(tile->id());

[vmpstr, 2013/07/03 23:47:51]

Done.

 }
 
 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
   return GlobalState().tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 }
 
 void 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)
     return;
 
   raster_worker_pool_->CheckForCompletedTasks();
 
-  AssignGpuMemoryToTiles();
+  TileVector tiles_that_need_to_be_rasterized;
+  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
 
-  if (!oom_tiles_that_need_to_be_initialized_for_activation_.empty())
-    ReassignGpuMemoryToOOMTilesRequiredForActivation();
+  if (!oom_tiles_that_need_to_be_initialized_for_activation_.empty()) {
+    ReassignGpuMemoryToOOMTilesRequiredForActivation(
+        &tiles_that_need_to_be_rasterized);
+  }
 
-  // |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();
        ++it) {
     Tile* tile = *it;
@@ skipping 134 matching lines @@
   TRACE_EVENT0("cc", "TileManager::SortTiles");
 
   // Sort by bin, resolution and time until needed.
   std::sort(tiles_.begin(), tiles_.end(), BinComparator());
 }
 
 void TileManager::ManageTiles() {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
   AssignBinsToTiles();
   SortTiles();
-  AssignGpuMemoryToTiles();
+
+  TileVector tiles_that_need_to_be_rasterized;
+  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
   CleanUpUnusedImageDecodeTasks();
 
   TRACE_EVENT_INSTANT1(
       "cc", "DidManage", TRACE_EVENT_SCOPE_THREAD,
       "state", TracedValue::FromValue(BasicStateAsValue().release()));
 
   // Finally, schedule rasterizer tasks.
-  ScheduleTasks();
+  ScheduleTasks(tiles_that_need_to_be_rasterized);
 }
 
 void TileManager::CheckForCompletedTileUploads() {
   raster_worker_pool_->CheckForCompletedTasks();
 
   if (did_initialize_visible_tile_) {
     client_->DidInitializeVisibleTile();
     did_initialize_visible_tile_ = false;
   }
 }
@@ skipping 79 matching lines @@
     raster_mode = LOW_QUALITY_RASTER_MODE;
   else if (tile->can_use_lcd_text())
     raster_mode = HIGH_QUALITY_RASTER_MODE;
   else if (mts.tile_versions[current_mode].has_text_ ||
            !mts.tile_versions[current_mode].IsReadyToDraw())
     raster_mode = HIGH_QUALITY_NO_LCD_RASTER_MODE;
 
   return std::min(raster_mode, current_mode);
 }
 
-void TileManager::AssignGpuMemoryToTiles() {
+void TileManager::AssignGpuMemoryToTiles(
+    TileVector* tiles_that_need_to_be_rasterized) {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
 
   // 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();
        ++it) {
     const Tile* tile = *it;
     const ManagedTileState& mts = tile->managed_state();
     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
@@ skipping 76 matching lines @@
     // Tile shouldn't be rasterized if we've failed to assign
     // gpu memory to a higher priority tile. This is important for
     // two reasons:
     // 1. Tile size should not impact raster priority.
     // 2. Tile with unreleasable memory could otherwise incorrectly
     //    be added as it's not affected by |bytes_allocatable|.
     if (higher_priority_tile_oomed)
       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(NULL) &&
         tile->required_for_activation()) {
       AddRequiredTileForActivation(tile);
     }
   }
 
   ever_exceeded_memory_budget_ |= bytes_that_exceeded_memory_budget > 0;
   if (ever_exceeded_memory_budget_) {
       TRACE_COUNTER_ID2("cc", "over_memory_budget", this,
                         "budget", global_state_.memory_limit_in_bytes,
                         "over", bytes_that_exceeded_memory_budget);
   }
   memory_stats_from_last_assign_.total_budget_in_bytes =
       global_state_.memory_limit_in_bytes;
   memory_stats_from_last_assign_.bytes_allocated =
       bytes_allocatable - bytes_left;
   memory_stats_from_last_assign_.bytes_unreleasable =
       bytes_allocatable - bytes_releasable;
   memory_stats_from_last_assign_.bytes_over =
       bytes_that_exceeded_memory_budget;
 }
 
-void TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation() {
+void TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation(
+    TileVector* tiles_that_need_to_be_rasterized) {
   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())
       continue;
@@ skipping 13 matching lines @@
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
     if (mts.tree_bin[PENDING_TREE] == NEVER_BIN &&
         mts.tree_bin[ACTIVE_TREE] != NOW_BIN) {
       ManagedTileState::TileVersion& tile_version =
           mts.tile_versions[mts.raster_mode];
 
       // 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.
       for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
         if (mts.tile_versions[mode].resource_) {
           DCHECK(!tile->required_for_activation());
           FreeResourceForTile(tile, static_cast<RasterMode>(mode));
           bytes_freed += tile->bytes_consumed_if_allocated();
         }
       }
     }
 
     if (bytes_oom_for_required_tiles <= bytes_freed)
       break;
   }
 
   for (TileVector::iterator it = tiles_requiring_memory_but_oomed.begin();
        it != tiles_requiring_memory_but_oomed.end() && bytes_freed > 0;
        ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
     size_t bytes_needed = tile->bytes_consumed_if_allocated();
     if (bytes_needed > bytes_freed)
       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);
   }
 }
 
 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)
@@ skipping 33 matching lines @@
 
 void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
   RasterMode used_mode = HIGH_QUALITY_RASTER_MODE;
   bool version_is_used = tile->IsReadyToDraw(&used_mode);
   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
     if (!version_is_used || mode != used_mode)
       FreeResourceForTile(tile, static_cast<RasterMode>(mode));
   }
 }
 
-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();
     ManagedTileState::TileVersion& tile_version =
         mts.tile_versions[mts.raster_mode];
 
     DCHECK(tile_version.requires_resource());
     DCHECK(!tile_version.resource_);
 
     if (tile_version.raster_task_.is_null())
@@ skipping 69 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,
     scoped_ptr<ResourcePool::Resource> resource,
     RasterMode raster_mode,
     const PicturePileImpl::Analysis& analysis,
     bool was_canceled) {
   TRACE_EVENT1("cc", "TileManager::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
 
+  TileMap::iterator managed_iter = managed_tiles_.find(managed_id);
+  if (managed_iter == managed_tiles_.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);
   }
 }
 
 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