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 459 matching lines @@
                eviction_priority_queue_is_up_to_date_);
   if (eviction_priority_queue_is_up_to_date_)
     return;
 
   eviction_priority_queue_.Reset();
   client_->BuildEvictionQueue(&eviction_priority_queue_,
                               global_state_.tree_priority);
   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();
   }
   return true;
 }
 
 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;
 
     Tile* tile = eviction_priority_queue_.Top();
     if (!other_priority.IsHigherPriorityThan(tile->combined_priority()))
       return false;
 
-    *usage -= MemoryUsage::FromTile(tile);
+    *usage -= MemoryUsageFromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
     eviction_priority_queue_.Pop();
   }
   return true;
 }
 
 bool TileManager::TilePriorityViolatesMemoryPolicy(
     const TilePriority& priority) {
   switch (global_state_.memory_limit_policy) {
     case ALLOW_NOTHING:
@@ skipping 20 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());
+  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_,
                             global_state_.tree_priority);
 
   while (!raster_priority_queue_.IsEmpty()) {
     Tile* tile = raster_priority_queue_.Top();
     TilePriority priority = tile->combined_priority();
 
     if (TilePriorityViolatesMemoryPolicy(priority)) {
@@ skipping 14 matching lines @@
     ManagedTileState& mts = tile->managed_state();
     mts.scheduled_priority = schedule_priority++;
 
     DCHECK(mts.draw_info.mode() ==
                ManagedTileState::DrawInfo::PICTURE_PILE_MODE ||
            !mts.draw_info.IsReadyToDraw());
 
     // 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());
     }
 
     bool tile_is_needed_now = priority.priority_bin == TilePriority::NOW;
 
     // 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 =
         FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
             tile_memory_limit - memory_required_by_tile_to_be_scheduled,
             priority,
             &memory_usage);
 
     // If we couldn't fit the tile into our current memory limit, then we're
     // done.
@@ skipping 13 matching lines @@
   // didn't reduce memory. This ensures that we always release as many resources
   // as possible to stay within the memory limit.
   FreeTileResourcesUntilUsageIsWithinLimit(hard_memory_limit, &memory_usage);
 
   UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget",
                         !had_enough_memory_to_schedule_tiles_needed_now);
   did_oom_on_last_assign_ = !had_enough_memory_to_schedule_tiles_needed_now;
 
   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;
 
   raster_priority_queue_.Reset();
 
   TRACE_EVENT_END2("cc",
                    "TileManager::AssignGpuMemoryToTiles",
                    "all_tiles_that_need_to_be_rasterized_are_scheduled",
                    all_tiles_that_need_to_be_rasterized_are_scheduled_,
                    "had_enough_memory_to_schedule_tiles_needed_now",
@@ skipping 224 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) {
+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