Remove limit on number of resources in cc

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 77c4df607639fd51e57cb22c35d6c344d618e200..c0672c65a913a93cd48af1c3728731c2c9b9f731 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -477,16 +477,15 @@ void TileManager::RebuildEvictionQueueIfNeeded() {
   eviction_priority_queue_is_up_to_date_ = true;
 }
 
-bool TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
-    const MemoryUsage& limit,
-    MemoryUsage* usage) {
-  while (usage->Exceeds(limit)) {
+bool TileManager::FreeTileResourcesUntilUsageIsWithinLimit(int64 limit,
+                                                           int64* usage) {
+  while (*usage > limit) {
     RebuildEvictionQueueIfNeeded();
     if (eviction_priority_queue_.IsEmpty())
       return false;
 
     Tile* tile = eviction_priority_queue_.Top();
-    *usage -= MemoryUsage::FromTile(tile);
+    *usage -= MemoryUsageFromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
     eviction_priority_queue_.Pop();
   }
@@ -494,10 +493,10 @@ bool TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
 }
 
 bool TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
-    const MemoryUsage& limit,
+    int64 limit,
     const TilePriority& other_priority,
-    MemoryUsage* usage) {
-  while (usage->Exceeds(limit)) {
+    int64* usage) {
+  while (*usage > limit) {
     RebuildEvictionQueueIfNeeded();
     if (eviction_priority_queue_.IsEmpty())
       return false;
@@ -506,7 +505,7 @@ bool TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
     if (!other_priority.IsHigherPriorityThan(tile->combined_priority()))
       return false;
 
-    *usage -= MemoryUsage::FromTile(tile);
+    *usage -= MemoryUsageFromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
     eviction_priority_queue_.Pop();
   }
@@ -547,12 +546,9 @@ void TileManager::AssignGpuMemoryToTiles(
   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());
+  int64 hard_memory_limit = global_state_.hard_memory_limit_in_bytes;

[vmpstr, 2014/10/27 17:58:55]

i would kinda weakly prefer to have something along the lines of 

typedef int64 MemoryUsage;

and keep everything as that, but lgtm either way.

[jamesr, 2014/10/27 18:03:25]

we use int64_t, etc, nowadays not int64

+  int64 soft_memory_limit = global_state_.soft_memory_limit_in_bytes;
+  int64 memory_usage = resource_pool_->acquired_memory_usage_bytes();
 
   eviction_priority_queue_is_up_to_date_ = false;
   client_->BuildRasterQueue(&raster_priority_queue_,
@@ -587,9 +583,9 @@ void TileManager::AssignGpuMemoryToTiles(
     // If the tile already has a raster_task, then the memory used by it is
     // already accounted for in memory_usage. Otherwise, we'll have to acquire
     // more memory to create a raster task.
-    MemoryUsage memory_required_by_tile_to_be_scheduled;
+    int64 memory_required_by_tile_to_be_scheduled = 0;
     if (!mts.raster_task.get()) {
-      memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
+      memory_required_by_tile_to_be_scheduled = MemoryUsageFromConfig(
           tile->size(), resource_pool_->resource_format());
     }
 
@@ -598,7 +594,7 @@ void TileManager::AssignGpuMemoryToTiles(
     // This is the memory limit that will be used by this tile. Depending on
     // the tile priority, it will be one of hard_memory_limit or
     // soft_memory_limit.
-    MemoryUsage& tile_memory_limit =
+    int64 tile_memory_limit =
         tile_is_needed_now ? hard_memory_limit : soft_memory_limit;
 
     bool memory_usage_is_within_limit =
@@ -632,7 +628,7 @@ void TileManager::AssignGpuMemoryToTiles(
 
   memory_stats_from_last_assign_.total_budget_in_bytes =
       global_state_.hard_memory_limit_in_bytes;
-  memory_stats_from_last_assign_.total_bytes_used = memory_usage.memory_bytes();
+  memory_stats_from_last_assign_.total_bytes_used = memory_usage;
   memory_stats_from_last_assign_.had_enough_memory =
       had_enough_memory_to_schedule_tiles_needed_now;
 
@@ -877,54 +873,18 @@ void TileManager::CheckIfReadyToActivate() {
     client_->NotifyReadyToActivate();
 }
 
-TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
+int64 TileManager::MemoryUsageFromConfig(const gfx::Size& size,
+                                         ResourceFormat format) {
+  return Resource::MemorySizeBytes(size, format);
 }
 
-TileManager::MemoryUsage::MemoryUsage(int64 memory_bytes, int resource_count)
-    : memory_bytes_(memory_bytes), resource_count_(resource_count) {
-}
-
-// static
-TileManager::MemoryUsage TileManager::MemoryUsage::FromConfig(
-    const gfx::Size& size,
-    ResourceFormat format) {
-  return MemoryUsage(Resource::MemorySizeBytes(size, format), 1);
-}
-
-// static
-TileManager::MemoryUsage TileManager::MemoryUsage::FromTile(const Tile* tile) {
+int64 TileManager::MemoryUsageFromTile(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 MemoryUsageFromConfig(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 0;
 }
 
 }  // namespace cc