cc: Only register live tiles with the TileManager

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 127 matching lines @@
   default:
       DCHECK(false) << "Unrecognized TileRasterState value";
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "<unknown TileRasterState value>"));
   }
 }
 
 ManagedTileState::ManagedTileState(Tile* tile)
     : tile(tile),
       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),
       resolution(NON_IDEAL_RESOLUTION),
       time_to_needed_in_seconds(std::numeric_limits<float>::infinity()),
       distance_to_visible_in_pixels(std::numeric_limits<float>::infinity()) {
   for (int i = 0; i < NUM_TREES; ++i) {
     tree_bin[i] = NEVER_BIN;
     bin[i] = NEVER_BIN;
   }
   tile->tile_manager()->RegisterManagedTile(this);
 }
 
 ManagedTileState::~ManagedTileState() {
   tile->tile_manager()->UnregisterManagedTile(this);
   DCHECK(!resource);
   DCHECK(!resource_is_being_initialized);
 }
 
 scoped_ptr<base::Value> ManagedTileState::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetBoolean("can_use_gpu_memory", can_use_gpu_memory);
-  state->SetBoolean("can_be_freed", can_be_freed);
+  state->SetBoolean("can_be_freed", can_be_freed());
   state->SetBoolean("has_resource", resource.get() != 0);
   state->SetBoolean("resource_is_being_initialized", resource_is_being_initialized);
   state->Set("raster_state", TileRasterStateAsValue(raster_state).release());
   state->Set("bin.0", TileManagerBinAsValue(bin[ACTIVE_TREE]).release());
   state->Set("bin.1", TileManagerBinAsValue(bin[PENDING_TREE]).release());
   state->Set("gpu_memmgr_stats_bin", TileManagerBinAsValue(bin[ACTIVE_TREE]).release());
   state->Set("resolution", TileResolutionAsValue(resolution).release());
   state->Set("time_to_needed_in_seconds", MathUtil::asValueSafely(time_to_needed_in_seconds).release());
   state->Set("distance_to_visible_in_pixels", MathUtil::asValueSafely(distance_to_visible_in_pixels).release());
   return state.PassAs<base::Value>();
