cc: Make LayerTreeHostImpl::SwapBuffers not virtual.

cc/trees/layer_tree_host_unittest_copyrequest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 756 matching lines @@
 
   void CheckNumTexturesAfterReadbackDestroyed() {
     // After the loss we had |num_textures_after_loss_| many textures, but
     // releasing the copy output request will cause the texture in the request
     // to be released, so we should have 1 less by now.
     EXPECT_EQ(num_textures_after_loss_ - 1,
               first_context_provider_->TestContext3d()->NumTextures());
     EndTest();
   }
 
-  void SwapBuffersOnThread(LayerTreeHostImpl* impl, bool result) override {
-    switch (impl->active_tree()->source_frame_number()) {
+  void SwapBuffersCompleteOnThread() override {
+    switch (num_swaps_++) {
       case 0:
         // The layers have been drawn, so their textures have been allocated.
         EXPECT_FALSE(result_);
         num_textures_without_readback_ =
             first_context_provider_->TestContext3d()->NumTextures();
 
         // Request a copy of the layer. This will use another texture.
         MainThreadTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&LayerTreeHostCopyRequestTestLostOutputSurface::
@@ skipping 33 matching lines @@
                            DestroyCopyResultAndCheckNumTextures,
                        base::Unretained(this)));
         break;
     }
   }
 
   void AfterTest() override {}
 
   scoped_refptr<TestContextProvider> first_context_provider_;
   scoped_refptr<TestContextProvider> second_context_provider_;
+  int num_swaps_ = 0;
   size_t num_textures_without_readback_ = 0;
   size_t num_textures_after_loss_ = 0;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> copy_layer_;
   std::unique_ptr<CopyOutputResult> result_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestLostOutputSurface);
@@ skipping 15 matching lines @@
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(copy_layer_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
-    num_textures_without_readback_ = 0;
-    num_textures_with_readback_ = 0;
     waited_sync_token_after_readback_.Clear();
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void RequestCopy(Layer* layer) = 0;
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The layers have been pushed to the impl side. The layer textures have
         // been allocated.
         RequestCopy(copy_layer_.get());
         break;
     }
   }
 
-  void SwapBuffersOnThread(LayerTreeHostImpl* impl, bool result) override {
-    switch (impl->active_tree()->source_frame_number()) {
+  void SwapBuffersCompleteOnThread() override {
+    switch (num_swaps_++) {
       case 0:
         // The layers have been drawn, so their textures have been allocated.
         num_textures_without_readback_ =
             context_provider_->TestContext3d()->NumTextures();
         break;
       case 1:
         // We did a readback, so there will be a readback texture around now.
         num_textures_with_readback_ =
             context_provider_->TestContext3d()->NumTextures();
         waited_sync_token_after_readback_ =
             context_provider_->TestContext3d()->last_waited_sync_token();
 
         MainThreadTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&LayerTreeHostCopyRequestTestCountTextures::DoEndTest,
                        base::Unretained(this)));
         break;
     }
   }
 
   virtual void DoEndTest() { EndTest(); }
 
   scoped_refptr<TestContextProvider> context_provider_;
-  size_t num_textures_without_readback_;
-  size_t num_textures_with_readback_;
+  int num_swaps_ = 0;
+  size_t num_textures_without_readback_ = 0;
+  size_t num_textures_with_readback_ = 0;
   gpu::SyncToken waited_sync_token_after_readback_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> copy_layer_;
 };
 
 class LayerTreeHostCopyRequestTestCreatesTexture
     : public LayerTreeHostCopyRequestTestCountTextures {
  protected:
   void RequestCopy(Layer* layer) override {
     // Request a normal texture copy. This should create a new texture.
     copy_layer_->RequestCopyOfOutput(
         CopyOutputRequest::CreateRequest(base::Bind(
             &LayerTreeHostCopyRequestTestCreatesTexture::CopyOutputCallback,
             base::Unretained(this))));
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_FALSE(result->IsEmpty());
     EXPECT_TRUE(result->HasTexture());
 
     TextureMailbox mailbox;
-    std::unique_ptr<SingleReleaseCallback> release;
-    result->TakeTexture(&mailbox, &release);
-    EXPECT_TRUE(release);
-
-    release->Run(gpu::SyncToken(), false);
+    result->TakeTexture(&mailbox, &release_);
+    EXPECT_TRUE(release_);
   }
 
   void AfterTest() override {
+    release_->Run(gpu::SyncToken(), false);
+
     // No sync point was needed.
     EXPECT_FALSE(waited_sync_token_after_readback_.HasData());
     // Except the copy to have made another texture.
     EXPECT_EQ(num_textures_without_readback_ + 1, num_textures_with_readback_);
   }
+
+  std::unique_ptr<SingleReleaseCallback> release_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestCreatesTexture);
 
 class LayerTreeHostCopyRequestTestProvideTexture
     : public LayerTreeHostCopyRequestTestCountTextures {
  protected:
   void BeginTest() override {
     external_context_provider_ = TestContextProvider::Create();
@@ skipping 310 matching lines @@
   int num_draws_;
   bool copy_happened_;
   bool draw_happened_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest);
 
 }  // namespace
 }  // namespace cc