GSB uses delta_hints to calculate scrolling chain.

third_party/WebKit/Source/core/input/ScrollManager.cpp

 // Copyright 2016 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 "core/input/ScrollManager.h"
 
 #include <memory>
 #include "core/dom/DOMNodeIds.h"
 #include "core/events/GestureEvent.h"
 #include "core/frame/BrowserControls.h"
@@ skipping 61 matching lines @@
          GetAutoscrollController()->MiddleClickAutoscrollInProgress();
 }
 
 AutoscrollController* ScrollManager::GetAutoscrollController() const {
   if (Page* page = frame_->GetPage())
     return &page->GetAutoscrollController();
   return nullptr;
 }
 
 void ScrollManager::RecomputeScrollChain(const Node& start_node,
+                                         const ScrollState& scroll_state,
                                          std::deque<int>& scroll_chain) {
+  DCHECK(!scroll_chain.size());
   scroll_chain.clear();
 
   DCHECK(start_node.GetLayoutObject());
   LayoutBox* cur_box = start_node.GetLayoutObject()->EnclosingBox();
   Element* document_element = frame_->GetDocument()->documentElement();
 
   // Scrolling propagates along the containing block chain and ends at the
   // RootScroller element. The RootScroller element will have a custom
   // applyScroll callback that scrolls the frame or element.
   while (cur_box) {
     Node* cur_node = cur_box->GetNode();
     Element* cur_element = nullptr;
 
     // FIXME: this should reject more elements, as part of crbug.com/410974.
     if (cur_node && cur_node->IsElementNode()) {
       cur_element = ToElement(cur_node);
     } else if (cur_node && cur_node->IsDocumentNode()) {
       // In normal circumastances, the documentElement will be the root
       // scroller but the documentElement itself isn't a containing block,
       // that'll be the document node rather than the element.
       cur_element = document_element;
     }
 
     if (cur_element) {
-      scroll_chain.push_front(DOMNodeIds::IdForNode(cur_element));
+      if (CanScroll(scroll_state, cur_element))
+        scroll_chain.push_front(DOMNodeIds::IdForNode(cur_element));
       if (IsViewportScrollingElement(*cur_element) ||
           cur_element == document_element)
         break;
     }
 
     cur_box = cur_box->ContainingBlock();
   }
 }
 
+bool ScrollManager::CanScroll(const ScrollState& scroll_state,
+                              const Element* current_element) {
+  const double delta_x = scroll_state.isBeginning() ? scroll_state.deltaXHint()
+                                                    : scroll_state.deltaX();
+  const double delta_y = scroll_state.isBeginning() ? scroll_state.deltaYHint()
+                                                    : scroll_state.deltaY();
+  DCHECK(delta_x || delta_y);
+  DCHECK(current_element);
+
+  ScrollableArea* scrollable_area = nullptr;
+  if (current_element == frame_->GetDocument()->documentElement()) {
+    scrollable_area =
+        frame_->View() ? frame_->View()->GetScrollableArea() : nullptr;
+  } else {
+    scrollable_area = current_element->GetLayoutBox()
+                          ? current_element->GetLayoutBox()->GetScrollableArea()
+                          : nullptr;
+  }
+  if (!scrollable_area)
+    return false;
+
+  if (scroll_state.ignoreDeltaHints()) {
+    DCHECK(scroll_state.isBeginning());
+    return true;
+  }
+
+  ScrollOffset current_offset = scrollable_area->GetScrollOffset();
+  ScrollOffset target_offset = current_offset + ScrollOffset(delta_x, delta_y);
+  ScrollOffset clamped_offset =
+      scrollable_area->ClampScrollOffset(target_offset);
+  return clamped_offset != current_offset;
+}
+
 bool ScrollManager::LogicalScroll(ScrollDirection direction,
                                   ScrollGranularity granularity,
                                   Node* start_node,
                                   Node* mouse_press_node) {
   Node* node = start_node;
 
   if (!node)
     node = frame_->GetDocument()->FocusedElement();
 
   if (!node)
@@ skipping 49 matching lines @@
   return ToLocalFrame(parent_frame)
       ->GetEventHandler()
       .BubblingScroll(direction, granularity, frame_->DeprecatedLocalOwner());
 }
 
 void ScrollManager::SetFrameWasScrolledByUser() {
   if (DocumentLoader* document_loader = frame_->Loader().GetDocumentLoader())
     document_loader->GetInitialScrollState().was_scrolled_by_user = true;
 }
 