@@ skipping 225 matching lines @@
 
   TRACE_EVENT_INSTANT1("cc", "DidManage", "state",
                        ValueToString(BasicStateAsValue()));
 
   // Finally, kick the rasterizer.
   DispatchMoreTasks();
 }
 
 void TileManager::CheckForCompletedTileUploads() {
   while (!tiles_with_pending_set_pixels_.empty()) {
-    ManagedTileState* mts = tiles_with_pending_set_pixels_.front();
+    // Note that a scoped_refptr must be used because the unsetting of
+    // cannot_be_freed_ref may cause mts to be unregistered.
+    scoped_refptr<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(
           mts->resource->id())) {
       break;
     }
 
     if (mts->tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0 &&
         mts->tile->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION)
       client_->DidUploadVisibleHighResolutionTile();
 
     // It's now safe to release the pixel buffer.
     resource_pool_->resource_provider()->releasePixelBuffer(
         mts->resource->id());
 
-    DidFinishTileInitialization(mts);
+    mts->resource_is_being_initialized = false;
+    mts->cannot_be_freed_ref = NULL;
 
     bytes_pending_set_pixels_ -= mts->tile->bytes_consumed_if_allocated();
     DidTileRasterStateChange(mts, IDLE_STATE);
     tiles_with_pending_set_pixels_.pop();
   }
 
   DispatchMoreTasks();
 }
 
 void TileManager::AbortPendingTileUploads() {
   while (!tiles_with_pending_set_pixels_.empty()) {
-    ManagedTileState* mts = tiles_with_pending_set_pixels_.front();
+    // Note that a scoped_refptr must be used because the unsetting of
+    // cannot_be_freed_ref may cause mts to be unregistered.
+    scoped_refptr<ManagedTileState> mts =
+        tiles_with_pending_set_pixels_.front();
     DCHECK(mts->resource);
 
     resource_pool_->resource_provider()->abortSetPixels(
         mts->resource->id());
     resource_pool_->resource_provider()->releasePixelBuffer(
         mts->resource->id());
 
     mts->resource_is_being_initialized = false;
-    mts->can_be_freed = true;
+    mts->cannot_be_freed_ref = NULL;
     mts->can_use_gpu_memory = false;
     FreeResourcesForTile(mts);
 
     bytes_pending_set_pixels_ -= mts->tile->bytes_consumed_if_allocated();
     DidTileRasterStateChange(mts, IDLE_STATE);
     tiles_with_pending_set_pixels_.pop();
   }
 }
 
 void TileManager::GetMemoryStats(
@@ skipping 118 matching lines @@
   // 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.
   // Some memory cannot be released. We figure out how much in this
   // loop as well.
   for (TileVector::iterator it = live_or_allocated_tiles_.begin();
        it != live_or_allocated_tiles_.end(); ++it) {
     ManagedTileState* mts = *it;
-    if (!mts->can_be_freed)
+    if (!mts->can_be_freed())
       unreleasable_bytes += mts->tile->bytes_consumed_if_allocated();
     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_that_exceeded_memory_budget_in_now_bin = 0;
   size_t bytes_left = bytes_allocatable;
   for (TileVector::iterator it = live_or_allocated_tiles_.begin(); it != live_or_allocated_tiles_.end(); ++it) {
     ManagedTileState* mts = *it;
     size_t tile_bytes = mts->tile->bytes_consumed_if_allocated();
-    if (!mts->can_be_freed)
+    if (!mts->can_be_freed())
       continue;
     if (mts->bin[HIGH_PRIORITY_BIN] == NEVER_BIN &&
         mts->bin[LOW_PRIORITY_BIN] == NEVER_BIN) {
       mts->can_use_gpu_memory = false;
       FreeResourcesForTile(mts);
       continue;
     }
     if (tile_bytes > bytes_left) {
       mts->can_use_gpu_memory = false;
       if (mts->bin[HIGH_PRIORITY_BIN] == NOW_BIN ||
@@ skipping 27 matching lines @@
       bytes_that_exceeded_memory_budget_in_now_bin;
 
   // Reverse two tiles_that_need_* vectors 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(ManagedTileState* mts) {
-  DCHECK(mts->can_be_freed);
+  DCHECK(mts->can_be_freed());
   if (mts->resource)
     resource_pool_->ReleaseResource(mts->resource.Pass());
 }
 
 bool TileManager::CanDispatchRasterTask(ManagedTileState* mts) {
   if (raster_worker_pool_->IsBusy())
     return false;
   size_t new_bytes_pending = bytes_pending_set_pixels_;
   new_bytes_pending += mts->tile->bytes_consumed_if_allocated();
   return new_bytes_pending <= kMaxPendingUploadBytes &&
@@ skipping 114 matching lines @@
 
 scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
     ManagedTileState* mts) {
   DCHECK(mts->can_use_gpu_memory);
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(mts->tile->tile_size_.size(),
                                       mts->tile->format_);
   resource_pool_->resource_provider()->acquirePixelBuffer(resource->id());
 
   mts->resource_is_being_initialized = true;
-  mts->can_be_freed = false;
+  mts->cannot_be_freed_ref = mts;
 
   DidTileRasterStateChange(mts, RASTER_STATE);
   return resource.Pass();
 }
 
 void TileManager::DispatchOneRasterTask(scoped_refptr<ManagedTileState> mts) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
   scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(mts);
   ResourceProvider::ResourceId resource_id = resource->id();
 
@@ skipping 31 matching lines @@
 
 void TileManager::OnRasterCompleted(
     scoped_refptr<ManagedTileState> mts,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
   TRACE_EVENT0("cc", "TileManager::OnRasterCompleted");
 
   // Release raster resources.
   resource_pool_->resource_provider()->unmapPixelBuffer(resource->id());
 
-  mts->can_be_freed = true;
+  mts->cannot_be_freed_ref = NULL;
 
   // 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 (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.
     mts->contents_swizzled =
         !PlatformColor::sameComponentOrder(mts->tile->format_);
 
     // Tile resources can't be freed until upload has completed.
-    mts->can_be_freed = false;
+    mts->cannot_be_freed_ref = mts;
 
     resource_pool_->resource_provider()->beginSetPixels(resource->id());
     has_performed_uploads_since_last_flush_ = true;
 
     mts->resource = resource.Pass();
 
     bytes_pending_set_pixels_ += mts->tile->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());
     mts->resource_is_being_initialized = false;
     DidTileRasterStateChange(mts, IDLE_STATE);
   }
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<ManagedTileState> mts,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
   OnRasterCompleted(mts, resource.Pass(),
                     manage_tiles_call_count_when_dispatched);
 }
 
-void TileManager::DidFinishTileInitialization(ManagedTileState* mts) {
-  DCHECK(mts->resource);
-  mts->resource_is_being_initialized = false;
-  mts->can_be_freed = true;
-}
-
 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);
 
     // Increment count for new state.
@@ skipping 91 matching lines @@
     decode_begin_time = base::TimeTicks::HighResNow();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::HighResNow() - decode_begin_time;
   }
 }
 
 }  // namespace cc