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);

[danakj, 2017/03/06 16:41:44]

btw these EXPECT_EQ are all backward, it should be (expected, actual)

[Khushal, 2017/03/06 21:46:25]

Done.

-    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();
   }
 
   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]);
@@ skipping 25 matching lines @@
         EXPECT_EQ(host_impl->active_tree()
                       ->OuterViewportScrollLayer()
                       ->CurrentScrollOffset(),
                   outer_viewport_offsets_[2]);
         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);
   }
 
   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