Changeset 270712 in webkit

Timestamp:

Dec 11, 2020 2:59:22 PM (3 years ago)

Author:

timothy_horton@apple.com

Message:

Trackpad and Mouse scroll events on iPad only fire "pointermove" -- not "wheel"
​https://bugs.webkit.org/show_bug.cgi?id=210071
<rdar://problem/54616853>

Reviewed by Simon Fraser.

Source/WebCore:

• page/EventHandler.cpp:

(WebCore::EventHandler::handleWheelEventInternal):
Fix a minor logic error when WHEEL_EVENT_LATCHING is off; allowScrolling
would always be true, even if the set of processing steps does not include any scrolling steps.

• rendering/EventRegion.h:

(WebCore::EventRegion::encode const):
(WebCore::EventRegion::decode):
Encode/decode the wheel and passive wheel event regions.

Source/WebKit:

• Platform/spi/ios/UIKitSPI.h:

Add some SPI.

• Shared/ios/WebIOSEventFactory.h:
• Shared/ios/WebIOSEventFactory.mm:

(toWebPhase):
(WebIOSEventFactory::createWebWheelEvent):
Add a UIScrollEvent->WebWheelEvent conversion helper.

• UIProcess/API/Cocoa/WKWebViewInternal.h:
• UIProcess/API/ios/WKWebViewIOS.h:
• UIProcess/API/ios/WKWebViewIOS.mm:

(-[WKWebView _setupScrollAndContentViews]):
Enable async UIScrollEvent handling for WKScrollView.

(-[WKWebView _scrollView:asynchronouslyHandleScrollEvent:completion:]):
Adopt new UIKit SPI to asynchronously defer UIScrollEvents.
We pass them to the Web Content process, where they are processed
*only* for event handling, not for scrolling.

If the event is not cancelable, we will synchronously reply that it was
not handled; if it is cancelable, or we don't yet know if it will be,
we'll wait to hear back from the Web Content process before replying.

UIKit will wait until our reply to apply the UIScrollEvent to the UIScrollView.

• UIProcess/PageClient.h:
• UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.h:
• UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.mm:

(WebKit::eventListenerTypesAtPoint):
Expose a mechanism for retrieving the event listener types at a given point,
similar to the existing mechanism for touch event listeners.

(-[WKChildScrollView initWithFrame:]):
Enable async UIScrollEvent handling for WKChildScrollView.

• UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.h:
• UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm:

(-[WKScrollingNodeScrollViewDelegate _scrollView:asynchronouslyHandleScrollEvent:completion:]):
(WebKit::ScrollingTreeScrollingNodeDelegateIOS::handleAsynchronousCancelableScrollEvent):
Plumb async scroll events for sub-scrollable regions through PageClient
to WKWebView; we don't actually care which UIScrollView they're handed to,
since we re-hit-test ourselves.

• UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::dispatchWheelEventWithoutScrolling):

• UIProcess/WebPageProxy.h:
• UIProcess/ios/PageClientImplIOS.h:
• UIProcess/ios/PageClientImplIOS.mm:

(WebKit::PageClientImpl::handleAsynchronousCancelableScrollEvent):

• WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::wheelEvent):
(WebKit::WebPage::dispatchWheelEventWithoutScrolling):

• WebProcess/WebPage/WebPage.h:
• WebProcess/WebPage/WebPage.messages.in:

Source/WTF:

• wtf/PlatformEnableCocoa.h:

Enable wheel event regions on iOS + macCatalyst.

Tools:

• TestWebKitAPI/Tests/ios/WKScrollViewTests.mm:

(-[WKUIScrollEvent initWithPhase:location:delta:]):
(-[WKUIScrollEvent phase]):
(-[WKUIScrollEvent locationInView:]):
(-[WKUIScrollEvent _adjustedAcceleratedDeltaInView:]):
(TEST):

• TestWebKitAPI/ios/UIKitSPI.h:

Add a very simple test that directly calls the new UIScrollViewDelegate SPI
and verifies that only the first event is cancelable (unless the first event
is canceled, in which case all subsequent events are cancelable).

Location:

trunk

Files:

• Source/WTF/ChangeLog (modified) (1 diff)
• Source/WTF/wtf/PlatformEnableCocoa.h (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/page/EventHandler.cpp (modified) (1 diff)
• Source/WebCore/page/EventHandler.h (modified) (1 diff)
• Source/WebCore/rendering/EventRegion.h (modified) (3 diffs)
• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/Platform/spi/ios/UIKitSPI.h (modified) (2 diffs)
• Source/WebKit/Shared/ios/WebIOSEventFactory.h (modified) (2 diffs)
• Source/WebKit/Shared/ios/WebIOSEventFactory.mm (modified) (2 diffs)
• Source/WebKit/UIProcess/API/Cocoa/WKWebViewInternal.h (modified) (2 diffs)
• Source/WebKit/UIProcess/API/ios/WKWebViewIOS.h (modified) (3 diffs)
• Source/WebKit/UIProcess/API/ios/WKWebViewIOS.mm (modified) (4 diffs)
• Source/WebKit/UIProcess/PageClient.h (modified) (2 diffs)
• Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.h (modified) (1 diff)
• Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.mm (modified) (2 diffs)
• Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.h (modified) (1 diff)
• Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm (modified) (2 diffs)
• Source/WebKit/UIProcess/WebPageProxy.cpp (modified) (1 diff)
• Source/WebKit/UIProcess/WebPageProxy.h (modified) (1 diff)
• Source/WebKit/UIProcess/ios/PageClientImplIOS.h (modified) (1 diff)
• Source/WebKit/UIProcess/ios/PageClientImplIOS.mm (modified) (1 diff)
• Source/WebKit/WebProcess/WebPage/WebPage.cpp (modified) (2 diffs)
• Source/WebKit/WebProcess/WebPage/WebPage.h (modified) (2 diffs)
• Source/WebKit/WebProcess/WebPage/WebPage.messages.in (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/Tests/ios/WKScrollViewTests.mm (modified) (2 diffs)
• Tools/TestWebKitAPI/ios/UIKitSPI.h (modified) (2 diffs)

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2020-12-11  Tim Horton  <timothy_horton@apple.com>
+
+        Trackpad and Mouse scroll events on iPad only fire "pointermove" -- not "wheel"
+        https://bugs.webkit.org/show_bug.cgi?id=210071
+        <rdar://problem/54616853>
+
+        Reviewed by Simon Fraser.
+
+        * wtf/PlatformEnableCocoa.h:
+        Enable wheel event regions on iOS + macCatalyst.
+
 2020-12-11  Brent Fulgham  <bfulgham@apple.com>
 

trunk/Source/WTF/wtf/PlatformEnableCocoa.h

@@ -523 +523 @@
 #endif
 
-#if !defined(ENABLE_WHEEL_EVENT_REGIONS) && PLATFORM(MAC)
+#if !defined(ENABLE_WHEEL_EVENT_REGIONS) && (PLATFORM(MAC) || PLATFORM(IOS) || PLATFORM(MACCATALYST))
 #define ENABLE_WHEEL_EVENT_REGIONS 1
 #endif

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-12-11  Tim Horton  <timothy_horton@apple.com>
+
+        Trackpad and Mouse scroll events on iPad only fire "pointermove" -- not "wheel"
+        https://bugs.webkit.org/show_bug.cgi?id=210071
+        <rdar://problem/54616853>
+
+        Reviewed by Simon Fraser.
+
+        * page/EventHandler.cpp:
+        (WebCore::EventHandler::handleWheelEventInternal):
+        Fix a minor logic error when WHEEL_EVENT_LATCHING is off; allowScrolling
+        would always be true, even if the set of processing steps does not include any scrolling steps.
+
+        * rendering/EventRegion.h:
+        (WebCore::EventRegion::encode const):
+        (WebCore::EventRegion::decode):
+        Encode/decode the wheel and passive wheel event regions.
+
 2020-12-11  Peng Liu  <peng.liu6@apple.com>
 

trunk/Source/WebCore/page/EventHandler.cpp

@@ -2915 +2915 @@
 
     bool handledEvent = false;
-    bool allowScrolling = true;
+    bool allowScrolling = m_currentWheelEventAllowsScrolling;
+
 #if ENABLE(WHEEL_EVENT_LATCHING)
-    allowScrolling = m_currentWheelEventAllowsScrolling && m_frame.page()->scrollLatchingController().latchingAllowsScrollingInFrame(m_frame, scrollableArea);
-#endif
+    if (allowScrolling)
+        allowScrolling = m_frame.page()->scrollLatchingController().latchingAllowsScrollingInFrame(m_frame, scrollableArea);
+#endif
+
     if (allowScrolling) {
         // FIXME: processWheelEventForScrolling() is only called for FrameView scrolling, not overflow scrolling, which is confusing.

trunk/Source/WebCore/page/EventHandler.h

@@ -347 +347 @@
     WEBCORE_EXPORT Optional<Cursor> selectCursor(const HitTestResult&, bool shiftKey);
 
+#if ENABLE(KINETIC_SCROLLING)
+    Optional<WheelScrollGestureState> wheelScrollGestureState() const { return m_wheelScrollGestureState; }
+#endif
+
 #if ENABLE(DRAG_SUPPORT)
     Element* draggingElement() const;

trunk/Source/WebCore/rendering/EventRegion.h

@@ -83 +83 @@
 
 #if ENABLE(WHEEL_EVENT_REGIONS)
-    OptionSet<EventListenerRegionType> eventListenerRegionTypesForPoint(const IntPoint&) const;
+    WEBCORE_EXPORT OptionSet<EventListenerRegionType> eventListenerRegionTypesForPoint(const IntPoint&) const;
     const Region& eventListenerRegionForType(EventListenerRegionType) const;
 #endif
@@ -126 +126 @@
 {
     encoder << m_region;
+#if ENABLE(WHEEL_EVENT_REGIONS)
+    encoder << m_wheelEventListenerRegion;
+    encoder << m_nonPassiveWheelEventListenerRegion;
+#endif
 #if ENABLE(TOUCH_ACTION_REGIONS)
     encoder << m_touchActionRegions;
@@ -144 +148 @@
     EventRegion eventRegion;
     eventRegion.m_region = WTFMove(*region);
+
+#if ENABLE(WHEEL_EVENT_REGIONS)
+    Optional<Region> wheelEventListenerRegion;
+    decoder >> wheelEventListenerRegion;
+    if (!wheelEventListenerRegion)
+        return WTF::nullopt;
+
+    eventRegion.m_wheelEventListenerRegion = WTFMove(*wheelEventListenerRegion);
+
+    Optional<Region> nonPassiveWheelEventListenerRegion;
+    decoder >> nonPassiveWheelEventListenerRegion;
+    if (!nonPassiveWheelEventListenerRegion)
+        return WTF::nullopt;
+
+    eventRegion.m_nonPassiveWheelEventListenerRegion = WTFMove(*nonPassiveWheelEventListenerRegion);
+#endif
 
 #if ENABLE(TOUCH_ACTION_REGIONS)

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2020-12-11  Tim Horton  <timothy_horton@apple.com>
+
+        Trackpad and Mouse scroll events on iPad only fire "pointermove" -- not "wheel"
+        https://bugs.webkit.org/show_bug.cgi?id=210071
+        <rdar://problem/54616853>
+
+        Reviewed by Simon Fraser.
+
+        * Platform/spi/ios/UIKitSPI.h:
+        Add some SPI.
+
+        * Shared/ios/WebIOSEventFactory.h:
+        * Shared/ios/WebIOSEventFactory.mm:
+        (toWebPhase):
+        (WebIOSEventFactory::createWebWheelEvent):
+        Add a UIScrollEvent->WebWheelEvent conversion helper.
+
+        * UIProcess/API/Cocoa/WKWebViewInternal.h:
+        * UIProcess/API/ios/WKWebViewIOS.h:
+        * UIProcess/API/ios/WKWebViewIOS.mm:
+        (-[WKWebView _setupScrollAndContentViews]):
+        Enable async UIScrollEvent handling for WKScrollView.
+
+        (-[WKWebView _scrollView:asynchronouslyHandleScrollEvent:completion:]):
+        Adopt new UIKit SPI to asynchronously defer UIScrollEvents.
+        We pass them to the Web Content process, where they are processed 
+        *only* for event handling, not for scrolling.
+
+        If the event is not cancelable, we will synchronously reply that it was
+        not handled; if it is cancelable, or we don't yet know if it will be,
+        we'll wait to hear back from the Web Content process before replying.
+
+        UIKit will wait until our reply to apply the UIScrollEvent to the UIScrollView.
+
+        * UIProcess/PageClient.h:
+        * UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.h:
+        * UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.mm:
+        (WebKit::eventListenerTypesAtPoint):
+        Expose a mechanism for retrieving the event listener types at a given point,
+        similar to the existing mechanism for touch event listeners.
+
+        (-[WKChildScrollView initWithFrame:]):
+        Enable async UIScrollEvent handling for WKChildScrollView.
+
+        * UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.h:
+        * UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm:
+        (-[WKScrollingNodeScrollViewDelegate _scrollView:asynchronouslyHandleScrollEvent:completion:]):
+        (WebKit::ScrollingTreeScrollingNodeDelegateIOS::handleAsynchronousCancelableScrollEvent):
+        Plumb async scroll events for sub-scrollable regions through PageClient
+        to WKWebView; we don't actually care which UIScrollView they're handed to,
+        since we re-hit-test ourselves.
+
+        * UIProcess/WebPageProxy.cpp:
+        (WebKit::WebPageProxy::dispatchWheelEventWithoutScrolling):
+        * UIProcess/WebPageProxy.h:
+        * UIProcess/ios/PageClientImplIOS.h:
+        * UIProcess/ios/PageClientImplIOS.mm:
+        (WebKit::PageClientImpl::handleAsynchronousCancelableScrollEvent):
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit::WebPage::wheelEvent):
+        (WebKit::WebPage::dispatchWheelEventWithoutScrolling):
+        * WebProcess/WebPage/WebPage.h:
+        * WebProcess/WebPage/WebPage.messages.in:
+
 2020-12-11  Brent Fulgham  <bfulgham@apple.com>
 

trunk/Source/WebKit/Platform/spi/ios/UIKitSPI.h

@@ -63 +63 @@
 #import <UIKit/UIResponder_Private.h>
 #import <UIKit/UIScene_Private.h>
+#import <UIKit/UIScrollEvent_Private.h>
+#import <UIKit/UIScrollView_ForWebKitOnly.h>
 #import <UIKit/UIScrollView_Private.h>
 #import <UIKit/UIStringDrawing_Private.h>
@@ -417 +419 @@
 @property (nonatomic, readonly) UIEdgeInsets _systemContentInset;
 @property (nonatomic, readonly) UIEdgeInsets _effectiveContentInset;
-@end
+@property (nonatomic, getter=_allowsAsyncScrollEvent, setter=_setAllowsAsyncScrollEvent:) BOOL _allowsAsyncScrollEvent;
+@end
+
+typedef NS_ENUM(NSUInteger, UIScrollPhase) {
+    UIScrollPhaseNone,
+    UIScrollPhaseMayBegin,
+    UIScrollPhaseBegan,
+    UIScrollPhaseChanged,
+    UIScrollPhaseEnded,
+    UIScrollPhaseCancelled
+};
+
+@interface UIScrollEvent : UIEvent
+
+@property (assign, readonly) UIScrollPhase phase;
+- (CGPoint)locationInView:(UIView *)view;
+- (CGVector)_adjustedAcceleratedDeltaInView:(UIView *)view;
+
+@end
+
 
 @interface NSString (UIKitDetails)

trunk/Source/WebKit/Shared/ios/WebIOSEventFactory.h

@@ -30 +30 @@
 #import "WebKeyboardEvent.h"
 #import "WebMouseEvent.h"
+#import "WebWheelEvent.h"
 #import <UIKit/UIKit.h>
 #import <WebCore/WebEvent.h>
+
+OBJC_CLASS UIScrollEvent;
 
 class WebIOSEventFactory {
@@ -37 +40 @@
     static WebKit::WebKeyboardEvent createWebKeyboardEvent(::WebEvent *, bool handledByInputMethod);
     static WebKit::WebMouseEvent createWebMouseEvent(::WebEvent *);
+    static WebKit::WebWheelEvent createWebWheelEvent(UIScrollEvent *, UIView *contentView);
 
     static UIKeyModifierFlags toUIKeyModifierFlags(OptionSet<WebKit::WebEvent::Modifier>);

trunk/Source/WebKit/Shared/ios/WebIOSEventFactory.mm

@@ -29 +29 @@
 #if PLATFORM(IOS_FAMILY)
 
+#import "UIKitSPI.h"
 #import <WebCore/KeyEventCodesIOS.h>
 #import <WebCore/PlatformEventFactoryIOS.h>
@@ -131 +132 @@
 }
 
+static WebKit::WebWheelEvent::Phase toWebPhase(UIScrollPhase phase)
+{
+    switch (phase) {
+    case UIScrollPhaseNone:
+        return WebKit::WebWheelEvent::PhaseNone;
+    case UIScrollPhaseMayBegin:
+        return WebKit::WebWheelEvent::PhaseMayBegin;
+    case UIScrollPhaseBegan:
+        return WebKit::WebWheelEvent::PhaseBegan;
+    case UIScrollPhaseChanged:
+        return WebKit::WebWheelEvent::PhaseChanged;
+    case UIScrollPhaseEnded:
+        return WebKit::WebWheelEvent::PhaseEnded;
+    case UIScrollPhaseCancelled:
+        return WebKit::WebWheelEvent::PhaseCancelled;
+    default:
+        ASSERT_NOT_REACHED();
+        return WebKit::WebWheelEvent::PhaseNone;
+    }
+}
+
+WebKit::WebWheelEvent WebIOSEventFactory::createWebWheelEvent(UIScrollEvent *event, UIView *contentView)
+{
+    WebCore::IntPoint scrollLocation = WebCore::roundedIntPoint([event locationInView:contentView]);
+    CGVector deltaVector = [event _adjustedAcceleratedDeltaInView:contentView];
+    WebCore::FloatSize delta(deltaVector.dx, deltaVector.dy);
+
+    return {
+        WebKit::WebEvent::Wheel,
+        scrollLocation,
+        scrollLocation,
+        delta,
+        { } /* wheelTicks */,
+        WebKit::WebWheelEvent::Granularity::ScrollByPixelWheelEvent,
+        false,
+        toWebPhase(event.phase),
+        WebKit::WebWheelEvent::PhaseNone,
+        true,
+        1,
+        delta,
+        { },
+        MonotonicTime::fromRawSeconds(event.timestamp).approximateWallTime()
+    };
+}
+
 #endif // PLATFORM(IOS_FAMILY)

trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebViewInternal.h

@@ -66 +66 @@
 }
 
+namespace WebCore {
+enum class WheelScrollGestureState : uint8_t;
+}
+
 namespace WebKit {
 enum class ContinueUnsafeLoad : bool;
@@ -230 +234 @@
     BOOL _visibleContentRectUpdateScheduledFromScrollViewInStableState;
 
+    Optional<WebCore::WheelScrollGestureState> _currentScrollGestureState;
+
     _WKDragInteractionPolicy _dragInteractionPolicy;
 

trunk/Source/WebKit/UIProcess/API/ios/WKWebViewIOS.h

@@ -25 +25 @@
 
 #import "WKWebViewInternal.h"
+
+@class UIScrollEvent;
 
 #if PLATFORM(IOS_FAMILY)
@@ -126 +128 @@
 - (void)_updateScrollViewInsetAdjustmentBehavior;
 
+- (BOOL)_effectiveAppearanceIsDark;
+- (BOOL)_effectiveUserInterfaceLevelIsElevated;
+
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+- (void)_scrollView:(UIScrollView *)scrollView asynchronouslyHandleScrollEvent:(UIScrollEvent *)scrollEvent completion:(void (^)(BOOL handled))completion;
+#endif
+
 @property (nonatomic, readonly) WKPasswordView *_passwordView;
 @property (nonatomic, readonly) WKWebViewContentProviderRegistry *_contentProviderRegistry;
@@ -138 +147 @@
 @property (nonatomic, readonly) int32_t _deviceOrientation;
 
-- (BOOL)_effectiveAppearanceIsDark;
-- (BOOL)_effectiveUserInterfaceLevelIsElevated;
-
 @end
 

trunk/Source/WebKit/UIProcess/API/ios/WKWebViewIOS.mm

@@ -30 +30 @@
 
 #import "FrontBoardServicesSPI.h"
+#import "NativeWebWheelEvent.h"
 #import "NavigationState.h"
 #import "RemoteLayerTreeDrawingAreaProxy.h"
 #import "RemoteLayerTreeScrollingPerformanceData.h"
+#import "RemoteLayerTreeViews.h"
 #import "RemoteScrollingCoordinatorProxy.h"
 #import "VideoFullscreenManagerProxy.h"
@@ -48 +50 @@
 #import "WKWebViewPrivateForTestingIOS.h"
 #import "WebBackForwardList.h"
+#import "WebIOSEventFactory.h"
 #import "WebPageProxy.h"
 #import "_WKActivatedElementInfoInternal.h"
@@ -141 +144 @@
     [_scrollView setInternalDelegate:self];
     [_scrollView setBouncesZoom:YES];
+
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+    [_scrollView _setAllowsAsyncScrollEvent:YES];
+#endif
 
     if ([_scrollView respondsToSelector:@selector(_setAvoidsJumpOnInterruptedBounce:)]) {
@@ -1593 +1600 @@
 }
 
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+- (void)_scrollView:(UIScrollView *)scrollView asynchronouslyHandleScrollEvent:(UIScrollEvent *)scrollEvent completion:(void (^)(BOOL handled))completion
+{
+    if (scrollEvent.phase == UIScrollPhaseMayBegin) {
+        completion(NO);
+        return;
+    }
+
+    WebCore::IntPoint scrollLocation = WebCore::roundedIntPoint([scrollEvent locationInView:_contentView.get()]);
+    auto eventListeners = WebKit::eventListenerTypesAtPoint(_contentView.get(), scrollLocation);
+    bool hasWheelHandlers = eventListeners.contains(WebCore::EventListenerRegionType::Wheel);
+    if (!hasWheelHandlers) {
+        completion(NO);
+        return;
+    }
+
+    bool isFirstEventInGesture = scrollEvent.phase == UIScrollPhaseBegan;
+    if (isFirstEventInGesture)
+        _currentScrollGestureState = WTF::nullopt;
+
+    bool hasActiveWheelHandlers = eventListeners.contains(WebCore::EventListenerRegionType::NonPassiveWheel);
+    bool isCancelable = hasActiveWheelHandlers && (!_currentScrollGestureState || _currentScrollGestureState == WebCore::WheelScrollGestureState::Blocking);
+    auto event = WebIOSEventFactory::createWebWheelEvent(scrollEvent, _contentView.get());
+
+    _page->dispatchWheelEventWithoutScrolling(event, [weakSelf = WeakObjCPtr<WKWebView>(self), strongCompletion = makeBlockPtr(completion), isCancelable, isFirstEventInGesture](bool handled) {
+        auto strongSelf = weakSelf.get();
+        if (!strongSelf) {
+            strongCompletion(NO);
+            return;
+        }
+
+        if (isCancelable) {
+            if (isFirstEventInGesture)
+                strongSelf->_currentScrollGestureState = handled ? WebCore::WheelScrollGestureState::Blocking : WebCore::WheelScrollGestureState::NonBlocking;
+            strongCompletion(handled);
+        }
+    });
+
+    if (!isCancelable)
+        completion(NO);
+}
+#endif // HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+
 - (void)scrollViewDidScroll:(UIScrollView *)scrollView
 {

trunk/Source/WebKit/UIProcess/PageClient.h

@@ -66 +66 @@
 OBJC_CLASS NSTextAlternatives;
 OBJC_CLASS UIGestureRecognizer;
+OBJC_CLASS UIScrollEvent;
+OBJC_CLASS UIScrollView;
 OBJC_CLASS _WKRemoteObjectRegistry;
 
@@ -464 +466 @@
 
     virtual void handleAutocorrectionContext(const WebAutocorrectionContext&) = 0;
+
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+    virtual void handleAsynchronousCancelableScrollEvent(UIScrollView *, UIScrollEvent *, void (^completion)(BOOL handled)) = 0;
+#endif
 #endif
 

trunk/Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.h

@@ -72 +72 @@
 UIScrollView *findActingScrollParent(UIScrollView *, const RemoteLayerTreeHost&);
 
+OptionSet<WebCore::EventListenerRegionType> eventListenerTypesAtPoint(UIView *rootView, const WebCore::IntPoint&);
+
 #if ENABLE(EDITABLE_REGION)
 bool mayContainEditableElementsInRect(UIView *rootView, const WebCore::FloatRect&);

trunk/Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.mm

@@ -206 +206 @@
 }
 
+#if ENABLE(WHEEL_EVENT_REGIONS)
+OptionSet<WebCore::EventListenerRegionType> eventListenerTypesAtPoint(UIView *rootView, const WebCore::IntPoint& point)
+{
+    Vector<UIView *, 16> viewsAtPoint;
+    collectDescendantViewsAtPoint(viewsAtPoint, rootView, point, nil);
+
+    if (viewsAtPoint.isEmpty())
+        return { };
+
+    UIView *hitView = nil;
+    for (auto *view : WTF::makeReversedRange(viewsAtPoint)) {
+        if ([view isKindOfClass:[WKCompositingView class]]) {
+            hitView = view;
+            break;
+        }
+    }
+
+    if (!hitView)
+        return { };
+
+    CGPoint hitViewPoint = [hitView convertPoint:point fromView:rootView];
+
+    auto* node = RemoteLayerTreeNode::forCALayer(hitView.layer);
+    if (!node)
+        return { };
+
+    return node->eventRegion().eventListenerRegionTypesForPoint(WebCore::IntPoint(hitViewPoint));
+}
+#endif
+
 UIScrollView *findActingScrollParent(UIScrollView *scrollView, const RemoteLayerTreeHost& host)
 {
@@ -405 +435 @@
 #endif
 
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+    [self _setAllowsAsyncScrollEvent:YES];
+#endif
+
     return self;
 }

trunk/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.h

@@ -66 +66 @@
     void repositionScrollingLayers();
 
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+    void handleAsynchronousCancelableScrollEvent(UIScrollView *, UIScrollEvent *, void (^completion)(BOOL handled));
+#endif
+
     OptionSet<WebCore::TouchAction> activeTouchActions() const { return m_activeTouchActions; }
     void computeActiveTouchActionsForGestureRecognizer(UIGestureRecognizer*);

trunk/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm

@@ -177 +177 @@
 }
 
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+- (void)_scrollView:(UIScrollView *)scrollView asynchronouslyHandleScrollEvent:(UIScrollEvent *)scrollEvent completion:(void (^)(BOOL handled))completion
+{
+    _scrollingTreeNodeDelegate->handleAsynchronousCancelableScrollEvent(scrollView, scrollEvent, completion);
+}
+#endif
+
 - (void)scrollViewWillBeginZooming:(UIScrollView *)scrollView withView:(UIView *)view
 {
@@ -299 +306 @@
 }
 
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+void ScrollingTreeScrollingNodeDelegateIOS::handleAsynchronousCancelableScrollEvent(UIScrollView *scrollView, UIScrollEvent *scrollEvent, void (^completion)(BOOL handled))
+{
+    auto& scrollingCoordinatorProxy = downcast<WebKit::RemoteScrollingTree>(scrollingTree()).scrollingCoordinatorProxy();
+    scrollingCoordinatorProxy.webPageProxy().pageClient().handleAsynchronousCancelableScrollEvent(scrollView, scrollEvent, completion);
+}
+#endif
+
 void ScrollingTreeScrollingNodeDelegateIOS::repositionScrollingLayers()
 {

trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

@@ -2639 +2639 @@
 }
 
+void WebPageProxy::dispatchWheelEventWithoutScrolling(const WebWheelEvent& event, CompletionHandler<void(bool)>&& completionHandler)
+{
+    sendWithAsyncReply(Messages::WebPage::DispatchWheelEventWithoutScrolling(event), WTFMove(completionHandler));
+}
+
 void WebPageProxy::handleWheelEvent(const NativeWebWheelEvent& event)
 {

trunk/Source/WebKit/UIProcess/WebPageProxy.h

@@ -1847 +1847 @@
 #endif
 
+    void dispatchWheelEventWithoutScrolling(const WebWheelEvent&, CompletionHandler<void(bool)>&&);
+
 private:
     WebPageProxy(PageClient&, WebProcessProxy&, Ref<API::PageConfiguration>&&);

trunk/Source/WebKit/UIProcess/ios/PageClientImplIOS.h

@@ -272 +272 @@
     void showDictationAlternativeUI(const WebCore::FloatRect&, WebCore::DictationContext) final;
 
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+    void handleAsynchronousCancelableScrollEvent(UIScrollView *, UIScrollEvent *, void (^completion)(BOOL handled)) final;
+#endif
+
     WeakObjCPtr<WKContentView> m_contentView;
     RetainPtr<WKEditorUndoTarget> m_undoTarget;

trunk/Source/WebKit/UIProcess/ios/PageClientImplIOS.mm

@@ -962 +962 @@
 }
 
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+void PageClientImpl::handleAsynchronousCancelableScrollEvent(UIScrollView *scrollView, UIScrollEvent *scrollEvent, void (^completion)(BOOL handled))
+{
+    [m_webView _scrollView:scrollView asynchronouslyHandleScrollEvent:scrollEvent completion:completion];
+}
+#endif
+
 } // namespace WebKit
 

trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

@@ -2871 +2871 @@
 }
 