-void ScrollManager::CustomizedScroll(const Node& start_node,
-                                     ScrollState& scroll_state) {
+void ScrollManager::CustomizedScroll(ScrollState& scroll_state) {
   if (scroll_state.FullyConsumed())
     return;
 
   if (scroll_state.deltaX() || scroll_state.deltaY())
     frame_->GetDocument()->UpdateStyleAndLayoutIgnorePendingStylesheets();
 
-  if (current_scroll_chain_.empty())
-    RecomputeScrollChain(start_node, current_scroll_chain_);
+  DCHECK(!current_scroll_chain_.empty());
   scroll_state.SetScrollChain(current_scroll_chain_);
 
   scroll_state.distributeToScrollChainDescendant();
 }
 
 void ScrollManager::ComputeScrollRelatedMetrics(
     uint32_t* non_composited_main_thread_scrolling_reasons,
     int* scroller_size) {
   // When scrolling on the main thread, the scrollableArea may or may not be
   // composited. Either way, we have recorded either the reasons stored in
@@ skipping 105 matching lines @@
                          scroll_gesture_handling_node_->GetLayoutObject());
 
   RecordScrollRelatedMetrics(gesture_event.source_device);
 
   current_scroll_chain_.clear();
   std::unique_ptr<ScrollStateData> scroll_state_data =
       WTF::MakeUnique<ScrollStateData>();
   IntPoint position = FlooredIntPoint(gesture_event.PositionInRootFrame());
   scroll_state_data->position_x = position.X();
   scroll_state_data->position_y = position.Y();
+  scroll_state_data->delta_x_hint = -gesture_event.DeltaXInRootFrame();
+  scroll_state_data->delta_y_hint = -gesture_event.DeltaYInRootFrame();
   scroll_state_data->is_beginning = true;
   scroll_state_data->from_user_input = true;
   scroll_state_data->is_direct_manipulation =
       gesture_event.source_device == kWebGestureDeviceTouchscreen;
   scroll_state_data->delta_consumed_for_scroll_sequence =
       delta_consumed_for_scroll_sequence_;
   ScrollState* scroll_state = ScrollState::Create(std::move(scroll_state_data));
-  CustomizedScroll(*scroll_gesture_handling_node_.Get(), *scroll_state);
+  RecomputeScrollChain(*scroll_gesture_handling_node_.Get(), *scroll_state,
+                       current_scroll_chain_);
+  if (current_scroll_chain_.empty()) {
+    return WebInputEventResult::kNotHandled;
+  }
+  CustomizedScroll(*scroll_state);
 
   if (gesture_event.source_device == kWebGestureDeviceTouchscreen)
     UseCounter::Count(frame_->GetDocument(), UseCounter::kScrollByTouch);
   else
     UseCounter::Count(frame_->GetDocument(), UseCounter::kScrollByWheel);
 
   return WebInputEventResult::kHandledSystem;
 }
 
 WebInputEventResult ScrollManager::HandleGestureScrollUpdate(
@@ skipping 48 matching lines @@
       delta_consumed_for_scroll_sequence_;
   ScrollState* scroll_state = ScrollState::Create(std::move(scroll_state_data));
   if (previous_gesture_scrolled_element_) {
     // The ScrollState needs to know what the current
     // native scrolling element is, so that for an
     // inertial scroll that shouldn't propagate, only the
     // currently scrolling element responds.
     scroll_state->SetCurrentNativeScrollingElement(
         previous_gesture_scrolled_element_);
   }
-  CustomizedScroll(*node, *scroll_state);
+
+  if (current_scroll_chain_.empty())
+    return WebInputEventResult::kNotHandled;
+
+  CustomizedScroll(*scroll_state);
   previous_gesture_scrolled_element_ =
       scroll_state->CurrentNativeScrollingElement();
   delta_consumed_for_scroll_sequence_ =
       scroll_state->DeltaConsumedForScrollSequence();
 
   bool did_scroll_x = scroll_state->deltaX() != delta.Width();
   bool did_scroll_y = scroll_state->deltaY() != delta.Height();
 
   if ((!previous_gesture_scrolled_element_ ||
        !IsViewportScrollingElement(*previous_gesture_scrolled_element_)) &&
@@ skipping 20 matching lines @@
     scroll_state_data->is_ending = true;
     scroll_state_data->is_in_inertial_phase =
         gesture_event.InertialPhase() == WebGestureEvent::kMomentumPhase;
     scroll_state_data->from_user_input = true;
     scroll_state_data->is_direct_manipulation =
         gesture_event.source_device == kWebGestureDeviceTouchscreen;
     scroll_state_data->delta_consumed_for_scroll_sequence =
         delta_consumed_for_scroll_sequence_;
     ScrollState* scroll_state =
         ScrollState::Create(std::move(scroll_state_data));
-    CustomizedScroll(*node, *scroll_state);
+    if (!current_scroll_chain_.empty())
+      CustomizedScroll(*scroll_state);
   }
 
   ClearGestureScrollState();
   return WebInputEventResult::kNotHandled;
 }
 
 Page* ScrollManager::GetPage() const {
   return frame_->GetPage();
 }
 
@@ skipping 205 matching lines @@
                                 &should_update_capture)) {
       if (should_update_capture)
         scrollbar_handling_scroll_gesture_ = scrollbar;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace blink