Diff
Modified: trunk/Source/WebCore/ChangeLog (270129 => 270130)
--- trunk/Source/WebCore/ChangeLog 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/ChangeLog 2020-11-20 21:21:25 UTC (rev 270130)
@@ -1,3 +1,55 @@
+2020-11-20 Simon Fraser <[email protected]>
+
+ Dispatch main-thread overflow scrolls to the scrolling thread as we do for page scrolls
+ https://bugs.webkit.org/show_bug.cgi?id=219213
+
+ Reviewed by Tim Horton.
+
+ Unify the behavior of overflow scrolling and page scrolling for synchronous scrolls.
+
+ Somewhat surprisingly, synchronous page scrolls move layers via a dispatch to the scrolling thread in
+ FrameView::handleWheelEventForScrolling(), but overflow scrolls just did main thread compositing updates
+ to set the new layer positions.
+
+ A future patch will require that the "began" event for a synchronous scroll gets back to the scrolling thread,
+ so unify these code paths to have overflow scrolls also leverage handleWheelEventAfterMainThread(), via
+ RenderLayer::handleWheelEventForScrolling().
+
+ There's some fallout from this. ThreadedScrollingTree::handleWheelEventAfterMainThread() calls into handleWheelEventWithNode(),
+ but in this special case that codepath needs to know that we're in a special "post main thread" mode that should
+ 1. Behave as if the node is latched, i.e. don't propagate to parent nodes,
+ and target the node if if it's scrolled to a the min or max to allow rubberbanding
+ 2. Scroll even if the node has synchronous scrolling reasons
+ This mode is represented by the EventTargeting value.
+
+ Finally, EventHandler::handleWheelEventInternal() should only clear latching state if the content has called preventDefault()
+ on the event.
+
+ * page/EventHandler.cpp:
+ (WebCore::EventHandler::handleWheelEventInternal):
+ * page/scrolling/ScrollLatchingController.cpp:
+ (WebCore::ScrollLatchingController::updateAndFetchLatchingStateForFrame):
+ * page/scrolling/ScrollingTree.cpp:
+ (WebCore::ScrollingTree::handleWheelEventWithNode):
+ * page/scrolling/ScrollingTree.h:
+ * page/scrolling/ScrollingTreeScrollingNode.cpp:
+ (WebCore::ScrollingTreeScrollingNode::canHandleWheelEvent const):
+ (WebCore::ScrollingTreeScrollingNode::handleWheelEvent):
+ * page/scrolling/ScrollingTreeScrollingNode.h:
+ * page/scrolling/ThreadedScrollingTree.cpp:
+ (WebCore::ThreadedScrollingTree::handleWheelEventAfterMainThread):
+ * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h:
+ * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:
+ (WebCore::ScrollingTreeFrameScrollingNodeMac::handleWheelEvent):
+ * page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h:
+ * page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.mm:
+ (WebCore::ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent):
+ * platform/cocoa/ScrollController.mm:
+ (WebCore::ScrollController::handleWheelEvent):
+ * rendering/RenderLayer.cpp:
+ (WebCore::RenderLayer::handleWheelEventForScrolling):
+ * rendering/RenderLayer.h:
+
2020-11-20 Zalan Bujtas <[email protected]>
[LFC][Integration] Rename LineIteratorLegacy::logicalLeft/right to contentLeft/right
Modified: trunk/Source/WebCore/page/EventHandler.cpp (270129 => 270130)
--- trunk/Source/WebCore/page/EventHandler.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/EventHandler.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -2941,7 +2941,8 @@
m_isHandlingWheelEvent = false;
if (scrollableArea && scrollableArea->scrollShouldClearLatchedState()) {
// Web developer is controlling scrolling, so don't attempt to latch.
- clearLatchedState();
+ if (handling.containsAll({ EventHandling::DispatchedToDOM, EventHandling::DefaultPrevented }))
+ clearLatchedState();
scrollableArea->setScrollShouldClearLatchedState(false);
}
Modified: trunk/Source/WebCore/page/scrolling/ScrollLatchingController.cpp (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/ScrollLatchingController.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/ScrollLatchingController.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -120,6 +120,7 @@
state.scrollableArea = scrollableArea;
state.isOverWidget = isOverWidget;
+ LOG_WITH_STREAM(ScrollLatching, stream << "ScrollLatchingController::updateAndFetchLatchingStateForFrame() - pushing state for Frame " << &frame << " element " << state.wheelEventElement.get() << " scrollableArea " << state.scrollableArea);
m_frameStateStack.append(WTFMove(state));
return;
}
@@ -143,6 +144,8 @@
latchedElement = state.wheelEventElement.get();
scrollableArea = state.scrollableArea;
isOverWidget = state.isOverWidget;
+
+ LOG_WITH_STREAM(ScrollLatching, stream << "ScrollLatchingController::updateAndFetchLatchingStateForFrame() - using state for Frame " << &frame << " element " << latchedElement.get() << " scrollableArea " << scrollableArea);
}
}
}
Modified: trunk/Source/WebCore/page/scrolling/ScrollingTree.cpp (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/ScrollingTree.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/ScrollingTree.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -168,12 +168,12 @@
return result;
}
-WheelEventHandlingResult ScrollingTree::handleWheelEventWithNode(const PlatformWheelEvent& wheelEvent, OptionSet<WheelEventProcessingSteps> processingSteps, ScrollingTreeNode* node)
+WheelEventHandlingResult ScrollingTree::handleWheelEventWithNode(const PlatformWheelEvent& wheelEvent, OptionSet<WheelEventProcessingSteps> processingSteps, ScrollingTreeNode* node, EventTargeting eventTargeting)
{
while (node) {
if (is<ScrollingTreeScrollingNode>(*node)) {
auto& scrollingNode = downcast<ScrollingTreeScrollingNode>(*node);
- auto result = scrollingNode.handleWheelEvent(wheelEvent);
+ auto result = scrollingNode.handleWheelEvent(wheelEvent, eventTargeting);
if (result.wasHandled) {
m_latchingController.nodeDidHandleEvent(scrollingNode.scrollingNodeID(), processingSteps, wheelEvent, m_allowLatching);
@@ -181,7 +181,7 @@
return result;
}
- if (result.needsMainThreadProcessing())
+ if (result.needsMainThreadProcessing() || eventTargeting != EventTargeting::Propagate)
return result;
}
Modified: trunk/Source/WebCore/page/scrolling/ScrollingTree.h (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/ScrollingTree.h 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/ScrollingTree.h 2020-11-20 21:21:25 UTC (rev 270130)
@@ -75,6 +75,8 @@
}
};
+enum class EventTargeting : uint8_t { NodeOnly, Propagate };
+
class ScrollingTree : public ThreadSafeRefCounted<ScrollingTree> {
friend class ScrollingTreeLatchingController;
public:
@@ -233,7 +235,7 @@
Vector<ScrollUpdate> takePendingScrollUpdates();
protected:
- WheelEventHandlingResult handleWheelEventWithNode(const PlatformWheelEvent&, OptionSet<WheelEventProcessingSteps>, ScrollingTreeNode*);
+ WheelEventHandlingResult handleWheelEventWithNode(const PlatformWheelEvent&, OptionSet<WheelEventProcessingSteps>, ScrollingTreeNode*, EventTargeting = EventTargeting::Propagate);
FloatPoint mainFrameScrollPosition() const;
void setMainFrameScrollPosition(FloatPoint);
Modified: trunk/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -134,7 +134,7 @@
return scrollingTree().latchedNodeID() == scrollingNodeID();
}
-bool ScrollingTreeScrollingNode::canHandleWheelEvent(const PlatformWheelEvent& wheelEvent) const
+bool ScrollingTreeScrollingNode::canHandleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting) const
{
if (!canHaveScrollbars())
return false;
@@ -145,13 +145,13 @@
// We always rubber-band the latched node, or the root node.
// The stateless wheel event doesn't trigger rubber-band.
- if (isLatchedNode() || (isRootNode() && !wheelEvent.isNonGestureEvent()))
+ if (isLatchedNode() || eventTargeting == EventTargeting::NodeOnly || (isRootNode() && !wheelEvent.isNonGestureEvent()))
return true;
return eventCanScrollContents(wheelEvent);
}
-WheelEventHandlingResult ScrollingTreeScrollingNode::handleWheelEvent(const PlatformWheelEvent&)
+WheelEventHandlingResult ScrollingTreeScrollingNode::handleWheelEvent(const PlatformWheelEvent&, EventTargeting)
{
return WheelEventHandlingResult::unhandled();
}
Modified: trunk/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h 2020-11-20 21:21:25 UTC (rev 270130)
@@ -28,11 +28,9 @@
#if ENABLE(ASYNC_SCROLLING)
#include "IntRect.h"
-#include "RectEdges.h"
#include "ScrollSnapOffsetsInfo.h"
-#include "ScrollTypes.h"
#include "ScrollableArea.h"
-#include "ScrollingCoordinator.h"
+#include "ScrollingTree.h"
#include "ScrollingTreeNode.h"
namespace WebCore {
@@ -55,8 +53,8 @@
void commitStateAfterChildren(const ScrollingStateNode&) override;
void didCompleteCommitForNode() final;
- virtual bool canHandleWheelEvent(const PlatformWheelEvent&) const;
- virtual WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&);
+ virtual bool canHandleWheelEvent(const PlatformWheelEvent&, EventTargeting) const;
+ virtual WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting = EventTargeting::Propagate);
FloatPoint currentScrollPosition() const { return m_currentScrollPosition; }
FloatPoint currentScrollOffset() const { return ScrollableArea::scrollOffsetFromPosition(m_currentScrollPosition, toFloatSize(m_scrollOrigin)); }
Modified: trunk/Source/WebCore/page/scrolling/ThreadedScrollingTree.cpp (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/ThreadedScrollingTree.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/ThreadedScrollingTree.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -66,13 +66,13 @@
bool ThreadedScrollingTree::handleWheelEventAfterMainThread(const PlatformWheelEvent& wheelEvent, ScrollingNodeID targetNodeID)
{
- LOG_WITH_STREAM(Scrolling, stream << "ThreadedScrollingTree::handleWheelEventAfterMainThread " << wheelEvent);
+ LOG_WITH_STREAM(Scrolling, stream << "ThreadedScrollingTree::handleWheelEventAfterMainThread " << wheelEvent << " node " << targetNodeID);
LockHolder locker(m_treeMutex);
SetForScope<bool> disallowLatchingScope(m_allowLatching, false);
RefPtr<ScrollingTreeNode> targetNode = nodeForID(targetNodeID);
- auto result = handleWheelEventWithNode(wheelEvent, { }, targetNode.get());
+ auto result = handleWheelEventWithNode(wheelEvent, { }, targetNode.get(), EventTargeting::NodeOnly);
return result.wasHandled;
}
Modified: trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h 2020-11-20 21:21:25 UTC (rev 270130)
@@ -51,7 +51,7 @@
void commitStateBeforeChildren(const ScrollingStateNode&) override;
void commitStateAfterChildren(const ScrollingStateNode&) override;
- WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&) override;
+ WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting) override;
WEBCORE_EXPORT void repositionRelatedLayers() override;
Modified: trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm 2020-11-20 21:21:25 UTC (rev 270130)
@@ -117,9 +117,9 @@
updateMainFramePinAndRubberbandState();
}
-WheelEventHandlingResult ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
+WheelEventHandlingResult ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
{
- if (!canHandleWheelEvent(wheelEvent))
+ if (!canHandleWheelEvent(wheelEvent, eventTargeting))
return WheelEventHandlingResult::unhandled();
bool handled = m_delegate.handleWheelEvent(wheelEvent);
Modified: trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h 2020-11-20 21:21:25 UTC (rev 270130)
@@ -53,7 +53,7 @@
void repositionScrollingLayers() override;
void repositionRelatedLayers() override;
- WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&) override;
+ WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting) override;
private:
void willBeDestroyed() final;
Modified: trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.mm (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.mm 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.mm 2020-11-20 21:21:25 UTC (rev 270130)
@@ -73,14 +73,14 @@
}
}
-WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
+WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
{
#if ENABLE(SCROLLING_THREAD)
- if (hasSynchronousScrollingReasons())
+ if (hasSynchronousScrollingReasons() && eventTargeting != EventTargeting::NodeOnly)
return { { WheelEventProcessingSteps::MainThreadForScrolling, WheelEventProcessingSteps::MainThreadForNonBlockingDOMEventDispatch }, false };
#endif
- if (!canHandleWheelEvent(wheelEvent))
+ if (!canHandleWheelEvent(wheelEvent, eventTargeting))
return WheelEventHandlingResult::unhandled();
return WheelEventHandlingResult::result(m_delegate.handleWheelEvent(wheelEvent));
Modified: trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeFrameScrollingNodeNicosia.cpp (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeFrameScrollingNodeNicosia.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeFrameScrollingNodeNicosia.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -158,9 +158,9 @@
}
#endif
-WheelEventHandlingResult ScrollingTreeFrameScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
+WheelEventHandlingResult ScrollingTreeFrameScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
{
- if (!canHandleWheelEvent(wheelEvent))
+ if (!canHandleWheelEvent(wheelEvent, eventTargeting))
return WheelEventHandlingResult::unhandled();
#if ENABLE(KINETIC_SCROLLING)
Modified: trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeFrameScrollingNodeNicosia.h (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeFrameScrollingNodeNicosia.h 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeFrameScrollingNodeNicosia.h 2020-11-20 21:21:25 UTC (rev 270130)
@@ -62,7 +62,7 @@
void ensureScrollAnimationSmooth();
#endif
- WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&) override;
+ WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting) override;
void stopScrollAnimations() override;
Modified: trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeOverflowScrollingNodeNicosia.cpp (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeOverflowScrollingNodeNicosia.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeOverflowScrollingNodeNicosia.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -148,9 +148,9 @@
}
#endif
-WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
+WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
{
- if (!canHandleWheelEvent(wheelEvent))
+ if (!canHandleWheelEvent(wheelEvent, eventTargeting))
return WheelEventHandlingResult::unhandled();
#if ENABLE(KINETIC_SCROLLING)
Modified: trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeOverflowScrollingNodeNicosia.h (270129 => 270130)
--- trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeOverflowScrollingNodeNicosia.h 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeOverflowScrollingNodeNicosia.h 2020-11-20 21:21:25 UTC (rev 270130)
@@ -57,7 +57,7 @@
void ensureScrollAnimationSmooth();
#endif
- WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&) override;
+ WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting) override;
void stopScrollAnimations() override;
Modified: trunk/Source/WebCore/platform/cocoa/ScrollController.mm (270129 => 270130)
--- trunk/Source/WebCore/platform/cocoa/ScrollController.mm 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/platform/cocoa/ScrollController.mm 2020-11-20 21:21:25 UTC (rev 270130)
@@ -256,6 +256,8 @@
shouldStretch = true;
}
}
+
+ LOG_WITH_STREAM(Scrolling, stream << "ScrollController::handleWheelEvent() - deltaX " << deltaX << " deltaY " << deltaY << " pinned " << m_client.pinnedInDirection(FloatSize(deltaX, deltaY)) << " shouldStretch " << shouldStretch);
}
bool handled = true;
Modified: trunk/Source/WebCore/rendering/RenderLayer.cpp (270129 => 270130)
--- trunk/Source/WebCore/rendering/RenderLayer.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/rendering/RenderLayer.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -3165,6 +3165,21 @@
return backing()->scrollingNodeIDForRole(ScrollCoordinationRole::Scrolling);
}
+bool RenderLayer::handleWheelEventForScrolling(const PlatformWheelEvent& wheelEvent)
+{
+ if (!isScrollableOrRubberbandable())
+ return false;
+
+#if ENABLE(ASYNC_SCROLLING)
+ if (usesAsyncScrolling() && scrollingNodeID()) {
+ if (auto* scrollingCoordinator = page().scrollingCoordinator())
+ return scrollingCoordinator->handleWheelEventForScrolling(wheelEvent, scrollingNodeID());
+ }
+#endif
+
+ return ScrollableArea::handleWheelEventForScrolling(wheelEvent);
+}
+
IntRect RenderLayer::visibleContentRectInternal(VisibleContentRectIncludesScrollbars scrollbarInclusion, VisibleContentRectBehavior) const
{
IntSize scrollbarSpace;
Modified: trunk/Source/WebCore/rendering/RenderLayer.h (270129 => 270130)
--- trunk/Source/WebCore/rendering/RenderLayer.h 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebCore/rendering/RenderLayer.h 2020-11-20 21:21:25 UTC (rev 270130)
@@ -493,6 +493,7 @@
Scrollbar* verticalScrollbar() const final { return m_vBar.get(); }
ScrollableArea* enclosingScrollableArea() const final;
+ bool handleWheelEventForScrolling(const PlatformWheelEvent&) final;
bool isScrollableOrRubberbandable() final;
bool hasScrollableOrRubberbandableAncestor() final;
bool useDarkAppearance() const final;
Modified: trunk/Source/WebKit/ChangeLog (270129 => 270130)
--- trunk/Source/WebKit/ChangeLog 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebKit/ChangeLog 2020-11-20 21:21:25 UTC (rev 270130)
@@ -1,5 +1,39 @@
2020-11-20 Simon Fraser <[email protected]>
+ Dispatch main-thread overflow scrolls to the scrolling thread as we do for page scrolls
+ https://bugs.webkit.org/show_bug.cgi?id=219213
+
+ Reviewed by Tim Horton.
+
+ Unify the behavior of overflow scrolling and page scrolling for synchronous scrolls.
+
+ Somewhat surprisingly, synchronous page scrolls move layers via a dispatch to the scrolling thread in
+ FrameView::handleWheelEventForScrolling(), but overflow scrolls just did main thread compositing updates
+ to set the new layer positions.
+
+ A future patch will require that the "began" event for a synchronous scroll gets back to the scrolling thread,
+ so unify these code paths to have overflow scrolls also leverage handleWheelEventAfterMainThread(), via
+ RenderLayer::handleWheelEventForScrolling().
+
+ There's some fallout from this. ThreadedScrollingTree::handleWheelEventAfterMainThread() calls into handleWheelEventWithNode(),
+ but in this special case that codepath needs to know that we're in a special "post main thread" mode that should
+ 1. Behave as if the node is latched, i.e. don't propagate to parent nodes,
+ and target the node if if it's scrolled to a the min or max to allow rubberbanding
+ 2. Scroll even if the node has synchronous scrolling reasons
+ This mode is represented by the EventTargeting value.
+
+ Finally, EventHandler::handleWheelEventInternal() should only clear latching state if the content has called preventDefault()
+ on the event.
+
+ * UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp:
+ (WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent):
+ * UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.h:
+ * UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp:
+ (WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent):
+ * UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.h:
+
+2020-11-20 Simon Fraser <[email protected]>
+
Rename some wheel-event handling functions for clarity
https://bugs.webkit.org/show_bug.cgi?id=219211
Modified: trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp (270129 => 270130)
--- trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -72,9 +72,9 @@
m_scrollerPair->updateValues();
}
-WheelEventHandlingResult ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
+WheelEventHandlingResult ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
{
- ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(wheelEvent);
+ ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(wheelEvent, eventTargeting);
return WheelEventHandlingResult::result(m_scrollerPair->handleWheelEvent(wheelEvent));
}
Modified: trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.h (270129 => 270130)
--- trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.h 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.h 2020-11-20 21:21:25 UTC (rev 270130)
@@ -44,7 +44,7 @@
ScrollingTreeFrameScrollingNodeRemoteMac(WebCore::ScrollingTree&, WebCore::ScrollingNodeType, WebCore::ScrollingNodeID);
void commitStateBeforeChildren(const WebCore::ScrollingStateNode&) override;
- WebCore::WheelEventHandlingResult handleWheelEvent(const WebCore::PlatformWheelEvent&) override;
+ WebCore::WheelEventHandlingResult handleWheelEvent(const WebCore::PlatformWheelEvent&, EventTargeting) override;
void repositionRelatedLayers() override;
std::unique_ptr<ScrollerPairMac> m_scrollerPair;
Modified: trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp (270129 => 270130)
--- trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp 2020-11-20 21:21:25 UTC (rev 270130)
@@ -72,9 +72,9 @@
m_scrollerPair->updateValues();
}
-WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
+WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
{
- ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent(wheelEvent);
+ ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent(wheelEvent, eventTargeting);
return WheelEventHandlingResult::result(m_scrollerPair->handleWheelEvent(wheelEvent));
}
Modified: trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.h (270129 => 270130)
--- trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.h 2020-11-20 20:56:12 UTC (rev 270129)
+++ trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.h 2020-11-20 21:21:25 UTC (rev 270130)
@@ -44,7 +44,7 @@
ScrollingTreeOverflowScrollingNodeRemoteMac(WebCore::ScrollingTree&, WebCore::ScrollingNodeID);
void commitStateBeforeChildren(const WebCore::ScrollingStateNode&) override;
- WebCore::WheelEventHandlingResult handleWheelEvent(const WebCore::PlatformWheelEvent&) override;
+ WebCore::WheelEventHandlingResult handleWheelEvent(const WebCore::PlatformWheelEvent&, EventTargeting) override;
void repositionRelatedLayers() override;
std::unique_ptr<ScrollerPairMac> m_scrollerPair;
