[cc] Evict UIResources when the renderer is not visible

cc/trees/layer_tree_host_unittest_context.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/basictypes.h"
 #include "cc/debug/test_context_provider.h"
 #include "cc/debug/test_web_graphics_context_3d.h"
 #include "cc/layers/content_layer.h"
@@ skipping 1528 matching lines @@
         // backtrack).
         EXPECT_EQ(1, scrollbar_layer_->update_count());
         LoseContext();
         break;
       case 2:
         // Second update, after the lost context, we should still upload 2
         // resources even if the contents haven't changed.
         EXPECT_EQ(2, scrollbar_layer_->update_count());
         EndTest();
         break;
+      case 3:
+        // Single thread proxy issues extra commits after context lost.
+        // http://crbug.com/287250
+        if (HasImplThread())
+          NOTREACHED();
+        break;
       default:
         NOTREACHED();
     }
   }
 
  private:
   int commits_;
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer_;
 };
 
@@ skipping 156 matching lines @@
         // Expects a valid UIResourceId.
         EXPECT_NE(0, ui_resource_->id());
         PostSetNeedsCommitToMainThread();
         break;
       case 4:
         // Release resource before ending the test.
         ui_resource_.reset();
         EndTest();
         break;
       case 5:
-        // Make sure no extra commits happened.
+        // Single thread proxy issues extra commits after context lost.
+        // http://crbug.com/287250
+        if (HasImplThread())
+          NOTREACHED();
+        break;
+      case 6:
         NOTREACHED();
     }
   }
 
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 1:
         // The resource should have been created on LTHI after the commit.
         EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
@@ skipping 84 matching lines @@
         break;
       case 8:
         NOTREACHED();
     }
   }
 
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 1:
         // Sequence 1 (continued):

[ccameron, 2013/09/09 09:16:43]

This is somewhat simplified by the fact that resources are recreated through the
commit flow, instead of through the LayerTreeHost::DidLoseOutputSurface call.

-        if (HasImplThread()) {
-          // The resources should have been recreated.
-          EXPECT_EQ(2, ui_resource_->resource_create_count);
-          // The "resource lost" callback was called once for the resource in
-          // the resource map.
-          EXPECT_EQ(1, ui_resource_->lost_resource_count);
-        } else {
-          // The extra commit that happens at context lost in the single thread
-          // proxy changes the timing so that the resource recreation callback
-          // is skipped.
-          // http://crbug.com/287250
-          EXPECT_EQ(1, ui_resource_->resource_create_count);
-          EXPECT_EQ(0, ui_resource_->lost_resource_count);
-        }
-        // Resource Id on the impl-side have been recreated as well. Note
-        // that the same UIResourceId persists after the context lost.
-        EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
+        // The first context lost happens before the resources were created,
+        // and because it resulted in no resources being destroyed, it does not
+        // trigger resource re-creation.
+        EXPECT_EQ(1, ui_resource_->resource_create_count);
+        EXPECT_EQ(0, ui_resource_->lost_resource_count);
+        // Resource Id on the impl-side has been created.
         PostSetNeedsCommitToMainThread();
         break;
       case 3:
         // Sequence 2 (continued):
         // The previous resource should have been deleted.
         EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id0_));
-        // The second resource should have been created.
-        EXPECT_NE(0u, impl->ResourceIdForUIResource(test_id1_));
         if (HasImplThread()) {
-          // The second resource called the resource callback once and since the
-          // context is lost, a "resource lost" callback was also issued.
-          EXPECT_EQ(2, ui_resource_->resource_create_count);
-          EXPECT_EQ(1, ui_resource_->lost_resource_count);
+          // The second resource should have been created.
+          EXPECT_NE(0u, impl->ResourceIdForUIResource(test_id1_));
         } else {
           // The extra commit that happens at context lost in the single thread
-          // proxy changes the timing so that the resource recreation callback
-          // is skipped.
+          // proxy changes the timing so that the resource has been destroyed.
           // http://crbug.com/287250
-          EXPECT_EQ(1, ui_resource_->resource_create_count);
-          EXPECT_EQ(0, ui_resource_->lost_resource_count);
+          EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id1_));
         }
