Animated scroll shouldn't consume unhandled scrolls for OOPIFs.

content/browser/site_per_process_browsertest.cc

 // Copyright (c) 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 "content/browser/site_per_process_browsertest.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1072 matching lines @@
 
   // The precise amount of scroll for the first view position update is not
   // deterministic, so this simply verifies that the OOPIF moved from its
   // earlier position.
   gfx::Rect update_rect = filter->last_rect();
   EXPECT_LT(update_rect.y(), bounds.y() - rwhv_root->GetViewBounds().y());
 }
 
 // Test that scrolling a nested out-of-process iframe bubbles unused scroll
 // delta to a parent frame.
 // Flaky: https://crbug.com/627238

[bokan, 2017/04/11 22:18:29]

If this used to be flaky, it means the functionality worked, right? So does that
mean that this test isn't testing bubbling from animated wheel scrolls? If so,
we need a test for that explicitly. If not, I'm confused.

[wjmaclean, 2017/04/12 15:54:47]

Yes and no. :-)
No.
It's a confusing story, but here goes:

First, the existing test (without this CL) works for --disable-smooth-scrolling.
Now, I've discovered that sometimes when the test runs, the scrolls sent to the
child *aren't* animated, and they bubble as expected. But on other runs, the
child scrolls are animated, and then the test fails without the code added by
this CL at the end of ScrollAnimated(), which sets the status to SCROLL_IGNORED
for unconsumed scrolls in children.

*** I do not know why the scrolls sent to the child have unpredictable behaviour
vis-á-vis animating or not.

A third failure mode exists with this CL enabled, namely that the animation
bubbled from the child hits a current animation in the parent. Normally this
should just combine and work, but it seems the new scroll delta gets ignored,
and the test timeouts waiting for the delta to be applied. I've filed a separate
bug for that case. The delay I've added to the test is meant to minimise that
case, but though it works well on my development machine, it still fails far too
often on the bots, so the test may have to be delayed until the
combining-animations bug is resolved.

+#if defined(OS_ANDROID)
+// Test failing on some Android builders, due to inaccurate coordinates on
+// some devices. See: https://crbug.com/700007.
+#define MAYBE_ScrollBubblingFromOOPIFTest DISABLED_ScrollBubblingFromOOPIFTest
+#else
+#define MAYBE_ScrollBubblingFromOOPIFTest ScrollBubblingFromOOPIFTest
+#endif
 IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
-                       DISABLED_ScrollBubblingFromOOPIFTest) {
+                       MAYBE_ScrollBubblingFromOOPIFTest) {
   GURL main_url(embedded_test_server()->GetURL(
       "a.com", "/cross_site_iframe_factory.html?a(b)"));
   EXPECT_TRUE(NavigateToURL(shell(), main_url));
 
   // It is safe to obtain the root frame tree node here, as it doesn't change.
   FrameTreeNode* root = static_cast<WebContentsImpl*>(shell()->web_contents())
                             ->GetFrameTree()
                             ->root();
   ASSERT_EQ(1U, root->child_count());
 
@@ skipping 79 matching lines @@
   while (update_rect.y() > initial_y) {
     base::RunLoop run_loop;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(), TestTimeouts::tiny_timeout());
     run_loop.Run();
     update_rect = filter->last_rect();
   }
 
   filter->Reset();
 
+  // TODO(wjmaclean): This is ugly, but it seems that it stops the scroll
+  // we're about to send from occassionally colliding with the previous
+  // scroll animation.
+  {
+    base::RunLoop run_loop;
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(), TestTimeouts::action_max_timeout());
+    run_loop.Run();
+    update_rect = filter->last_rect();
+  }
+
   // Scroll the parent down again in order to test scroll bubbling from
   // gestures.
   scroll_event.delta_y = -5.0f;
   rwhv_parent->ProcessMouseWheelEvent(scroll_event, ui::LatencyInfo());
 
   // Ensure ensuing offset change is received, and then reset the filter.
   filter->Wait();
   filter->Reset();
 
   // Scroll down the nested iframe via gesture. This requires 3 separate input
@@ skipping 8656 matching lines @@
     names.insert(root->children[0]->frame_entry->frame_unique_name());
   }
 
   // More than one entry in the set means that the subframe frame navigation
   // entries didn't have a consistent unique name. This will break history
   // navigations =(
   EXPECT_THAT(names, SizeIs(1)) << "Mismatched names for subframe!";
 }
 
 }  // namespace content