-void WebPage::wheelEvent(const WebWheelEvent& wheelEvent, OptionSet<WheelEventProcessingSteps> processingSteps)
+bool WebPage::wheelEvent(const WebWheelEvent& wheelEvent, OptionSet<WheelEventProcessingSteps> processingSteps)
 {
     m_userActivity.impulse();
@@ -2881 +2881 @@
     if (processingSteps.contains(WheelEventProcessingSteps::MainThreadForScrolling))
         send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(wheelEvent.type()), handled));
+
+    return handled;
+}
+
+void WebPage::dispatchWheelEventWithoutScrolling(const WebWheelEvent& wheelEvent, CompletionHandler<void(bool)>&& completionHandler)
+{
+#if ENABLE(KINETIC_SCROLLING)
+    auto gestureState = m_page->mainFrame().eventHandler().wheelScrollGestureState();
+    bool isCancelable = !gestureState || gestureState == WheelScrollGestureState::Blocking;
+#else
+    bool isCancelable = true;
+#endif
+    bool handled = this->wheelEvent(wheelEvent, { isCancelable ? WheelEventProcessingSteps::MainThreadForBlockingDOMEventDispatch : WheelEventProcessingSteps::MainThreadForNonBlockingDOMEventDispatch });
+    completionHandler(handled);
 }
 

trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

@@ -1014 +1014 @@
 #endif
 
-    void wheelEvent(const WebWheelEvent&, OptionSet<WebCore::WheelEventProcessingSteps>);
+    bool wheelEvent(const WebWheelEvent&, OptionSet<WebCore::WheelEventProcessingSteps>);
 
     void wheelEventHandlersChanged(bool);
@@ -1371 +1371 @@
     bool createAppHighlightInSelectedRange(CreateNewGroupForHighlight);
 #endif
+
+    void dispatchWheelEventWithoutScrolling(const WebWheelEvent&, CompletionHandler<void(bool)>&&);
 
 private:

trunk/Source/WebKit/WebProcess/WebPage/WebPage.messages.in

@@ -622 +622 @@
 #endif
 
+    DispatchWheelEventWithoutScrolling(WebKit::WebWheelEvent event) -> (bool handled) Async
 }

trunk/Tools/ChangeLog

@@ +1 @@
+2020-12-11  Tim Horton  <timothy_horton@apple.com>
+
+        Trackpad and Mouse scroll events on iPad only fire "pointermove" -- not "wheel"
+        https://bugs.webkit.org/show_bug.cgi?id=210071
+        <rdar://problem/54616853>
+
+        Reviewed by Simon Fraser.
+
+        * TestWebKitAPI/Tests/ios/WKScrollViewTests.mm:
+        (-[WKUIScrollEvent initWithPhase:location:delta:]):
+        (-[WKUIScrollEvent phase]):
+        (-[WKUIScrollEvent locationInView:]):
+        (-[WKUIScrollEvent _adjustedAcceleratedDeltaInView:]):
+        (TEST):
+        * TestWebKitAPI/ios/UIKitSPI.h:
+        Add a very simple test that directly calls the new UIScrollViewDelegate SPI
+        and verifies that only the first event is cancelable (unless the first event
+        is canceled, in which case all subsequent events are cancelable).
+
 2020-12-11  Jonathan Bedard  <jbedard@apple.com>
 

trunk/Tools/TestWebKitAPI/Tests/ios/WKScrollViewTests.mm

@@ -30 +30 @@
 #import "PlatformUtilities.h"
 #import "TestWKWebView.h"
+#import "UIKitSPI.h"
 #import <WebKit/WKWebViewPrivate.h>
+
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+@interface WKUIScrollEvent : UIScrollEvent
+
+- (instancetype)initWithPhase:(UIScrollPhase)phase location:(CGPoint)location delta:(CGVector)delta;
+
+@end
+
+@implementation WKUIScrollEvent {
+    UIScrollPhase _phase;
+    CGPoint _location;
+    CGVector _delta;
+}
+
+- (instancetype)initWithPhase:(UIScrollPhase)phase location:(CGPoint)location delta:(CGVector)delta
+{
+    self = [super init];
+    if (!self)
+        return nil;
+
+    _phase = phase;
+    _location = location;
+    _delta = delta;
+
+    return self;
+}
+
+- (UIScrollPhase)phase
+{
+    return _phase;
+}
+
+- (CGPoint)locationInView:(UIView *)view
+{
+    return _location;
+}
+
+- (CGVector)_adjustedAcceleratedDeltaInView:(UIView *)view
+{
+    return _delta;
+}
+
+@end
+#endif // HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
 
 static void traverseLayerTree(CALayer *layer, void(^block)(CALayer *))
