Refactor client visibility handling

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 413 matching lines @@
   FakeContentLayerClient client_;
   bool toggled_visibility_;
   bool did_notify_ready_to_draw_;
   bool did_draw_;
 };
 
 // Note: With this test setup, we only get tiles flagged as REQUIRED_FOR_DRAW in
 // single threaded mode.
 SINGLE_THREAD_TEST_F(LayerTreeHostTestReadyToDrawVisibility);
 
-class LayerTreeHostFreeWorkerContextResourcesTest : public LayerTreeHostTest {
+class LayerTreeHostNotifyContextCacheControllerTest : public LayerTreeHostTest {
  public:
   std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
-    auto mock_worker_context_support_owned =
-        base::MakeUnique<MockContextSupport>();
-    mock_context_support_ptr_ = mock_worker_context_support_owned.get();
+    // Create the main ContextProvider with a MockContextCacheController.
+    auto main_support = base::MakeUnique<TestContextSupport>();
+    auto main_context = TestWebGraphicsContext3D::Create();
+    auto main_cache_controller =
+        base::MakeUnique<::testing::StrictMock<MockContextCacheController>>(
+            main_support.get());
+    mock_main_cache_controller_ = main_cache_controller.get();
+    auto test_main_context_provider = TestContextProvider::Create(
+        std::move(main_context), std::move(main_support),
+        std::move(main_cache_controller));
 
-    auto mock_worker_context_provider = make_scoped_refptr(
-        new MockContextProvider(std::move(mock_worker_context_support_owned)));
-    mock_context_provider_ptr_ = mock_worker_context_provider.get();
+    // Create the worker ContextProvider with a MockContextCacheController.
+    auto worker_support = base::MakeUnique<TestContextSupport>();
+    auto worker_context = TestWebGraphicsContext3D::Create();
+    auto worker_cache_controller =
+        base::MakeUnique<::testing::StrictMock<MockContextCacheController>>(
+            main_support.get());
+    mock_worker_cache_controller_ = worker_cache_controller.get();
+    auto test_worker_context_provider = TestContextProvider::Create(
+        std::move(worker_context), std::move(worker_support),
+        std::move(worker_cache_controller));
+    test_worker_context_provider->BindToCurrentThread();
 
-    // Workers are bound on the main thread.
-    mock_worker_context_provider->BindToCurrentThread();
-
-    // Ensure that our mock calls execute in sequence.
-    ::testing::InSequence s;
-
-    // At init, visibility is set to true and we will call
-    // SetAggressivelyFreeResources(false).
-    EXPECT_CALL(*mock_context_support_ptr_, SetClientVisible(0, true));
-    EXPECT_CALL(*mock_context_support_ptr_, AnyClientsVisible())
-        .WillOnce(::testing::Return(true));
-    EXPECT_CALL(*mock_context_support_ptr_,
-                SetAggressivelyFreeResources(false));
+    // At init, visibility is set to true.
+    EXPECT_CALL(*mock_main_cache_controller_, OnClientBecameVisible());
+    EXPECT_CALL(*mock_worker_cache_controller_, OnClientBecameVisible());
 
     return LayerTreeHostTest::CreateDelegatingOutputSurface(
-        std::move(compositor_context_provider),
-        std::move(mock_worker_context_provider));
+        std::move(test_main_context_provider),
+        std::move(test_worker_context_provider));
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->gpu_rasterization_enabled = true;
     settings->gpu_rasterization_forced = true;
   }
 
   void BeginTest() override {}
 
