cc: Fix flaky LayerTreeHostScrollTestImplSideInvalidation

cc/trees/layer_tree_host_unittest_scroll.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/trees/layer_tree_host.h"
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 2061 matching lines @@
   void AfterTest() override {}
 
  private:
   gfx::ScrollOffset initial_scroll_;
   gfx::ScrollOffset second_scroll_;
   gfx::Vector2dF scroll_amount_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostScrollTestPropertyTreeUpdate);
 
-// Disabled due to flakes/crashes, see https://crbug.com/697652.
-class DISABLED_LayerTreeHostScrollTestImplSideInvalidation
+class LayerTreeHostScrollTestImplSideInvalidation
     : public LayerTreeHostScrollTest {
   void BeginTest() override {
     layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
-        base::Bind(&DISABLED_LayerTreeHostScrollTestImplSideInvalidation::
+        base::Bind(&LayerTreeHostScrollTestImplSideInvalidation::
                        DidScrollOuterViewport,
                    base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void DidScrollOuterViewport(const gfx::ScrollOffset& offset) {
     // Defer responding to the main frame until an impl-side pending tree is
     // created for the invalidation request.
     {
       CompletionEvent completion;
       task_runner_provider()->ImplThreadTaskRunner()->PostTask(
-          FROM_HERE,
-          base::Bind(&DISABLED_LayerTreeHostScrollTestImplSideInvalidation::
-                         WaitForInvalidationOnImplThread,
-                     base::Unretained(this), &completion));
+          FROM_HERE, base::Bind(&LayerTreeHostScrollTestImplSideInvalidation::
+                                    WaitForInvalidationOnImplThread,
+                                base::Unretained(this), &completion));
       completion.Wait();
     }
 
     switch (++num_of_deltas_) {
       case 1: {
         // First set of deltas is here. The impl thread will scroll to the
         // second case on activation, so add a delta from the main thread that
         // takes us to the final value.
         Layer* outer_viewport_layer =
             layer_tree_host()->outer_viewport_scroll_layer();
@@ skipping 51 matching lines @@
         // after this tree is activated.
         host_impl->RequestImplSideInvalidation();
         break;
       default:
         NOTREACHED();
     }
   }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
                                      CommitEarlyOutReason reason) override {
-    // The aborted main frame is bound to come after the fourth activation,
-    // since the activation should occur synchronously after the impl-side
-    // invalidation, and the main thread is released after this activation. It
-    // should leave the scroll offset unchanged.
-    EXPECT_EQ(reason, CommitEarlyOutReason::FINISHED_NO_UPDATES);
-    EXPECT_EQ(num_of_activations_, 4);
-    EXPECT_EQ(num_of_main_frames_, 3);
-    EXPECT_EQ(host_impl->active_tree()
-                  ->OuterViewportScrollLayer()
-                  ->CurrentScrollOffset(),
-              outer_viewport_offsets_[2]);
-    EndTest();
+    EXPECT_EQ(CommitEarlyOutReason::FINISHED_NO_UPDATES, reason);
+    EXPECT_EQ(3, num_of_main_frames_);
+    EXPECT_EQ(outer_viewport_offsets_[2], host_impl->active_tree()
+                                              ->OuterViewportScrollLayer()
+                                              ->CurrentScrollOffset());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     switch (++num_of_activations_) {
       case 1:
         // Now that we have the active tree, scroll a layer and ask for a commit
         // to send a BeginMainFrame with the scroll delta to the main thread.
         host_impl->active_tree()
             ->OuterViewportScrollLayer()
             ->SetCurrentScrollOffset(outer_viewport_offsets_[0]);
         host_impl->SetNeedsCommit();
         break;
       case 2:
         // The second activation is from an impl-side pending tree so the source
         // frame number on the active tree remains unchanged, and the scroll
         // offset on the active tree should also remain unchanged.
-        EXPECT_EQ(host_impl->active_tree()->source_frame_number(), 0);
-        EXPECT_EQ(host_impl->active_tree()
-                      ->OuterViewportScrollLayer()
-                      ->CurrentScrollOffset(),
-                  outer_viewport_offsets_[1]);
+        EXPECT_EQ(0, host_impl->active_tree()->source_frame_number());
+        EXPECT_EQ(outer_viewport_offsets_[1], host_impl->active_tree()
+                                                  ->OuterViewportScrollLayer()
+                                                  ->CurrentScrollOffset());
         break;
       case 3:
         // The third activation is from a commit. The scroll offset on the
         // active tree should include deltas sent from the main thread.
         EXPECT_EQ(host_impl->active_tree()->source_frame_number(), 1);
         EXPECT_EQ(host_impl->active_tree()
                       ->OuterViewportScrollLayer()
                       ->CurrentScrollOffset(),
                   outer_viewport_offsets_[2]);
         break;
       case 4:
         // The fourth activation is from an impl-side pending tree, which should
         // leave the scroll offset unchanged.
-        EXPECT_EQ(host_impl->active_tree()->source_frame_number(), 1);
-        EXPECT_EQ(host_impl->active_tree()
-                      ->OuterViewportScrollLayer()
-                      ->CurrentScrollOffset(),
-                  outer_viewport_offsets_[2]);
+        EXPECT_EQ(1, host_impl->active_tree()->source_frame_number());
+        EXPECT_EQ(outer_viewport_offsets_[2], host_impl->active_tree()
+                                                  ->OuterViewportScrollLayer()
+                                                  ->CurrentScrollOffset());
         break;
       default:
         NOTREACHED();
     }
   }
 
+  void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
+    if (++num_of_draws_ == 4)
+      EndTest();
+  }
+
   void AfterTest() override {
-    EXPECT_EQ(num_of_activations_, 4);
-    EXPECT_EQ(num_of_deltas_, 2);
-    EXPECT_EQ(num_of_main_frames_, 3);
+    EXPECT_EQ(4, num_of_activations_);
+    EXPECT_EQ(2, num_of_deltas_);
+    EXPECT_EQ(3, num_of_main_frames_);
   }
 
   const gfx::ScrollOffset outer_viewport_offsets_[3] = {
       gfx::ScrollOffset(20, 20), gfx::ScrollOffset(50, 50),
       gfx::ScrollOffset(70, 70)};
 
   // Impl thread.
   int num_of_activations_ = 0;
+  int num_of_draws_ = 0;
   int num_of_main_frames_ = 0;
   bool invalidated_on_impl_thread_ = false;
   CompletionEvent* impl_side_invalidation_event_ = nullptr;
 
   // Main thread.
   int num_of_deltas_ = 0;
 };
 
-MULTI_THREAD_TEST_F(DISABLED_LayerTreeHostScrollTestImplSideInvalidation);
+MULTI_THREAD_TEST_F(LayerTreeHostScrollTestImplSideInvalidation);
 
 }  // namespace
 }  // namespace cc