All scrolls scroll visual viewport first. (Chromium-side)

Scrolling the viewport involves scrolling two scrollers, the visual and
layout viewports. Until now, we would first try to scroll the layout
viewport, then, if that was at its maximum scroll extent, we would bubble
the scroll to the visual viewport. This CL flips the order of the viewports
so that we scroll the visual first when the --invert-viewport-scroll-order
flag is set.

BUG=443724
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1258953003

Cr-Commit-Position: refs/heads/master@{#341747}

3 files changed, 74 insertions, 6 deletions

diff --git a/cc/layers/viewport.cc b/cc/layers/viewport.cc
index e5e3053..38f4c27 100644
--- a/cc/layers/viewport.cc
+++ b/cc/layers/viewport.cc
@@ -43,9 +43,17 @@ Viewport::ScrollResult Viewport::ScrollBy(const gfx::Vector2dF& delta,
 
   gfx::Vector2dF pending_content_delta = content_delta;
 
-  pending_content_delta -=
-      host_impl_->ScrollLayer(OuterScrollLayer(), pending_content_delta,
-                              viewport_point, is_direct_manipulation);
+  bool invert_scroll_order =
+      host_impl_->settings().invert_viewport_scroll_order;
+  LayerImpl* primary_layer =
+      invert_scroll_order ? InnerScrollLayer() : OuterScrollLayer();
+  LayerImpl* secondary_layer =
+      invert_scroll_order ? OuterScrollLayer() : InnerScrollLayer();
+
+  pending_content_delta -= host_impl_->ScrollLayer(primary_layer,
+                                                   pending_content_delta,
+                                                   viewport_point,
+                                                   is_direct_manipulation);
 
   ScrollResult result;
 
@@ -54,9 +62,10 @@ Viewport::ScrollResult Viewport::ScrollBy(const gfx::Vector2dF& delta,
   if (gfx::ToRoundedVector2d(pending_content_delta).IsZero()) {
     result.consumed_delta = delta;
   } else {
-    pending_content_delta -=
-        host_impl_->ScrollLayer(InnerScrollLayer(), pending_content_delta,
-                                viewport_point, is_direct_manipulation);
+    pending_content_delta -= host_impl_->ScrollLayer(secondary_layer,
+                                                     pending_content_delta,
+                                                     viewport_point,
+                                                     is_direct_manipulation);
     result.consumed_delta = delta - AdjustOverscroll(pending_content_delta);
   }
 
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index a99c7b4..03c02e7 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -1135,6 +1135,64 @@ TEST_F(LayerTreeHostImplTest, ImplPinchZoom) {
   }
 }
 
+TEST_F(LayerTreeHostImplTest, ViewportScrollOrder) {
+  LayerTreeSettings settings = DefaultSettings();
+  settings.invert_viewport_scroll_order = true;
+  CreateHostImpl(settings,
+                 CreateOutputSurface());
+  host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.25f, 4.f);
+
+  const gfx::Size content_size(1000, 1000);
+  const gfx::Size viewport_size(500, 500);
+  CreateBasicVirtualViewportLayers(viewport_size, content_size);
+
+  LayerImpl* outer_scroll_layer = host_impl_->OuterViewportScrollLayer();
+  LayerImpl* inner_scroll_layer = host_impl_->InnerViewportScrollLayer();
+
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(500, 500),
+      outer_scroll_layer->MaxScrollOffset());
+
+  host_impl_->ScrollBegin(gfx::Point(250, 250), InputHandler::GESTURE);
+  host_impl_->PinchGestureBegin();
+  host_impl_->PinchGestureUpdate(2.f, gfx::Point(0, 0));
+  host_impl_->PinchGestureEnd();
+  host_impl_->ScrollEnd();
+
+  // Sanity check - we're zoomed in, starting from the origin.
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(0, 0),
+      outer_scroll_layer->CurrentScrollOffset());
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(0, 0),
+      inner_scroll_layer->CurrentScrollOffset());
+
+  // Scroll down - only the inner viewport should scroll.
+  host_impl_->ScrollBegin(gfx::Point(0, 0), InputHandler::GESTURE);
+  host_impl_->ScrollBy(gfx::Point(0, 0), gfx::Vector2dF(100.f, 100.f));
+  host_impl_->ScrollEnd();
+
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(50, 50),
+      inner_scroll_layer->CurrentScrollOffset());
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(0, 0),
+      outer_scroll_layer->CurrentScrollOffset());
+
+  // Scroll down - outer viewport should start scrolling after the inner is at
+  // its maximum.
+  host_impl_->ScrollBegin(gfx::Point(0, 0), InputHandler::GESTURE);
+  host_impl_->ScrollBy(gfx::Point(0, 0), gfx::Vector2dF(1000.f, 1000.f));
+  host_impl_->ScrollEnd();
+
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(250, 250),
+      inner_scroll_layer->CurrentScrollOffset());
+  EXPECT_VECTOR_EQ(
+      gfx::Vector2dF(300, 300),
+      outer_scroll_layer->CurrentScrollOffset());
+}
+
 TEST_F(LayerTreeHostImplTest, ScrollDuringPinchScrollsInnerViewport) {
   LayerTreeSettings settings = DefaultSettings();
   settings.invert_viewport_scroll_order = true;
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index c9344b9..d45583e 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -1102,6 +1102,7 @@ void RenderView::ApplyWebPreferences(const WebPreferences& prefs,
 
   settings->setSupportsMultipleWindows(prefs.supports_multiple_windows);
 
+  settings->setInvertViewportScrollOrder(prefs.invert_viewport_scroll_order);
   settings->setViewportEnabled(prefs.viewport_enabled);
   settings->setLoadWithOverviewMode(prefs.initialize_at_minimum_page_scale);
   settings->setViewportMetaEnabled(prefs.viewport_meta_enabled);