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 2063 matching lines @@
 TEST_F(GLRendererPartialSwapTest, PartialSwap) {
   RunTest(true);
 }
 
 TEST_F(GLRendererPartialSwapTest, NoPartialSwap) {
   RunTest(false);
 }
 
 class GLRendererWithMockContextTest : public ::testing::Test {
  protected:
-  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());
   };
 
   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 context_provider = TestContextProvider::Create(
+        TestWebGraphicsContext3D::Create(), std::move(context_support));
+    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_;
   std::unique_ptr<OutputSurface> output_surface_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<GLRenderer> renderer_;
 };
 
 TEST_F(GLRendererWithMockContextTest,
        ContextPurgedWhenRendererBecomesInvisible) {
-  // Ensure our expectations run in order.
-  ::testing::InSequence s;
-
-  EXPECT_CALL(*context_support_ptr_, SetClientVisible(0, true));
-  EXPECT_CALL(*context_support_ptr_, AnyClientsVisible())
-      .WillOnce(Return(true));
   EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(false));

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

This is testing mocks 2 levels in now, hm. I wonder about making the cc::CCC a
virtual interface so you could mock that but idk. I kinda liked it not being
virtual for no reason. Eh.. thots?

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

Yeah... I thought of this as well - it felt like making it virtual for no reason
wasn't great, but I guess it would make it easier to test...

   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));
   renderer_->SetVisible(false);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 }
 
 }  // namespace
 }  // namespace cc