Remove limit on number of resources in cc

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 144 matching lines @@
   if (context_capabilities.gpu.egl_image_external)
     return GL_TEXTURE_EXTERNAL_OES;
   if (context_capabilities.gpu.texture_rectangle)
     return GL_TEXTURE_RECTANGLE_ARB;
 
   return GL_TEXTURE_2D;
 }
 
 size_t GetMaxStagingResourceCount() {
   // Upper bound for number of staging resource to allow.
-  return 32;
+  return 32 * 512 * 512 * 4;
 }
 
 }  // namespace
 
 class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
  public:
   static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
       LayerTreeHostImpl* layer_tree_host_impl,
       scoped_refptr<DelayBasedTimeSource> time_source) {
     return make_scoped_ptr(
@@ skipping 101 matching lines @@
       should_bubble_scrolls_(false),
       wheel_scrolling_(false),
       scroll_affects_scroll_handler_(false),
       scroll_layer_id_when_mouse_over_scrollbar_(0),
       tile_priorities_dirty_(false),
       root_layer_scroll_offset_delegate_(NULL),
       settings_(settings),
       visible_(true),
       cached_managed_memory_policy_(
           PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
-          gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
-          ManagedMemoryPolicy::kDefaultNumResourcesLimit),
+          gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING),
       pinch_gesture_active_(false),
       pinch_gesture_end_should_clear_scrolling_layer_(false),
       fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
       paint_time_counter_(PaintTimeCounter::Create()),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       texture_mailbox_deleter_(new TextureMailboxDeleter(
           proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
                                   : proxy_->MainThreadTaskRunner())),
       max_memory_needed_bytes_(0),
@@ skipping 923 matching lines @@
     global_tile_state_.soft_memory_limit_in_bytes =
         (static_cast<int64>(global_tile_state_.hard_memory_limit_in_bytes) *
          settings_.max_memory_for_prepaint_percentage) /
         100;
   }
   global_tile_state_.memory_limit_policy =
       ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
           visible_ ?
           policy.priority_cutoff_when_visible :
           gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING);
-  global_tile_state_.num_resources_limit = policy.num_resources_limit;
 
   // TODO(reveman): We should avoid keeping around unused resources if
   // possible. crbug.com/224475
   // Unused limit is calculated from soft-limit, as hard-limit may
   // be very high and shouldn't typically be exceeded.
   size_t unused_memory_limit_in_bytes = static_cast<size_t>(
       (static_cast<int64>(global_tile_state_.soft_memory_limit_in_bytes) *
        settings_.max_unused_resource_memory_percentage) /
       100);
 
   DCHECK(resource_pool_);
   resource_pool_->CheckBusyResources();
   // Soft limit is used for resource pool such that memory returns to soft
   // limit after going over.
   resource_pool_->SetResourceUsageLimits(
       global_tile_state_.soft_memory_limit_in_bytes,
-      unused_memory_limit_in_bytes,
-      global_tile_state_.num_resources_limit);
+      unused_memory_limit_in_bytes);
 
   // Release all staging resources when invisible.
   if (staging_resource_pool_) {
     staging_resource_pool_->CheckBusyResources();
-    staging_resource_pool_->SetResourceUsageLimits(
-        std::numeric_limits<size_t>::max(),
-        std::numeric_limits<size_t>::max(),
-        visible_ ? GetMaxStagingResourceCount() : 0);
+    size_t staging_bytes_limit = visible_ ? GetMaxStagingResourceCount() : 0u;
+    staging_resource_pool_->SetResourceUsageLimits(staging_bytes_limit,
+                                                   staging_bytes_limit);
   }
 
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::DidModifyTilePriorities() {
   DCHECK(settings_.impl_side_painting);
   // Mark priorities as dirty and schedule a ManageTiles().
   tile_priorities_dirty_ = true;
   client_->SetNeedsManageTilesOnImplThread();
@@ skipping 2209 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc