Refactor client visibility handling

cc/output/gl_renderer_unittest.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/output/gl_renderer.h"
 
 #include <stdint.h>
 
 #include <set>
 
@@ skipping 2061 matching lines @@
 };
 
 TEST_F(GLRendererPartialSwapTest, PartialSwap) {
   RunTest(true);
 }
 
 TEST_F(GLRendererPartialSwapTest, NoPartialSwap) {
   RunTest(false);
 }
 
-class GLRendererWithMockContextTest : public ::testing::Test {
+class GLRendererWithMockContextCacheControllerTest : public ::testing::Test {
  protected:
-  class MockContextProvider : public TestContextProvider {
+  class MockContextCacheController : public ContextCacheController {
    public:
-    explicit MockContextProvider(std::unique_ptr<TestContextSupport> support)
-        : TestContextProvider(std::move(support),
-                              base::MakeUnique<TestGLES2Interface>(),
-                              TestWebGraphicsContext3D::Create()) {}
+    explicit MockContextCacheController(gpu::ContextSupport* support)
+        : ContextCacheController(support) {}
+    MOCK_METHOD0(OnClientBecameVisible, void());
+    MOCK_METHOD0(OnClientBecameNotVisible, void());
 
-    MOCK_METHOD0(DeleteCachedResources, void());
+    std::unique_ptr<ScopedVisibility> ClientBecameVisible() {
+      if (num_visible_clients_ == 0)
+        OnClientBecameVisible();
+      ++num_visible_clients_;
+      return CreateScopedVisibilityForTesting();

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

this could just call ContextCacheController::OnClientBecameVisible() i guess to
not need ForTesting too? but spliting the interface/impl probably helps more.

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

Made un-virtual, so no longer an issue.

+    }
+
+    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;
-  };
-
-  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());
+    int num_visible_clients_ = 0;
   };
 
   void SetUp() override {
-    auto context_support = base::MakeUnique<MockContextSupport>();
-    context_support_ptr_ = context_support.get();
-    context_provider_ = new MockContextProvider(std::move(context_support));
-    output_surface_ = FakeOutputSurface::Create3d(context_provider_);
+    auto support = base::MakeUnique<TestContextSupport>();
+    auto context = TestWebGraphicsContext3D::Create();
+    auto cache_controller =
+        base::MakeUnique<::testing::StrictMock<MockContextCacheController>>(
+            support.get());
+    mock_cache_controller_ = cache_controller.get();
+    auto context_provider = TestContextProvider::Create(
+        std::move(context), std::move(support), std::move(cache_controller));
+    output_surface_ = FakeOutputSurface::Create3d(std::move(context_provider));
     output_surface_->BindToClient(&output_surface_client_);
     resource_provider_ =
         FakeResourceProvider::Create(output_surface_.get(), nullptr);
     renderer_ =
         base::MakeUnique<GLRenderer>(&settings_, output_surface_.get(),
                                      resource_provider_.get(), nullptr, 0);
     renderer_->Initialize();
   }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
-  MockContextSupport* context_support_ptr_;
-  scoped_refptr<MockContextProvider> context_provider_;
+  MockContextCacheController* mock_cache_controller_;
   std::unique_ptr<OutputSurface> output_surface_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<GLRenderer> renderer_;
 };
 
-TEST_F(GLRendererWithMockContextTest,
+TEST_F(GLRendererWithMockContextCacheControllerTest,
        ContextPurgedWhenRendererBecomesInvisible) {
-  // Ensure our expectations run in order.
-  ::testing::InSequence s;
+  EXPECT_CALL(*mock_cache_controller_, OnClientBecameVisible());
+  renderer_->SetVisible(true);
+  Mock::VerifyAndClearExpectations(mock_cache_controller_);
 
-  EXPECT_CALL(*context_support_ptr_, SetClientVisible(0, true));
-  EXPECT_CALL(*context_support_ptr_, AnyClientsVisible())
-      .WillOnce(Return(true));
-  EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(false));
-  renderer_->SetVisible(true);
-  Mock::VerifyAndClearExpectations(context_support_ptr_);
-
-  EXPECT_CALL(*context_support_ptr_, SetClientVisible(0, false));
-  EXPECT_CALL(*context_support_ptr_, AnyClientsVisible())
-      .WillOnce(Return(false));
-  EXPECT_CALL(*context_provider_, DeleteCachedResources());
-  EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
+  EXPECT_CALL(*mock_cache_controller_, OnClientBecameNotVisible());
   renderer_->SetVisible(false);
-  Mock::VerifyAndClearExpectations(context_support_ptr_);
+  Mock::VerifyAndClearExpectations(mock_cache_controller_);
 }
 
 }  // namespace
 }  // namespace cc