cc: Remove memory state from tile management

cc/resources/tile_manager.cc

Index: cc/resources/tile_manager.cc
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index f0363b7831926a111e41754e23cfb53515cbebcb..b70fe288e4e52b34c802e94adf3e17c520cc2be6 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -307,7 +307,6 @@ void TileManager::CheckForCompletedTileUploads() {
        ++it) {
     Tile* tile = *it;
     if (!tile->managed_state().raster_task.is_null() &&
-        tile->tile_version().memory_state_ == USING_UNRELEASABLE_MEMORY &&
         !tile->tile_version().forced_upload_) {
       if (!raster_worker_pool_->ForceUploadToComplete(
               tile->managed_state().raster_task))
@@ -348,7 +347,7 @@ void TileManager::GetMemoryStats(
       *memory_required_bytes += tile_bytes;
     if (mts.gpu_memmgr_stats_bin != NEVER_BIN)
       *memory_nice_to_have_bytes += tile_bytes;
-    if (tile->tile_version().memory_state_ != NOT_ALLOWED_TO_USE_MEMORY)
+    if (!tile->managed_state().raster_task.is_null())

[reveman, 2013/06/03 14:11:34]

This is not the same. raster_task is only set while tile is being initialized.

[vmpstr, 2013/06/03 17:08:26]

Done.

       *memory_used_bytes += tile_bytes;
   }
 }
@@ -413,7 +412,7 @@ void TileManager::AssignGpuMemoryToTiles() {
        it != tiles_.end();
        ++it) {
     const Tile* tile = *it;
-    if (tile->tile_version().memory_state_ == USING_UNRELEASABLE_MEMORY)
+    if (!tile->managed_state().raster_task.is_null())

[reveman, 2013/06/03 14:11:34]

It's a bit weird that we examine |raster_task| to determine available memory.
Maybe we should compute bytes_allocatable as the sum of all releasable memory +
max(0, memory_limit_in_bytes - resource_pool_->memory_usage_bytes()).

[vmpstr, 2013/06/03 17:08:26]

Done.

       unreleasable_bytes += tile->bytes_consumed_if_allocated();
   }
 
@@ -443,15 +442,12 @@ void TileManager::AssignGpuMemoryToTiles() {
     // Memory is already reserved for tile with unreleasable memory
     // so adding it to |tiles_that_need_to_be_rasterized_| doesn't
     // affect bytes_allocatable.
-    if (tile_version.memory_state_ == USING_UNRELEASABLE_MEMORY)
+    if (!mts.raster_task.is_null())
       tile_bytes = 0;

[reveman, 2013/06/03 14:11:34]

Maybe we should reverse this. Make tile_bytes=0 by default and increase it based
on the needs for the tile. ie. maintaining a resource requires
tile->bytes_consumed_if_allocated(), creating a RasterTask for tile requires
another tile->bytes_consumed_if_allocated(). Wdyt?

Comment above needs to be updated anyhow. We shouldn't refer to unreleasable
memory anymore.

[vmpstr, 2013/06/03 17:08:26]

Done.

 
     // If the tile is not needed, free it up.
     if (mts.is_in_never_bin_on_both_trees()) {
-      if (tile_version.memory_state_ != USING_UNRELEASABLE_MEMORY) {
-        FreeResourcesForTile(tile);
-        tile_version.memory_state_ = NOT_ALLOWED_TO_USE_MEMORY;
-      }
+      FreeResourcesForTile(tile);
       continue;
     }
 
@@ -494,8 +490,7 @@ void TileManager::AssignGpuMemoryToTiles() {
       Tile* tile = *it;
       ManagedTileState& mts = tile->managed_state();
       ManagedTileState::TileVersion& tile_version = tile->tile_version();
-      if ((tile_version.memory_state_ == CAN_USE_MEMORY ||
-           tile_version.memory_state_ == USING_RELEASABLE_MEMORY) &&
+      if (tile_version.resource_ &&
           mts.tree_bin[PENDING_TREE] == NEVER_BIN &&
           mts.tree_bin[ACTIVE_TREE] != NOW_BIN) {
         DCHECK(!tile->required_for_activation());
@@ -545,12 +540,10 @@ void TileManager::AssignGpuMemoryToTiles() {
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
-  DCHECK_NE(USING_UNRELEASABLE_MEMORY, tile->tile_version().memory_state_);
   if (tile->tile_version().resource_) {
     resource_pool_->ReleaseResource(
         tile->tile_version().resource_.Pass());
   }
-  tile->tile_version().memory_state_ = NOT_ALLOWED_TO_USE_MEMORY;
 }
 
 void TileManager::ScheduleTasks() {
@@ -627,8 +620,6 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
           tile->tile_version().resource_format_);
   const Resource* const_resource = resource.get();
 
-  DCHECK_EQ(CAN_USE_MEMORY, tile->tile_version().memory_state_);
-  tile->tile_version().memory_state_ = USING_UNRELEASABLE_MEMORY;
   tile->tile_version().resource_id_ = resource->id();
 
   PicturePileImpl::Analysis* analysis = new PicturePileImpl::Analysis;
@@ -699,11 +690,7 @@ void TileManager::OnRasterTaskCompleted(
   DCHECK(!mts.raster_task.is_null());
   mts.raster_task.Reset();
 
-  // Tile resources can't be freed until task has completed.
-  DCHECK_EQ(USING_UNRELEASABLE_MEMORY, tile->tile_version().memory_state_);
-
   if (was_canceled) {
-    tile->tile_version().memory_state_ = CAN_USE_MEMORY;
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
@@ -715,7 +702,6 @@ void TileManager::OnRasterTaskCompleted(
     tile->tile_version().set_solid_color(analysis->solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
-    tile->tile_version().memory_state_ = USING_RELEASABLE_MEMORY;
     tile->tile_version().resource_ = resource.Pass();
   }