cc: Complete swap promise for aborted commit after pending activation.

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 1563 matching lines @@
         // a second commit as a result.
         layer_tree_host()->SetDeviceScaleFactor(4.f);
         break;
       default:
         // No extra commits.
         EXPECT_EQ(2, layer_tree_host()->source_frame_number());
         break;
     }
   }
 
-  void AfterTest() override {
-  }
+  void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate);
 
@@ skipping 529 matching lines @@
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& scroll_delta,
                            const gfx::Vector2dF&,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float scale,
                            float) override {
     gfx::ScrollOffset offset = scroll_layer_->scroll_offset();
-    scroll_layer_->SetScrollOffset(ScrollOffsetWithDelta(offset,
-                                                         scroll_delta));
+    scroll_layer_->SetScrollOffset(ScrollOffsetWithDelta(offset, scroll_delta));
     layer_tree_host()->SetPageScaleFactorAndLimits(scale, 0.5f, 2.f);
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     // We get one commit before the first draw, and the animation doesn't happen
     // until the second draw.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
         // We'll start an animation when we get back to the main thread.
         break;
       case 1:
         EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
         break;
       case 2:
         EXPECT_EQ(1.25f, impl->active_tree()->current_page_scale_factor());
         EndTest();
         break;
       case 3:
         break;
       default:
         NOTREACHED();
     }
   }
 
   void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
-        layer_tree_host()->StartPageScaleAnimation(
-            gfx::Vector2d(), false, 1.25f, base::TimeDelta());
+        layer_tree_host()->StartPageScaleAnimation(gfx::Vector2d(), false,
+                                                   1.25f, base::TimeDelta());
         break;
     }
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<Layer> scroll_layer_;
 };
 
@@ skipping 175 matching lines @@
   scoped_refptr<Layer> layer_;
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousInvalidate);
 
 class LayerTreeHostTestDeferCommits : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeferCommits()