+        // The second resource called the resource callback once and since the
+        // context is lost, a "resource lost" callback was also issued.
+        EXPECT_EQ(2, ui_resource_->resource_create_count);
+        EXPECT_EQ(1, ui_resource_->lost_resource_count);
         break;
       case 5:
         // Sequence 3 (continued):
         // Expect the resource callback to have been called once.
         EXPECT_EQ(1, ui_resource_->resource_create_count);
         // No "resource lost" callbacks.
         EXPECT_EQ(0, ui_resource_->lost_resource_count);
         // The UI resource id should not be valid
         EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id0_));
         break;
@@ skipping 91 matching lines @@
 TEST_F(UIResourceLostBeforeActivateTree,
        RunMultiThread_DirectRenderer_ImplSidePaint) {
   RunTest(true, false, true);
 }
 
 TEST_F(UIResourceLostBeforeActivateTree,
        RunMultiThread_DelegatingRenderer_ImplSidePaint) {
   RunTest(true, true, true);
 }
 
+// Resources evicted explicitly and by visibility changes.
+class UIResourceLostEviction : public UIResourceLostTestSimple {
+ public:
+  virtual void StepCompleteOnMainThread(int step) OVERRIDE {
+    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    switch (step) {
+      case 0:
+        ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
+        EXPECT_NE(0, ui_resource_->id());
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 2:
+        // Make the tree not visible.
+        PostSetVisibleToMainThread(false);
+        break;
+      case 3:
+        // Release resource before ending the test.
+        ui_resource_.reset();
+        EndTest();
+        break;
+      case 4:
+        NOTREACHED();
+    }
+  }
+
+  virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* impl,
+                                       bool visible) OVERRIDE {
+    TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
+        impl->output_surface()->context_provider()->Context3d());
+    if (!visible) {
+      // All resources should have been evicted.
+      ASSERT_EQ(0u, context->NumTextures());
+      EXPECT_EQ(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
+      EXPECT_EQ(2, ui_resource_->resource_create_count);
+      EXPECT_EQ(1, ui_resource_->lost_resource_count);
+      // Drawing is disabled both because of the evicted resources and
+      // because the renderer is not visible.
+      EXPECT_FALSE(impl->CanDraw());
+      // Make the renderer visible again.
+      PostSetVisibleToMainThread(true);
+    }
+  }
+
+  virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
+    TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
+        impl->output_surface()->context_provider()->Context3d());
+    LayerTreeHostContextTest::CommitCompleteOnThread(impl);
+    switch (time_step_) {
+      case 1:
+        // The resource should have been created on LTHI after the commit.
+        ASSERT_EQ(1u, context->NumTextures());
+        EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
+        EXPECT_EQ(1, ui_resource_->resource_create_count);
+        EXPECT_EQ(0, ui_resource_->lost_resource_count);
+        EXPECT_TRUE(impl->CanDraw());
+        // Evict all UI resources. This will trigger a commit.
+        impl->DeleteAllUIResources();
+        ASSERT_EQ(0u, context->NumTextures());
+        EXPECT_EQ(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
+        EXPECT_EQ(1, ui_resource_->resource_create_count);
+        EXPECT_EQ(0, ui_resource_->lost_resource_count);
+        EXPECT_FALSE(impl->CanDraw());
+        break;
+      case 2:
+        // The resource should have been recreated.
+        ASSERT_EQ(1u, context->NumTextures());
+        EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
+        EXPECT_EQ(2, ui_resource_->resource_create_count);
+        EXPECT_EQ(1, ui_resource_->lost_resource_count);
+        EXPECT_TRUE(impl->CanDraw());
+        break;
+      case 3:
+        // The resource should have been recreated after visibility was
+        // restored.
+        ASSERT_EQ(1u, context->NumTextures());
+        EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
+        EXPECT_EQ(3, ui_resource_->resource_create_count);
+        EXPECT_EQ(2, ui_resource_->lost_resource_count);
+        EXPECT_TRUE(impl->CanDraw());
+        break;
+    }
+  }
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(UIResourceLostEviction);
+
 }  // namespace
 }  // namespace cc