Update Context Client Visibility to use Scoped Pattern

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 434 matching lines @@
     mock_context_provider_ptr_ = mock_worker_context_provider.get();
 
     // 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_, ClientBecameVisible())
+        .WillOnce(
+            ::testing::Invoke(mock_context_support_ptr_,
+                              &MockContextSupport::SuperClientBecameVisible));
     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));
   }
 
   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_, ClientBecameNotVisible_(_))
+        .WillOnce(::testing::Invoke(
+            mock_context_support_ptr_,
+            &MockContextSupport::SuperClientBecameNotVisible));
     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.
     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:
+    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();
+    }
   };
 
   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
     : public LayerTreeHostFreeWorkerContextResourcesTest {
@@ skipping 6504 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