-      : num_will_begin_impl_frame_(0),
-        num_send_begin_main_frame_(0) {}
+      : num_will_begin_impl_frame_(0), num_send_begin_main_frame_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
                                   const BeginFrameArgs& args) override {
     num_will_begin_impl_frame_++;
     switch (num_will_begin_impl_frame_) {
       case 1:
         break;
       case 2:
@@ skipping 474 matching lines @@
         CreateDisplayOutputSurface(compositor_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         layer_tree_host()->settings().renderer_settings, ImplThreadTaskRunner(),
         false /* synchronous_composite */,
         false /* force_disable_reclaim_resources */,
         std::move(on_draw_callback));
     output_surface_ = output_surface.get();
     return std::move(output_surface);
   }
 
-  void BeginTest() override {
-    PostSetNeedsCommitToMainThread();
-  }
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CallOnDraw() {
     if (!TestEnded()) {
       // Synchronous compositor does not draw unless told to do so by the output
       // surface. But it needs to be done on a new stack frame.
       bool resourceless_software_draw = true;
       ImplThreadTaskRunner()->PostTask(
           FROM_HERE, base::Bind(&OnDrawOutputSurface::OnDraw,
                                 base::Unretained(output_surface_),
                                 resourceless_software_draw));
@@ skipping 148 matching lines @@
       int id) {
     return base::WrapUnique(new PushPropertiesCountingLayerImpl(tree_impl, id));
   }
 
   ~PushPropertiesCountingLayerImpl() override {}
 
   void PushPropertiesTo(LayerImpl* layer) override {
     LayerImpl::PushPropertiesTo(layer);
     push_properties_count_++;
     // Push state to the active tree because we can only access it from there.
-    static_cast<PushPropertiesCountingLayerImpl*>(
-        layer)->push_properties_count_ = push_properties_count_;
+    static_cast<PushPropertiesCountingLayerImpl*>(layer)
+        ->push_properties_count_ = push_properties_count_;
   }
 
   std::unique_ptr<LayerImpl> CreateLayerImpl(
       LayerTreeImpl* tree_impl) override {
     return PushPropertiesCountingLayerImpl::Create(tree_impl, id());
   }
 
   size_t push_properties_count() const { return push_properties_count_; }
   void reset_push_properties_count() { push_properties_count_ = 0; }
 
  private:
   size_t push_properties_count_;
 
   PushPropertiesCountingLayerImpl(LayerTreeImpl* tree_impl, int id)
-      : LayerImpl(tree_impl, id),
-        push_properties_count_(0) {
+      : LayerImpl(tree_impl, id), push_properties_count_(0) {
     SetBounds(gfx::Size(1, 1));
   }
 };
 
 class PushPropertiesCountingLayer : public Layer {
  public:
   static scoped_refptr<PushPropertiesCountingLayer> Create() {
     return new PushPropertiesCountingLayer();
   }
 
@@ skipping 997 matching lines @@
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesSetPropertyInChildThenParent);
 
 // This test verifies that the tree activation callback is invoked correctly.
 class LayerTreeHostTestTreeActivationCallback : public LayerTreeHostTest {
  public:
   LayerTreeHostTestTreeActivationCallback()
       : num_commits_(0), callback_count_(0) {}
 
-  void BeginTest() override {
-    PostSetNeedsCommitToMainThread();
-  }
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     ++num_commits_;
     switch (num_commits_) {
       case 1:
         EXPECT_EQ(0, callback_count_);
         callback_count_ = 0;
         SetCallback(host_impl, true);
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_EQ(1, callback_count_);
         callback_count_ = 0;
         SetCallback(host_impl, false);
         PostSetNeedsCommitToMainThread();
         break;
       case 3:
         EXPECT_EQ(0, callback_count_);
         callback_count_ = 0;
         EndTest();
         break;
       default:
         ADD_FAILURE() << num_commits_;
         EndTest();
         break;
     }
-    return LayerTreeHostTest::PrepareToDrawOnThread(
-        host_impl, frame_data, draw_result);
+    return LayerTreeHostTest::PrepareToDrawOnThread(host_impl, frame_data,
+                                                    draw_result);
   }
 
   void AfterTest() override { EXPECT_EQ(3, num_commits_); }
 
   void SetCallback(LayerTreeHostImpl* host_impl, bool enable) {
     host_impl->SetTreeActivationCallback(
         enable
             ? base::Bind(
                   &LayerTreeHostTestTreeActivationCallback::ActivationCallback,
                   base::Unretained(this))
@@ skipping 627 matching lines @@
   void AfterTest() override {}
 
  private:
   int num_swaps_ = 0;
   scoped_refptr<Layer> layer_;
   TestSwapPromiseResult swap_promise_result_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestKeepSwapPromise);
 
+class LayerTreeHostTestKeepSwapPromiseMFBA : public LayerTreeHostTest {
+ public:
+  LayerTreeHostTestKeepSwapPromiseMFBA() {}
+
+  void InitializeSettings(LayerTreeSettings* settings) override {
+    settings->main_frame_before_activation_enabled = true;
+  }
+
+  void BeginTest() override {
+    layer_ = SolidColorLayer::Create();
+    layer_->SetIsDrawable(true);
+    layer_->SetBounds(gfx::Size(10, 10));
+    layer_tree_host()->SetRootLayer(layer_);
+    gfx::Size bounds(100, 100);
+    layer_tree_host()->SetViewportSize(bounds);
+    PostSetNeedsCommitToMainThread();
+  }
+
+  void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
+    // Safe to check frame number here because main thread is blocked.
+    if (layer_tree_host()->source_frame_number() == 0) {
+      host_impl->BlockNotifyReadyToActivateForTesting(true);
+    } else {
+      NOTREACHED();
+    }
+  }
+
+  void DidCommit() override {
+    MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&LayerTreeHostTestKeepSwapPromiseMFBA::ChangeFrame,
+                   base::Unretained(this)));
+  }
+
+  void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
+                                     CommitEarlyOutReason reason) override {
+    base::AutoLock lock(swap_promise_result_.lock);
+    EXPECT_FALSE(swap_promise_result_.did_not_swap_called);
+    EXPECT_FALSE(swap_promise_result_.did_activate_called);
+    EXPECT_FALSE(swap_promise_result_.did_swap_called);
+    host_impl->BlockNotifyReadyToActivateForTesting(false);
+  }
+
+  void ChangeFrame() {
+    switch (layer_tree_host()->source_frame_number()) {
+      case 1:
+        // Make no changes so that we abort the next commit caused by queuing
+        // the swap promise.
+        layer_tree_host()->QueueSwapPromise(
+            base::WrapUnique(new TestSwapPromise(&swap_promise_result_)));
+        layer_tree_host()->SetNeedsUpdateLayers();
+        break;
+      case 2:
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+
+  void WillActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
+    if (host_impl->pending_tree()) {
+      if (host_impl->pending_tree()->source_frame_number() == 1) {
+        base::AutoLock lock(swap_promise_result_.lock);
+        EXPECT_FALSE(swap_promise_result_.did_activate_called);
+        EXPECT_FALSE(swap_promise_result_.did_swap_called);
+        SetCallback(host_impl, true);
+      } else {
+        SetCallback(host_impl, false);
+      }
+    }
+  }
+
+  void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
+    if (host_impl->active_tree()->source_frame_number() == 1) {
+      base::AutoLock lock(swap_promise_result_.lock);
+      EXPECT_TRUE(swap_promise_result_.did_activate_called);
+      EXPECT_FALSE(swap_promise_result_.did_swap_called);
+    }
+  }
+
+  void ActivationCallback() {
+    // DidActivate needs to happen before the tree activation callback.
+    base::AutoLock lock(swap_promise_result_.lock);
+    EXPECT_TRUE(swap_promise_result_.did_activate_called);
+  }
+
+  void SetCallback(LayerTreeHostImpl* host_impl, bool enable) {
+    host_impl->SetTreeActivationCallback(
+        enable ? base::Bind(
+                     &LayerTreeHostTestKeepSwapPromiseMFBA::ActivationCallback,
+                     base::Unretained(this))
+               : base::Closure());
+  }
+
+  void DisplayDidDrawAndSwapOnThread() override {
+    num_swaps_++;
+    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 { EXPECT_EQ(1, num_swaps_); }
+
+ private:
+  int num_swaps_ = 0;
+  scoped_refptr<Layer> layer_;
+  TestSwapPromiseResult swap_promise_result_;
+};
+
+MULTI_THREAD_TEST_F(LayerTreeHostTestKeepSwapPromiseMFBA);
+
 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_));
     layer_tree_host()->QueueSwapPromise(std::move(swap_promise));
   }
 
   void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
                                   const BeginFrameArgs& args) override {
     MainThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LayerTreeHostTestBreakSwapPromiseForVisibility
-                       ::SetVisibleFalseAndQueueSwapPromise,
-            base::Unretained(this)));
+        FROM_HERE, base::Bind(&LayerTreeHostTestBreakSwapPromiseForVisibility::
+                                  SetVisibleFalseAndQueueSwapPromise,
+                              base::Unretained(this)));
   }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
                                      CommitEarlyOutReason reason) override {
     EndTest();
   }
 
   void AfterTest() override {
     {
       base::AutoLock lock(swap_promise_result_.lock);
       EXPECT_FALSE(swap_promise_result_.did_activate_called);
       EXPECT_FALSE(swap_promise_result_.did_swap_called);
       EXPECT_TRUE(swap_promise_result_.did_not_swap_called);
       EXPECT_EQ(SwapPromise::COMMIT_FAILS, swap_promise_result_.reason);
       EXPECT_TRUE(swap_promise_result_.dtor_called);
     }
   }
 
   TestSwapPromiseResult swap_promise_result_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromiseForVisibility);
 
 class LayerTreeHostTestBreakSwapPromiseForContext : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestBreakSwapPromiseForContext()
-      : output_surface_lost_triggered_(false) {
-  }
+      : output_surface_lost_triggered_(false) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void LoseOutputSurfaceAndQueueSwapPromise() {
     layer_tree_host()->DidLoseOutputSurface();
     std::unique_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
     layer_tree_host()->QueueSwapPromise(std::move(swap_promise));
   }
 
   void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
                                   const BeginFrameArgs& args) override {
     if (output_surface_lost_triggered_)
       return;
     output_surface_lost_triggered_ = true;
 
     MainThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LayerTreeHostTestBreakSwapPromiseForContext
-                       ::LoseOutputSurfaceAndQueueSwapPromise,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(&LayerTreeHostTestBreakSwapPromiseForContext::
+                                  LoseOutputSurfaceAndQueueSwapPromise,
+                              base::Unretained(this)));
   }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
                                      CommitEarlyOutReason reason) override {
     // This is needed so that the impl-thread state matches main-thread state.
     host_impl->DidLoseOutputSurface();
     EndTest();
   }
 
   void AfterTest() override {
     {
       base::AutoLock lock(swap_promise_result_.lock);
       EXPECT_FALSE(swap_promise_result_.did_activate_called);
       EXPECT_FALSE(swap_promise_result_.did_swap_called);
       EXPECT_TRUE(swap_promise_result_.did_not_swap_called);
       EXPECT_EQ(SwapPromise::COMMIT_FAILS, swap_promise_result_.reason);
       EXPECT_TRUE(swap_promise_result_.dtor_called);
     }
   }
 
   bool output_surface_lost_triggered_;
   TestSwapPromiseResult swap_promise_result_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostTestBreakSwapPromiseForContext);
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromiseForContext);
 
 class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
  public:
   SimpleSwapPromiseMonitor(LayerTreeHost* layer_tree_host,
                            LayerTreeHostImpl* layer_tree_host_impl,
                            int* set_needs_commit_count,
                            int* set_needs_redraw_count)
       : SwapPromiseMonitor(layer_tree_host, layer_tree_host_impl),
         set_needs_commit_count_(set_needs_commit_count) {}
 
