cc: Make LayerTreeHostImpl::SwapBuffers not virtual.

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 112 matching lines @@
     MAIN_DID_BEGIN_FRAME,
     MAIN_END,
   };
 
   enum ImplOrder : int {
     IMPL_START = 1,
     IMPL_COMMIT,
     IMPL_COMMIT_COMPLETE,
     IMPL_ACTIVATE,
     IMPL_DRAW,
-    IMPL_SWAP,
     IMPL_END,
   };
 
   template <typename T>
   bool CheckStep(T next, T* var) {
     int expected = next - 1;
     EXPECT_EQ(expected, *var);
     bool correct = expected == *var;
     *var = next;
     return correct;
@@ skipping 20 matching lines @@
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_TRUE(CheckStep(IMPL_COMMIT_COMPLETE, &impl_));
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_TRUE(CheckStep(IMPL_ACTIVATE, &impl_));
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_TRUE(CheckStep(IMPL_DRAW, &impl_));
-  }
-
-  void SwapBuffersCompleteOnThread(LayerTreeHostImpl* impl) override {
-    EXPECT_TRUE(CheckStep(IMPL_SWAP, &impl_));
-
     EndTest();
   }
 
   void AfterTest() override {
     EXPECT_TRUE(CheckStep(MAIN_END, &main_));
     EXPECT_TRUE(CheckStep(IMPL_END, &impl_));
   }
 
   MainOrder main_ = MAIN_START;
   ImplOrder impl_ = IMPL_START;
@@ skipping 2606 matching lines @@
       EXPECT_EQ(2u, frame_data->render_passes.size());
 
       // At least root layer quad in root render pass.
       EXPECT_GE(frame_data->render_passes[0]->quad_list.size(), 1u);
       // At least parent and child layer quads in parent render pass.
       EXPECT_GE(frame_data->render_passes[1]->quad_list.size(), 2u);
     }
     return draw_result;
   }
 
-  void SwapBuffersCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+  void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     swap_count_++;
     switch (swap_count_) {
       case 1:
         host_impl->SetNeedsRedraw();
         break;
       case 2:
         EndTest();
         break;
       default:
         NOTREACHED();
@@ skipping 1463 matching lines @@
     // Lost context sometimes takes two frames to recreate. The third frame
     // is sometimes aborted, so wait until the fourth frame to verify that
     // the memory has been set, and the fifth frame to end the test.
     if (layer_tree_host()->source_frame_number() < 5) {
       layer_tree_host()->SetNeedsCommit();
     } else if (layer_tree_host()->source_frame_number() == 5) {
       EndTest();
     }
   }
 
-  void SwapBuffersOnThread(LayerTreeHostImpl* impl, bool result) override {
+  void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     switch (impl->active_tree()->source_frame_number()) {
       case 1:
         EXPECT_EQ(first_output_surface_memory_limit_,
                   impl->memory_allocation_limit_bytes());
         // Lose the output surface.
         first_context_provider_->TestContext3d()->loseContextCHROMIUM(
             GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
         break;
       case 4:
         EXPECT_EQ(second_output_surface_memory_limit_,
@@ skipping 84 matching lines @@
     if (frame == -1) {
       host_impl->active_tree()->QueuePinnedSwapPromise(base::WrapUnique(
           new TestSwapPromise(&pinned_active_swap_promise_result_)));
       host_impl->pending_tree()->QueueSwapPromise(
           base::WrapUnique(new TestSwapPromise(&pending_swap_promise_result_)));
       host_impl->active_tree()->QueueSwapPromise(
           base::WrapUnique(new TestSwapPromise(&active_swap_promise_result_)));
     }
   }
 
-  void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
-    EndTest();
-  }
+  void SwapBuffersCompleteOnThread() override { EndTest(); }
 
   void AfterTest() override {
     // The pending swap promise should activate and swap.
     EXPECT_TRUE(pending_swap_promise_result_.did_activate_called);
     EXPECT_TRUE(pending_swap_promise_result_.did_swap_called);
 
     // The active swap promise should fail to swap (it is cancelled by
     // the activation of a new frame).
     EXPECT_FALSE(active_swap_promise_result_.did_activate_called);
     EXPECT_FALSE(active_swap_promise_result_.did_swap_called);
@@ skipping 51 matching lines @@
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     commit_complete_count_++;
     if (commit_complete_count_ == 1) {
       // This commit will be aborted because no actual update.
       PostSetNeedsUpdateLayersToMainThread();
     }
   }
 
-  void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
+  void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     int frame = host_impl->active_tree()->source_frame_number();
     if (frame == 2) {
       EndTest();
     }
   }
 
   void AfterTest() override {
     // 3 commits are scheduled. 2 completes. 1 is aborted.
     EXPECT_EQ(commit_count_, 3);
     EXPECT_EQ(commit_complete_count_, 2);
@@ skipping 99 matching lines @@
   }
 
   void SetCallback(bool enable) {
     output_surface()->SetTreeActivationCallback(
         enable
             ? base::Bind(&LayerTreeHostTestKeepSwapPromise::ActivationCallback,
                          base::Unretained(this))
             : base::Closure());
   }
 
-  void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
-    EXPECT_TRUE(result);
-    if (host_impl->active_tree()->source_frame_number() >= 1) {
+  void SwapBuffersCompleteOnThread() override {
+    if (num_swaps_++ >= 1) {
       // The commit changes layers so it should cause a swap.
       base::AutoLock lock(swap_promise_result_.lock);
       EXPECT_TRUE(swap_promise_result_.did_swap_called);
       EXPECT_FALSE(swap_promise_result_.did_not_swap_called);
       EXPECT_TRUE(swap_promise_result_.dtor_called);
       EndTest();
     }
   }
 
   void AfterTest() override {}
 
  private:
+  int num_swaps_ = 0;
   scoped_refptr<Layer> layer_;
   TestSwapPromiseResult swap_promise_result_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestKeepSwapPromise);
+SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(
+    LayerTreeHostTestKeepSwapPromise);
 
 class LayerTreeHostTestBreakSwapPromiseForVisibility
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetVisibleFalseAndQueueSwapPromise() {
     layer_tree_host()->SetVisible(false);
     std::unique_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
@@ skipping 2060 matching lines @@
 // Makes sure that painted_device_scale_factor is propagated to the
 // frame's metadata.
 class LayerTreeHostTestPaintedDeviceScaleFactor : public LayerTreeHostTest {
  protected:
   void BeginTest() override {
     layer_tree_host()->SetPaintedDeviceScaleFactor(2.0f);
     EXPECT_EQ(1.0f, layer_tree_host()->device_scale_factor());
     PostSetNeedsCommitToMainThread();
   }
 
-  void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
+  void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
+    EXPECT_EQ(2.0f, host_impl->active_tree()->painted_device_scale_factor());

[danakj, 2016/07/13 21:50:18]

Check the tree state when we draw. Check the swapped frame only after swap.

+    EXPECT_EQ(1.0f, host_impl->active_tree()->device_scale_factor());
+  }
+
+  void SwapBuffersCompleteOnThread() override {
     EXPECT_EQ(
         2.0f,
         output_surface()->last_sent_frame()->metadata.device_scale_factor);
-    EXPECT_EQ(2.0f, host_impl->active_tree()->painted_device_scale_factor());
-    EXPECT_EQ(1.0f, host_impl->active_tree()->device_scale_factor());
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
 }  // namespace
 }  // namespace cc