Added experiment for changing viewport scroll ordering.

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 2614 matching lines @@
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
   if (!CurrentlyScrollingLayer())
     return InputHandlerScrollResult();
 
   gfx::Vector2dF pending_delta = scroll_delta;
   gfx::Vector2dF unused_root_delta;
   bool did_scroll_x = false;
   bool did_scroll_y = false;
   bool did_scroll_top_controls = false;
 
+  if (pinch_gesture_active_ && settings().invert_viewport_scroll_order) {
+    // Scrolls during a pinch gesture should pan the visual viewport, rather
+    // than a typical bubbling scroll.
+    viewport()->Pan(pending_delta);
+    return InputHandlerScrollResult();
+  }
+
   for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
        layer_impl;
        layer_impl = layer_impl->parent()) {
     // Skip the outer viewport scroll layer so that we try to scroll the
     // viewport only once. i.e. The inner viewport layer represents the
     // viewport.
     if (!layer_impl->scrollable() || layer_impl == OuterViewportScrollLayer())
       continue;
 
     gfx::Vector2dF applied_delta;
     if (layer_impl == InnerViewportScrollLayer()) {
+      bool affect_top_controls = true;
       Viewport::ScrollResult result = viewport()->ScrollBy(pending_delta,
                                                            viewport_point,
-                                                           wheel_scrolling_);
+                                                           wheel_scrolling_,
+                                                           affect_top_controls);
       applied_delta = result.applied_delta;
       unused_root_delta = result.unused_scroll_delta;
       did_scroll_top_controls = result.top_controls_applied_delta.y() != 0;
     } else {
       applied_delta = ScrollLayer(layer_impl,
                                   pending_delta,
                                   viewport_point,
                                   wheel_scrolling_);
     }
 
@@ skipping 268 matching lines @@
 
   // Keep the center-of-pinch anchor specified by (x, y) in a stable
   // position over the course of the magnify.
   float page_scale = active_tree_->current_page_scale_factor();
   gfx::PointF previous_scale_anchor = gfx::ScalePoint(anchor, 1.f / page_scale);
   active_tree_->SetPageScaleOnActiveTree(page_scale * magnify_delta);
   page_scale = active_tree_->current_page_scale_factor();
   gfx::PointF new_scale_anchor = gfx::ScalePoint(anchor, 1.f / page_scale);
   gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
 
+  // Scale back to viewport space since that's the coordinate space ScrollBy
+  // uses.
+  move.Scale(page_scale);
+
   previous_pinch_anchor_ = anchor;
 
   // If clamping the inner viewport scroll offset causes a change, it should
   // be accounted for from the intended move.
   move -= InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
 
-  // We manually manage the bubbling behaviour here as it is different to that
-  // implemented in LayerTreeHostImpl::ScrollBy(). Specifically:
-  // 1) we want to explicit limit the bubbling to the outer/inner viewports,
-  // 2) we don't want the directional limitations on the unused parts that
-  //    ScrollBy() implements, and
-  // 3) pinching should not engage the top controls manager.
-  gfx::Vector2dF unused = OuterViewportScrollLayer()
-                              ? OuterViewportScrollLayer()->ScrollBy(move)
-                              : move;
-
-  if (!unused.IsZero()) {
-    InnerViewportScrollLayer()->ScrollBy(unused);
-    InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
+  if (settings().invert_viewport_scroll_order) {
+    viewport()->Pan(move);
+  } else {
+    gfx::Point viewport_point;
+    bool is_wheel_event = false;
+    bool affect_top_controls = false;
+    viewport()->ScrollBy(move,
+                         viewport_point,
+                         is_wheel_event,
+                         affect_top_controls);
   }
 
   active_tree_->SetRootLayerScrollOffsetDelegate(
       root_layer_scroll_offset_delegate_);
 
   client_->SetNeedsCommitOnImplThread();
   SetNeedsRedraw();
   client_->RenewTreePriority();
 }
 
@@ skipping 474 matching lines @@
   new_target.SetToMin(layer_impl->MaxScrollOffset());
 
   curve->UpdateTarget(
       animation->TrimTimeToCurrentIteration(CurrentBeginFrameArgs().frame_time)
           .InSecondsF(),
       new_target);
 
   return true;
 }
 }  // namespace cc