-  void BeforeVisibilityChange() {
-    // Ensure that our initialization expectations have completed.
-    Mock::VerifyAndClearExpectations(mock_context_support_ptr_);
-
-    // Ensure that our mock calls execute in sequence.
-    ::testing::InSequence s;
-
-    // While running, visibility is set to false, and we will call
-    // DeleteCachedResources and SetAggressivelyFreeResources(true).
-    EXPECT_CALL(*mock_context_support_ptr_, SetClientVisible(0, false));
-    EXPECT_CALL(*mock_context_support_ptr_, AnyClientsVisible())
-        .WillOnce(::testing::Return(false));
-    EXPECT_CALL(*mock_context_provider_ptr_, DeleteCachedResources());
-    EXPECT_CALL(*mock_context_support_ptr_, SetAggressivelyFreeResources(true))
-        .WillOnce(testing::Invoke([this](bool is_visible) { EndTest(); }));
+  void AfterTest() override {
+    // Ensure all expectations are satisfied.

[danakj, 2016/08/29 23:56:20]

I don't think these are needed.. gmock will do this when they are destroyed?

[ericrk, 2016/08/30 18:18:58]

Done.

+    Mock::VerifyAndClearExpectations(mock_main_cache_controller_);
+    Mock::VerifyAndClearExpectations(mock_worker_cache_controller_);
   }
 
-  void AfterTest() override {
-    // Ensure all expectations are satisfied.
-    Mock::VerifyAndClearExpectations(mock_context_support_ptr_);
-    Mock::VerifyAndClearExpectations(mock_context_provider_ptr_);
-  }
+ protected:
+  class MockContextCacheController : public ContextCacheController {
+   public:
+    explicit MockContextCacheController(gpu::ContextSupport* support)
+        : ContextCacheController(support) {}
+    MOCK_METHOD0(OnClientBecameVisible, void());
+    MOCK_METHOD0(OnClientBecameNotVisible, void());
 
- private:
-  class MockContextProvider : public TestContextProvider {
-   public:
-    explicit MockContextProvider(std::unique_ptr<TestContextSupport> support)
-        : TestContextProvider(std::move(support),
-                              base::MakeUnique<TestGLES2Interface>(),
-                              TestWebGraphicsContext3D::Create()) {}
+    std::unique_ptr<ScopedVisibility> ClientBecameVisible() {
+      if (num_visible_clients_ == 0)
+        OnClientBecameVisible();
+      ++num_visible_clients_;
+      return CreateScopedVisibilityForTesting();
+    }
 
-    MOCK_METHOD0(DeleteCachedResources, void());
+    void ClientBecameNotVisible(
+        std::unique_ptr<ScopedVisibility> scoped_visibility) {
+      --num_visible_clients_;
+      if (num_visible_clients_ == 0)
+        OnClientBecameNotVisible();
+      ReleaseScopedVisibilityForTesting(std::move(scoped_visibility));
+    }
 
    private:
-    ~MockContextProvider() = default;
+    int num_visible_clients_ = 0;
   };
 
-  class MockContextSupport : public TestContextSupport {
-   public:
-    MockContextSupport() {}
-    MOCK_METHOD1(SetAggressivelyFreeResources,
-                 void(bool aggressively_free_resources));
-    MOCK_METHOD2(SetClientVisible, void(int client_id, bool is_visible));
-    MOCK_CONST_METHOD0(AnyClientsVisible, bool());
-  };
-
-  MockContextSupport* mock_context_support_ptr_;
-  MockContextProvider* mock_context_provider_ptr_;
+  MockContextCacheController* mock_main_cache_controller_;
+  MockContextCacheController* mock_worker_cache_controller_;
 };
 
-// Test if the LTH successfully frees resources on the worker context when
-// visibility is set to false.
-class LayerTreeHostFreeWorkerContextResourcesOnInvisible
-    : public LayerTreeHostFreeWorkerContextResourcesTest {
+// Test if the LTH successfully notifies the main/worker
+// ContextCacheControllers when visibility is set to false.
+class LayerTreeHostNotifiesCCCOnInvisible
+    : public LayerTreeHostNotifyContextCacheControllerTest {
  public:
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
-    BeforeVisibilityChange();
+    // Ensure that our initialization expectations have completed.
+    Mock::VerifyAndClearExpectations(mock_main_cache_controller_);
+    Mock::VerifyAndClearExpectations(mock_worker_cache_controller_);
+
+    // Update visibility and make sure our two CCCs are updated.
+    EXPECT_CALL(*mock_main_cache_controller_, OnClientBecameNotVisible());
+    EXPECT_CALL(*mock_worker_cache_controller_, OnClientBecameNotVisible())
+        .WillOnce(testing::Invoke([this]() { EndTest(); }));
     PostSetVisibleToMainThread(false);
   }
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostFreeWorkerContextResourcesOnInvisible);
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostNotifiesCCCOnInvisible);
 
-// Test if the LTH successfully frees resources on the worker context when
-// hard memory limit is set to zero.
-class LayerTreeHostFreeWorkerContextResourcesOnZeroMemoryLimit
-    : public LayerTreeHostFreeWorkerContextResourcesTest {
+// Test if the LTH successfully notifies the worker ContextCacheController when
+// the hard memory limit is set to zero.
+class LayerTreeHostNotifiesCCCOnZeroMemoryLimit
+    : public LayerTreeHostNotifyContextCacheControllerTest {
  public:
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
-    BeforeVisibilityChange();
+    // Ensure that our initialization expectations have completed.
+    Mock::VerifyAndClearExpectations(mock_worker_cache_controller_);
+
+    // Worker CC should be notified when hard memory limit is zeroed.
+    EXPECT_CALL(*mock_worker_cache_controller_, OnClientBecameNotVisible())
+        .WillOnce(testing::Invoke([this]() {
+          // Main context is unchanged. It will go invisible on destruction.
+          EXPECT_CALL(*mock_main_cache_controller_, OnClientBecameNotVisible());
+          EndTest();
+        }));
     ManagedMemoryPolicy zero_policy(
         0, gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING, 0);
     host_impl->SetMemoryPolicy(zero_policy);

[danakj, 2016/08/29 23:56:20]

You could just VerifyAndClear/EXPECT_CALL/EndTest() after this call, there's
nothing async going on here right? That's easier to follow than WillOnce()

[ericrk, 2016/08/30 18:18:58]

Sadly, because we don't want to interrupt in-process work, we actually do a
round-trip of scheduling tiles / AllTileTasksCompleted to hit this, so it is
actually async.

   }
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostFreeWorkerContextResourcesOnZeroMemoryLimit);
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostNotifiesCCCOnZeroMemoryLimit);
 
