GSB uses delta_hints to calculate scrolling chain.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 2752 matching lines @@
 
   active_tree_->SetCurrentlyScrollingNode(scrolling_node);
   // TODO(majidvp): get rid of wheel_scrolling_ and set is_direct_manipulation
   // in input_handler_proxy instead.
   wheel_scrolling_ = IsWheelBasedScroll(type);
   scroll_state->set_is_direct_manipulation(!wheel_scrolling_);
   // Invoke |DistributeScrollDelta| even with zero delta and velocity to ensure
   // scroll customization callbacks are invoked.
   DistributeScrollDelta(scroll_state);
 
+  // If the CurrentlyScrollingNode doesn't exist after distributing scroll
+  // delta, no scroller can scroll in the given delta hint direction(s).
+  if (!active_tree_->CurrentlyScrollingNode()) {
+    scroll_status.thread = InputHandler::SCROLL_IGNORED;
+    scroll_status.main_thread_scrolling_reasons =
+        MainThreadScrollingReason::kNotScrollingOnMain;
+    return scroll_status;
+  }
+
   client_->RenewTreePriority();
   RecordCompositorSlowScrollMetric(type, CC_THREAD);
 
   UpdateScrollSourceInfo(wheel_scrolling_);
 
   return scroll_status;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::RootScrollBegin(
     ScrollState* scroll_state,
@@ skipping 106 matching lines @@
   }
 
   // If |first_scrolling_layer_or_drawn_scrollbar| is not scrollable, it must
   // be a drawn scrollbar. These hit tests require falling back to main-thread
   // scrolling.
   DCHECK(first_scrolling_layer_or_drawn_scrollbar->IsDrawnScrollbar());
   return false;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimatedBegin(
-    const gfx::Point& viewport_point) {
+    ScrollState* scroll_state) {
   InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
   if (scroll_node) {
     gfx::Vector2dF delta;
 
     if (ScrollAnimationUpdateTarget(scroll_node, delta, base::TimeDelta())) {
       scroll_status.thread = SCROLL_ON_IMPL_THREAD;
     } else {
       scroll_status.thread = SCROLL_IGNORED;
       scroll_status.main_thread_scrolling_reasons =
           MainThreadScrollingReason::kNotScrollable;
     }
     return scroll_status;
   }
-  ScrollStateData scroll_state_data;
-  scroll_state_data.position_x = viewport_point.x();
-  scroll_state_data.position_y = viewport_point.y();
-  ScrollState scroll_state(scroll_state_data);
 
   // ScrollAnimated is used for animated wheel scrolls. We find the first layer
   // that can scroll and set up an animation of its scroll offset. Note that
   // this does not currently go through the scroll customization machinery
   // that ScrollBy uses for non-animated wheel scrolls.
-  scroll_status = ScrollBegin(&scroll_state, WHEEL);
+  scroll_status = ScrollBegin(scroll_state, WHEEL);
   if (scroll_status.thread == SCROLL_ON_IMPL_THREAD) {
     scroll_animating_latched_node_id_ = ScrollTree::kInvalidNodeId;
     ScrollStateData scroll_state_end_data;
     scroll_state_end_data.is_ending = true;
     ScrollState scroll_state_end(scroll_state_end_data);
     ScrollEnd(&scroll_state_end);
   }
   return scroll_status;
 }
 
@@ skipping 344 matching lines @@
 }
 
 void LayerTreeHostImpl::DistributeScrollDelta(ScrollState* scroll_state) {
   // TODO(majidvp): in Blink we compute scroll chain only at scroll begin which
   // is not the case here. We eventually want to have the same behaviour on both
   // sides but it may become a non issue if we get rid of scroll chaining (see
   // crbug.com/526462)
   std::list<ScrollNode*> current_scroll_chain;
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
   ScrollNode* viewport_scroll_node = OuterViewportScrollNode();

[bokan, 2017/05/30 15:07:06]

While you're here, please change this from OuterViewportScrollNode to
viewport()->MainScrollLayer().

[sahel, 2017/05/31 17:50:00]

Done.

   if (scroll_node) {
     // TODO(bokan): The loop checks for a null parent but don't we still want to
     // distribute to the root scroll node?
     for (; scroll_tree.parent(scroll_node);
          scroll_node = scroll_tree.parent(scroll_node)) {
       if (scroll_node == viewport_scroll_node) {
         // Don't chain scrolls past the outer viewport scroll layer. Once we
         // reach that, we should scroll the viewport which is represented by the
         // main viewport scroll layer.
         DCHECK(viewport_scroll_node);
-        current_scroll_chain.push_front(viewport_scroll_node);
+        if (CanConsumeDelta(viewport_scroll_node, *scroll_state))
+          current_scroll_chain.push_front(viewport_scroll_node);
         break;
       }
 
       if (!scroll_node->scrollable)
         continue;
 
-      current_scroll_chain.push_front(scroll_node);
+      if (CanConsumeDelta(scroll_node, *scroll_state))
+        current_scroll_chain.push_front(scroll_node);
     }
   }
+  active_tree_->SetCurrentlyScrollingNode(
+      current_scroll_chain.empty() ? nullptr : current_scroll_chain.back());
   scroll_state->set_scroll_chain_and_layer_tree(current_scroll_chain,
                                                 active_tree());
   scroll_state->DistributeToScrollChainDescendant();
 }
 
+bool LayerTreeHostImpl::CanConsumeDelta(ScrollNode* scroll_node,
+                                        const ScrollState& scroll_state) {
+  gfx::Vector2dF delta_to_scroll;
+  if (scroll_state.is_beginning()) {
+    if (scroll_state.ignore_delta_hints())
+      return true;
+
+    delta_to_scroll = gfx::Vector2dF(scroll_state.delta_x_hint(),
+                                     scroll_state.delta_y_hint());
+  } else {
+    delta_to_scroll =
+        gfx::Vector2dF(scroll_state.delta_x(), scroll_state.delta_y());
+  }
+
+  if (delta_to_scroll == gfx::Vector2dF())
+    return true;
+
+  return ComputeScrollDelta(scroll_node, delta_to_scroll) != gfx::Vector2dF();
+}
+
 InputHandlerScrollResult LayerTreeHostImpl::ScrollBy(
     ScrollState* scroll_state) {
   DCHECK(scroll_state);
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
 
   if (!scroll_node)
     return InputHandlerScrollResult();
@@ skipping 1020 matching lines @@
 
 void LayerTreeHostImpl::ShowScrollbarsForImplScroll(ElementId element_id) {
   if (!element_id)
     return;
   if (ScrollbarAnimationController* animation_controller =
           ScrollbarAnimationControllerForElementId(element_id))
     animation_controller->DidScrollUpdate();
 }
 
 }  // namespace cc