cc: Refactored Tile::GetResourceId

cc/tile_manager.cc

Index: cc/tile_manager.cc
diff --git a/cc/tile_manager.cc b/cc/tile_manager.cc
index d06e18dc677e39931ed954cc393aabdb30ae22da..d330e2cbb9759d17ebe7246df0005f82ca1832e8 100644
--- a/cc/tile_manager.cc
+++ b/cc/tile_manager.cc
@@ -137,9 +137,6 @@ scoped_ptr<base::Value> TileRasterStateAsValue(
 
 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),
@@ -153,16 +150,16 @@ ManagedTileState::ManagedTileState()
 }
 
 ManagedTileState::~ManagedTileState() {
-  DCHECK(!resource);
-  DCHECK(!resource_is_being_initialized);
+  DCHECK(!drawing_info.resource_);
+  DCHECK(!drawing_info.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->SetBoolean("can_be_freed", drawing_info.can_be_freed_);
+  state->SetBoolean("has_resource", drawing_info.resource_.get() != 0);
+  state->SetBoolean("resource_is_being_initialized", drawing_info.resource_is_being_initialized_);

[enne (OOO), 2013/03/12 19:42:13]

style nit: 80 col, here and the rest of this function.

   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());
@@ -373,8 +370,8 @@ void TileManager::ManageTiles() {
 
     if (tile->priority(ACTIVE_TREE).is_live ||
         tile->priority(PENDING_TREE).is_live ||
-        tile->managed_state().resource ||
-        tile->managed_state().resource_is_being_initialized) {
+        mts.drawing_info.resource_ ||
+        mts.drawing_info.resource_is_being_initialized_) {
       live_or_allocated_tiles_.push_back(tile);
     }
   }
@@ -396,11 +393,12 @@ void TileManager::ManageTiles() {
 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;
     }
 
@@ -410,7 +408,7 @@ void TileManager::CheckForCompletedTileUploads() {
 
     // 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);
 
@@ -426,15 +424,15 @@ 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);
 
@@ -579,7 +577,7 @@ void TileManager::AssignGpuMemoryToTiles() {
   for (TileVector::iterator it = live_or_allocated_tiles_.begin();
        it != live_or_allocated_tiles_.end(); ++it) {
     Tile* tile = *it;
-    if (!tile->managed_state().can_be_freed)
+    if (!tile->managed_state().drawing_info.can_be_freed_)
       unreleasable_bytes += tile->bytes_consumed_if_allocated();
     if (tile->managed_state().raster_state == WAITING_FOR_RASTER_STATE)
       DidTileRasterStateChange(tile, IDLE_STATE);
@@ -592,7 +590,7 @@ void TileManager::AssignGpuMemoryToTiles() {
     Tile* tile = *it;
     size_t tile_bytes = tile->bytes_consumed_if_allocated();
     ManagedTileState& managed_tile_state = tile->managed_state();
-    if (!managed_tile_state.can_be_freed)
+    if (!managed_tile_state.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) {
@@ -610,8 +608,8 @@ void TileManager::AssignGpuMemoryToTiles() {
     }
     bytes_left -= tile_bytes;
     managed_tile_state.can_use_gpu_memory = true;
-    if (!managed_tile_state.resource &&
-        !managed_tile_state.resource_is_being_initialized) {
+    if (!managed_tile_state.drawing_info.resource_ &&
+        !managed_tile_state.drawing_info.resource_is_being_initialized_) {
       tiles_that_need_to_be_rasterized_.push_back(tile);
       DidTileRasterStateChange(tile, WAITING_FOR_RASTER_STATE);
     }
@@ -641,9 +639,10 @@ void TileManager::AssignGpuMemoryToTiles() {
 
 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 {
@@ -780,8 +779,8 @@ scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
       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();
@@ -835,7 +834,7 @@ void TileManager::OnRasterTaskCompleted(
   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
@@ -851,16 +850,16 @@ void TileManager::OnRasterTaskCompleted(
     // 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);
@@ -868,16 +867,16 @@ void TileManager::OnRasterTaskCompleted(
   } 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) {