Remove limit on number of resources in cc

cc/trees/layer_tree_host_unittest.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.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 2076 matching lines @@
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     ++num_commits_;
     switch (num_commits_) {
       case 1:
         // All three backings should have memory.
         EXPECT_EQ(
             100u * 100u * 4u * 3u,
             layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
         // Set a new policy that will kick out 1 of the 3 resources.
         // Because a resource was evicted, a commit will be kicked off.
-        host_impl->SetMemoryPolicy(
-            ManagedMemoryPolicy(100 * 100 * 4 * 2,
-                                gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
-                                1000));
+        host_impl->SetMemoryPolicy(ManagedMemoryPolicy(
+            100 * 100 * 4 * 2, gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING));
         break;
       case 2:
         // Only two backings should have memory.
         EXPECT_EQ(
             100u * 100u * 4u * 2u,
             layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
         // Become backgrounded, which will cause 1 more resource to be
         // evicted.
         PostSetVisibleToMainThread(false);
         break;
@@ skipping 2176 matching lines @@
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     switch (num_commits_) {
       case 1:
         break;
       case 2:
         // This will trigger a commit because the priority cutoff has changed.
         impl->SetMemoryPolicy(ManagedMemoryPolicy(
             16u * 1024u * 1024u,
-            gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
-            1000));
+            gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE));
         break;
       case 3:
         // This will not trigger a commit because the priority cutoff has not
         // changed, and there is already enough memory for all allocations.
         impl->SetMemoryPolicy(ManagedMemoryPolicy(
             32u * 1024u * 1024u,
-            gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
-            1000));
+            gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE));
         break;
       case 4:
         NOTREACHED();
         break;
     }
   }
 
   void AfterTest() override {}
 
  private:
@@ skipping 25 matching lines @@
                                                     : first_context_provider_);
     scoped_ptr<FakeOutputSurface> output_surface;
     if (delegating_renderer())
       output_surface = FakeOutputSurface::CreateDelegating3d(provider);
     else
       output_surface = FakeOutputSurface::Create3d(provider);
     output_surface->SetMemoryPolicyToSetAtBind(
         make_scoped_ptr(new ManagedMemoryPolicy(
             second_context_provider_.get() ? second_output_surface_memory_limit_
                                            : first_output_surface_memory_limit_,
-            gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
-            ManagedMemoryPolicy::kDefaultNumResourcesLimit)));
+            gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE)));
     return output_surface.Pass();
   }
 
   void SetupTree() override {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
@@ skipping 782 matching lines @@
   }
 
   int commit_count_;
   TestSwapPromiseResult swap_promise_result_[3];
 };
 
 // Impl-side painting is not supported for synchronous compositing.
 SINGLE_THREAD_NOIMPL_TEST_F(LayerTreeHostTestSynchronousCompositeSwapPromise);
 
 }  // namespace cc