@@ -72 +117 @@
 }
 
+#if HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+TEST(WKScrollViewTests, AsynchronousWheelEventHandling)
+{
+    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:CGRectMake(0, 0, 320, 500)]);
+    [webView synchronouslyLoadHTMLString:@""
+        "<style>#handler { width: 200px; height: 200px; }</style>"
+        "<div id='handler'></div>"
+        "<script>window.preventDefaultOnScrollEvents = false;"
+        "document.getElementById('handler').addEventListener('wheel', "
+        "function (e) {"
+        "   window.lastWheelEvent = e;"
+        "   if (window.preventDefaultOnScrollEvents)"
+        "       e.preventDefault();"
+        "})</script>"];
+    [webView waitForNextPresentationUpdate];
+
+    __block bool done;
+    __block bool wasHandled;
+
+    auto synchronouslyHandleScrollEvent = ^(UIScrollPhase phase, CGPoint location, CGVector delta) {
+        done = false;
+        auto event = adoptNS([[WKUIScrollEvent alloc] initWithPhase:phase location:location delta:delta]);
+        [webView _scrollView:[webView scrollView] asynchronouslyHandleScrollEvent:event.get() completion:^(BOOL handled) {
+            wasHandled = handled;
+            done = true;
+        }];
+        TestWebKitAPI::Util::run(&done);
+    };
+
+    // Don't preventDefault() at all.
+    synchronouslyHandleScrollEvent(UIScrollPhaseMayBegin, CGPointMake(100, 100), CGVectorMake(0, 0));
+    EXPECT_FALSE(wasHandled);
+    synchronouslyHandleScrollEvent(UIScrollPhaseBegan, CGPointMake(100, 100), CGVectorMake(0, 10));
+    EXPECT_FALSE(wasHandled);
+    EXPECT_TRUE([[webView objectByEvaluatingJavaScript:@"window.lastWheelEvent.cancelable"] intValue]);
+    EXPECT_EQ(-10, [[webView objectByEvaluatingJavaScript:@"window.lastWheelEvent.deltaY"] intValue]);
+    synchronouslyHandleScrollEvent(UIScrollPhaseChanged, CGPointMake(100, 100), CGVectorMake(0, 10));
+    EXPECT_FALSE(wasHandled);
+    synchronouslyHandleScrollEvent(UIScrollPhaseEnded, CGPointMake(100, 100), CGVectorMake(0, 0));
+    EXPECT_FALSE(wasHandled);
+
+    // preventDefault() on all events.
+    [webView stringByEvaluatingJavaScript:@"window.preventDefaultOnScrollEvents = true;"];
+    synchronouslyHandleScrollEvent(UIScrollPhaseMayBegin, CGPointMake(100, 100), CGVectorMake(0, 0));
+    EXPECT_FALSE(wasHandled);
+    synchronouslyHandleScrollEvent(UIScrollPhaseBegan, CGPointMake(100, 100), CGVectorMake(0, 10));
+    EXPECT_TRUE(wasHandled);
+    synchronouslyHandleScrollEvent(UIScrollPhaseChanged, CGPointMake(100, 100), CGVectorMake(0, 10));
+    EXPECT_TRUE(wasHandled);
+    synchronouslyHandleScrollEvent(UIScrollPhaseEnded, CGPointMake(100, 100), CGVectorMake(0, 0));
+    EXPECT_FALSE(wasHandled);
+
+    // preventDefault() on all but the begin event; it will be ignored.
+    [webView stringByEvaluatingJavaScript:@"window.preventDefaultOnScrollEvents = false;"];
+    synchronouslyHandleScrollEvent(UIScrollPhaseMayBegin, CGPointMake(100, 100), CGVectorMake(0, 0));
+    EXPECT_FALSE(wasHandled);
+    synchronouslyHandleScrollEvent(UIScrollPhaseBegan, CGPointMake(100, 100), CGVectorMake(0, 10));
+    EXPECT_TRUE([[webView objectByEvaluatingJavaScript:@"window.lastWheelEvent.cancelable"] intValue]);
+    EXPECT_FALSE(wasHandled);
+    [webView stringByEvaluatingJavaScript:@"window.preventDefaultOnScrollEvents = true;"];
+    synchronouslyHandleScrollEvent(UIScrollPhaseChanged, CGPointMake(100, 100), CGVectorMake(0, 10));
+    EXPECT_FALSE(wasHandled);
+    EXPECT_FALSE([[webView objectByEvaluatingJavaScript:@"window.lastWheelEvent.cancelable"] intValue]);
+    synchronouslyHandleScrollEvent(UIScrollPhaseEnded, CGPointMake(100, 100), CGVectorMake(0, 0));
+    EXPECT_FALSE(wasHandled);
+
+    // preventDefault() on the begin event, and some subsequent events.
+    [webView stringByEvaluatingJavaScript:@"window.preventDefaultOnScrollEvents = true;"];
+    synchronouslyHandleScrollEvent(UIScrollPhaseMayBegin, CGPointMake(100, 100), CGVectorMake(0, 0));
+    EXPECT_FALSE(wasHandled);
+    synchronouslyHandleScrollEvent(UIScrollPhaseBegan, CGPointMake(100, 100), CGVectorMake(0, 10));
+    EXPECT_TRUE(wasHandled);
+    synchronouslyHandleScrollEvent(UIScrollPhaseChanged, CGPointMake(100, 100), CGVectorMake(0, 10));
+    EXPECT_TRUE(wasHandled);
+    [webView stringByEvaluatingJavaScript:@"window.preventDefaultOnScrollEvents = false;"];
+    synchronouslyHandleScrollEvent(UIScrollPhaseChanged, CGPointMake(100, 100), CGVectorMake(0, 10));
+    EXPECT_FALSE(wasHandled);
+    synchronouslyHandleScrollEvent(UIScrollPhaseEnded, CGPointMake(100, 100), CGVectorMake(0, 0));
+    EXPECT_FALSE(wasHandled);
+}
+#endif // HAVE(UISCROLLVIEW_ASYNCHRONOUS_SCROLL_EVENT_HANDLING)
+
 #endif // PLATFORM(IOS_FAMILY)

trunk/Tools/TestWebKitAPI/ios/UIKitSPI.h

@@ -38 +38 @@
 #import <UIKit/UIResponder_Private.h>
 #import <UIKit/UIScreen_Private.h>
+#import <UIKit/UIScrollEvent_Private.h>
+#import <UIKit/UIScrollView_ForWebKitOnly.h>
 #import <UIKit/UIScrollView_Private.h>
 #import <UIKit/UITextAutofillSuggestion.h>
@@ -241 +243 @@
 @end
 
+@interface UIScrollEvent : UIEvent
+@end
+
+@interface NSObject (UIScrollViewDelegate_ForWebKitOnly)
+- (void)_scrollView:(UIScrollView *)scrollView asynchronouslyHandleScrollEvent:(UIScrollEvent *)scrollEvent completion:(void (^)(BOOL handled))completion;
+@end
+
 #endif // USE(APPLE_INTERNAL_SDK)