Do not give GPU memory to backgrounded compositors.

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 1885 matching lines @@
       case 0:
         EXPECT_TRUE(renderer->HasAllocatedResourcesForTesting(
             surface1_render_pass_id));
         EXPECT_TRUE(renderer->HasAllocatedResourcesForTesting(
             surface2_render_pass_id));
 
         // Reduce the memory limit to only fit the root layer and one render
         // surface. This prevents any contents drawing into surfaces
         // from being allocated.
         host_impl->SetMemoryPolicy(ManagedMemoryPolicy(100 * 100 * 4 * 2));
-        host_impl->SetDiscardBackBufferWhenNotVisible(true);
         break;
       case 1:
         EXPECT_FALSE(renderer->HasAllocatedResourcesForTesting(
             surface1_render_pass_id));
         EXPECT_FALSE(renderer->HasAllocatedResourcesForTesting(
             surface2_render_pass_id));
 
         EndTest();
         break;
     }
@@ skipping 507 matching lines @@
     child_layer1_->SetBounds(gfx::Size(100, 100));
     child_layer2_->SetBounds(gfx::Size(100, 100));
     root_layer_->AddChild(child_layer1_);
     root_layer_->AddChild(child_layer2_);
     layer_tree_host()->SetRootLayer(root_layer_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
                                        bool visible) OVERRIDE {
-    // One backing should remain unevicted.
-    EXPECT_EQ(100u * 100u * 4u * 1u,
-              layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
+    if (visible) {
+      // One backing should remain unevicted.
+      EXPECT_EQ(
+          100u * 100u * 4u * 1u,
+          layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
+    } else {
+      EXPECT_EQ(
+          0u,
+          layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
+    }
+
     // Make sure that contents textures are marked as having been
     // purged.
     EXPECT_TRUE(host_impl->active_tree()->ContentsTexturesPurged());
     // End the test in this state.
     EndTest();
   }
 
   virtual 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,
-                                100 * 100 * 4 * 1,
-                                gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
                                 1000));
-        host_impl->SetDiscardBackBufferWhenNotVisible(true);
         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 2500 matching lines @@
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     int frame = num_commits_;
     switch (frame) {
       case 0:
         break;
       case 1:
         // This will trigger a commit because the priority cutoff has changed.
         impl->SetMemoryPolicy(ManagedMemoryPolicy(
             16u*1024u*1024u,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
-            0,
-            gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING,
             1000));
         break;
       case 2:
         // 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,
-            0,
-            gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING,
             1000));
         break;
       case 3:
         NOTREACHED();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
@@ skipping 132 matching lines @@
         FakeOutputSurface::Create3d(
             second_context_provider_ ?
                 second_context_provider_ :
                 first_context_provider_));
     output_surface->SetMemoryPolicyToSetAtBind(make_scoped_ptr(
         new ManagedMemoryPolicy(
             second_context_provider_ ?
                 second_output_surface_memory_limit_ :
                 first_output_surface_memory_limit_,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
-            0,
-            gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING,
             ManagedMemoryPolicy::kDefaultNumResourcesLimit)));
     return output_surface.PassAs<OutputSurface>();
   }
 
   virtual void SetupTree() OVERRIDE {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
@@ skipping 39 matching lines @@
   size_t second_output_surface_memory_limit_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
 };
 
 // No output to copy for delegated renderers.
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface);
 
 }  // namespace cc