@@ skipping 442 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterizationForced);
 
 class LayerTreeHostTestWillBeginImplFrameHasDidFinishImplFrame
     : public LayerTreeHostTest {
  public:
   enum { kExpectedNumImplFrames = 10 };
 
   LayerTreeHostTestWillBeginImplFrameHasDidFinishImplFrame()
       : will_begin_impl_frame_count_(0), did_finish_impl_frame_count_(0) {}
 
-  void BeginTest() override {
-    PostSetNeedsCommitToMainThread();
-  }
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
                                   const BeginFrameArgs& args) override {
     EXPECT_EQ(will_begin_impl_frame_count_, did_finish_impl_frame_count_);
     EXPECT_FALSE(TestEnded());
     will_begin_impl_frame_count_++;
   }
 
   void DidFinishImplFrameOnThread(LayerTreeHostImpl* host_impl) override {
     did_finish_impl_frame_count_++;
@@ skipping 283 matching lines @@
   void ApplyViewportDeltas(const gfx::Vector2dF& inner,
                            const gfx::Vector2dF& outer,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float scale_delta,
                            float top_controls_delta) override {
     EXPECT_EQ(info_.page_scale_delta, scale_delta);
     EXPECT_EQ(info_.top_controls_delta, top_controls_delta);
     deltas_sent_to_client_ = true;
   }
 
-  void AfterTest() override {
-    EXPECT_TRUE(deltas_sent_to_client_);
-  }
+  void AfterTest() override { EXPECT_TRUE(deltas_sent_to_client_); }
 
   ScrollAndScaleSet info_;
   bool deltas_sent_to_client_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAcceptsDeltasFromImplWithoutRootLayer);
 
 class LayerTreeHostTestCrispUpAfterPinchEnds : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestCrispUpAfterPinchEnds()
@@ skipping 1333 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