-// Test if the LTH successfully frees resources on the worker context when
-// hard memory limit is set to zero while using a synchronous compositor (like
-// Android WebView).
-class LayerTreeHostFreeWorkerContextResourcesOnZeroMemoryLimitSynchronous
-    : public LayerTreeHostFreeWorkerContextResourcesOnZeroMemoryLimit {
+// Test if the LTH successfully notifies the ContextCacheController of
+// visibility changes when hard memory limit is set to zero while using a
+// synchronous compositor (like Android WebView).
+class LayerTreeHostNotifiesCCCOnZeroMemoryLimitSynchronous
+    : public LayerTreeHostNotifiesCCCOnZeroMemoryLimit {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
-    LayerTreeHostFreeWorkerContextResourcesTest::InitializeSettings(settings);
+    LayerTreeHostNotifyContextCacheControllerTest::InitializeSettings(settings);
     settings->using_synchronous_renderer_compositor = true;
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostFreeWorkerContextResourcesOnZeroMemoryLimitSynchronous);
+    LayerTreeHostNotifiesCCCOnZeroMemoryLimitSynchronous);
+
+// Test if the LTH successfully notifies the main and worker
+// ContextCacheControllers of visibility changes when the OutputSurface is
+// destroyed.
+class LayerTreeHostNotifyCCCOnDestroy
+    : public LayerTreeHostNotifyContextCacheControllerTest {
+ public:
+  void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
+                                  const BeginFrameArgs& args) override {
+    // Ensure that our initialization expectations have completed.
+    Mock::VerifyAndClearExpectations(mock_main_cache_controller_);
+    Mock::VerifyAndClearExpectations(mock_worker_cache_controller_);
+
+    // We leave the LTHI visible, so it will notify CC on destruction.
+    EXPECT_CALL(*mock_worker_cache_controller_, OnClientBecameNotVisible());
+    EXPECT_CALL(*mock_main_cache_controller_, OnClientBecameNotVisible());
+    EndTest();
+  }
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostNotifyCCCOnDestroy);
+
+// Test if the LTH successfully notifies the main and worker
+// ContextCacheControllers of visibility changes when the OutputSurface is
+// lost and recreated.
+class LayerTreeHostNotifyCCCOnOutputSurfaceRecreated
+    : public LayerTreeHostNotifyContextCacheControllerTest {
+ public:
+  void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
+                                  const BeginFrameArgs& args) override {
+    // Ensure that our initialization expectations have completed.
+    Mock::VerifyAndClearExpectations(mock_main_cache_controller_);
+    Mock::VerifyAndClearExpectations(mock_worker_cache_controller_);
+
+    if (has_recreated_) {
+      // Destruction exptectations.
+      EXPECT_CALL(*mock_worker_cache_controller_, OnClientBecameNotVisible());
+      EXPECT_CALL(*mock_main_cache_controller_, OnClientBecameNotVisible());
+      EndTest();
+      return;
+    }
+    has_recreated_ = true;
+
+    // Output surface lost expectations.
+    EXPECT_CALL(*mock_worker_cache_controller_, OnClientBecameNotVisible());
+    EXPECT_CALL(*mock_main_cache_controller_, OnClientBecameNotVisible());
+    host_impl->DidLoseOutputSurface();
+  }
+
+ private:
+  bool has_recreated_ = false;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostNotifyCCCOnOutputSurfaceRecreated);
 
 // Two setNeedsCommits in a row should lead to at least 1 commit and at least 1
 // draw with frame 0.
 class LayerTreeHostTestSetNeedsCommit1 : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsCommit1() : num_commits_(0), num_draws_(0) {}
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     PostSetNeedsCommitToMainThread();
@@ skipping 1621 matching lines @@
 
 // Single thread proxy does not support impl-side page scale changes.
 MULTI_THREAD_TEST_F(LayerTreeHostTestStartPageScaleAnimation);
 
 class LayerTreeHostTestSetVisible : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetVisible() : num_draws_(0) {}
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
+  }
+
+  void WillCommit() override {
     PostSetVisibleToMainThread(false);
     // This is suppressed while we're invisible.
     PostSetNeedsRedrawToMainThread();
     // Triggers the redraw.
     PostSetVisibleToMainThread(true);
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_TRUE(impl->visible());
     ++num_draws_;
@@ skipping 4813 matching lines @@
  private:
   FakeContentLayerClient client_;
   const gfx::Size viewport_size_;
   const gfx::Size large_image_size_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(GpuRasterizationSucceedsWithLargeImage);
 
 }  // namespace
 }  // namespace cc