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 422 matching lines @@
 
 class LayerTreeHostFreeWorkerContextResourcesTest : 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();
 
-    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();
+    auto test_worker_context_provider = TestContextProvider::Create(
+        TestWebGraphicsContext3D::Create(),
+        std::move(mock_worker_context_support_owned));
 
     // Workers are bound on the main thread.
-    mock_worker_context_provider->BindToCurrentThread();
-
-    // Ensure that our mock calls execute in sequence.
-    ::testing::InSequence s;
+    test_worker_context_provider->BindToCurrentThread();
 
     // 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));
 
     return LayerTreeHostTest::CreateDelegatingOutputSurface(
         std::move(compositor_context_provider),
-        std::move(mock_worker_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());
+    // SetAggressivelyFreeResources(true).
     EXPECT_CALL(*mock_context_support_ptr_, SetAggressivelyFreeResources(true))
         .WillOnce(testing::Invoke([this](bool is_visible) { EndTest(); }));
   }
 
   void AfterTest() override {
     // Ensure all expectations are satisfied.
     Mock::VerifyAndClearExpectations(mock_context_support_ptr_);
-    Mock::VerifyAndClearExpectations(mock_context_provider_ptr_);
   }
 
  private:
-  class MockContextProvider : public TestContextProvider {
-   public:
-    explicit MockContextProvider(std::unique_ptr<TestContextSupport> support)
-        : TestContextProvider(std::move(support),
-                              base::MakeUnique<TestGLES2Interface>(),
-                              TestWebGraphicsContext3D::Create()) {}
-
-    MOCK_METHOD0(DeleteCachedResources, void());
-
-   private:
-    ~MockContextProvider() = default;
-  };
-
   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_;
 };
 
 // Test if the LTH successfully frees resources on the worker context when
 // visibility is set to false.
 class LayerTreeHostFreeWorkerContextResourcesOnInvisible

[danakj, 2016/08/26 23:49:09]

Should these test the compositor context too?

.. and we do this in SetVisible for the compositor not the worker context.. wait
what is happening in this test then?

[ericrk, 2016/08/29 22:43:23]

SetVisible also modifies the memory policy, zeroing it when we go invisible.
That eventually causes the worker context to free as well... But we should test
the main context here as well.

     : public LayerTreeHostFreeWorkerContextResourcesTest {
  public:
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
     BeforeVisibilityChange();
     PostSetVisibleToMainThread(false);
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 6497 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