Cleanup viewport scrolling for future scroll customization work.

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 2592 matching lines @@
       layer_impl->CurrentScrollOffset() - previous_offset;
   gfx::Vector2dF consumed_scroll(scrolled.x(), scrolled.y());
   consumed_scroll.Scale(page_scale_factor);
 
   return consumed_scroll;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::ScrollLayer(LayerImpl* layer_impl,
                                               const gfx::Vector2dF& delta,
                                               const gfx::Point& viewport_point,
-                                              bool is_wheel_scroll) {
-  // Gesture events need to be transformed from viewport coordinates to
-  // local layer coordinates so that the scrolling contents exactly follow
-  // the user's finger. In contrast, wheel events represent a fixed amount
-  // of scrolling so we can just apply them directly, but the page scale
-  // factor is applied to the scroll delta.
-  if (is_wheel_scroll) {
-    float scale_factor = active_tree()->current_page_scale_factor();
-    return ScrollLayerWithLocalDelta(layer_impl,
-                                     delta,
-                                     scale_factor);
-  }
-
-  return ScrollLayerWithViewportSpaceDelta(layer_impl,
-                                           viewport_point,
-                                           delta);
+                                              bool is_direct_manipulation) {
+  // Events representing direct manipulation of the screen (such as gesture
+  // events) need to be transformed from viewport coordinates to local layer
+  // coordinates so that the scrolling contents exactly follow the user's
+  // finger. In contrast, events not representing direct manipulation of the
+  // screen (such as wheel events) represent a fixed amount of scrolling so we
+  // can just apply them directly, but the page scale factor is applied to the
+  // scroll delta.
+  if (is_direct_manipulation)

[Ian Vollick, 2015/07/06 15:33:16]

It looks like there's a real behavior change here. Is that true? If so, this
should have some new test coverage.

[tdresser, 2015/07/06 15:39:29]

Nope, no behavior change. With scroll customization, we're trying not to tie
things to the kind of input device (i.e. mousewheel or touch). Instead, we're
trying to base behavior on properties of the input device. In this case, the
property of the input device that we care about is whether or not the user is
interacting directly with the screen (which currently will only be through
touch) or not (which currently will only be through trackpad). Throughout this
change, is_direct_manipulation == !is_wheel_scroll, and we invert the relevant
conditions where needed.

With scroll customization, we'll be passing this information in the ScrollIntent
object, as described here:
https://docs.google.com/document/d/1VnvAqeWFG9JFZfgG5evBqrLGDZYRE5w6G5jEDORek....

+    return ScrollLayerWithViewportSpaceDelta(layer_impl, viewport_point, delta);
+  float scale_factor = active_tree()->current_page_scale_factor();
+  return ScrollLayerWithLocalDelta(layer_impl, delta, scale_factor);
 }
 
 static LayerImpl* nextLayerInScrollOrder(LayerImpl* layer) {
   if (layer->scroll_parent())
     return layer->scroll_parent();
 
   return layer->parent();
 }
 
 InputHandlerScrollResult LayerTreeHostImpl::ScrollBy(
     const gfx::Point& viewport_point,
     const gfx::Vector2dF& scroll_delta) {
   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 = nextLayerInScrollOrder(layer_impl)) {
     // 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_,
-                                                           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;
+      applied_delta =
+          viewport()->ScrollBy(pending_delta, viewport_point, !wheel_scrolling_,
+                               affect_top_controls);
+      unused_root_delta = pending_delta - applied_delta;
     } else {
-      applied_delta = ScrollLayer(layer_impl,
-                                  pending_delta,
-                                  viewport_point,
-                                  wheel_scrolling_);
+      applied_delta = ScrollLayer(layer_impl, pending_delta, viewport_point,
+                                  !wheel_scrolling_);
     }
 
     // If the layer wasn't able to move, try the next one in the hierarchy.
     const float kEpsilon = 0.1f;
-    bool did_move_layer_x = std::abs(applied_delta.x()) > kEpsilon;
-    bool did_move_layer_y = std::abs(applied_delta.y()) > kEpsilon;
-    did_scroll_x |= did_move_layer_x;
-    did_scroll_y |= did_move_layer_y;
+    bool did_layer_consume_delta_x = std::abs(applied_delta.x()) > kEpsilon;
+    bool did_layer_consume_delta_y = std::abs(applied_delta.y()) > kEpsilon;
 
-    if (did_move_layer_x || did_move_layer_y) {
+    did_scroll_x |= did_layer_consume_delta_x;
+    did_scroll_y |= did_layer_consume_delta_y;
+
+    if (did_layer_consume_delta_x || did_layer_consume_delta_y) {
       did_lock_scrolling_layer_ = true;
 
       // When scrolls are allowed to bubble, it's important that the original
       // scrolling layer be preserved. This ensures that, after a scroll
       // bubbles, the user can reverse scroll directions and immediately resume
       // scrolling the original layer that scrolled.
       if (!should_bubble_scrolls_) {
         active_tree_->SetCurrentlyScrollingLayer(layer_impl);
         break;
       }
@@ skipping 33 matching lines @@
   }
 
   // Scrolling along an axis resets accumulated root overscroll for that axis.
   if (did_scroll_x)
     accumulated_root_overscroll_.set_x(0);
   if (did_scroll_y)
     accumulated_root_overscroll_.set_y(0);
   accumulated_root_overscroll_ += unused_root_delta;
 
   InputHandlerScrollResult scroll_result;
-  scroll_result.did_scroll = did_scroll_content || did_scroll_top_controls;
+  scroll_result.did_scroll = did_scroll_content;
   scroll_result.did_overscroll_root = !unused_root_delta.IsZero();
   scroll_result.accumulated_root_overscroll = accumulated_root_overscroll_;
   scroll_result.unused_scroll_delta = unused_root_delta;
   return scroll_result;
 }
 
 // This implements scrolling by page as described here:
 // http://msdn.microsoft.com/en-us/library/windows/desktop/ms645601(v=vs.85).aspx#_win32_The_Mouse_Wheel
 // for events with WHEEL_PAGESCROLL set.
 bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
@@ skipping 679 matching lines @@
   new_target.SetToMin(layer_impl->MaxScrollOffset());
 
   curve->UpdateTarget(
       animation->TrimTimeToCurrentIteration(CurrentBeginFrameArgs().frame_time)
           .InSecondsF(),
       new_target);
 
   return true;
 }
 }  // namespace cc