cc: Refactored Tile::GetResourceId

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"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/devtools_instrumentation.h"
-#include "cc/math_util.h"
 #include "cc/platform_color.h"
 #include "cc/raster_worker_pool.h"
 #include "cc/resource_pool.h"
 #include "cc/tile.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
 namespace cc {
 
 namespace {
 
@@ skipping 112 matching lines @@
   case UPLOAD_STATE:
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "UPLOAD_STATE"));
   default:
       DCHECK(false) << "Unrecognized TileRasterState value";
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "<unknown TileRasterState value>"));
   }
 }
 
-ManagedTileState::ManagedTileState()
-    : 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()),
-      picture_pile_analyzed(false) {
-  for (int i = 0; i < NUM_TREES; ++i) {
-    tree_bin[i] = NEVER_BIN;
-    bin[i] = NEVER_BIN;
-  }
-}
-
-ManagedTileState::~ManagedTileState() {
-  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("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());
-  state->SetBoolean("is_picture_pile_analyzed", picture_pile_analyzed);
-  state->SetBoolean("is_cheap_to_raster", picture_pile_analysis.is_cheap_to_raster);
-  state->SetBoolean("is_transparent", picture_pile_analysis.is_transparent);
-  state->SetBoolean("is_solid_color", picture_pile_analysis.is_solid_color);
-  return state.PassAs<base::Value>();
-}
-
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
     bool use_cheapness_estimator,
     bool use_color_estimator,
     bool prediction_benchmarking)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(this, num_raster_threads)),
@@ skipping 184 matching lines @@
     DidTileTreeBinChange(tile,
         bin_map[BinFromTilePriority(tile->priority(ACTIVE_TREE))],
         ACTIVE_TREE);
     DidTileTreeBinChange(tile,
         bin_map[BinFromTilePriority(tile->priority(PENDING_TREE))],
         PENDING_TREE);
 
     for (int i = 0; i < NUM_BIN_PRIORITIES; ++i)
       mts.bin[i] = bin_map[mts.bin[i]];
 
-    if (!tile->managed_state().resource &&
-        !tile->managed_state().resource_is_being_initialized &&
+    if (!mts.drawing_info.resource_ &&
+        !mts.drawing_info.resource_is_being_initialized_ &&
         !tile->priority(ACTIVE_TREE).is_live &&
         !tile->priority(PENDING_TREE).is_live)
       continue;
 
     live_or_allocated_tiles_.push_back(tile);
   }
   TRACE_COUNTER_ID1("cc", "LiveOrAllocatedTileCount", this,
                     live_or_allocated_tiles_.size());
 
   SortTiles();
 
   // Assign gpu memory and determine what tiles need to be rasterized.
   AssignGpuMemoryToTiles();
 
   TRACE_EVENT_INSTANT1("cc", "DidManage", "state",
                        ValueToString(BasicStateAsValue()));
 
   // Finally, kick the rasterizer.
   DispatchMoreTasks();
 }
 
 void TileManager::CheckForCompletedTileUploads() {
   while (!tiles_with_pending_upload_.empty()) {
     Tile* tile = tiles_with_pending_upload_.front();
-    DCHECK(tile->managed_state().resource);
+    ManagedTileState& managed_tile_state = tile->managed_state();
+    DCHECK(managed_tile_state.drawing_info.resource_);
 
     // Set pixel tasks complete in the order they are posted.
     if (!resource_pool_->resource_provider()->DidSetPixelsComplete(
-          tile->managed_state().resource->id())) {
+          managed_tile_state.drawing_info.resource_->id())) {
       break;
     }
 
     if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0 &&
         tile->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION)
       client_->DidUploadVisibleHighResolutionTile();
 
     // It's now safe to release the pixel buffer.
     resource_pool_->resource_provider()->ReleasePixelBuffer(
-        tile->managed_state().resource->id());
+        managed_tile_state.drawing_info.resource_->id());
 
     DidFinishTileInitialization(tile);
 
     bytes_pending_upload_ -= tile->bytes_consumed_if_allocated();
     DidTileRasterStateChange(tile, IDLE_STATE);
     tiles_with_pending_upload_.pop();
   }
 
   DispatchMoreTasks();
 }
 
 void TileManager::AbortPendingTileUploads() {
   while (!tiles_with_pending_upload_.empty()) {
     Tile* tile = tiles_with_pending_upload_.front();
     ManagedTileState& managed_tile_state = tile->managed_state();
-    DCHECK(managed_tile_state.resource);
+    DCHECK(managed_tile_state.drawing_info.resource_);
 
     resource_pool_->resource_provider()->AbortSetPixels(
-        managed_tile_state.resource->id());
+        managed_tile_state.drawing_info.resource_->id());
     resource_pool_->resource_provider()->ReleasePixelBuffer(
-        managed_tile_state.resource->id());
+        managed_tile_state.drawing_info.resource_->id());
 
-    managed_tile_state.resource_is_being_initialized = false;
-    managed_tile_state.can_be_freed = true;
+    managed_tile_state.drawing_info.resource_is_being_initialized_ = false;
+    managed_tile_state.drawing_info.can_be_freed_ = true;
     managed_tile_state.can_use_gpu_memory = false;
     FreeResourcesForTile(tile);
 
     bytes_pending_upload_ -= tile->bytes_consumed_if_allocated();
     DidTileRasterStateChange(tile, IDLE_STATE);
     tiles_with_pending_upload_.pop();
   }
 }
 
 void TileManager::DidCompleteFrame() {
   allow_cheap_tasks_ = true;
   did_schedule_cheap_tasks_ = false;
 }
 
 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 < live_or_allocated_tiles_.size(); i++) {
     const Tile* tile = live_or_allocated_tiles_[i];
     const ManagedTileState& mts = tile->managed_state();
-    if (tile->is_transparent() || tile->is_solid_color())
+    if (!tile->drawing_info().requires_resource())
       continue;
 
     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;
   }
@@ skipping 102 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) {
     Tile* tile = *it;
-    if (tile->is_solid_color() || tile->is_transparent())
+    ManagedTileState& mts = tile->managed_state();
+    if (!tile->drawing_info().requires_resource())
       continue;
 
-    ManagedTileState& managed_tile_state = tile->managed_state();
-    if (!managed_tile_state.can_be_freed)
+    if (!mts.drawing_info.can_be_freed_)
       unreleasable_bytes += tile->bytes_consumed_if_allocated();
-    if (managed_tile_state.raster_state == WAITING_FOR_RASTER_STATE)
+    if (mts.raster_state == WAITING_FOR_RASTER_STATE)
       DidTileRasterStateChange(tile, 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) {
     Tile* tile = *it;
-    if (tile->is_solid_color() || tile->is_transparent())
+    ManagedTileState& mts = tile->managed_state();
+    if (!tile->drawing_info().requires_resource())
       continue;
 
-    ManagedTileState& managed_tile_state = tile->managed_state();
     size_t tile_bytes = tile->bytes_consumed_if_allocated();
-    if (!managed_tile_state.can_be_freed)
+    if (!mts.drawing_info.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;
+    if (mts.bin[HIGH_PRIORITY_BIN] == NEVER_BIN &&
+        mts.bin[LOW_PRIORITY_BIN] == NEVER_BIN) {
+      mts.can_use_gpu_memory = false;
       FreeResourcesForTile(tile);
       continue;
     }
     if (tile_bytes > bytes_left) {
-      managed_tile_state.can_use_gpu_memory = false;
-      if (managed_tile_state.bin[HIGH_PRIORITY_BIN] == NOW_BIN ||
-          managed_tile_state.bin[LOW_PRIORITY_BIN] == NOW_BIN)
+      mts.can_use_gpu_memory = false;
+      if (mts.bin[HIGH_PRIORITY_BIN] == NOW_BIN ||
+          mts.bin[LOW_PRIORITY_BIN] == NOW_BIN)
           bytes_that_exceeded_memory_budget_in_now_bin += tile_bytes;
       FreeResourcesForTile(tile);
       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) {
+    mts.can_use_gpu_memory = true;
+    if (!mts.drawing_info.resource_ &&
+        !mts.drawing_info.resource_is_being_initialized_) {
       tiles_that_need_to_be_rasterized_.push_back(tile);
       DidTileRasterStateChange(tile, WAITING_FOR_RASTER_STATE);
     }
   }
 
   ever_exceeded_memory_budget_ |=
       bytes_that_exceeded_memory_budget_in_now_bin > 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_in_now_bin);
   }
   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 = unreleasable_bytes;
   memory_stats_from_last_assign_.bytes_over =
       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(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());
+  DCHECK(managed_tile_state.drawing_info.can_be_freed_);
+  if (managed_tile_state.drawing_info.resource_)
+    resource_pool_->ReleaseResource(
+        managed_tile_state.drawing_info.resource_.Pass());
 }
 
 bool TileManager::CanDispatchRasterTask(Tile* tile) const {
   if (pending_tasks_ >= max_pending_tasks_)
     return false;
   size_t new_bytes_pending = bytes_pending_upload_;
   new_bytes_pending += tile->bytes_consumed_if_allocated();
   return new_bytes_pending <= kMaxPendingUploadBytes &&
          tiles_with_pending_upload_.size() < kMaxPendingUploads;
 }
@@ skipping 19 matching lines @@
       ++it;
     }
   }
 
   // Process all tiles in the need_to_be_rasterized queue. If a tile is
   // solid/transparent, then we are done (we don't need to rasterize
   // the tile). 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();
-    ManagedTileState& managed_tile_state = tile->managed_state();
+    ManagedTileState& mts = tile->managed_state();
 
     AnalyzeTile(tile);
