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

cc/resources/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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 162 matching lines @@
   raster_worker_pool_->Shutdown();
   raster_worker_pool_->CheckForCompletedTasks();
 
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
 }
 
 void TileManager::SetGlobalState(
     const GlobalStateThatImpactsTilePriority& global_state) {
   global_state_ = global_state;
-  resource_pool_->SetMemoryUsageLimits(
+  resource_pool_->SetResourceUsageLimits(
       global_state_.memory_limit_in_bytes,
       global_state_.unused_memory_limit_in_bytes,
       global_state_.num_resources_limit);
 }
 
 void TileManager::RegisterTile(Tile* tile) {
   DCHECK(!tile->required_for_activation());
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;
@@ skipping 298 matching lines @@
   // the needs-to-be-rasterized queue.
   all_tiles_that_need_to_be_rasterized_have_memory_ = true;
   all_tiles_required_for_activation_have_memory_ = true;
   all_tiles_required_for_activation_have_been_initialized_ = true;
 
   // Cast to prevent overflow.
   int64 bytes_available =
       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);
   size_t resources_allocatable = std::max(0, resources_available);
 
   size_t bytes_that_exceeded_memory_budget = 0;
   size_t bytes_left = bytes_allocatable;
   size_t resources_left = resources_allocatable;
   bool oomed = false;
 
@@ skipping 183 matching lines @@
 
     DCHECK(tile_version.requires_resource());
     DCHECK(!tile_version.resource_);
 
     if (tile_version.raster_task_.is_null())
       tile_version.raster_task_ = CreateRasterTask(tile);
 
     tasks.Append(tile_version.raster_task_, tile->required_for_activation());
   }
 
+  // We must reduce the amount of unused resoruces before calling
+  // ScheduleTasks to prevent usage from rising above limits.
+  resource_pool_->ReduceResourceUsage();
+
   // Schedule running of |tasks|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // in |tasks|.
   raster_worker_pool_->ScheduleTasks(&tasks);
 }
 
 RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
     Tile* tile, skia::LazyPixelRef* pixel_ref) {
   return RasterWorkerPool::CreateImageDecodeTask(
       pixel_ref,
@@ skipping 119 matching lines @@
     bytes_releasable_ += tile->bytes_consumed_if_allocated();
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
 }
 
 }  // namespace cc