Do not give GPU memory to backgrounded compositors.

cc/trees/layer_tree_host_unittest_damage.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/trees/layer_tree_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/time/time.h"
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_painted_scrollbar_layer.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace cc {
 namespace {
 
 // These tests deal with damage tracking.
 class LayerTreeHostDamageTest : public LayerTreeTest {};
 
 // Changing visibility alone does not cause drawing.
 class LayerTreeHostDamageTestSetVisibleDoesNotDraw

[ccameron, 2013/10/31 03:30:13]

I wasn't sure what to do with this test.

It's not clear that the behavior that the test is testing is still present. The
test relies on the ability to have visibility change without any resources being
evicted (gone) and without the backbuffer being discarded (also gone).

The results (see the comments in the diff itself) are also not what I was
expecting in terms of behavior. I did verify that this test requires the below
changes, without any of the other changes in this CL if (1) the
SetManagedMemoryPolicy call below is removed and (2) the test changes its
behavior to discard backbuffers when made non-visible (so if the results aren't
expected, it's not because of this CL).

[piman, 2013/10/31 04:00:25]

Do we know if this test was introduced with a particular CL to fix a particular
bug? Can we check the behavior wrt that bug?

At the very least we should rename the test, because it tests the opposite of
what it says :)

[danakj, 2013/10/31 17:11:24]

I think delete this test. It did not come out of a bug, but out of me
experimenting trying to repro/explore behaviour. It's becoming way too awkward
to be useful now IMO.

     : public LayerTreeHostDamageTest {
   virtual void BeginTest() OVERRIDE {
     step_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void SetupTree() OVERRIDE {
     // Viewport is 10x10.
     scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_);
     root->SetBounds(gfx::Size(10, 10));
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostDamageTest::SetupTree();
   }
 
   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* impl,
                                      LayerTreeHostImpl::FrameData* frame_data,
                                      bool result) OVERRIDE {
     EXPECT_TRUE(result);
 
     RenderSurfaceImpl* root_surface =
         impl->active_tree()->root_layer()->render_surface();
     gfx::RectF root_damage =
         root_surface->damage_tracker()->current_damage_rect();
 
     switch (step_) {
       case 0:
         // The first frame has full damage.
         EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
-
-        // No evictions when we become not-visible.
-        impl->SetMemoryPolicy(ManagedMemoryPolicy(
-            1000 * 1000 * 1000,
-            gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
-            1000 * 1000 * 1000,
-            gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
-            ManagedMemoryPolicy::kDefaultNumResourcesLimit));
-
         PostSetVisibleToMainThread(false);
         break;
       case 1:
         // The compositor has been set not-visible.
         EXPECT_FALSE(impl->visible());
         // This frame not visible, so not drawn.
         NOTREACHED();
         break;
       case 2:
         // The compositor has been set visible again.
         EXPECT_TRUE(impl->visible());
-        // But it still does not draw.
-        NOTREACHED();
+        if (!impl->settings().impl_side_painting) {
+          // Evicting resources for non-impl-side painting will trigger a full
+          // redraw.
+          EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
+        } else {
+          // Otherwise there will be no redraw.
+          NOTREACHED();
+        }
         break;
       case 3:
-        // Finally we force a draw, but it will have no damage.
-        EXPECT_EQ(gfx::RectF().ToString(), root_damage.ToString());
+        if (impl->settings().impl_side_painting && !delegating_renderer()) {
+          // The forced draw will have full damage with a direct impl-side
+          // painting renderer.
+          EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
+        } else {
+          // Finally we force a draw, but it will have no damage.
+          EXPECT_EQ(gfx::RectF().ToString(), root_damage.ToString());
+        }
         EndTest();
         break;
       case 4:
         NOTREACHED();
     }
     return result;
   }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* impl,
                                        bool visible) OVERRIDE {
@@ skipping 690 matching lines @@
   FakeContentLayerClient client_;
   int swap_count_;
   int prepare_to_draw_count_;
   int update_visible_tile_count_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestVisibleTilesStillTriggerDraws);
 
 }  // namespace
 }  // namespace cc