Remove limit on number of resources in cc

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 529 matching lines @@
   // resource(s) was returned. Note that in that case, one also need to
   // invalidate when releasing some resource from the pool.
   resource_pool_->CheckBusyResources();
 
   // Now give memory out to the tiles until we're out, and build
   // the needs-to-be-rasterized queue.
   unsigned schedule_priority = 1u;
   all_tiles_that_need_to_be_rasterized_are_scheduled_ = true;
   bool had_enough_memory_to_schedule_tiles_needed_now = true;
 
-  MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes,
-                                global_state_.num_resources_limit);
-  MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes,
-                                global_state_.num_resources_limit);
-  MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
-                           resource_pool_->acquired_resource_count());
+  MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes);
+  MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes);
+  MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes());
 
   eviction_priority_queue_is_up_to_date_ = false;
   client_->BuildRasterQueue(&raster_priority_queue_,
                             global_state_.tree_priority);
 
   while (!raster_priority_queue_.IsEmpty()) {
     Tile* tile = raster_priority_queue_.Top();
     TilePriority priority = tile->combined_priority();
 
     if (TilePriorityViolatesMemoryPolicy(priority)) {
@@ skipping 304 matching lines @@
 void TileManager::CheckIfReadyToActivate() {
   TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
 
   rasterizer_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   if (IsReadyToActivate())
     client_->NotifyReadyToActivate();
 }
 
-TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
+TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0) {
 }
 
-TileManager::MemoryUsage::MemoryUsage(int64 memory_bytes, int resource_count)
-    : memory_bytes_(memory_bytes), resource_count_(resource_count) {
+TileManager::MemoryUsage::MemoryUsage(int64 memory_bytes)
+    : memory_bytes_(memory_bytes) {
 }
 
 // static
 TileManager::MemoryUsage TileManager::MemoryUsage::FromConfig(
     const gfx::Size& size,
     ResourceFormat format) {
-  return MemoryUsage(Resource::MemorySizeBytes(size, format), 1);
+  return MemoryUsage(Resource::MemorySizeBytes(size, format));
 }
 
 // static
 TileManager::MemoryUsage TileManager::MemoryUsage::FromTile(const Tile* tile) {
   const ManagedTileState& mts = tile->managed_state();
   if (mts.draw_info.resource_) {
     return MemoryUsage::FromConfig(tile->size(),
                                    mts.draw_info.resource_->format());
   }
   return MemoryUsage();
 }
 
 TileManager::MemoryUsage& TileManager::MemoryUsage::operator+=(
     const MemoryUsage& other) {
   memory_bytes_ += other.memory_bytes_;
-  resource_count_ += other.resource_count_;
   return *this;
 }
 
 TileManager::MemoryUsage& TileManager::MemoryUsage::operator-=(
     const MemoryUsage& other) {
   memory_bytes_ -= other.memory_bytes_;
-  resource_count_ -= other.resource_count_;
   return *this;
 }
 
 TileManager::MemoryUsage TileManager::MemoryUsage::operator-(
     const MemoryUsage& other) {
   MemoryUsage result = *this;
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
-  return memory_bytes_ > limit.memory_bytes_ ||
-         resource_count_ > limit.resource_count_;
+  return memory_bytes_ > limit.memory_bytes_;
 }
 
 }  // namespace cc