-    if (tile->is_solid_color() || tile->is_transparent()) {
+    if (!tile->drawing_info().requires_resource()) {
       DidTileRasterStateChange(tile, IDLE_STATE);
       tiles_that_need_to_be_rasterized_.pop_back();
       continue;
     }
 
     DispatchImageDecodeTasksForTile(tile);
-    if (!managed_tile_state.pending_pixel_refs.empty()) {
+    if (!mts.pending_pixel_refs.empty()) {
       tiles_with_image_decoding_tasks_.push_back(tile);
     } else {
       if (!CanDispatchRasterTask(tile))
         return;
       DispatchOneRasterTask(tile);
     }
     tiles_that_need_to_be_rasterized_.pop_back();
   }
 }
 
 void TileManager::AnalyzeTile(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   if ((use_cheapness_estimator_ || use_color_estimator_) &&
       !managed_tile_state.picture_pile_analyzed) {
     tile->picture_pile()->AnalyzeInRect(
         tile->content_rect(),
         tile->contents_scale(),
         &managed_tile_state.picture_pile_analysis);
     managed_tile_state.picture_pile_analysis.is_cheap_to_raster &=
         use_cheapness_estimator_;
     managed_tile_state.picture_pile_analysis.is_solid_color &=
         use_color_estimator_;
     managed_tile_state.picture_pile_analysis.is_transparent &=
         use_color_estimator_;
     managed_tile_state.picture_pile_analyzed = true;
+
+    if (managed_tile_state.picture_pile_analysis.is_solid_color)
+      tile->drawing_info().set_solid_color(
+        managed_tile_state.picture_pile_analysis.solid_color);
+    else if (managed_tile_state.picture_pile_analysis.is_transparent)
+      tile->drawing_info().set_transparent();
   }
 }
 
 void TileManager::GatherPixelRefsForTile(Tile* tile) {
   TRACE_EVENT0("cc", "TileManager::GatherPixelRefsForTile");
   ManagedTileState& managed_tile_state = tile->managed_state();
   if (managed_tile_state.need_to_gather_pixel_refs) {
     base::TimeTicks gather_begin_time;
     if (record_rendering_stats_)
       gather_begin_time = base::TimeTicks::HighResNow();
@@ skipping 72 matching lines @@
 }
 
 scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
     Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_use_gpu_memory);
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(tile->tile_size_.size(), tile->format_);
   resource_pool_->resource_provider()->AcquirePixelBuffer(resource->id());
 
-  managed_tile_state.resource_is_being_initialized = true;
-  managed_tile_state.can_be_freed = false;
+  managed_tile_state.drawing_info.resource_is_being_initialized_ = true;
+  managed_tile_state.drawing_info.can_be_freed_ = false;
 
   DidTileRasterStateChange(tile, RASTER_STATE);
   return resource.Pass();
 }
 
 void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
   scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
   ResourceProvider::ResourceId resource_id = resource->id();
   uint8* buffer =
@@ skipping 45 matching lines @@
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
   TRACE_EVENT0("cc", "TileManager::OnRasterTaskCompleted");
 
   pending_tasks_--;
 
   // Release raster resources.
   resource_pool_->resource_provider()->UnmapPixelBuffer(resource->id());
 
   ManagedTileState& managed_tile_state = tile->managed_state();
-  managed_tile_state.can_be_freed = true;
+  managed_tile_state.drawing_info.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
   // 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 (managed_tile_state.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 =
+    managed_tile_state.drawing_info.contents_swizzled_ =
         !PlatformColor::sameComponentOrder(tile->format_);
 
     // Tile resources can't be freed until upload has completed.
-    managed_tile_state.can_be_freed = false;
+    managed_tile_state.drawing_info.can_be_freed_ = false;
 
     resource_pool_->resource_provider()->BeginSetPixels(resource->id());
     has_performed_uploads_since_last_flush_ = true;
 
-    managed_tile_state.resource = resource.Pass();
+    managed_tile_state.drawing_info.resource_ = resource.Pass();
 
     bytes_pending_upload_ += tile->bytes_consumed_if_allocated();
     DidTileRasterStateChange(tile, UPLOAD_STATE);
     tiles_with_pending_upload_.push(tile);
   } else {
     resource_pool_->resource_provider()->ReleasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
-    managed_tile_state.resource_is_being_initialized = false;
+    managed_tile_state.drawing_info.resource_is_being_initialized_ = false;
     DidTileRasterStateChange(tile, IDLE_STATE);
   }
 }
 
 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;
+  ManagedTileState& managed_state = tile->managed_state();
+  DCHECK(managed_state.drawing_info.resource_);
+  managed_state.drawing_info.resource_is_being_initialized_ = false;
+  managed_state.drawing_info.can_be_freed_ = true;
 }
 
 void TileManager::DidTileRasterStateChange(Tile* tile, TileRasterState state) {
   ManagedTileState& mts = tile->managed_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);
@@ skipping 160 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