Remove touch scroll chaining from compositor scrolling.

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 162 matching lines @@
       proxy_(proxy),
       current_begin_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
       content_is_suitable_for_gpu_rasterization_(true),
       has_gpu_rasterization_trigger_(false),
       use_gpu_rasterization_(false),
       use_msaa_(false),
       gpu_rasterization_status_(GpuRasterizationStatus::OFF_DEVICE),
       tree_resources_for_gpu_rasterization_dirty_(false),
       input_handler_client_(NULL),
       did_lock_scrolling_layer_(false),
-      should_bubble_scrolls_(false),
       wheel_scrolling_(false),
       scroll_affects_scroll_handler_(false),
       scroll_layer_id_when_mouse_over_scrollbar_(0),
       tile_priorities_dirty_(false),
       root_layer_scroll_offset_delegate_(NULL),
       settings_(settings),
       visible_(true),
       cached_managed_memory_policy_(
           GetDefaultMemoryAllocationLimit(),
           gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
@@ skipping 2195 matching lines @@
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBeginImpl(
     LayerImpl* scrolling_layer_impl,
     InputHandler::ScrollInputType type) {
   if (!scrolling_layer_impl)
     return SCROLL_IGNORED;
 
   top_controls_manager_->ScrollBegin();
 
   active_tree_->SetCurrentlyScrollingLayer(scrolling_layer_impl);
-  should_bubble_scrolls_ = (type != NON_BUBBLING_GESTURE);
   wheel_scrolling_ = (type == WHEEL);
   client_->RenewTreePriority();
   UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
   return SCROLL_STARTED;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::RootScrollBegin(
     InputHandler::ScrollInputType type) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::RootScrollBegin");
 
@@ skipping 22 matching lines @@
             device_viewport_point);
     if (scroll_layer_impl && !HasScrollAncestor(layer_impl, scroll_layer_impl))
       return SCROLL_UNKNOWN;
   }
 
   bool scroll_on_main_thread = false;
   LayerImpl* scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
       device_viewport_point, type, layer_impl, &scroll_on_main_thread,
       &scroll_affects_scroll_handler_);
 
+  // The inner viewport layer represents the viewport during scrolling.

[jdduke (slow), 2015/09/09 14:41:10]

Should we instead move this adjustment into
FindScrollLayerForDeviceViewportPoint?

[tdresser, 2015/09/10 13:56:51]

Absolutely, thanks.
Done.

+  if (scrolling_layer_impl == OuterViewportScrollLayer())
+    scrolling_layer_impl = InnerViewportScrollLayer();
+
   if (scroll_on_main_thread) {
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
     return SCROLL_ON_MAIN_THREAD;
   }
 
   return ScrollBeginImpl(scrolling_layer_impl, type);
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
     const gfx::Point& viewport_point,
@@ skipping 184 matching lines @@
       // in which the layer moved.
       applied_delta = MathUtil::ProjectVector(delta, applied_delta);
     }
     scroll_state->set_caused_scroll(std::abs(applied_delta.x()) > kEpsilon,
                                     std::abs(applied_delta.y()) > kEpsilon);
     scroll_state->ConsumeDelta(applied_delta.x(), applied_delta.y());
   }
 
   if (!scrolled)
     return;
-  // 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 (!scroll_state->should_propagate())
-    scroll_state->set_current_native_scrolling_layer(layer);
+
+  scroll_state->set_current_native_scrolling_layer(layer);
 }
 
 InputHandlerScrollResult LayerTreeHostImpl::ScrollBy(
     const gfx::Point& viewport_point,
     const gfx::Vector2dF& scroll_delta) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
   if (!CurrentlyScrollingLayer())
     return InputHandlerScrollResult();
 
   float initial_top_controls_offset =
       top_controls_manager_->ControlsTopOffset();
   ScrollState scroll_state(
       scroll_delta.x(), scroll_delta.y(), viewport_point.x(),
-      viewport_point.y(), should_bubble_scrolls_ /* should_propagate */,
+      viewport_point.y(), false /* should_propagate */,
       did_lock_scrolling_layer_ /* delta_consumed_for_scroll_sequence */,
       !wheel_scrolling_ /* is_direct_manipulation */);
   scroll_state.set_current_native_scrolling_layer(CurrentlyScrollingLayer());
 
   std::list<LayerImpl*> current_scroll_chain;
   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.
@@ skipping 117 matching lines @@
 
 void LayerTreeHostImpl::ScrollEnd() {
   top_controls_manager_->ScrollEnd();
   ClearCurrentlyScrollingLayer();
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
   if (!CurrentlyScrollingLayer())
     return SCROLL_IGNORED;
 
-  bool currently_scrolling_viewport =
-      CurrentlyScrollingLayer() == OuterViewportScrollLayer() ||
-      CurrentlyScrollingLayer() == InnerViewportScrollLayer();
-  if (!wheel_scrolling_ && !currently_scrolling_viewport) {
-    // Allow the fling to lock to the first layer that moves after the initial
-    // fling |ScrollBy()| event, unless we're already scrolling the viewport.
-    did_lock_scrolling_layer_ = false;
-    should_bubble_scrolls_ = false;
-  }
-
   return SCROLL_STARTED;
 }
 
 float LayerTreeHostImpl::DeviceSpaceDistanceToLayer(
     const gfx::PointF& device_viewport_point,
     LayerImpl* layer_impl) {
   if (!layer_impl)
     return std::numeric_limits<float>::max();
 
   gfx::Rect layer_impl_bounds(layer_impl->bounds());
@@ skipping 789 matching lines @@
   if (active_tree()) {
     LayerAnimationValueProvider* layer = active_tree()->LayerById(layer_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc