Re-target wheel events only when a new scroll sequence has started.

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 195 matching lines @@
           this,
           &EventHandler::ActiveIntervalTimerFired) {}
 
 DEFINE_TRACE(EventHandler) {
   visitor->Trace(frame_);
   visitor->Trace(selection_controller_);
   visitor->Trace(capturing_mouse_events_node_);
   visitor->Trace(last_mouse_move_event_subframe_);
   visitor->Trace(last_scrollbar_under_mouse_);
   visitor->Trace(drag_target_);
+  visitor->Trace(wheel_target_);
   visitor->Trace(frame_set_being_resized_);
   visitor->Trace(scroll_manager_);
   visitor->Trace(mouse_event_manager_);
   visitor->Trace(keyboard_event_manager_);
   visitor->Trace(pointer_event_manager_);
   visitor->Trace(gesture_manager_);
   visitor->Trace(last_deferred_tap_element_);
 }
 
 void EventHandler::Clear() {
   hover_timer_.Stop();
   cursor_update_timer_.Stop();
   active_interval_timer_.Stop();
   last_mouse_move_event_subframe_ = nullptr;
   last_scrollbar_under_mouse_ = nullptr;
   frame_set_being_resized_ = nullptr;
   drag_target_ = nullptr;
+  wheel_target_ = nullptr;
   should_only_fire_drag_over_event_ = false;
   last_mouse_down_user_gesture_token_.Clear();
   capturing_mouse_events_node_ = nullptr;
   pointer_event_manager_->Clear();
   scroll_manager_->Clear();
   gesture_manager_->Clear();
   mouse_event_manager_->Clear();
   last_deferred_tap_element_ = nullptr;
   event_handler_will_reset_capturing_mouse_events_node_ = false;
 }
@@ skipping 1015 matching lines @@
          mouse_event_type == EventTypeNames::mouseup);
 
   const auto& event_result = pointer_event_manager_->SendMousePointerEvent(
       UpdateMouseEventTargetNode(target_node), canvas_region_id,
       mouse_event_type, mouse_event, coalesced_events);
   return event_result;
 }
 
 WebInputEventResult EventHandler::HandleWheelEvent(
     const WebMouseWheelEvent& event) {
+  bool wheel_scroll_latching =
+      RuntimeEnabledFeatures::TouchpadAndWheelScrollLatchingEnabled();
+
+  if (wheel_scroll_latching) {
+    const int kWheelEventPhaseNoEventMask =
+        WebMouseWheelEvent::kPhaseEnded | WebMouseWheelEvent::kPhaseCancelled |
+        WebMouseWheelEvent::kPhaseMayBegin;
+
+    if ((event.phase & kWheelEventPhaseNoEventMask) ||
+        (event.momentum_phase & kWheelEventPhaseNoEventMask)) {
+      // Filter wheel events with zero deltas and reset the wheel_target_ node.
+      DCHECK(!event.delta_x && !event.delta_y);
+      wheel_target_ = nullptr;
+      return WebInputEventResult::kNotHandled;
+    }
+
+    if (event.phase == WebMouseWheelEvent::kPhaseBegan) {
+      // Find and save the wheel_target_, this target will be used for the rest
+      // of the current scrolling sequence.
+      DCHECK(!wheel_target_);
+      Document* doc = frame_->GetDocument();
+
+      if (doc->GetLayoutViewItem().IsNull())
+        return WebInputEventResult::kNotHandled;
+
+      LocalFrameView* view = frame_->View();
+      if (!view)
+        return WebInputEventResult::kNotHandled;
+
+      LayoutPoint v_point = view->RootFrameToContents(
+          FlooredIntPoint(event.PositionInRootFrame()));
+
+      HitTestRequest request(HitTestRequest::kReadOnly);
+      HitTestResult result(request, v_point);
+      doc->GetLayoutViewItem().HitTest(result);
+
+      wheel_target_ = result.InnerNode();
+      // Wheel events should not dispatch to text nodes.
+      if (wheel_target_ && wheel_target_->IsTextNode())
+        wheel_target_ = FlatTreeTraversal::Parent(*wheel_target_);
+
+      // If we're over the frame scrollbar, scroll the document.
+      if (!wheel_target_ && result.GetScrollbar())
+        wheel_target_ = doc->documentElement();
+    }
+  } else {  // !wheel_scroll_latching, wheel_target_ will be updated for each
+            // wheel event.
 #if OS(MACOSX)
-  // Filter Mac OS specific phases, usually with a zero-delta.
-  // https://crbug.com/553732
-  // TODO(chongz): EventSender sends events with
-  // |WebMouseWheelEvent::PhaseNone|,
-  // but it shouldn't.
-  const int kWheelEventPhaseNoEventMask = WebMouseWheelEvent::kPhaseEnded |
-                                          WebMouseWheelEvent::kPhaseCancelled |
-                                          WebMouseWheelEvent::kPhaseMayBegin;
-  if ((event.phase & kWheelEventPhaseNoEventMask) ||
-      (event.momentum_phase & kWheelEventPhaseNoEventMask))
-    return WebInputEventResult::kNotHandled;
+    // Filter Mac OS specific phases, usually with a zero-delta.
+    // https://crbug.com/553732
+    // TODO(chongz): EventSender sends events with
+    // |WebMouseWheelEvent::PhaseNone|,
+    // but it shouldn't.
+    const int kWheelEventPhaseNoEventMask =
+        WebMouseWheelEvent::kPhaseEnded | WebMouseWheelEvent::kPhaseCancelled |
+        WebMouseWheelEvent::kPhaseMayBegin;
+    if ((event.phase & kWheelEventPhaseNoEventMask) ||
+        (event.momentum_phase & kWheelEventPhaseNoEventMask))
+      return WebInputEventResult::kNotHandled;
 #endif
-  Document* doc = frame_->GetDocument();
 
-  if (doc->GetLayoutViewItem().IsNull())
-    return WebInputEventResult::kNotHandled;
+    Document* doc = frame_->GetDocument();
 
-  LocalFrameView* view = frame_->View();
-  if (!view)
-    return WebInputEventResult::kNotHandled;
+    if (doc->GetLayoutViewItem().IsNull())
+      return WebInputEventResult::kNotHandled;
 
-  LayoutPoint v_point =
-      view->RootFrameToContents(FlooredIntPoint(event.PositionInRootFrame()));
+    LocalFrameView* view = frame_->View();
+    if (!view)
+      return WebInputEventResult::kNotHandled;
 
-  HitTestRequest request(HitTestRequest::kReadOnly);
-  HitTestResult result(request, v_point);
-  doc->GetLayoutViewItem().HitTest(result);
+    LayoutPoint v_point =
+        view->RootFrameToContents(FlooredIntPoint(event.PositionInRootFrame()));
 
-  Node* node = result.InnerNode();
-  // Wheel events should not dispatch to text nodes.
-  if (node && node->IsTextNode())
-    node = FlatTreeTraversal::Parent(*node);
+    HitTestRequest request(HitTestRequest::kReadOnly);
+    HitTestResult result(request, v_point);
+    doc->GetLayoutViewItem().HitTest(result);
 
-  // If we're over the frame scrollbar, scroll the document.
-  if (!node && result.GetScrollbar())
-    node = doc->documentElement();
+    Node* node = result.InnerNode();
+    // Wheel events should not dispatch to text nodes.
+    if (node && node->IsTextNode())
+      node = FlatTreeTraversal::Parent(*node);
 
-  LocalFrame* subframe = SubframeForTargetNode(node);
+    // If we're over the frame scrollbar, scroll the document.
+    if (!node && result.GetScrollbar())
+      node = doc->documentElement();
+
+    wheel_target_ = node;
+  }
+
+  LocalFrame* subframe = SubframeForTargetNode(wheel_target_.Get());
   if (subframe) {
     WebInputEventResult result =
         subframe->GetEventHandler().HandleWheelEvent(event);
     if (result != WebInputEventResult::kNotHandled)
       scroll_manager_->SetFrameWasScrolledByUser();
     return result;
   }
 
-  if (node) {
+  if (wheel_target_) {
     WheelEvent* dom_event =
-        WheelEvent::Create(event, node->GetDocument().domWindow());
-    DispatchEventResult dom_event_result = node->DispatchEvent(dom_event);
+        WheelEvent::Create(event, wheel_target_->GetDocument().domWindow());
+    DispatchEventResult dom_event_result =
+        wheel_target_->DispatchEvent(dom_event);
     if (dom_event_result != DispatchEventResult::kNotCanceled)
       return EventHandlingUtil::ToWebInputEventResult(dom_event_result);
   }
 
   return WebInputEventResult::kNotHandled;
 }
 
 WebInputEventResult EventHandler::HandleGestureEvent(
     const WebGestureEvent& gesture_event) {
   // Propagation to inner frames is handled below this function.
@@ skipping 819 matching lines @@
     MouseEventWithHitTestResults& mev,
     LocalFrame* subframe) {
   WebInputEventResult result =
       subframe->GetEventHandler().HandleMouseReleaseEvent(mev.Event());
   if (result != WebInputEventResult::kNotHandled)
     return result;
   return WebInputEventResult::kHandledSystem;
 }
 
 }  // namespace blink