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 62 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))

[bokan, 2017/06/19 21:43:17]

Do we have to do this after we've added our first element? i.e. Why do we have
to change the scroll chain computation apart from which element we latch to
initially?

[sahel, 2017/06/22 16:34:20]

Once scroll latching is enabled, we can get rid of the chain and only have one
target element. But, for now since it is still behind a flag, we still compute
the chain.

[bokan, 2017/06/22 21:44:37]

Right, but I don't mean making the chain just one element. I mean, shouldn't
this be `if (!scroll_chain.IsEmpty() || CanScroll())`? That is, once you've
added an element to the chain, we could just add the rest of the Elements as
usual I think. That said, I *think* it shouldn't make a difference.

Also though, why is it ok that this isn't behind a RuntimeEnabledFeature check?
Won't this change behavior for latching being off?

[sahel, 2017/06/23 18:22:03]

When scroll latching is off, there will be one GSB for each GSU, so for handling
each GSU we will only add elements to the chain that can at least partially
consume the delta hints on GSB which is identical to the GSU's actual deltas. In
terms of behavior it will be exactly the same while in terms of performance, we
are skipping the nodes that cannot consume any delta which means going up the
chain while handling GSU will be more efficient.

[bokan, 2017/06/23 18:56:44]

Right, thanks for the explanation.

+        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();
+  if (!delta_x && !delta_y)
+    return true;
+
+  if (scroll_state.ignoreDeltaHints()) {
+    DCHECK(scroll_state.isBeginning());
+    return true;
+  }
+
+  DCHECK(current_element);

[bokan, 2017/06/19 21:43:17]

Rather than DCHECK, just pass the Element by const ref.

[sahel, 2017/06/22 16:34:18]

Done.

+
+  if (IsViewportScrollingElement(*current_element))
+    return true;
+
+  if (current_element == frame_->GetDocument()->documentElement())
+    return true;
+
+  ScrollableArea* scrollable_area =
+      current_element->GetLayoutBox()
+          ? current_element->GetLayoutBox()->GetScrollableArea()
+          : nullptr;
+  if (!scrollable_area)
+    return false;
+
+  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,
     bool* scroller_size_updated) {
   // When scrolling on the main thread, the scrollableArea may or may not be
@@ skipping 104 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->ignore_delta_hints =
+      gesture_event.data.scroll_begin.ignore_delta_hints;
   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()) {

[bokan, 2017/06/19 21:43:17]

Nit: no {}

[sahel, 2017/06/22 16:34:18]

Done.

+    return WebInputEventResult::kNotHandled;
+  }
+  CustomizedScroll(*scroll_state);
 
   if (gesture_event.source_device == kWebGestureDeviceTouchscreen)
     UseCounter::Count(frame_->GetDocument(), WebFeature::kScrollByTouch);
   else
     UseCounter::Count(frame_->GetDocument(), WebFeature::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())

[bokan, 2017/06/19 21:43:17]

We can early out before creating and initializing the scroll_state_data.

[sahel, 2017/06/22 16:34:19]

Done.

+    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())

[bokan, 2017/06/19 21:43:17]

We should skip the scroll_state_data initialization above as well.

[sahel, 2017/06/22 16:34:18]

Done.

+      CustomizedScroll(*scroll_state);
   }
 
   ClearGestureScrollState();
   return WebInputEventResult::kNotHandled;
 }
 
 Page* ScrollManager::GetPage() const {
   return frame_->GetPage();
 }
 
@@ skipping 207 matching lines @@
                                 &should_update_capture)) {
       if (should_update_capture)
         scrollbar_handling_scroll_gesture_ = scrollbar;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace blink