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 163 matching lines @@
       current_begin_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
       output_surface_(nullptr),
       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),
       settings_(settings),
       visible_(true),
       cached_managed_memory_policy_(
           GetDefaultMemoryAllocationLimit(),
           gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
           ManagedMemoryPolicy::kDefaultNumResourcesLimit),
@@ skipping 2169 matching lines @@
     if (optional_has_ancestor_scroll_handler &&
         scroll_layer_impl->have_scroll_event_handlers())
       *optional_has_ancestor_scroll_handler = true;
 
     if (status == SCROLL_STARTED && !potentially_scrolling_layer_impl)
       potentially_scrolling_layer_impl = scroll_layer_impl;
   }
 
   // Falling back to the root scroll layer ensures generation of root overscroll
   // notifications while preventing scroll updates from being unintentionally
-  // forwarded to the main thread.
+  // forwarded to the main thread. The inner viewport layer represents the
+  // viewport during scrolling.
   if (!potentially_scrolling_layer_impl)
     potentially_scrolling_layer_impl = InnerViewportScrollLayer();
 
   // The inner viewport layer represents the viewport.
   if (potentially_scrolling_layer_impl == OuterViewportScrollLayer())
     potentially_scrolling_layer_impl = InnerViewportScrollLayer();
 
   return potentially_scrolling_layer_impl;
 }
 
@@ skipping 10 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 228 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 121 matching lines @@
 }
 
 void LayerTreeHostImpl::ScrollEnd() {
   top_controls_manager_->ScrollEnd();
   ClearCurrentlyScrollingLayer();
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
   if (!CurrentlyScrollingLayer())
     return SCROLL_IGNORED;
-
-  bool currently_scrolling_viewport =
-      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 777 matching lines @@
   if (active_tree()) {
     LayerAnimationValueProvider* layer = active_tree()->LayerById(layer_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc