Update Context Client Visibility to use Scoped Pattern

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 2080 matching lines @@
                               TestWebGraphicsContext3D::Create()) {}
 
     MOCK_METHOD0(DeleteCachedResources, void());
 
    private:
     ~MockContextProvider() = default;
   };
 
   class MockContextSupport : public TestContextSupport {
    public:
+    using VisibilityToken = std::unique_ptr<ScopedVisibility>;
     MockContextSupport() {}
-    MOCK_METHOD1(SetAggressivelyFreeResources,
-                 void(bool aggressively_free_resources));
-    MOCK_METHOD2(SetClientVisible, void(int client_id, bool is_visible));
+    MOCK_METHOD0(ClientBecameVisible, VisibilityToken());
+    MOCK_METHOD1(ClientBecameNotVisible_,
+                 void(VisibilityToken& visibility));  // NOLINT
     MOCK_CONST_METHOD0(AnyClientsVisible, bool());
+
+    // Wrapper to allow mocking w/ move-only type.
+    void ClientBecameNotVisible(VisibilityToken visibility) override {
+      ClientBecameNotVisible_(visibility);
+    }
+
+    // Wrappers to allow forwarding to super class implementation.
+    void SuperClientBecameNotVisible(VisibilityToken& visibility) {  // NOLINT
+      TestContextSupport::ClientBecameNotVisible(std::move(visibility));
+    }
+    VisibilityToken SuperClientBecameVisible() {
+      return TestContextSupport::ClientBecameVisible();
+    }
   };
 
   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_);
     output_surface_->BindToClient(&output_surface_client_);
     resource_provider_ =
         FakeResourceProvider::Create(output_surface_.get(), nullptr);
@@ skipping 10 matching lines @@
   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_, ClientBecameVisible())
+      .WillOnce(::testing::Invoke(
+          context_support_ptr_, &MockContextSupport::SuperClientBecameVisible));
   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_, ClientBecameNotVisible_(_))
+      .WillOnce(
+          ::testing::Invoke(context_support_ptr_,
+                            &MockContextSupport::SuperClientBecameNotVisible));
   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