cc: Prevent the tile manager from allocating more memory than allowed.

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 7cf5096ce3b0db931de4b92c56b4b1bd4a54f9f0..8ece30bb0f0594a27a0b330af6ec29c61ba7a9cf 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -509,9 +509,10 @@ void TileManager::AssignGpuMemoryToTiles(
       static_cast<int64>(bytes_releasable) +
       static_cast<int64>(global_state_.memory_limit_in_bytes) -
       static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
-  int resources_available = resources_releasable +
-                            global_state_.num_resources_limit -
-                            resource_pool_->NumResources();
+  int resources_available =
+      resources_releasable +
+      global_state_.num_resources_limit -
+      resource_pool_->acquired_resource_count();
 
   size_t bytes_allocatable =
       std::max(static_cast<int64>(0), bytes_available);
@@ -709,6 +710,10 @@ void TileManager::ScheduleTasks(
     tasks.Append(tile_version.raster_task_, tile->required_for_activation());
   }
 
+  // We must reduce the amount of unused memory before calling
+  // ScheduleTasks to prevent usage from rising above limit.
+  resource_pool_->ReduceMemoryUsage();

[vmpstr, 2013/08/15 18:26:37]

I'm not sure I follow this. Wouldn't we want to ReduceMemoryUsage after
SchedulingTasks? There is no guarantee that ScheduleTasks won't take us over the
limit and in the case that we are currently over limit, we'll end up releasing a
bunch of resources only to create them again during ScheduleTasks (assuming same
format and size). Am I missing something?

[reveman, 2013/08/15 19:13:55]

ScheduleTasks can't create new resources. It can only allocate the ones already
given to it.

So at this point we've already requested all resources that can be used by
ScheduleTasks and they are accounted for by the resource pool but they have not
yet been allocated as allocation is lazy. We've likely requested more resources
than allowed at this point as we might not have been able to recycle all unused
resources. This is good as it means the memory available to us is not affected
by our ability to recycle tiles and odd-sized tiles wont keep hanging around and
affect available memory. We just need to make sure we free enough unused
resources to stay below the limit before calling ScheduleTasks as that call will
cause real memory to be allocated.

+
   // Schedule running of |tasks|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // in |tasks|.