Attachment #384789 for bug #188043

View Details Raw Unified Return to Bug 188043

| Differences between

and this patch



2019-11-28  Cathie Chen  <cathiechen@igalia.com>

        Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
        https://bugs.webkit.org/show_bug.cgi?id=188043

        Reviewed by NOBODY (OOPS!).

        Based on the patch by FrÃ©dÃ©ric Wang.

        This patch introduces a programmatic smooth scrolling in WebKit from the CSSOM View
        specification [1]. To use this effect, web developers can pass a behavior parameter (auto,
        smooth, or instant) to Element.scroll, Element.scrollTo, Element.scrollBy,
        Element.scrollIntoView, Window.scroll, Window.scrollTo or Window.scrollBy [2]. When behavior
        is auto, the instant/smooth characteristic is actually taken from the value of a new CSS
        scroll-behavior property [3]. Both the new CSS and DOM behavior are protected by a runtime
        flag. The Element.scrollIntoView part will be refined later in bug 189907. The actual
        animation on non-iOS platforms, executed in the scrolling thread, relies on the existing
        ScrollAnimationSmooth. On iOS, it relies on UIScrollView's native scroll animation support
        and is executed in the UI process.

        [1] https://drafts.csswg.org/cssom-view
        [2] https://drafts.csswg.org/cssom-view/#dictdef-scrolloptions
        [3] https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior

        Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties

        Tests: imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-default-css.html
               imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-element.html
               imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html
               imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html
               imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested.html
               imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-smooth-positions.html
               imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html
               imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html
               fast/scrolling/ios/scroll-behavior-default-css.html
               fast/scrolling/ios/scroll-behavior-element.html
               fast/scrolling/ios/scroll-behavior-main-frame-root.html
               fast/scrolling/ios/scroll-behavior-main-frame-window.html
               fast/scrolling/ios/scroll-behavior-scrollintoview-nested.html
               fast/scrolling/ios/scroll-behavior-smooth-positions.html
               fast/scrolling/ios/scroll-behavior-subframe-root.html
               fast/scrolling/ios/scroll-behavior-subframe-window.html

        * CMakeLists.txt: Add IDL files for ScrollOptions and ScrollBehavior.
        * DerivedSources.make: Ditto.
        * Headers.cmake: Add headers for ScrollBehavor and ScrollOptions.
        * Sources.txt: Add ScrollBehavor and ScrollOptions implementation. Also build
        ScrollAnimationSmooth.cpp on all platforms.
        * SourcesGTK.txt: Remove ScrollAnimationSmooth.cpp since it is built on all platforms now.
        * WebCore.xcodeproj/project.pbxproj: Add files to the build system.
        * css/CSSComputedStyleDeclaration.cpp: Handle scroll-behavior.
        (WebCore::ComputedStyleExtractor::valueForPropertyInStyle):
        * css/CSSProperties.json: Add scroll-behavior.
        * css/CSSValueKeywords.in: Add keywords for scroll-behavior.
        * css/parser/CSSParserContext.cpp: Add runtime config for scroll-behavior.
        (WebCore::CSSParserContext::CSSParserContext):
        (WebCore::operator==):
        * css/parser/CSSParserContext.h: Ditto.
        (WebCore::CSSParserContextHash::hash):
        * css/parser/CSSParserFastPaths.cpp: Remove scroll-behavior templates. It is handled in the
        slow path since property can be disabled.
        (WebCore::CSSParserFastPaths::isValidKeywordPropertyAndValue):
        (WebCore::CSSParserFastPaths::isKeywordPropertyID):
        * css/parser/CSSPropertyParser.cpp:
        (WebCore::consumeScrollBehavior):
        (WebCore::CSSPropertyParser::parseSingleValue): Parse scroll-behavior (only if enabled).
        * dom/Element.cpp:
        (WebCore::Element::scrollIntoView): Pass scroll behavior, if any.
        (WebCore::Element::scrollBy):
        (WebCore::Element::scrollTo): Handle the case when scroll behavior is smooth.
        (WebCore::Element::setScrollLeft): Handle the case when scroll behavior is smooth.
        (WebCore::Element::setScrollTop): Handle the case when scroll behavior is smooth.
        * page/DOMWindow.cpp:
        (WebCore::DOMWindow::scrollBy const):
        (WebCore::DOMWindow::scrollTo const): Handle the case when scroll behavior is smooth.
        The optimization of cancel (0, 0) scrolling is skipped if an animated scroll is in progress.
        Otherwise, the previous scroll won't be stopped by a follow-up scroll.
        * page/FrameView.cpp:
        (WebCore::FrameView::scrollToOffsetWithAnimation): Start an animated scroll.
        * page/FrameView.h:
        * page/ScrollBehavior.cpp: Added.
        (WebCore::useSmoothScrolling): Helper funciton to determine the scroll behavior to apply to
        an element from the CSS and DOM behavior.
        * page/ScrollBehavior.h: Added.
        * page/ScrollBehavior.idl: Added.
        * page/ScrollIntoViewOptions.h: Make this class inherits from ScrollOption. Also remove
        unnecessary forward declaration.
        * page/ScrollIntoViewOptions.idl: Make this class inherits from ScrollOption.
        * page/ScrollOptions.h: Added.
        * page/ScrollOptions.idl: Added.
        * page/ScrollToOptions.h: Make this struct inherits from ScrollOptions.
        (WebCore::normalizeNonFiniteCoordinatesOrFallBackTo): Copy the current ScrollToOptions so
        that the scroll behavior is preserved.
        * page/ScrollToOptions.idl: Make this class inherit from ScrollOptions.
        * page/Settings.yaml: New setting for CSSOM View smooth scrolling.
        * page/scrolling/AsyncScrollingCoordinator.cpp:
        (WebCore::AsyncScrollingCoordinator::requestScrollPositionUpdate): Add a flag to indicate if this is an animated scroll or not.
        (WebCore::AsyncScrollingCoordinator::setScrollAnimationInProgress): Update the scroll animation status from the UI process.
        * page/scrolling/AsyncScrollingCoordinator.h:
        * page/scrolling/ScrollingStateScrollingNode.cpp:
        (WebCore::ScrollingStateScrollingNode::ScrollingStateScrollingNode): Add m_requestedScrollPositionWithAnimation to indicate it's animated.
        (WebCore::ScrollingStateScrollingNode::setRequestedScrollPosition): Ditto.
        (WebCore::ScrollingStateScrollingNode::dumpProperties const): Ditto.
        * page/scrolling/ScrollingStateScrollingNode.h:
        (WebCore::ScrollingStateScrollingNode::requestedScrollPositionWithAnimation const): Ditto.
        * page/scrolling/ScrollingTree.h:
        (WebCore::ScrollingTree::scrollingTreeNodeRequestsScroll): Add withAnimation.
        (WebCore::ScrollingTree::scrollingTreeNodeIsScrollAnimationInProgressDidChange): Update the scroll animation status.
        * page/scrolling/ScrollingTreeScrollingNode.cpp:
        (WebCore::ScrollingTreeScrollingNode::commitStateAfterChildren): Add a flag to indicate the scroll is animated or not.
        (WebCore::ScrollingTreeScrollingNode::scrollTo): If needSyncScrollPosition is true, send the scroll position to the Web process, even if the scroll position doesn't change.
        Maintain the status of m_stopScrollAnimation and m_requestScrollWithAnimation.
        (WebCore::ScrollingTreeScrollingNode::currentScrollPositionChanged): Animated scroll won't change the scroll position immediately, so don't notify the scrolling info now.
        (WebCore::ScrollingTreeScrollingNode::setRequestScrollWithAnimation): m_requestScrollWithAnimation indicates that this is an animated scroll request.
        (WebCore::ScrollingTreeScrollingNode::requestScrollWithAnimation const): Ditto.
        (WebCore::ScrollingTreeScrollingNode::setScrollAnimationInProgress): Maintain the scroll animation status.
        (WebCore::ScrollingTreeScrollingNode::scrollAnimationInProgress const): Ditto.
        (WebCore::ScrollingTreeScrollingNode::setNeedsStopCurrentScrollAnimation): If the Node is performing a scroll animation, the previous scroll animation should stop first.
        (WebCore::ScrollingTreeScrollingNode::needsStopCurrentScrollAnimation const): Ditto.
        * page/scrolling/ScrollingTreeScrollingNode.h:
        * platform/ScrollAnimation.h:
        (WebCore::ScrollAnimation::scroll): Function to animate scrolling to a specified position.
        (WebCore::ScrollAnimation::isScrollInProgress const):
        * platform/ScrollAnimationKinetic.cpp:
        (WebCore::ScrollAnimationKinetic::isScrollInProgress const):
        * platform/ScrollAnimationKinetic.h:
        * platform/ScrollAnimationSmooth.cpp: Build this file on all platforms. Add a
        smoothFactorForProgrammaticScroll parameter to slow down the smooth scrolling.
        (WebCore::ScrollAnimationSmooth::scroll):
        (WebCore::ScrollAnimationSmooth::updatePerAxisData): Scale the time parameters of the
        animation so that it looks smoother.
        * platform/ScrollAnimationSmooth.h: Declare the class on all platforms.
        * platform/ScrollAnimator.cpp:
        (WebCore::ScrollAnimator::ScrollAnimator): Initialize animation member for programmatic scrolling.
        (WebCore::ScrollAnimator::isScrollInProgress const): For now, only claims scroll is in
        progress if smooth programmatic scroll is in progress.
        (WebCore::ScrollAnimator::scrollToOffset): Animate scrolling to the specified position.
        (WebCore::ScrollAnimator::cancelAnimations): Copy logic from ScrollAnimationSmooth.cpp.
        (WebCore::ScrollAnimator::serviceScrollAnimations): Ditto.
        (WebCore::ScrollAnimator::willEndLiveResize): Ditto.
        (WebCore::ScrollAnimator::didAddVerticalScrollbar): Ditto.
        (WebCore::ScrollAnimator::didAddHorizontalScrollbar): Ditto.
        * platform/ScrollAnimator.h: New animation member for smooth programmatic scrolling.
        * platform/ScrollTypes.h: Add ScrollBehaviorType to indicate it's instant or smooth scroll.
        Add ScrollBehaviorStatus to indicate the status of scrolling.
        * platform/ScrollView.cpp:
        (WebCore::ScrollView::setScrollPosition): Follow the CSSOM View spec: If a scroll is in
        progress, we interrupt it and continue the scroll call (even when we are at the final
        position).
        * platform/ScrollableArea.cpp:
        (WebCore::ScrollableArea::ScrollableArea): Add m_currentScrollBehaviorType.
        (WebCore::ScrollableArea::isScrollInProgress): Helper function to check whether scroll
        animation is in progress on the animator. Using the m_currentScrollBehaviorStatus,
        if it's WebAnimationTimerStarted and m_scrollAnimator does not exist we don't construct it.
        (WebCore::ScrollableArea::isWebScrollAnimationInProgress): Check if the m_scrollAnimator of
        the Web process is performing a scroll animation.
        (WebCore::ScrollableArea::scrollToOffsetWithAnimation):
        (WebCore::ScrollableArea::setScrollOffsetFromInternals):
        (WebCore::ScrollableArea::setScrollOffsetFromAnimation): To avoid iterate calling,
        move the requestScrollPositionUpdate(position) checking out of setScrollOffsetFromAnimation().
        * platform/ScrollableArea.h:
        (WebCore::ScrollableArea::currentScrollBehaviorStatus const): Maintain currentScrollBehaviorStatus.
        (WebCore::ScrollableArea::setScrollBehaviorStatus):
        (WebCore::ScrollableArea::currentScrollBehaviorType const): Maintain currentScrollBehaviorType.
        (WebCore::ScrollableArea::setCurrentScrollBehaviorType):
        * platform/generic/ScrollAnimatorGeneric.cpp:
        (WebCore::ScrollAnimatorGeneric::updatePosition):
        * platform/mac/ScrollAnimatorMac.mm:
        (WebCore::ScrollAnimatorMac::cancelAnimations): Call parent member to handle programmatic scrolling.
        * rendering/RenderBox.cpp:
        (WebCore::RenderBox::setScrollLeft): Add flag to indicate animated or not.
        (WebCore::RenderBox::setScrollTop): Ditto.
        (WebCore::RenderBox::setScrollPosition):
        * rendering/RenderBox.h:
        * rendering/RenderLayer.cpp:
        (WebCore::RenderLayer::scrollToXPosition): Ditto.
        (WebCore::RenderLayer::scrollToYPosition): Ditto.
        (WebCore::RenderLayer::scrollToPosition):
        (WebCore::RenderLayer::scrollToOffset): Follow the CSSOM View spec: If a scroll is in
        progress, we interrupt it and continue the scroll call (even when we are at the final
        position). It's ScrollBehaviorType::Instant scroll.
        (WebCore::RenderLayer::requestScrollPositionUpdate):
        (WebCore::RenderLayer::scrollToOffsetWithAnimation): Ditto. This is similar to scrollToOffset
        but animates the scroll. It's ScrollBehaviorType::Smooth scroll.
        (WebCore::RenderLayer::scrollTo):
        (WebCore::RenderLayer::scrollRectToVisible): Again don't do an early return if scroll is in
        progress. We call scrollToOffsetWithAnimation instead of scrollToOffset when appropriate.
        Note that this function may not work well for several nested scroll boxes with at least one
        element with smooth behavior. It will handled in bug Follow.
        * rendering/RenderLayer.h: Add scroll behavior to ScrollTectToVisibleOptions.
        * rendering/RenderListBox.cpp:
        (WebCore::RenderListBox::setScrollLeft): Add animated flag.
        (WebCore::RenderListBox::setScrollTop): Ditto.
        * rendering/RenderListBox.h:
        * rendering/RenderTextControlSingleLine.cpp:
        (WebCore::RenderTextControlSingleLine::setScrollLeft):
        (WebCore::RenderTextControlSingleLine::setScrollTop):
        * rendering/RenderTextControlSingleLine.h:
        * rendering/style/RenderStyle.h: Handle 'smooth scrolling' boolean data.
        (WebCore::RenderStyle::useSmoothScrolling const):
        (WebCore::RenderStyle::setUseSmoothScrolling):
        (WebCore::RenderStyle::initialUseSmoothScrolling):
        * rendering/style/StyleRareNonInheritedData.cpp: Ditto.
        (WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
        (WebCore::StyleRareNonInheritedData::operator== const):
        * rendering/style/StyleRareNonInheritedData.h: Ditto.
        * style/StyleBuilderConverter.h:
        (WebCore::Style::BuilderConverter::convertSmoothScrolling):
        * testing/Internals.cpp:
        (WebCore::Internals::unconstrainedScrollTo):

2019-11-26  Manuel Rego Casasnovas  <rego@igalia.com>

        [css-grid] Avoid serializing [] in grid-template-* specified values



2019-11-28  Cathie Chen  <cathiechen@igalia.com>

        Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
        https://bugs.webkit.org/show_bug.cgi?id=188043

        Reviewed by NOBODY (OOPS!).

        Based on the patch by FrÃ©dÃ©ric Wang.

        Add CSSOM smooth scrolling as an experimental feature. On ios platform, use native animated scrolling
        interfaces to performance smooth scroll and send the scroll position to the Web process.

        * Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp: Deal with requestedScrollPositionWithAnimation encode and decode.
        (ArgumentCoder<ScrollingStateScrollingNode>::encode):
        (ArgumentCoder<ScrollingStateScrollingNode>::decode):
        (WebKit::dump):
        * Shared/WebPreferences.yaml:
        * UIProcess/API/Cocoa/WKWebView.mm:
        (pointsEqualInRoundToDevicePixel): Help function to check if two float points are not equal but in the same device pixel.
        (-[WKWebView _scrollToContentScrollPosition:scrollOrigin:animated:]): Add animated flag to start a animated scroll if needed.
        (-[WKWebView scrollViewDidEndScrollingAnimation:]): Send sroll end message to the Web process.
        * UIProcess/API/Cocoa/WKWebViewInternal.h:
        * UIProcess/PageClient.h:
        (WebKit::PageClient::requestScrollWithAnimation): Provide interface for animated scrolling.
        * UIProcess/RemoteLayerTree/RemoteLayerTreeDrawingAreaProxy.mm:
        (WebKit::RemoteLayerTreeDrawingAreaProxy::commitLayerTree): Add animated flag.
        * UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp:
        (WebKit::RemoteScrollingCoordinatorProxy::scrollingTreeNodeDidScroll): Sync the scroll position to the Web process.
        (WebKit::RemoteScrollingCoordinatorProxy::scrollingTreeNodeRequestsScroll): Add animated scrolling info to m_requestedScrollInfo.
        (WebKit::RemoteScrollingCoordinatorProxy::scrollingTreeNodeIsScrollAnimationInProgressDidChange): Sync scrollAnimationInProgress to the Web process.
        (WebKit::RemoteScrollingCoordinatorProxy::scrollingTreeRootNodeIsScrollAnimationInProgressDidChange): Ditto. It's specific to the root node.
        * UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.h:
        * UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp:
        (WebKit::RemoteScrollingTree::scrollingTreeNodeDidScroll): Add animated info.
        (WebKit::RemoteScrollingTree::scrollingTreeNodeRequestsScroll): Ditto.
        (WebKit::RemoteScrollingTree::scrollingTreeNodeIsScrollAnimationInProgressDidChange): Ditto.
        * UIProcess/RemoteLayerTree/RemoteScrollingTree.h:
        * UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.h:
        * UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm:
        (-[WKScrollingNodeScrollViewDelegate scrollViewDidEndScrollingAnimation:]): Send scoll end info to the Web process.
        (WebKit::ScrollingTreeScrollingNodeDelegateIOS::commitStateAfterChildren): If the scroll position of the Web process isn't equal to the UI process,
        the scroll position should be synchronized, even there's no scrolling performed in the UI process.
        (WebKit::ScrollingTreeScrollingNodeDelegateIOS::repositionScrollingLayers): Calling the native animated scrolling interface for smooth scroll.
        If there's a scroll animation performing, it should be stopped first, then start a new scrolling.
        (WebKit::ScrollingTreeScrollingNodeDelegateIOS::scrollViewDidEndScrollingAnimation): Sync scroll end info to the Web process.
        * UIProcess/WebPageProxy.cpp:
        (WebKit::WebPageProxy::requestScroll): To call different functions for smooth and instant scroll.
        * UIProcess/WebPageProxy.h:
        * UIProcess/ios/PageClientImplIOS.h:
        * UIProcess/ios/PageClientImplIOS.mm:
        (WebKit::PageClientImpl::requestScroll):
        (WebKit::PageClientImpl::requestScrollWithAnimation):
        * WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.h:
        * WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.messages.in:
        * WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.mm:
        (WebKit::RemoteScrollingCoordinator::scrollAnimationInProgressChangedForNode):

2019-11-26  Carlos Garcia Campos  <cgarcia@igalia.com>

        Unreviewed. Update OptionsGTK.cmake and NEWS for 2.27.3 release



2019-11-28  Cathie Chen  <cathiechen@igalia.com>

        Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
        https://bugs.webkit.org/show_bug.cgi?id=188043

        Reviewed by NOBODY (OOPS!).

        Based on the patch by FrÃ©dÃ©ric Wang.

        * WebView/WebPreferenceKeysPrivate.h: Handle CSSOMViewSmoothScrolling by.
        * WebView/WebPreferences.mm:
        ([WebPreferences initialize]): Disable CSSOMViewSmoothScrolling by default.
        (-[WebPreferences CSSOMViewSmoothScrollingEnabled]): Getter.
        (-[WebPreferences setCSSOMViewSmoothScrollingEnabled:]): Setter.
        * WebView/WebPreferencesPrivate.h:
        * WebView/WebView.mm:
        (-[WebView _preferencesChanged:]):

2019-11-21  Daniel Bates  <dabates@apple.com>

        Remove unneeded code that annotated DOMHTMLElement as conforming to UITextInputTraits protocol



2019-11-28  Cathie Chen  <cathiechen@igalia.com>

        Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
        https://bugs.webkit.org/show_bug.cgi?id=188043

        Reviewed by NOBODY (OOPS!).

        Based on the patch by FrÃ©dÃ©ric Wang.

        * Interfaces/IWebPreferencesPrivate.idl: Handle smooth scrolling option.
        * WebPreferenceKeysPrivate.h: Ditto.
        * WebPreferences.cpp: Ditto.
        (WebPreferences::initializeDefaultSettings):
        (WebPreferences::CSSOMViewSmoothScrollingEnabled):
        (WebPreferences::setCSSOMViewSmoothScrollingEnabled):
        * WebPreferences.h: Ditto.
        * WebView.cpp: Ditto.
        (WebView::notifyPreferencesChanged):

2019-10-31  Ryosuke Niwa  <rniwa@webkit.org>

        Windows build fix attempt after r251798.



    page/ResizeObserverCallback.idl
    page/ResizeObserverEntry.idl
    page/Screen.idl
    page/ScrollBehavior.idl
    page/ScrollIntoViewOptions.idl
    page/ScrollLogicalPosition.idl
    page/ScrollOptions.idl
    page/ScrollToOptions.idl
    page/ShareData.idl
    page/UndoItem.idl



    $(WebCore)/page/ResizeObserverCallback.idl \
    $(WebCore)/page/ResizeObserverEntry.idl \
    $(WebCore)/page/Screen.idl \
    $(WebCore)/page/ScrollBehavior.idl \
    $(WebCore)/page/ScrollIntoViewOptions.idl \
    $(WebCore)/page/ScrollLogicalPosition.idl \
    $(WebCore)/page/ScrollOptions.idl \
    $(WebCore)/page/ScrollToOptions.idl \
    $(WebCore)/page/ShareData.idl \
    $(WebCore)/page/UndoItem.idl \



    page/RemoteFrame.h
    page/RenderingUpdateScheduler.h
    page/RuntimeEnabledFeatures.h
    page/ScrollBehavior.h
    page/ScrollIntoViewOptions.h
    page/ScrollLogicalPosition.h
    page/ScrollOptions.h
    page/ScrollToOptions.h
    page/SecurityOrigin.h
    page/SecurityOriginData.h



page/ResourceUsageThread.cpp
page/RuntimeEnabledFeatures.cpp
page/Screen.cpp
page/ScrollBehavior.cpp
page/SecurityOrigin.cpp
page/SecurityOriginData.cpp
page/SecurityPolicy.cpp

platform/RuntimeApplicationChecks.cpp
platform/SSLKeyGenerator.cpp
platform/ScrollAnimator.cpp
platform/ScrollAnimationSmooth.cpp
platform/ScrollView.cpp
platform/ScrollableArea.cpp
platform/Scrollbar.cpp

JSSVGZoomEvent.cpp
JSScreen.cpp
JSScriptProcessorNode.cpp
JSScrollBehavior.cpp
JSScrollIntoViewOptions.cpp
JSScrollLogicalPosition.cpp
JSScrollOptions.cpp
JSScrollToOptions.cpp
JSSecurityPolicyViolationEvent.cpp
JSServiceWorker.cpp

Lines 63-69 page/scrolling/nicosia/ScrollingTreeStickyNode.cpp a/Source/WebCore/SourcesGTK.txt_sec1
- a/Source/WebCore/SourcesGTK.txt -1 lines
63	page/scrolling/generic/ScrollingThreadGeneric.cpp	63	page/scrolling/generic/ScrollingThreadGeneric.cpp
64		64
65	platform/ScrollAnimationKinetic.cpp	65	platform/ScrollAnimationKinetic.cpp
66	platform/ScrollAnimationSmooth.cpp
67	platform/UserAgentQuirks.cpp	66	platform/UserAgentQuirks.cpp
68		67
69	platform/generic/ScrollAnimatorGeneric.cpp	68	platform/generic/ScrollAnimatorGeneric.cpp

Lines 3393-3398 RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyInStyle(const RenderSty a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec1
- a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp +4 lines
3393	return cssValuePool.createIdentifierValue(CSSValueAuto);	3393	return cssValuePool.createIdentifierValue(CSSValueAuto);
3394	return cssValuePool.createIdentifierValue(CSSValueTouch);	3394	return cssValuePool.createIdentifierValue(CSSValueTouch);
3395	#endif	3395	#endif
		3396	case CSSPropertyScrollBehavior:
		3397	if (!style.useSmoothScrolling())
		3398	return cssValuePool.createIdentifierValue(CSSValueAuto);
		3399	return cssValuePool.createIdentifierValue(CSSValueSmooth);
3396	case CSSPropertyPerspective:	3400	case CSSPropertyPerspective:
3397	if (!style.hasPerspective())	3401	if (!style.hasPerspective())
3398	return cssValuePool.createIdentifierValue(CSSValueNone);	3402	return cssValuePool.createIdentifierValue(CSSValueNone);



                "url": "https://www.w3.org/TR/SVG/shapes.html"
            }
        },
        "scroll-behavior": {
            "values": [
                "auto",
                "smooth"
            ],
            "specification": {
                "category": "cssom-view",
                "url": "https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior"
            }
        },
        "shape-rendering": {
            "inherited": true,
            "values": [

                "url": "https://www.w3.org/TR/css-ui-4/#propdef-user-select"
            }
        },
        "scroll-behavior": {
            "values": [
                "auto",
                "smooth"
            ],
            "codegen-properties": {
                "converter": "SmoothScrolling",
                "name-for-methods": "UseSmoothScrolling"
            },
            "status": {
                "status": "experimental"
            },
            "specification": {
                "url": "https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior"
            }
        },
        "scroll-padding": {
            "codegen-properties": {
                "enable-if": "ENABLE_CSS_SCROLL_SNAP",

Lines 1387-1392 pan-y a/Source/WebCore/css/CSSValueKeywords.in_sec1
- a/Source/WebCore/css/CSSValueKeywords.in +4 lines
1387	pinch-zoom	1387	pinch-zoom
1388	#endif	1388	#endif
1389		1389
		1390	// scroll-behavior
		1391	// auto
		1392	smooth
		1393
1390	// hanging-punctuation	1394	// hanging-punctuation
1391	allow-end	1395	allow-end
1392	first	1396	first



    attachmentEnabled = RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled();
#endif
    deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();
    scrollBehaviorEnabled = document.settings().CSSOMViewSmoothScrollingEnabled();
    useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;
}


        && a.attachmentEnabled == b.attachmentEnabled
#endif
        && a.deferredCSSParserEnabled == b.deferredCSSParserEnabled
        && a.scrollBehaviorEnabled == b.scrollBehaviorEnabled
        && a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin
        && a.useSystemAppearance == b.useSystemAppearance;
}



    bool attachmentEnabled { false };
#endif
    bool deferredCSSParserEnabled { false };
    bool scrollBehaviorEnabled { false };
    
    // This is only needed to support getMatchedCSSRules.
    bool hasDocumentSecurityOrigin { false };

#if ENABLE(ATTACHMENT_ELEMENT)
            & key.attachmentEnabled                         << 11
#endif
            & key.scrollBehaviorEnabled                     << 12
            & key.mode                                      << 13; // Keep this last.
        hash ^= WTF::intHash(bits);
        return hash;
    }



            || valueID == CSSValueSticky || valueID == CSSValueWebkitSticky;
    case CSSPropertyResize: // none | both | horizontal | vertical | auto
        return valueID == CSSValueNone || valueID == CSSValueBoth || valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueAuto;
    // FIXME-NEWPARSER: Investigate this property.
    // case CSSPropertyScrollBehavior: // auto | smooth
    //     ASSERT(RuntimeEnabledFeatures::cssomSmoothScrollEnabled());
    //   return valueID == CSSValueAuto || valueID == CSSValueSmooth;
    case CSSPropertyShapeRendering:
        return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueCrispedges || valueID == CSSValueGeometricPrecision;
    case CSSPropertyStrokeLinejoin:

    // case CSSPropertyFontKerning:
    // case CSSPropertyHyphens:
    // case CSSPropertyOverflowAnchor:
    // case CSSPropertyScrollBehavior:
    // case CSSPropertyScrollSnapType:
    // case CSSPropertyTextAlignLast:
    // case CSSPropertyTextCombineUpright:

Lines 2321-2326 static RefPtr<CSSValueList> consumeScrollSnapType(CSSParserTokenRange& range) a/Source/WebCore/css/parser/CSSPropertyParser.cpp_sec1
- a/Source/WebCore/css/parser/CSSPropertyParser.cpp +12 lines
2321		2321
2322	#endif	2322	#endif
2323		2323
		2324	static RefPtr<CSSPrimitiveValue> consumeScrollBehavior(CSSParserTokenRange& range)
		2325	{
		2326	auto valueID = range.peek().id();
		2327	if (valueID != CSSValueAuto && valueID != CSSValueSmooth)
		2328	return nullptr;
		2329	return consumeIdent(range);
		2330	}
		2331
2324	static RefPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParserMode cssParserMode)	2332	static RefPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParserMode cssParserMode)
2325	{	2333	{
2326	RefPtr<CSSPrimitiveValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);	2334	RefPtr<CSSPrimitiveValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
Lines 3920-3925 RefPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID property, CSS a/Source/WebCore/css/parser/CSSPropertyParser.cpp_sec2
3920	case CSSPropertyScrollSnapType:	3928	case CSSPropertyScrollSnapType:
3921	return consumeScrollSnapType(m_range);	3929	return consumeScrollSnapType(m_range);
3922	#endif	3930	#endif
		3931	case CSSPropertyScrollBehavior:
		3932	if (!m_context.scrollBehaviorEnabled)
		3933	return nullptr;
		3934	return consumeScrollBehavior(m_range);
3923	case CSSPropertyClip:	3935	case CSSPropertyClip:
3924	return consumeClip(m_range, m_context.mode);	3936	return consumeClip(m_range, m_context.mode);
3925	#if ENABLE(POINTER_EVENTS)	3937	#if ENABLE(POINTER_EVENTS)



    bool insideFixed;
    LayoutRect absoluteBounds = renderer()->absoluteAnchorRect(&insideFixed);

    // FIXME(webkit.org/b/188043): Support ScrollBehavior.
    ScrollIntoViewOptions options;
    if (arg) {
        auto value = arg.value();

        SelectionRevealMode::Reveal,
        isHorizontal ? alignX : alignY,
        isHorizontal ? alignY : alignX,
        ShouldAllowCrossOriginScrolling::No,
        options.behavior.valueOr(ScrollBehavior::Auto)
    };
    renderer()->scrollRectToVisible(absoluteBounds, insideFixed, visibleOptions);
}


void Element::scrollBy(double x, double y)
{
    scrollBy(ScrollToOptions(x, y));
}

void Element::scrollTo(const ScrollToOptions& options, ScrollClamping clamping)

        adjustForAbsoluteZoom(renderer->scrollLeft(), *renderer),
        adjustForAbsoluteZoom(renderer->scrollTop(), *renderer)
    );
    IntPoint scrollPosition(
        clampToInteger(scrollToOptions.left.value() * renderer->style().effectiveZoom()),
        clampToInteger(scrollToOptions.top.value() * renderer->style().effectiveZoom())
    );
    bool animated = useSmoothScrolling(scrollToOptions.behavior.valueOr(ScrollBehavior::Auto), *this);
    renderer->setScrollPosition(scrollPosition, ScrollType::Programmatic, animated, clamping);
}

void Element::scrollTo(double x, double y)
{
    scrollTo(ScrollToOptions(x, y));
}

void Element::scrollByUnits(int units, ScrollGranularity granularity)

    document().updateLayoutIgnorePendingStylesheets();

    if (document().scrollingElement() == this) {
        if (auto* frame = documentFrameWithNonNullView()) {
            // FIXME: Should we use document()->scrollingElement()?
            // See https://github.com/w3c/csswg-drafts/issues/2977
            bool animated = document().documentElement() && useSmoothScrolling(ScrollBehavior::Auto, *document().documentElement());
            frame->view()->setScrollPosition(IntPoint(static_cast<int>(newLeft * frame->pageZoomFactor() * frame->frameScaleFactor()), frame->view()->scrollY()), animated);
        }
        return;
    }

    if (auto* renderer = renderBox()) {
        int effectiveLeft = clampToInteger(newLeft * renderer->style().effectiveZoom());
        bool animated = useSmoothScrolling(ScrollBehavior::Auto, *this);
        renderer->setScrollLeft(effectiveLeft, ScrollType::Programmatic, animated, ScrollClamping::Clamped);
        if (auto* scrollableArea = renderer->layer())
            scrollableArea->setScrollShouldClearLatchedState(true);
    }

    document().updateLayoutIgnorePendingStylesheets();

    if (document().scrollingElement() == this) {
        if (auto* frame = documentFrameWithNonNullView()) {
            // FIXME: Should we use document()->scrollingElement()?
            // See https://github.com/w3c/csswg-drafts/issues/2977
            bool animated = document().documentElement() && useSmoothScrolling(ScrollBehavior::Auto, *document().documentElement());
            frame->view()->setScrollPosition(IntPoint(frame->view()->scrollX(), static_cast<int>(newTop * frame->pageZoomFactor() * frame->frameScaleFactor())), animated);
        }
        return;
    }

    if (auto* renderer = renderBox()) {
        int effectiveTop = clampToInteger(newTop * renderer->style().effectiveZoom());
        bool animated = useSmoothScrolling(ScrollBehavior::Auto, *this);
        renderer->setScrollTop(effectiveTop, ScrollType::Programmatic, animated, ScrollClamping::Clamped);
        if (auto* scrollableArea = renderer->layer())
            scrollableArea->setScrollShouldClearLatchedState(true);
    }




void DOMWindow::scrollBy(double x, double y) const
{
    scrollBy(ScrollToOptions(x, y));
}

void DOMWindow::scrollBy(const ScrollToOptions& options) const


void DOMWindow::scrollTo(double x, double y, ScrollClamping clamping) const
{
    scrollTo(ScrollToOptions(x, y), clamping);
}

void DOMWindow::scrollTo(const ScrollToOptions& options, ScrollClamping clamping) const
{
    if (!isCurrentlyDisplayedInFrame())
        return;

        view->contentsScrollPosition().x(), view->contentsScrollPosition().y()
    );

    if (!view->isScrollInProgress() && !scrollToOptions.left.value() && !scrollToOptions.top.value() && view->contentsScrollPosition() == IntPoint(0, 0))
        return;

    document()->updateLayoutIgnorePendingStylesheets();

    IntPoint layoutPos(view->mapFromCSSToLayoutUnits(scrollToOptions.left.value()), view->mapFromCSSToLayoutUnits(scrollToOptions.top.value()));

    // FIXME: Should we use document()->scrollingElement()?
    // See https://github.com/w3c/csswg-drafts/issues/2977
    if (document()->documentElement() && useSmoothScrolling(scrollToOptions.behavior.valueOr(ScrollBehavior::Auto), *document()->documentElement())) {
        view->scrollToOffsetWithAnimation(layoutPos, ScrollType::Programmatic, clamping);
        return;
    }

    view->setContentsScrollPosition(layoutPos);
}


Lines 2267-2273 void FrameView::scrollElementToRect(const Element& element, const IntRect& rect) a/Source/WebCore/page/FrameView.cpp_sec1
- a/Source/WebCore/page/FrameView.cpp -2 / +25 lines
2267	setScrollPosition(IntPoint(bounds.x() - centeringOffsetX - rect.x(), bounds.y() - centeringOffsetY - rect.y()));	2267	setScrollPosition(IntPoint(bounds.x() - centeringOffsetX - rect.x(), bounds.y() - centeringOffsetY - rect.y()));
2268	}	2268	}
2269		2269
2270	void FrameView::setScrollPosition(const ScrollPosition& scrollPosition)	2270	void FrameView::setScrollPosition(const ScrollPosition& scrollPosition, bool animated)
2271	{	2271	{
2272	LOG_WITH_STREAM(Scrolling, stream << "FrameView::setScrollPosition " << scrollPosition << " , clearing anchor");	2272	LOG_WITH_STREAM(Scrolling, stream << "FrameView::setScrollPosition " << scrollPosition << " , clearing anchor");
2273		2273
Lines 2280-2286 void FrameView::setScrollPosition(const ScrollPosition& scrollPosition) a/Source/WebCore/page/FrameView.cpp_sec2
2280	Page* page = frame().page();	2280	Page* page = frame().page();
2281	if (page && page->isMonitoringWheelEvents())	2281	if (page && page->isMonitoringWheelEvents())
2282	scrollAnimator().setWheelEventTestMonitor(page->wheelEventTestMonitor());	2282	scrollAnimator().setWheelEventTestMonitor(page->wheelEventTestMonitor());
2283	ScrollView::setScrollPosition(scrollPosition);	2283	if (animated)
		2284	scrollToOffsetWithAnimation(scrollOffsetFromPosition(scrollPosition), currentScrollType());
		2285	else
		2286	ScrollView::setScrollPosition(scrollPosition);
2284		2287
2285	setCurrentScrollType(oldScrollType);	2288	setCurrentScrollType(oldScrollType);
2286	}	2289	}
Lines 3648-3653 void FrameView::scrollTo(const ScrollPosition& newPosition) a/Source/WebCore/page/FrameView.cpp_sec3
3648	didChangeScrollOffset();	3651	didChangeScrollOffset();
3649	}	3652	}
3650		3653
		3654	void FrameView::scrollToOffsetWithAnimation(const ScrollOffset& offset, ScrollType scrollType, ScrollClamping)
		3655	{
		3656	auto previousScrollType = currentScrollType();
		3657	setCurrentScrollType(scrollType);
		3658
		3659	#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
		3660	setCurrentScrollBehaviorType(ScrollBehaviorType::Smooth);
		3661	if (requestScrollPositionUpdate(scrollPositionFromOffset(offset))) {
		3662	setCurrentScrollType(previousScrollType);
		3663	return;
		3664	}
		3665	#endif
		3666
		3667	if (isWebScrollAnimationInProgress())
		3668	scrollAnimator().cancelAnimations();
		3669	if (offset != this->scrollOffset())
		3670	ScrollableArea::scrollToOffsetWithAnimation(offset);
		3671	setCurrentScrollType(previousScrollType);
		3672	}
		3673
3651	float FrameView::adjustScrollStepForFixedContent(float step, ScrollbarOrientation orientation, ScrollGranularity granularity)	3674	float FrameView::adjustScrollStepForFixedContent(float step, ScrollbarOrientation orientation, ScrollGranularity granularity)
3652	{	3675	{
3653	if (granularity != ScrollByPage \|\| orientation == HorizontalScrollbar)	3676	if (granularity != ScrollByPage \|\| orientation == HorizontalScrollbar)

Lines 222-228 public: a/Source/WebCore/page/FrameView.h_sec1
- a/Source/WebCore/page/FrameView.h -1 / +3 lines
222	#if USE(COORDINATED_GRAPHICS)	222	#if USE(COORDINATED_GRAPHICS)
223	WEBCORE_EXPORT void setFixedVisibleContentRect(const IntRect&) final;	223	WEBCORE_EXPORT void setFixedVisibleContentRect(const IntRect&) final;
224	#endif	224	#endif
225	WEBCORE_EXPORT void setScrollPosition(const ScrollPosition&) final;	225	WEBCORE_EXPORT void setScrollPosition(const ScrollPosition&, bool animated = false) final;
226	void restoreScrollbar();	226	void restoreScrollbar();
227	void scheduleScrollToFocusedElement(SelectionRevealMode);	227	void scheduleScrollToFocusedElement(SelectionRevealMode);
228	void scrollToFocusedElementImmediatelyIfNeeded();	228	void scrollToFocusedElementImmediatelyIfNeeded();
Lines 658-663 public: a/Source/WebCore/page/FrameView.h_sec2
658		658
659	void renderLayerDidScroll(const RenderLayer&);	659	void renderLayerDidScroll(const RenderLayer&);
660		660
		661	WEBCORE_EXPORT void scrollToOffsetWithAnimation(const ScrollOffset&, ScrollType = ScrollType::Programmatic, ScrollClamping = ScrollClamping::Clamped);
		662
661	protected:	663	protected:
662	bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect) final;	664	bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect) final;
663	void scrollContentsSlowPath(const IntRect& updateRect) final;	665	void scrollContentsSlowPath(const IntRect& updateRect) final;



/*
 * Copyright (C) 2019 Igalia S.L. All rights reserved.
 *
 * 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
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "ScrollBehavior.h"

#include "Element.h"
#include "RenderElement.h"
#include "RenderStyle.h"
#include "Settings.h"

namespace WebCore {

bool useSmoothScrolling(ScrollBehavior behavior, Element& associatedElement)
{
    if (!associatedElement.document().settings().CSSOMViewSmoothScrollingEnabled() || !associatedElement.renderer())
        return false;

    // https://drafts.csswg.org/cssom-view/#scrolling
    switch (behavior) {
    case ScrollBehavior::Auto:
        return associatedElement.renderer()->style().useSmoothScrolling();
    case ScrollBehavior::Instant:
        return false;
    case ScrollBehavior::Smooth:
        return true;
    }
    ASSERT_NOT_REACHED();
    return false;
}

} // namespace WebCore



/*
 * Copyright (C) 2019 Igalia S.L. All rights reserved.
 *
 * 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
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

namespace WebCore {

class Element;

enum class ScrollBehavior : uint8_t {
    Auto = 0,
    Instant,
    Smooth
};

bool useSmoothScrolling(ScrollBehavior, Element& associatedElement);

} // namespace WebCore



/*
 * Copyright (C) 2019 Igalia S.L. All rights reserved.
 *
 * 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
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

enum ScrollBehavior { "auto", "instant", "smooth" };



#pragma once

#include "ScrollLogicalPosition.h"
#include "ScrollOptions.h"

namespace WebCore {

struct ScrollIntoViewOptions : ScrollOptions {

struct ScrollIntoViewOptions {
    Optional<ScrollLogicalPosition> blockPosition { ScrollLogicalPosition::Start };
    Optional<ScrollLogicalPosition> inlinePosition { ScrollLogicalPosition::Nearest };
};



 * Boston, MA 02110-1301, USA.
 */

dictionary ScrollIntoViewOptions : ScrollOptions {
dictionary ScrollIntoViewOptions {
    [ImplementedAs=blockPosition] ScrollLogicalPosition block = "start";
    [ImplementedAs=inlinePosition] ScrollLogicalPosition inline = "nearest";
};



/*
 * Copyright (C) 2019 Igalia S.L. All rights reserved.
 *
 * 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
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include "ScrollBehavior.h"

namespace WebCore {

struct ScrollOptions {
    Optional<ScrollBehavior> behavior { ScrollBehavior::Auto };
};

} // namespace WebCore



/*
 * Copyright (C) 2019 Igalia S.L. All rights reserved.
 *
 * 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
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

dictionary ScrollOptions {
    ScrollBehavior behavior = "auto";
};




#pragma once

#include "ScrollOptions.h"
#include <cmath>
#include <wtf/Optional.h>

namespace WebCore {

struct ScrollToOptions : ScrollOptions {
    Optional<double> left;
    Optional<double> top;

    ScrollToOptions() = default;
    ScrollToOptions(double x, double y)
        : left(x)
        , top(y)
    { }
};

inline double normalizeNonFiniteValueOrFallBackTo(Optional<double> value, double fallbackValue)

// FIXME(https://webkit.org/b/88339): Consider using FloatPoint or DoublePoint for fallback and return values.
inline ScrollToOptions normalizeNonFiniteCoordinatesOrFallBackTo(const ScrollToOptions& value, double x, double y)
{
    ScrollToOptions options = value;
    options.left = normalizeNonFiniteValueOrFallBackTo(value.left, x);
    options.top = normalizeNonFiniteValueOrFallBackTo(value.top, y);
    return options;



 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

dictionary ScrollToOptions : ScrollOptions {
dictionary ScrollToOptions {
    unrestricted double left;
    unrestricted double top;
};

Lines 615-620 syntheticEditingCommandsEnabled: a/Source/WebCore/page/Settings.yaml_sec1
- a/Source/WebCore/page/Settings.yaml +3 lines
615	CSSOMViewScrollingAPIEnabled:	615	CSSOMViewScrollingAPIEnabled:
616	initial: false	616	initial: false
617		617
		618	CSSOMViewSmoothScrollingEnabled:
		619	initial: false
		620
618	inputEventsEnabled:	621	inputEventsEnabled:
619	initial: true	622	initial: true
620		623




    bool inBackForwardCache = frameView->frame().document()->backForwardCacheState() != Document::NotInBackForwardCache;
    bool inProgrammaticScroll = scrollableArea.currentScrollType() == ScrollType::Programmatic;
    bool animated = false;

#if PLATFORM(IOS_FAMILY)
    animated = scrollableArea.currentScrollBehaviorType() == ScrollBehaviorType::Smooth;
#endif

    // The scroll position of animated scrolling will be set from the the UI process. So it shouldn't be set now.
    if (!animated && (inProgrammaticScroll || inBackForwardCache))
        updateScrollPositionAfterAsyncScroll(scrollingNodeID, scrollPosition, { }, ScrollType::Programmatic, ScrollingLayerPositionAction::Set);

    // If this frame view's document is being put into the back/forward cache, we don't want to update our

    if (!stateNode)
        return false;

#if PLATFORM(IOS_FAMILY)
    if (animated)
        scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::InUINativeAnimation);
    else
        scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
#else
    // If web scroll animation is in progress, this is set by scroll animator, otherwise, the animation should stop first.
    if (!scrollableArea.isWebScrollAnimationInProgress())
        scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
#endif

    stateNode->setRequestedScrollPosition(scrollPosition, inProgrammaticScroll, animated);
    return true;
}


    m_updateNodeScrollPositionTimer.startOneShot(0_s);
}

void AsyncScrollingCoordinator::setScrollAnimationInProgress(ScrollingNodeID nodeID, bool isScrollAnimationInProgress)
{
    ASSERT(isMainThread());

    if (!m_page)
        return;

    auto* frameView = frameViewForScrollingNode(nodeID);
    if (!frameView)
        return;

    if (nodeID == frameView->scrollingNodeID()) {
        if (!isScrollAnimationInProgress)
            frameView->setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
        return;
    }

    // Overflow-scroll area.
    if (auto* scrollableArea = frameView->scrollableAreaForScrollLayerID(nodeID)) {
        if (!isScrollAnimationInProgress)
            scrollableArea->setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
    }
}

void AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired()
{
    updateScrollPositionAfterAsyncScroll(m_scheduledScrollUpdate.nodeID, m_scheduledScrollUpdate.scrollPosition, m_scheduledScrollUpdate.layoutViewportOrigin, ScrollType::User, m_scheduledScrollUpdate.updateLayerPositionAction);

Lines 53-58 public: a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h_sec1
- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h +2 lines
53		53
54	WEBCORE_EXPORT void scheduleUpdateScrollPositionAfterAsyncScroll(ScrollingNodeID, const FloatPoint&, const Optional<FloatPoint>& layoutViewportOrigin, ScrollingLayerPositionAction);	54	WEBCORE_EXPORT void scheduleUpdateScrollPositionAfterAsyncScroll(ScrollingNodeID, const FloatPoint&, const Optional<FloatPoint>& layoutViewportOrigin, ScrollingLayerPositionAction);
55		55
		56	WEBCORE_EXPORT void setScrollAnimationInProgress(ScrollingNodeID, bool isScrollAnimationInProgress);
		57
56	#if PLATFORM(COCOA)	58	#if PLATFORM(COCOA)
57	WEBCORE_EXPORT void setActiveScrollSnapIndices(ScrollingNodeID, unsigned horizontalIndex, unsigned verticalIndex);	59	WEBCORE_EXPORT void setActiveScrollSnapIndices(ScrollingNodeID, unsigned horizontalIndex, unsigned verticalIndex);
58	void deferWheelEventTestCompletionForReason(WheelEventTestMonitor::ScrollableAreaIdentifier, WheelEventTestMonitor::DeferReason) const;	60	void deferWheelEventTestCompletionForReason(WheelEventTestMonitor::ScrollableAreaIdentifier, WheelEventTestMonitor::DeferReason) const;




    const FloatPoint& requestedScrollPosition() const { return m_requestedScrollPosition; }
    bool requestedScrollPositionRepresentsProgrammaticScroll() const { return m_requestedScrollPositionRepresentsProgrammaticScroll; }
    bool requestedScrollPositionWithAnimation() const { return m_requestedScrollPositionWithAnimation; }
    WEBCORE_EXPORT void setRequestedScrollPosition(const FloatPoint&, bool representsProgrammaticScroll, bool requestedWithAnimation = false);

    bool isMonitoringWheelEvents() const { return m_isMonitoringWheelEvents; }
    WEBCORE_EXPORT void setIsMonitoringWheelEvents(bool);

    ScrollableAreaParameters m_scrollableAreaParameters;

    bool m_requestedScrollPositionRepresentsProgrammaticScroll { false };
    bool m_requestedScrollPositionWithAnimation { false };
    bool m_isMonitoringWheelEvents { false };
};


Lines 83-89 public: a/Source/WebCore/page/scrolling/ScrollingTree.h_sec1
- a/Source/WebCore/page/scrolling/ScrollingTree.h -1 / +4 lines
83	virtual void scrollingTreeNodeDidScroll(ScrollingTreeScrollingNode&, ScrollingLayerPositionAction = ScrollingLayerPositionAction::Sync) = 0;	83	virtual void scrollingTreeNodeDidScroll(ScrollingTreeScrollingNode&, ScrollingLayerPositionAction = ScrollingLayerPositionAction::Sync) = 0;
84		84
85	// Called for requested scroll position updates.	85	// Called for requested scroll position updates.
86	virtual void scrollingTreeNodeRequestsScroll(ScrollingNodeID, const FloatPoint& /scrollPosition/, bool /representsProgrammaticScroll/) { }	86	virtual void scrollingTreeNodeRequestsScroll(ScrollingNodeID, const FloatPoint& /scrollPosition/, bool /representsProgrammaticScroll/, bool /withAnimation/) { }
		87
		88	// Called for scroll animation status updates.
		89	virtual void scrollingTreeNodeIsScrollAnimationInProgressDidChange(WebCore::ScrollingNodeID, bool /isScrollAnimationInProgress/) { }
87		90
88	// Delegated scrolling/zooming has caused the viewport to change, so update viewport-constrained layers	91	// Delegated scrolling/zooming has caused the viewport to change, so update viewport-constrained layers
89	WEBCORE_EXPORT void mainFrameViewportChangedViaDelegatedScrolling(const FloatPoint& scrollPosition, const WebCore::FloatRect& layoutViewport, double scale);	92	WEBCORE_EXPORT void mainFrameViewportChangedViaDelegatedScrolling(const FloatPoint& scrollPosition, const WebCore::FloatRect& layoutViewport, double scale);

Lines 108-114 void ScrollingTreeScrollingNode::commitStateAfterChildren(const ScrollingStateNo a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp_sec1
- a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp -5 / +47 lines
108	{	108	{
109	const ScrollingStateScrollingNode& scrollingStateNode = downcast<ScrollingStateScrollingNode>(stateNode);	109	const ScrollingStateScrollingNode& scrollingStateNode = downcast<ScrollingStateScrollingNode>(stateNode);
110	if (scrollingStateNode.hasChangedProperty(ScrollingStateScrollingNode::RequestedScrollPosition))	110	if (scrollingStateNode.hasChangedProperty(ScrollingStateScrollingNode::RequestedScrollPosition))
111	scrollingTree().scrollingTreeNodeRequestsScroll(scrollingNodeID(), scrollingStateNode.requestedScrollPosition(), scrollingStateNode.requestedScrollPositionRepresentsProgrammaticScroll());	111	scrollingTree().scrollingTreeNodeRequestsScroll(scrollingNodeID(), scrollingStateNode.requestedScrollPosition(), scrollingStateNode.requestedScrollPositionRepresentsProgrammaticScroll(), scrollingStateNode.requestedScrollPositionWithAnimation());
112		112
113	m_isFirstCommit = false;	113	m_isFirstCommit = false;
114	}	114	}
Lines 157-167 void ScrollingTreeScrollingNode::scrollBy(const FloatSize& delta, ScrollPosition a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp_sec2
157	scrollTo(currentScrollPosition() + delta, ScrollType::User, clamp);	157	scrollTo(currentScrollPosition() + delta, ScrollType::User, clamp);
158	}	158	}
159		159
160	void ScrollingTreeScrollingNode::scrollTo(const FloatPoint& position, ScrollType scrollType, ScrollPositionClamp clamp)	160	void ScrollingTreeScrollingNode::scrollTo(const FloatPoint& position, ScrollType scrollType, ScrollPositionClamp clamp, bool needSyncScrollPosition)
161	{	161	{
162	if (position == m_currentScrollPosition)	162	if (position == m_currentScrollPosition) {
		163	// Send the scroll position to the Web process.
		164	if (requestScrollWithAnimation() && needSyncScrollPosition)
		165	scrollingTree().scrollingTreeNodeDidScroll(*this, ScrollingLayerPositionAction::Sync);
		166	scrollingTree().scrollingTreeNodeIsScrollAnimationInProgressDidChange(scrollingNodeID(), false);
		167	setRequestScrollWithAnimation(false);
163	return;	168	return;
		169	}
164		170
		171	// If during a scroll animation, need to stop it before starting a new one.
		172	if (scrollAnimationInProgress())
		173	setNeedsStopCurrentScrollAnimation(true);
165	scrollingTree().setIsHandlingProgrammaticScroll(scrollType == ScrollType::Programmatic);	174	scrollingTree().setIsHandlingProgrammaticScroll(scrollType == ScrollType::Programmatic);
166		175
167	m_currentScrollPosition = adjustedScrollPosition(position, clamp);	176	m_currentScrollPosition = adjustedScrollPosition(position, clamp);
Lines 171-176 void ScrollingTreeScrollingNode::scrollTo(const FloatPoint& position, ScrollType a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp_sec3
171	updateViewportForCurrentScrollPosition();	180	updateViewportForCurrentScrollPosition();
172	currentScrollPositionChanged();	181	currentScrollPositionChanged();
173		182
		183	setNeedsStopCurrentScrollAnimation(false);
		184	setRequestScrollWithAnimation(false);
174	scrollingTree().setIsHandlingProgrammaticScroll(false);	185	scrollingTree().setIsHandlingProgrammaticScroll(false);
175	}	186	}
176		187
Lines 179-186 void ScrollingTreeScrollingNode::currentScrollPositionChanged() a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp_sec4
179	repositionScrollingLayers();	190	repositionScrollingLayers();
180	repositionRelatedLayers();	191	repositionRelatedLayers();
181		192
182	scrollingTree().notifyRelatedNodesAfterScrollPositionChange(*this);	193	if (!requestScrollWithAnimation()) {
183	scrollingTree().scrollingTreeNodeDidScroll(*this);	194	scrollingTree().notifyRelatedNodesAfterScrollPositionChange(*this);
		195	scrollingTree().scrollingTreeNodeDidScroll(*this);
		196	}
184	}	197	}
185		198
186	bool ScrollingTreeScrollingNode::scrollPositionAndLayoutViewportMatch(const FloatPoint& position, Optional<FloatRect>)	199	bool ScrollingTreeScrollingNode::scrollPositionAndLayoutViewportMatch(const FloatPoint& position, Optional<FloatRect>)
Lines 266-271 void ScrollingTreeScrollingNode::dumpProperties(TextStream& ts, ScrollingStateTr a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp_sec5
266	ts.dumpProperty("scrollable area parameters", m_scrollableAreaParameters);	279	ts.dumpProperty("scrollable area parameters", m_scrollableAreaParameters);
267	}	280	}
268		281
		282	void ScrollingTreeScrollingNode::setRequestScrollWithAnimation(bool withAnimation)
		283	{
		284	m_requestScrollWithAnimation = withAnimation;
		285	}
		286
		287	bool ScrollingTreeScrollingNode::requestScrollWithAnimation() const
		288	{
		289	return m_requestScrollWithAnimation;
		290	}
		291
		292	void ScrollingTreeScrollingNode::setScrollAnimationInProgress(bool inProgress)
		293	{
		294	m_scrollAnimationInProgress = inProgress;
		295	}
		296
		297	bool ScrollingTreeScrollingNode::scrollAnimationInProgress() const
		298	{
		299	return m_scrollAnimationInProgress;
		300	}
		301
		302	void ScrollingTreeScrollingNode::setNeedsStopCurrentScrollAnimation(bool stop)
		303	{
		304	m_needsStopCurrentScrollAnimation = stop;
		305	}
		306
		307	bool ScrollingTreeScrollingNode::needsStopCurrentScrollAnimation() const
		308	{
		309	return m_needsStopCurrentScrollAnimation;
		310	}
269	} // namespace WebCore	311	} // namespace WebCore
270		312
271	#endif // ENABLE(ASYNC_SCROLLING)	313	#endif // ENABLE(ASYNC_SCROLLING)

Lines 60-66 public: a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h_sec1
- a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h -1 / +11 lines
60	FloatSize scrollDeltaSinceLastCommit() const { return m_currentScrollPosition - m_lastCommittedScrollPosition; }	60	FloatSize scrollDeltaSinceLastCommit() const { return m_currentScrollPosition - m_lastCommittedScrollPosition; }
61		61
62	// These are imperative; they adjust the scrolling layers.	62	// These are imperative; they adjust the scrolling layers.
63	void scrollTo(const FloatPoint&, ScrollType = ScrollType::User, ScrollPositionClamp = ScrollPositionClamp::ToContentEdges);	63	void scrollTo(const FloatPoint&, ScrollType = ScrollType::User, ScrollPositionClamp = ScrollPositionClamp::ToContentEdges, bool needSyncScrollPosition = false);
64	void scrollBy(const FloatSize&, ScrollPositionClamp = ScrollPositionClamp::ToContentEdges);	64	void scrollBy(const FloatSize&, ScrollPositionClamp = ScrollPositionClamp::ToContentEdges);
65		65
66	void wasScrolledByDelegatedScrolling(const FloatPoint& position, Optional<FloatRect> overrideLayoutViewport = { }, ScrollingLayerPositionAction = ScrollingLayerPositionAction::Sync);	66	void wasScrolledByDelegatedScrolling(const FloatPoint& position, Optional<FloatRect> overrideLayoutViewport = { }, ScrollingLayerPositionAction = ScrollingLayerPositionAction::Sync);
Lines 91-96 public: a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h_sec2
91	const LayerRepresentation& scrollContainerLayer() const { return m_scrollContainerLayer; }	91	const LayerRepresentation& scrollContainerLayer() const { return m_scrollContainerLayer; }
92	const LayerRepresentation& scrolledContentsLayer() const { return m_scrolledContentsLayer; }	92	const LayerRepresentation& scrolledContentsLayer() const { return m_scrolledContentsLayer; }
93		93
		94	void setRequestScrollWithAnimation(bool);
		95	bool requestScrollWithAnimation() const;
		96	void setScrollAnimationInProgress(bool);
		97	bool scrollAnimationInProgress() const;
		98	void setNeedsStopCurrentScrollAnimation(bool);
		99	bool needsStopCurrentScrollAnimation() const;
		100
94	protected:	101	protected:
95	ScrollingTreeScrollingNode(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);	102	ScrollingTreeScrollingNode(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
96		103
Lines 147-152 private: a/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h_sec3
147	#endif	154	#endif
148	ScrollableAreaParameters m_scrollableAreaParameters;	155	ScrollableAreaParameters m_scrollableAreaParameters;
149	bool m_isFirstCommit { true };	156	bool m_isFirstCommit { true };
		157	bool m_requestScrollWithAnimation { false };
		158	bool m_scrollAnimationInProgress { false };
		159	bool m_needsStopCurrentScrollAnimation { false };
150		160
151	LayerRepresentation m_scrollContainerLayer;	161	LayerRepresentation m_scrollContainerLayer;
152	LayerRepresentation m_scrolledContentsLayer;	162	LayerRepresentation m_scrolledContentsLayer;




class FloatPoint;
class ScrollableArea;
enum class ScrollClamping : uint8_t;

class ScrollAnimation {
    WTF_MAKE_FAST_ALLOCATED;
public:
    virtual ~ScrollAnimation() { };
    virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float /* step */, float /* multiplier */) { return true; };
    virtual void scroll(const FloatPoint&) { };
    virtual void stop() = 0;
    virtual void updateVisibleLengths() { };
    virtual void setCurrentPosition(const FloatPoint&) { };
    virtual void serviceAnimation() { };
    virtual bool isScrollInProgress() const { return false; }

protected:
    ScrollAnimation(ScrollableArea& scrollableArea)

Lines 165-168 void ScrollAnimationKinetic::animationTimerFired() a/Source/WebCore/platform/ScrollAnimationKinetic.cpp_sec1
- a/Source/WebCore/platform/ScrollAnimationKinetic.cpp +5 lines
165	m_notifyPositionChangedFunction(FloatPoint(m_position));	165	m_notifyPositionChangedFunction(FloatPoint(m_position));
166	}	166	}
167		167
		168	bool ScrollAnimationKinetic::isScrollInProgress() const
		169	{
		170	return m_animationTimer.isActive();
		171	}
		172
168	} // namespace WebCore	173	} // namespace WebCore

Lines 66-71 public: a/Source/WebCore/platform/ScrollAnimationKinetic.h_sec1
- a/Source/WebCore/platform/ScrollAnimationKinetic.h +1 lines
66	private:	66	private:
67	void stop() override;	67	void stop() override;
68	void animationTimerFired();	68	void animationTimerFired();
		69	bool isScrollInProgress() const override;
69		70
70	std::function<void(FloatPoint&&)> m_notifyPositionChangedFunction;	71	std::function<void(FloatPoint&&)> m_notifyPositionChangedFunction;
71		72



#include "config.h"
#include "ScrollAnimationSmooth.h"

#if ENABLE(SMOOTH_SCROLLING)

#include "FloatPoint.h"
#include "ScrollableArea.h"


static const double frameRate = 60;
static const Seconds tickTime = 1_s / frameRate;
static const Seconds minimumTimerInterval { 1_ms };
static const double smoothFactorForProgrammaticScroll = 5;

ScrollAnimationSmooth::ScrollAnimationSmooth(ScrollableArea& scrollableArea, const FloatPoint& position, WTF::Function<void (FloatPoint&&)>&& notifyPositionChangedFunction)
    : ScrollAnimation(scrollableArea)

    return needToScroll;
}

void ScrollAnimationSmooth::scroll(const FloatPoint& position)
{
    ScrollGranularity granularity = ScrollByPage;
    bool needToScroll = updatePerAxisData(m_horizontalData, granularity, position.x() - m_horizontalData.currentPosition, m_scrollableArea.minimumScrollPosition().x(), m_scrollableArea.maximumScrollPosition().x(), smoothFactorForProgrammaticScroll);
    needToScroll |=
        updatePerAxisData(m_verticalData, granularity, position.y() - m_verticalData.currentPosition, m_scrollableArea.minimumScrollPosition().y(), m_scrollableArea.maximumScrollPosition().y(), smoothFactorForProgrammaticScroll);
    if (needToScroll && !animationTimerActive()) {
        m_startTime = m_horizontalData.startTime;
        animationTimerFired();
    }
};

void ScrollAnimationSmooth::stop()
{
    m_animationTimer.stop();

    }
}

bool ScrollAnimationSmooth::updatePerAxisData(PerAxisData& data, ScrollGranularity granularity, float delta, float minScrollPosition, float maxScrollPosition, double smoothFactor)
{
    if (!data.startTime || !delta || (delta < 0) != (data.desiredPosition - data.currentPosition < 0)) {
        data.desiredPosition = data.currentPosition;

    Curve coastTimeCurve;
    getAnimationParametersForGranularity(granularity, animationTime, repeatMinimumSustainTime, attackTime, releaseTime, coastTimeCurve, maximumCoastTime);

    animationTime *= smoothFactor;
    repeatMinimumSustainTime *= smoothFactor;
    attackTime *= smoothFactor;
    releaseTime *= smoothFactor;
    maximumCoastTime *= smoothFactor;

    data.desiredPosition = newPosition;
    if (!data.startTime)
        data.attackTime = attackTime;

}

} // namespace WebCore

#endif // ENABLE(SMOOTH_SCROLLING)




#include "ScrollAnimation.h"

#if ENABLE(SMOOTH_SCROLLING)

#include "Timer.h"

namespace WebCore {

class FloatPoint;
class ScrollableArea;
enum class ScrollClamping : uint8_t;

class ScrollAnimationSmooth final: public ScrollAnimation {
public:


private:
    bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier) override;
    void scroll(const FloatPoint&) override;
    void stop() override;
    void updateVisibleLengths() override;
    void setCurrentPosition(const FloatPoint&) override;
    bool isScrollInProgress() const override { return animationTimerActive(); }

    struct PerAxisData {
        PerAxisData() = delete;

        int visibleLength { 0 };
    };

    bool updatePerAxisData(PerAxisData&, ScrollGranularity, float delta, float minScrollPosition, float maxScrollPosition, double smoothFactor = 1);
    bool animateScroll(PerAxisData&, MonotonicTime currentTime);

    void requestAnimationTimerFired();


} // namespace WebCore

#endif // ENABLE(SMOOTH_SCROLLING)



#include "FloatPoint.h"
#include "LayoutSize.h"
#include "PlatformWheelEvent.h"
#include "ScrollAnimationSmooth.h"
#include "ScrollableArea.h"
#include <algorithm>


#if ENABLE(CSS_SCROLL_SNAP) || ENABLE(RUBBER_BANDING)
    , m_scrollController(*this)
#endif
    , m_animationProgrammaticScroll(makeUnique<ScrollAnimationSmooth>(scrollableArea, m_currentPosition, [this](FloatPoint&& position) {
        auto previousScrollType = m_scrollableArea.currentScrollType();
        m_scrollableArea.setCurrentScrollType(ScrollType::Programmatic);
        bool updated = m_scrollableArea.requestScrollPositionUpdate(roundedIntPoint(position));
        m_scrollableArea.setCurrentScrollType(previousScrollType);
        if (updated)
            return;

        FloatSize delta = position - m_currentPosition;
        m_currentPosition = WTFMove(position);
        notifyPositionChanged(delta);
    }))
{
}

ScrollAnimator::~ScrollAnimator() = default;

bool ScrollAnimator::isScrollInProgress() const
{
    // FIXME (TODO): This should also take into account animations in derived classes.
    return m_animationProgrammaticScroll->isScrollInProgress();
}

bool ScrollAnimator::scroll(ScrollbarOrientation orientation, ScrollGranularity, float step, float multiplier)
{
    FloatPoint currentPosition = this->currentPosition();

    return true;
}

void ScrollAnimator::scrollToOffset(const FloatPoint& offset)
{
    m_animationProgrammaticScroll->setCurrentPosition(m_currentPosition);
    auto newPosition = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));
    m_animationProgrammaticScroll->scroll(newPosition);
    m_scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::WebAnimationTimerStarted);
}

void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping)
{
    FloatPoint newPositon = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));

}
#endif

void ScrollAnimator::cancelAnimations()
{
#if !USE(REQUEST_ANIMATION_FRAME_TIMER)
    m_animationProgrammaticScroll->stop();
#endif
    m_scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
}

void ScrollAnimator::serviceScrollAnimations()
{
#if !USE(REQUEST_ANIMATION_FRAME_TIMER)
    m_animationProgrammaticScroll->serviceAnimation();
#endif
}

void ScrollAnimator::willEndLiveResize()
{
    m_animationProgrammaticScroll->updateVisibleLengths();
}

void ScrollAnimator::didAddVerticalScrollbar(Scrollbar*)
{
    m_animationProgrammaticScroll->updateVisibleLengths();
}

void ScrollAnimator::didAddHorizontalScrollbar(Scrollbar*)
{
    m_animationProgrammaticScroll->updateVisibleLengths();
}

} // namespace WebCore




class FloatPoint;
class PlatformTouchEvent;
class ScrollAnimation;
class ScrollableArea;
class Scrollbar;
class WheelEventTestMonitor;

    // The base class implementation always scrolls immediately, never animates.
    virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier);

    void scrollToOffset(const FloatPoint&);
    virtual void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);

    ScrollableArea& scrollableArea() const { return m_scrollableArea; }

    void setCurrentPosition(const FloatPoint&);
    const FloatPoint& currentPosition() const { return m_currentPosition; }

    virtual void cancelAnimations();
    virtual void serviceScrollAnimations();

    virtual void contentAreaWillPaint() const { }
    virtual void mouseEnteredContentArea() { }

    virtual void mouseIsDownInScrollbar(Scrollbar*, bool) const { }
    virtual void willStartLiveResize() { }
    virtual void contentsResized() const { }
    virtual void willEndLiveResize();
    virtual void contentAreaDidShow() { }
    virtual void contentAreaDidHide() { }

    virtual void lockOverlayScrollbarStateToHidden(bool) { }
    virtual bool scrollbarsCanBeActive() const { return true; }

    virtual void didAddVerticalScrollbar(Scrollbar*);
    virtual void willRemoveVerticalScrollbar(Scrollbar*) { }
    virtual void didAddHorizontalScrollbar(Scrollbar*);
    virtual void willRemoveHorizontalScrollbar(Scrollbar*) { }

    virtual void invalidateScrollbarPartLayers(Scrollbar*) { }


    virtual bool isRubberBandInProgress() const { return false; }
    virtual bool isScrollSnapInProgress() const { return false; }
    bool isScrollInProgress() const;

    void setWheelEventTestMonitor(RefPtr<WheelEventTestMonitor>&& testMonitor) { m_wheelEventTestMonitor = testMonitor; }


    ScrollController m_scrollController;
#endif
    FloatPoint m_currentPosition;

    std::unique_ptr<ScrollAnimation> m_animationProgrammaticScroll;
};

} // namespace WebCore



    ToContentEdges,
};

enum class ScrollBehaviorType : uint8_t {
    Instant,
    Smooth,
};

enum class ScrollBehaviorStatus : uint8_t {
    NotInAnimation,
    WebAnimationTimerStarted,
#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
    InUINativeAnimation,
#endif
};

inline ScrollDirection logicalToPhysical(ScrollLogicalDirection direction, bool isVertical, bool isFlipped)
{
    switch (direction) {

Lines 461-470 void ScrollView::completeUpdatesAfterScrollTo(const IntSize& scrollDelta) a/Source/WebCore/platform/ScrollView.cpp_sec1
- a/Source/WebCore/platform/ScrollView.cpp -4 / +11 lines
461	updateCompositingLayersAfterScrolling();	461	updateCompositingLayersAfterScrolling();
462	}	462	}
463		463
464	void ScrollView::setScrollPosition(const ScrollPosition& scrollPosition)	464	void ScrollView::setScrollPosition(const ScrollPosition& scrollPosition, bool/* animated*/)
465	{	465	{
466	LOG_WITH_STREAM(Scrolling, stream << "ScrollView::setScrollPosition " << scrollPosition);	466	LOG_WITH_STREAM(Scrolling, stream << "ScrollView::setScrollPosition " << scrollPosition);
467		467	#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
		468	setCurrentScrollBehaviorType(ScrollBehaviorType::Instant);
		469	#endif
468	if (prohibitsScrolling())	470	if (prohibitsScrolling())
469	return;	471	return;
470		472
Lines 475-487 void ScrollView::setScrollPosition(const ScrollPosition& scrollPosition) a/Source/WebCore/platform/ScrollView.cpp_sec2
475		477
476	ScrollPosition newScrollPosition = !delegatesScrolling() ? adjustScrollPositionWithinRange(scrollPosition) : scrollPosition;	478	ScrollPosition newScrollPosition = !delegatesScrolling() ? adjustScrollPositionWithinRange(scrollPosition) : scrollPosition;
477		479
478	if ((!delegatesScrolling() \|\| currentScrollType() == ScrollType::User) && newScrollPosition == this->scrollPosition())	480	if ((!delegatesScrolling() \|\| currentScrollType() == ScrollType::User) && !isScrollInProgress() && newScrollPosition == this->scrollPosition())
479	return;	481	return;
480		482
		483	if (isWebScrollAnimationInProgress())
		484	scrollAnimator().cancelAnimations();
		485
481	if (requestScrollPositionUpdate(newScrollPosition))	486	if (requestScrollPositionUpdate(newScrollPosition))
482	return;	487	return;
483		488
484	updateScrollbars(newScrollPosition);	489	updateScrollbars(newScrollPosition);
		490	setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
485	}	491	}
486		492
487	bool ScrollView::scroll(ScrollDirection direction, ScrollGranularity granularity)	493	bool ScrollView::scroll(ScrollDirection direction, ScrollGranularity granularity)
Lines 538-544 void ScrollView::updateScrollbars(const ScrollPosition& desiredPosition) a/Source/WebCore/platform/ScrollView.cpp_sec3
538		544
539	if (!managesScrollbars()) {	545	if (!managesScrollbars()) {
540	if (scrollOriginChanged()) {	546	if (scrollOriginChanged()) {
541	ScrollableArea::scrollToOffsetWithoutAnimation(scrollOffsetFromPosition(desiredPosition));	547	if (!requestScrollPositionUpdate(desiredPosition))
		548	ScrollableArea::scrollToOffsetWithoutAnimation(scrollOffsetFromPosition(desiredPosition));
542	resetScrollOriginChanged();	549	resetScrollOriginChanged();
543	}	550	}
544	return;	551	return;

Lines 260-266 public: a/Source/WebCore/platform/ScrollView.h_sec1
- a/Source/WebCore/platform/ScrollView.h -1 / +1 lines
260	ScrollPosition cachedScrollPosition() const { return m_cachedScrollPosition; }	260	ScrollPosition cachedScrollPosition() const { return m_cachedScrollPosition; }
261		261
262	// Functions for scrolling the view.	262	// Functions for scrolling the view.
263	virtual void setScrollPosition(const ScrollPosition&);	263	virtual void setScrollPosition(const ScrollPosition&, bool animated = false);
264	void scrollBy(const IntSize& s) { return setScrollPosition(scrollPosition() + s); }	264	void scrollBy(const IntSize& s) { return setScrollPosition(scrollPosition() + s); }
265		265
266	// This function scrolls by lines, pages or pixels.	266	// This function scrolls by lines, pages or pixels.



    , m_scrollOriginChanged(false)
    , m_currentScrollType(static_cast<unsigned>(ScrollType::User))
    , m_scrollShouldClearLatchedState(false)
#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
    , m_currentScrollBehaviorType(static_cast<unsigned>(ScrollBehaviorType::Instant))
#endif
{
}


    return step;
}

bool ScrollableArea::isScrollInProgress()
{
    if (m_currentScrollBehaviorStatus == ScrollBehaviorStatus::WebAnimationTimerStarted) {
        if (!(m_scrollAnimator && scrollAnimator().isScrollInProgress()))
            m_currentScrollBehaviorStatus = ScrollBehaviorStatus::NotInAnimation;
    }
    return m_currentScrollBehaviorStatus != ScrollBehaviorStatus::NotInAnimation;
}

bool ScrollableArea::isWebScrollAnimationInProgress()
{
    if (m_currentScrollBehaviorStatus == ScrollBehaviorStatus::WebAnimationTimerStarted) {
        if (!(m_scrollAnimator && scrollAnimator().isScrollInProgress()))
            m_currentScrollBehaviorStatus = ScrollBehaviorStatus::NotInAnimation;
    }
    return m_currentScrollBehaviorStatus == ScrollBehaviorStatus::WebAnimationTimerStarted;
}

bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
{
    ScrollbarOrientation orientation;

    return scrollAnimator().scroll(orientation, granularity, step, multiplier);
}

void ScrollableArea::scrollToOffsetWithAnimation(const FloatPoint& offset, ScrollClamping)
{
    LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffset " << offset);
    scrollAnimator().scrollToOffset(offset);
}

void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping clamping)
{
    LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffsetWithoutAnimation " << offset);

// NOTE: Only called from Internals for testing.
void ScrollableArea::setScrollOffsetFromInternals(const ScrollOffset& offset)
{
    if (requestScrollPositionUpdate(scrollPositionFromOffset(offset)))
        return;

    setScrollOffsetFromAnimation(offset);
}

void ScrollableArea::setScrollOffsetFromAnimation(const ScrollOffset& offset)
{
    scrollPositionChanged(scrollPositionFromOffset(offset));
    if (requestScrollPositionUpdate(position))
        return;

    scrollPositionChanged(position);
}

void ScrollableArea::willStartLiveResize()

Lines 62-68 inline int offsetForOrientation(ScrollOffset offset, ScrollbarOrientation orient a/Source/WebCore/platform/ScrollableArea.h_sec1
- a/Source/WebCore/platform/ScrollableArea.h +17 lines
62		62
63	class ScrollableArea : public CanMakeWeakPtr<ScrollableArea> {	63	class ScrollableArea : public CanMakeWeakPtr<ScrollableArea> {
64	public:	64	public:
		65	WEBCORE_EXPORT bool isScrollInProgress();
		66	bool isWebScrollAnimationInProgress();
		67	ScrollBehaviorStatus currentScrollBehaviorStatus() const { return m_currentScrollBehaviorStatus; }
		68	void setScrollBehaviorStatus(ScrollBehaviorStatus status) { m_currentScrollBehaviorStatus = status; }
		69
65	WEBCORE_EXPORT bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);	70	WEBCORE_EXPORT bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
		71	WEBCORE_EXPORT void scrollToOffsetWithAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
66	WEBCORE_EXPORT void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);	72	WEBCORE_EXPORT void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
67	void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);	73	void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);
68		74
Lines 242-247 public: a/Source/WebCore/platform/ScrollableArea.h_sec2
242	ScrollType currentScrollType() const { return static_cast<ScrollType>(m_currentScrollType); }	248	ScrollType currentScrollType() const { return static_cast<ScrollType>(m_currentScrollType); }
243	void setCurrentScrollType(ScrollType scrollType) { m_currentScrollType = static_cast<unsigned>(scrollType); }	249	void setCurrentScrollType(ScrollType scrollType) { m_currentScrollType = static_cast<unsigned>(scrollType); }
244		250
		251	#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
		252	ScrollBehaviorType currentScrollBehaviorType() const { return static_cast<ScrollBehaviorType>(m_currentScrollBehaviorType); }
		253	void setCurrentScrollBehaviorType(ScrollBehaviorType scrollBehaviorType) { m_currentScrollBehaviorType = static_cast<unsigned>(scrollBehaviorType); }
		254	#endif
		255
245	bool scrollShouldClearLatchedState() const { return m_scrollShouldClearLatchedState; }	256	bool scrollShouldClearLatchedState() const { return m_scrollShouldClearLatchedState; }
246	void setScrollShouldClearLatchedState(bool shouldClear) { m_scrollShouldClearLatchedState = shouldClear; }	257	void setScrollShouldClearLatchedState(bool shouldClear) { m_scrollShouldClearLatchedState = shouldClear; }
247		258
Lines 378-383 private: a/Source/WebCore/platform/ScrollableArea.h_sec3
378	unsigned m_currentVerticalSnapPointIndex { 0 };	389	unsigned m_currentVerticalSnapPointIndex { 0 };
379	#endif	390	#endif
380		391
		392	ScrollBehaviorStatus m_currentScrollBehaviorStatus { ScrollBehaviorStatus::NotInAnimation };
		393
381	// There are 8 possible combinations of writing mode and direction. Scroll origin will be non-zero in the x or y axis	394	// There are 8 possible combinations of writing mode and direction. Scroll origin will be non-zero in the x or y axis
382	// if there is any reversed direction or writing-mode. The combinations are:	395	// if there is any reversed direction or writing-mode. The combinations are:
383	// writing-mode / direction scrollOrigin.x() set scrollOrigin.y() set	396	// writing-mode / direction scrollOrigin.x() set scrollOrigin.y() set
Lines 403-408 private: a/Source/WebCore/platform/ScrollableArea.h_sec4
403	unsigned m_scrollOriginChanged : 1;	416	unsigned m_scrollOriginChanged : 1;
404	unsigned m_currentScrollType : 1; // ScrollType	417	unsigned m_currentScrollType : 1; // ScrollType
405	unsigned m_scrollShouldClearLatchedState : 1;	418	unsigned m_scrollShouldClearLatchedState : 1;
		419	#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
		420	unsigned m_currentScrollBehaviorType : 1;
		421	#endif
		422
406	};	423	};
407		424
408	} // namespace WebCore	425	} // namespace WebCore

Lines 162-167 void ScrollAnimatorGeneric::willEndLiveResize() a/Source/WebCore/platform/generic/ScrollAnimatorGeneric.cpp_sec1
- a/Source/WebCore/platform/generic/ScrollAnimatorGeneric.cpp +2 lines
162		162
163	void ScrollAnimatorGeneric::updatePosition(FloatPoint&& position)	163	void ScrollAnimatorGeneric::updatePosition(FloatPoint&& position)
164	{	164	{
		165	if (m_scrollableArea.requestScrollPositionUpdate(roundedIntPoint(position)))
		166	return;
165	FloatSize delta = position - m_currentPosition;	167	FloatSize delta = position - m_currentPosition;
166	m_currentPosition = WTFMove(position);	168	m_currentPosition = WTFMove(position);
167	notifyPositionChanged(delta);	169	notifyPositionChanged(delta);

Lines 1155-1160 void ScrollAnimatorMac::notifyContentAreaScrolled(const FloatSize& delta) a/Source/WebCore/platform/mac/ScrollAnimatorMac.mm_sec1
- a/Source/WebCore/platform/mac/ScrollAnimatorMac.mm +1 lines
1155		1155
1156	void ScrollAnimatorMac::cancelAnimations()	1156	void ScrollAnimatorMac::cancelAnimations()
1157	{	1157	{
		1158	ScrollAnimator::cancelAnimations();
1158	m_haveScrolledSincePageLoad = false;	1159	m_haveScrolledSincePageLoad = false;
1159		1160
1160	if (scrollbarPaintTimerIsActive())	1161	if (scrollbarPaintTimerIsActive())



    layer.scrollAnimator().setWheelEventTestMonitor(page.wheelEventTestMonitor());
}

void RenderBox::setScrollLeft(int newLeft, ScrollType scrollType, bool animated, ScrollClamping clamping)
{
    if (!hasOverflowClip() || !layer())
        return;
    setupWheelEventMonitor(*layer());
    layer()->scrollToXPosition(newLeft, scrollType, animated, clamping);
}

void RenderBox::setScrollTop(int newTop, ScrollType scrollType, bool animated, ScrollClamping clamping)
{
    if (!hasOverflowClip() || !layer())
        return;
    setupWheelEventMonitor(*layer());
    layer()->scrollToYPosition(newTop, scrollType, animated, clamping);
}

void RenderBox::setScrollPosition(const ScrollPosition& position, ScrollType scrollType, bool animated, ScrollClamping clamping)
{
    if (!hasOverflowClip() || !layer())
        return;
    setupWheelEventMonitor(*layer());
    layer()->scrollToPosition(position, scrollType, animated, clamping);
}

void RenderBox::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const



    virtual int scrollTop() const;
    virtual int scrollWidth() const;
    virtual int scrollHeight() const;
    virtual void setScrollLeft(int, ScrollType, bool animated = false, ScrollClamping = ScrollClamping::Clamped);
    virtual void setScrollTop(int, ScrollType, bool animated = false, ScrollClamping = ScrollClamping::Clamped);
    void setScrollPosition(const ScrollPosition&, ScrollType, bool animated = false, ScrollClamping = ScrollClamping::Clamped);

    LayoutUnit marginTop() const override { return m_marginBox.top(); }
    LayoutUnit marginBottom() const override { return m_marginBox.bottom(); }



#include "ScaleTransformOperation.h"
#include "ScriptDisallowedScope.h"
#include "ScrollAnimator.h"
#include "ScrollBehavior.h"
#include "Scrollbar.h"
#include "ScrollbarTheme.h"
#include "ScrollingCoordinator.h"

    m_postLayoutScrollPosition = WTF::nullopt;
}

void RenderLayer::scrollToXPosition(int x, ScrollType scrollType, bool animated, ScrollClamping clamping)
{
    ScrollPosition position(x, m_scrollPosition.y());
    scrollToPosition(position, scrollType, animated, clamping);
}

void RenderLayer::scrollToYPosition(int y, ScrollType scrollType, bool animated, ScrollClamping clamping)
{
    ScrollPosition position(m_scrollPosition.x(), y);
    scrollToPosition(position, scrollType, animated, clamping);
}

void RenderLayer::scrollToPosition(const ScrollPosition& position, ScrollType scrollType, bool animated, ScrollClamping clamping)
{
    if (animated)
        scrollToOffsetWithAnimation(scrollOffsetFromPosition(position), scrollType, clamping);
    else
        scrollToOffset(scrollOffsetFromPosition(position), scrollType, clamping);
}

ScrollOffset RenderLayer::clampScrollOffset(const ScrollOffset& scrollOffset) const


void RenderLayer::scrollToOffset(const ScrollOffset& scrollOffset, ScrollType scrollType, ScrollClamping clamping)
{
#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
    setCurrentScrollBehaviorType(ScrollBehaviorType::Instant);
#endif
    if (isWebScrollAnimationInProgress())
        scrollAnimator().cancelAnimations();

    ScrollOffset clampedScrollOffset = clamping == ScrollClamping::Clamped ? clampScrollOffset(scrollOffset) : scrollOffset;
    if (clampedScrollOffset == this->scrollOffset()) {
#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
        // If UIScrollView is performing a scroll animation, the scroll offset of the Web process might be overridden.
        // So we need to call requestScrollPositionUpdate here and let it be checked on the UI process.
        // If the scroll offset on the UI process is different, the correct scroll offset needs to sync back to the Web process.
        if (currentScrollBehaviorStatus() == ScrollBehaviorStatus::InUINativeAnimation)
            requestScrollPositionUpdate(scrollPositionFromOffset(clampedScrollOffset));
#endif
        return;
    }

    auto previousScrollType = currentScrollType();
    setCurrentScrollType(scrollType);

    bool handled = false;
#if ENABLE(ASYNC_SCROLLING)
    handled = requestScrollPositionUpdate(scrollPositionFromOffset(clampedScrollOffset));
        handled = scrollingCoordinator->requestScrollPositionUpdate(*this, scrollPositionFromOffset(clampedScrollOffset));
#endif

    if (!handled)
        scrollToOffsetWithoutAnimation(clampedScrollOffset, clamping);

    setCurrentScrollType(previousScrollType);
    setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
}

bool RenderLayer::requestScrollPositionUpdate(const ScrollPosition& position)
{
#if ENABLE(ASYNC_SCROLLING)
    if (ScrollingCoordinator* scrollingCoordinator = page().scrollingCoordinator())
        return scrollingCoordinator->requestScrollPositionUpdate(*this, position);
#endif
    return false;
}

void RenderLayer::scrollToOffsetWithAnimation(const ScrollOffset& offset, ScrollType scrollType, ScrollClamping clamping)
{
    auto previousScrollType = currentScrollType();
    setCurrentScrollType(scrollType);

#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
    setCurrentScrollBehaviorType(ScrollBehaviorType::Smooth);
    if (requestScrollPositionUpdate(scrollPositionFromOffset(offset))) {
        setCurrentScrollType(previousScrollType);
        return;
    }
#endif

    ScrollOffset newScrollOffset = clamping == ScrollClamping::Clamped ? clampScrollOffset(offset) : offset;
    if (isWebScrollAnimationInProgress())
        scrollAnimator().cancelAnimations();
    if (newScrollOffset != this->scrollOffset())
        ScrollableArea::scrollToOffsetWithAnimation(newScrollOffset);
    setCurrentScrollType(previousScrollType);
}

void RenderLayer::scrollTo(const ScrollPosition& position)

#endif
    }
    
    if (m_scrollPosition == newPosition && !isScrollInProgress()) {
        // FIXME: Nothing guarantees we get a scrollTo() with an unchanged position at the end of a user gesture.
        // The ScrollingCoordinator probably needs to message the main thread when a gesture ends.
        if (requiresScrollPositionReconciliation()) {

        LayoutRect revealRect = getRectToExpose(layerBounds, localExposeRect, insideFixed, options.alignX, options.alignY);

        ScrollOffset clampedScrollOffset = clampScrollOffset(scrollOffset() + toIntSize(roundedIntRect(revealRect).location()));
        if (isScrollInProgress() || clampedScrollOffset != scrollOffset()) {
            ScrollOffset oldScrollOffset = scrollOffset();
            bool animated = (box->element() && useSmoothScrolling(options.behavior, *box->element()));
            scrollToPosition(scrollPositionFromOffset(clampedScrollOffset), ScrollType::Programmatic, animated);
            IntSize scrollOffsetDifference = clampedScrollOffset - oldScrollOffset;
            localExposeRect.move(-scrollOffsetDifference);
            newRect = LayoutRect(box->localToAbsoluteQuad(FloatQuad(FloatRect(localExposeRect)), UseTransforms).boundingBox());
        }

                LayoutRect viewRect = frameView.visibleContentRect(LegacyIOSDocumentVisibleRect);
                LayoutRect exposeRect = getRectToExpose(viewRect, absoluteRect, insideFixed, options.alignX, options.alignY);

                IntPoint scrollPosition(roundedIntPoint(exposeRect.location()));
                // Adjust offsets if they're outside of the allowable range.
                scrollPosition = scrollPosition.constrainedBetween(IntPoint(), IntPoint(frameView.contentsSize()));
                // FIXME: Should we use contentDocument()->scrollingElement()?
                // See https://github.com/w3c/csswg-drafts/issues/2977
                bool animated = ownerElement->contentDocument() && ownerElement->contentDocument()->documentElement() && useSmoothScrolling(options.behavior, *ownerElement->contentDocument()->documentElement());
                frameView.setScrollPosition(scrollPosition, animated);

                if (options.shouldAllowCrossOriginScrolling == ShouldAllowCrossOriginScrolling::Yes || frameView.safeToPropagateScrollToParent()) {
                    parentLayer = ownerElement->renderer()->enclosingLayer();

            // Avoid scrolling to the rounded value of revealRect.location() if we don't actually need to scroll
            if (revealRect != viewRect) {
                ScrollOffset clampedScrollPosition = roundedIntPoint(revealRect.location()).constrainedBetween(minScrollPosition, maxScrollPosition);
                // FIXME: Should we use document()->scrollingElement()?
                // See https://github.com/w3c/csswg-drafts/issues/2977
                bool animated = renderer().document().documentElement() && useSmoothScrolling(options.behavior, *renderer().document().documentElement());
                frameView.setScrollPosition(clampedScrollPosition, animated);
            }

            // This is the outermost view of a web page, so after scrolling this view we

Lines 50-55 a/Source/WebCore/rendering/RenderLayer.h_sec1
- a/Source/WebCore/rendering/RenderLayer.h -2 / +8 lines
50	#include "PaintInfo.h"	50	#include "PaintInfo.h"
51	#include "RenderBox.h"	51	#include "RenderBox.h"
52	#include "RenderPtr.h"	52	#include "RenderPtr.h"
		53	#include "ScrollBehavior.h"
53	#include "ScrollableArea.h"	54	#include "ScrollableArea.h"
54	#include <memory>	55	#include <memory>
55	#include <wtf/WeakPtr.h>	56	#include <wtf/WeakPtr.h>
Lines 134-139 struct ScrollRectToVisibleOptions { a/Source/WebCore/rendering/RenderLayer.h_sec2
134	const ScrollAlignment& alignX { ScrollAlignment::alignCenterIfNeeded };	135	const ScrollAlignment& alignX { ScrollAlignment::alignCenterIfNeeded };
135	const ScrollAlignment& alignY { ScrollAlignment::alignCenterIfNeeded };	136	const ScrollAlignment& alignY { ScrollAlignment::alignCenterIfNeeded };
136	ShouldAllowCrossOriginScrolling shouldAllowCrossOriginScrolling { ShouldAllowCrossOriginScrolling::No };	137	ShouldAllowCrossOriginScrolling shouldAllowCrossOriginScrolling { ShouldAllowCrossOriginScrolling::No };
		138	ScrollBehavior behavior { ScrollBehavior::Auto };
137	};	139	};
138		140
139	class RenderLayer final : public ScrollableArea {	141	class RenderLayer final : public ScrollableArea {
Lines 434-442 public: a/Source/WebCore/rendering/RenderLayer.h_sec3
434	void scrollByRecursively(const IntSize& delta, ScrollableArea** scrolledArea = nullptr);	436	void scrollByRecursively(const IntSize& delta, ScrollableArea** scrolledArea = nullptr);
435		437
436	WEBCORE_EXPORT void scrollToOffset(const ScrollOffset&, ScrollType = ScrollType::Programmatic, ScrollClamping = ScrollClamping::Clamped);	438	WEBCORE_EXPORT void scrollToOffset(const ScrollOffset&, ScrollType = ScrollType::Programmatic, ScrollClamping = ScrollClamping::Clamped);
		439	WEBCORE_EXPORT void scrollToOffsetWithAnimation(const ScrollOffset&, ScrollType = ScrollType::Programmatic, ScrollClamping = ScrollClamping::Clamped);
437		440
438	void scrollToXPosition(int x, ScrollType, ScrollClamping = ScrollClamping::Clamped);	441	bool requestScrollPositionUpdate(const ScrollPosition&) override;
439	void scrollToYPosition(int y, ScrollType, ScrollClamping = ScrollClamping::Clamped);	442
		443	void scrollToXPosition(int x, ScrollType, bool animated, ScrollClamping = ScrollClamping::Clamped);
		444	void scrollToYPosition(int y, ScrollType, bool animated, ScrollClamping = ScrollClamping::Clamped);
		445	void scrollToPosition(const ScrollPosition&, ScrollType, bool animated, ScrollClamping = ScrollClamping::Clamped);
440		446
441	// These are only used by marquee.	447	// These are only used by marquee.
442	void scrollToXOffset(int x) { scrollToOffset(ScrollOffset(x, scrollOffset().y()), ScrollType::Programmatic, ScrollClamping::Unclamped); }	448	void scrollToXOffset(int x) { scrollToOffset(ScrollOffset(x, scrollOffset().y()), ScrollType::Programmatic, ScrollClamping::Unclamped); }



    return 0;
}

void RenderListBox::setScrollLeft(int, ScrollType, bool, ScrollClamping)
{
}


    renderer.scrollAnimator().setWheelEventTestMonitor(renderer.page().wheelEventTestMonitor());
}

void RenderListBox::setScrollTop(int newTop, ScrollType, bool, ScrollClamping)
{
    // Determine an index and scroll to it.    
    int index = newTop / itemHeight();



    int scrollTop() const override;
    int scrollWidth() const override;
    int scrollHeight() const override;
    void setScrollLeft(int, ScrollType, bool, ScrollClamping) override;
    void setScrollTop(int, ScrollType, bool, ScrollClamping) override;

    bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;




    return RenderBlockFlow::scrollTop();
}

void RenderTextControlSingleLine::setScrollLeft(int newLeft, ScrollType, bool, ScrollClamping)
{
    if (innerTextElement())
        innerTextElement()->setScrollLeft(newLeft);
}

void RenderTextControlSingleLine::setScrollTop(int newTop, ScrollType, bool, ScrollClamping)
{
    if (innerTextElement())
        innerTextElement()->setScrollTop(newTop);



    int scrollTop() const override;
    int scrollWidth() const override;
    int scrollHeight() const override;
    void setScrollLeft(int, ScrollType, bool, ScrollClamping) override;
    void setScrollTop(int, ScrollType, bool, ScrollClamping) override;
    bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1, Element** stopElement = nullptr, RenderBox* startBox = nullptr, const IntPoint& wheelEventAbsolutePoint = IntPoint()) final;
    bool logicalScroll(ScrollLogicalDirection, ScrollGranularity, float multiplier = 1, Element** stopElement = 0) final;


Lines 736-741 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec1
- a/Source/WebCore/rendering/style/RenderStyle.h +6 lines
736	bool useTouchOverflowScrolling() const { return m_rareInheritedData->useTouchOverflowScrolling; }	736	bool useTouchOverflowScrolling() const { return m_rareInheritedData->useTouchOverflowScrolling; }
737	#endif	737	#endif
738		738
		739	bool useSmoothScrolling() const { return m_rareNonInheritedData->useSmoothScrolling; }
		740
739	#if ENABLE(TEXT_AUTOSIZING)	741	#if ENABLE(TEXT_AUTOSIZING)
740	TextSizeAdjustment textSizeAdjust() const { return m_rareInheritedData->textSizeAdjust; }	742	TextSizeAdjustment textSizeAdjust() const { return m_rareInheritedData->textSizeAdjust; }
741	AutosizeStatus autosizeStatus() const;	743	AutosizeStatus autosizeStatus() const;
Lines 1267-1272 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec2
1267	void setUseTouchOverflowScrolling(bool v) { SET_VAR(m_rareInheritedData, useTouchOverflowScrolling, v); }	1269	void setUseTouchOverflowScrolling(bool v) { SET_VAR(m_rareInheritedData, useTouchOverflowScrolling, v); }
1268	#endif	1270	#endif
1269		1271
		1272	void setUseSmoothScrolling(bool v) { SET_VAR(m_rareNonInheritedData, useSmoothScrolling, v); }
		1273
1270	#if ENABLE(TEXT_AUTOSIZING)	1274	#if ENABLE(TEXT_AUTOSIZING)
1271	void setTextSizeAdjust(TextSizeAdjustment adjustment) { SET_VAR(m_rareInheritedData, textSizeAdjust, adjustment); }	1275	void setTextSizeAdjust(TextSizeAdjustment adjustment) { SET_VAR(m_rareInheritedData, textSizeAdjust, adjustment); }
1272	void setAutosizeStatus(AutosizeStatus);	1276	void setAutosizeStatus(AutosizeStatus);
Lines 1704-1709 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec3
1704	static bool initialUseTouchOverflowScrolling() { return false; }	1708	static bool initialUseTouchOverflowScrolling() { return false; }
1705	#endif	1709	#endif
1706		1710
		1711	static bool initialUseSmoothScrolling() { return false; }
		1712
1707	static const FilterOperations& initialFilter() { static NeverDestroyed<FilterOperations> ops; return ops; }	1713	static const FilterOperations& initialFilter() { static NeverDestroyed<FilterOperations> ops; return ops; }
1708	static const FilterOperations& initialAppleColorFilter() { static NeverDestroyed<FilterOperations> ops; return ops; }	1714	static const FilterOperations& initialAppleColorFilter() { static NeverDestroyed<FilterOperations> ops; return ops; }
1709		1715



#if ENABLE(POINTER_EVENTS)
    , touchActions(static_cast<unsigned>(RenderStyle::initialTouchActions()))
#endif
    , useSmoothScrolling(static_cast<unsigned>(RenderStyle::initialUseSmoothScrolling()))
    , pageSizeType(PAGE_SIZE_AUTO)
    , transformStyle3D(static_cast<unsigned>(RenderStyle::initialTransformStyle3D()))
    , backfaceVisibility(static_cast<unsigned>(RenderStyle::initialBackfaceVisibility()))

#if ENABLE(POINTER_EVENTS)
    , touchActions(o.touchActions)
#endif
    , useSmoothScrolling(o.useSmoothScrolling)
    , pageSizeType(o.pageSizeType)
    , transformStyle3D(o.transformStyle3D)
    , backfaceVisibility(o.backfaceVisibility)

#if ENABLE(POINTER_EVENTS)
        && touchActions == o.touchActions
#endif
        && useSmoothScrolling == o.useSmoothScrolling
#if ENABLE(CSS_COMPOSITING)
        && effectiveBlendMode == o.effectiveBlendMode
        && isolation == o.isolation

Lines 175-180 public: a/Source/WebCore/rendering/style/StyleRareNonInheritedData.h_sec1
- a/Source/WebCore/rendering/style/StyleRareNonInheritedData.h +2 lines
175	unsigned touchActions : 6; // TouchAction	175	unsigned touchActions : 6; // TouchAction
176	#endif	176	#endif
177		177
		178	unsigned useSmoothScrolling : 1; // ScrollBehavior
		179
178	unsigned pageSizeType : 2; // PageSizeType	180	unsigned pageSizeType : 2; // PageSizeType
179	unsigned transformStyle3D : 1; // TransformStyle3D	181	unsigned transformStyle3D : 1; // TransformStyle3D
180	unsigned backfaceVisibility : 1; // BackfaceVisibility	182	unsigned backfaceVisibility : 1; // BackfaceVisibility

Lines 129-134 public: a/Source/WebCore/style/StyleBuilderConverter.h_sec1
- a/Source/WebCore/style/StyleBuilderConverter.h +6 lines
129	static bool convertOverflowScrolling(BuilderState&, const CSSValue&);	129	static bool convertOverflowScrolling(BuilderState&, const CSSValue&);
130	#endif	130	#endif
131	static FontFeatureSettings convertFontFeatureSettings(BuilderState&, const CSSValue&);	131	static FontFeatureSettings convertFontFeatureSettings(BuilderState&, const CSSValue&);
		132	static bool convertSmoothScrolling(BuilderState&, const CSSValue&);
132	static FontSelectionValue convertFontWeightFromValue(const CSSValue&);	133	static FontSelectionValue convertFontWeightFromValue(const CSSValue&);
133	static FontSelectionValue convertFontStretchFromValue(const CSSValue&);	134	static FontSelectionValue convertFontStretchFromValue(const CSSValue&);
134	static Optional<FontSelectionValue> convertFontStyleFromValue(const CSSValue&);	135	static Optional<FontSelectionValue> convertFontStyleFromValue(const CSSValue&);
Lines 1403-1408 inline bool BuilderConverter::convertOverflowScrolling(BuilderState&, const CSSV a/Source/WebCore/style/StyleBuilderConverter.h_sec2
1403	}	1404	}
1404	#endif	1405	#endif
1405		1406
		1407	inline bool BuilderConverter::convertSmoothScrolling(BuilderState&, const CSSValue& value)
		1408	{
		1409	return downcast<CSSPrimitiveValue>(value).valueID() == CSSValueSmooth;
		1410	}
		1411
1406	inline SVGLengthValue BuilderConverter::convertSVGLengthValue(BuilderState&, const CSSValue& value)	1412	inline SVGLengthValue BuilderConverter::convertSVGLengthValue(BuilderState&, const CSSValue& value)
1407	{	1413	{
1408	return SVGLengthValue::fromCSSPrimitiveValue(downcast<CSSPrimitiveValue>(value));	1414	return SVGLengthValue::fromCSSPrimitiveValue(downcast<CSSPrimitiveValue>(value));

Lines 1764-1770 ExceptionOr<void> Internals::unconstrainedScrollTo(Element& element, double x, d a/Source/WebCore/testing/Internals.cpp_sec1
- a/Source/WebCore/testing/Internals.cpp -1 / +1 lines
1764	if (!document \|\| !document->view())	1764	if (!document \|\| !document->view())
1765	return Exception { InvalidAccessError };	1765	return Exception { InvalidAccessError };
1766		1766
1767	element.scrollTo({ x, y }, ScrollClamping::Unclamped);	1767	element.scrollTo(ScrollToOptions(x, y), ScrollClamping::Unclamped);
1768	return { };	1768	return { };
1769	}	1769	}
1770		1770

Lines 152-157 void ArgumentCoder<ScrollingStateScrollingNode>::encode(Encoder& encoder, const a/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp_sec1
- a/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp -1 / +7 lines
152	SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::ScrollableAreaParams, scrollableAreaParameters)	152	SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::ScrollableAreaParams, scrollableAreaParameters)
153	SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::RequestedScrollPosition, requestedScrollPosition)	153	SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::RequestedScrollPosition, requestedScrollPosition)
154	SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::RequestedScrollPosition, requestedScrollPositionRepresentsProgrammaticScroll)	154	SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::RequestedScrollPosition, requestedScrollPositionRepresentsProgrammaticScroll)
		155	SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::RequestedScrollPosition, requestedScrollPositionWithAnimation)
155		156
156	if (node.hasChangedProperty(ScrollingStateScrollingNode::ScrollContainerLayer))	157	if (node.hasChangedProperty(ScrollingStateScrollingNode::ScrollContainerLayer))
157	encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.scrollContainerLayer());	158	encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.scrollContainerLayer());
Lines 260-266 bool ArgumentCoder<ScrollingStateScrollingNode>::decode(Decoder& decoder, Scroll a/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp_sec2
260	if (!decoder.decode(representsProgrammaticScroll))	261	if (!decoder.decode(representsProgrammaticScroll))
261	return false;	262	return false;
262		263
263	node.setRequestedScrollPosition(scrollPosition, representsProgrammaticScroll);	264	bool scrollWithAnimation;
		265	if (!decoder.decode(scrollWithAnimation))
		266	return false;
		267
		268	node.setRequestedScrollPosition(scrollPosition, representsProgrammaticScroll, scrollWithAnimation);
264	}	269	}
265		270
266	if (node.hasChangedProperty(ScrollingStateScrollingNode::ScrollContainerLayer)) {	271	if (node.hasChangedProperty(ScrollingStateScrollingNode::ScrollContainerLayer)) {
Lines 608-613 static void dump(TextStream& ts, const ScrollingStateScrollingNode& node, bool c a/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp_sec3
608	if (!changedPropertiesOnly \|\| node.hasChangedProperty(ScrollingStateScrollingNode::RequestedScrollPosition)) {	613	if (!changedPropertiesOnly \|\| node.hasChangedProperty(ScrollingStateScrollingNode::RequestedScrollPosition)) {
609	ts.dumpProperty("requested-scroll-position", node.requestedScrollPosition());	614	ts.dumpProperty("requested-scroll-position", node.requestedScrollPosition());
610	ts.dumpProperty("requested-scroll-position-is-programatic", node.requestedScrollPositionRepresentsProgrammaticScroll());	615	ts.dumpProperty("requested-scroll-position-is-programatic", node.requestedScrollPositionRepresentsProgrammaticScroll());
		616	ts.dumpProperty("requested-scroll-position-with-animation", node.requestedScrollPositionWithAnimation());
611	}	617	}
612		618
613	if (!changedPropertiesOnly \|\| node.hasChangedProperty(ScrollingStateScrollingNode::ScrollContainerLayer))	619	if (!changedPropertiesOnly \|\| node.hasChangedProperty(ScrollingStateScrollingNode::ScrollContainerLayer))

Lines 1309-1314 BlockingOfSmallPluginsEnabled: a/Source/WebKit/Shared/WebPreferences.yaml_sec1
- a/Source/WebKit/Shared/WebPreferences.yaml +7 lines
1309	humanReadableDescription: "Stop plugins smaller than a certain threshold from loading."	1309	humanReadableDescription: "Stop plugins smaller than a certain threshold from loading."
1310	category: internal	1310	category: internal
1311		1311
		1312	CSSOMViewSmoothScrollingEnabled:
		1313	type: bool
		1314	defaultValue: true
		1315	humanReadableName: "CSSOM View Smooth Scrolling"
		1316	humanReadableDescription: "Enable DOM API and CSS property for 'smooth' scroll behavior"
		1317	category: experimental
		1318
1312	WebAnimationsEnabled:	1319	WebAnimationsEnabled:
1313	type: bool	1320	type: bool
1314	defaultValue: true	1321	defaultValue: true

Lines 1616-1621 static inline bool pointsEqualInDevicePixels(CGPoint a, CGPoint b, float deviceS a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm_sec1
- a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm -4 / +22 lines
1616	&& fabs(a.y * deviceScaleFactor - b.y * deviceScaleFactor) < std::numeric_limits<float>::epsilon();	1616	&& fabs(a.y * deviceScaleFactor - b.y * deviceScaleFactor) < std::numeric_limits<float>::epsilon();
1617	}	1617	}
1618		1618
		1619	static inline bool pointsEqualInRoundToDevicePixel(CGPoint a, CGPoint b, float deviceScaleFactor)
		1620	{
		1621	return CGRound(a.x * deviceScaleFactor) == CGRound(b.x * deviceScaleFactor)
		1622	&& CGRound(a.y * deviceScaleFactor) == CGRound(b.y * deviceScaleFactor);
		1623	}
1619	static CGSize roundScrollViewContentSize(const WebKit::WebPageProxy& page, CGSize contentSize)	1624	static CGSize roundScrollViewContentSize(const WebKit::WebPageProxy& page, CGSize contentSize)
1620	{	1625	{
1621	float deviceScaleFactor = page.deviceScaleFactor();	1626	float deviceScaleFactor = page.deviceScaleFactor();
Lines 2340-2348 static WebCore::FloatPoint constrainContentOffset(WebCore::FloatPoint contentOff a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm_sec2
2340	return contentOffset.constrainedBetween(WebCore::FloatPoint(), WebCore::FloatPoint(maximumContentOffset));	2345	return contentOffset.constrainedBetween(WebCore::FloatPoint(), WebCore::FloatPoint(maximumContentOffset));
2341	}	2346	}
2342		2347
2343	- (void)_scrollToContentScrollPosition:(WebCore::FloatPoint)scrollPosition scrollOrigin:(WebCore::IntPoint)scrollOrigin	2348	- (void)_scrollToContentScrollPosition:(WebCore::FloatPoint)scrollPosition scrollOrigin:(WebCore::IntPoint)scrollOrigin animated:(BOOL)animated
2344	{	2349	{
2345	if (_commitDidRestoreScrollPosition \|\| _dynamicViewportUpdateMode != WebKit::DynamicViewportUpdateMode::NotResizing)	2350	// Animated scrolling shouldn't be skipped.
		2351	if (!animated && (_commitDidRestoreScrollPosition \|\| _dynamicViewportUpdateMode != WebKit::DynamicViewportUpdateMode::NotResizing))
2346	return;	2352	return;
2347		2353
2348	WebCore::FloatPoint contentOffset = WebCore::ScrollableArea::scrollOffsetFromPosition(scrollPosition, toFloatSize(scrollOrigin));	2354	WebCore::FloatPoint contentOffset = WebCore::ScrollableArea::scrollOffsetFromPosition(scrollPosition, toFloatSize(scrollOrigin));
Lines 2356-2368 static WebCore::FloatPoint constrainContentOffset(WebCore::FloatPoint contentOff a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm_sec3
2356		2362
2357	[_scrollView _stopScrollingAndZoomingAnimations];	2363	[_scrollView _stopScrollingAndZoomingAnimations];
2358		2364
2359	if (!CGPointEqualToPoint(contentOffsetInScrollViewCoordinates, [_scrollView contentOffset]))	2365	// It's possible that they are not equal, but in the same device pixel, so _scrollView won't change.
2360	[_scrollView setContentOffset:contentOffsetInScrollViewCoordinates];	2366	// We need to calculate the round to device pixel here.
		2367	if (!pointsEqualInRoundToDevicePixel(contentOffsetInScrollViewCoordinates, [_scrollView contentOffset], _page->deviceScaleFactor()))
		2368	[_scrollView setContentOffset:contentOffsetInScrollViewCoordinates animated:animated];
2361	else {	2369	else {
2362	// If we haven't changed anything, there would not be any VisibleContentRect update sent to the content.	2370	// If we haven't changed anything, there would not be any VisibleContentRect update sent to the content.
2363	// The WebProcess would keep the invalid contentOffset as its scroll position.	2371	// The WebProcess would keep the invalid contentOffset as its scroll position.
2364	// To synchronize the WebProcess with what is on screen, we send the VisibleContentRect again.	2372	// To synchronize the WebProcess with what is on screen, we send the VisibleContentRect again.
2365	_page->resendLastVisibleContentRects();	2373	_page->resendLastVisibleContentRects();
		2374	// If _scrollView won't change, we still need to tell the Web process that the animation stopped.
		2375	if (animated) {
		2376	WebKit::RemoteScrollingCoordinatorProxy* coordinator = _page->scrollingCoordinatorProxy();
		2377	if (coordinator)
		2378	coordinator->scrollingTreeRootNodeIsScrollAnimationInProgressDidChange(false);
		2379	}
2366	}	2380	}
2367	}	2381	}
2368		2382
Lines 2878-2883 static WebCore::FloatPoint constrainContentOffset(WebCore::FloatPoint contentOff a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm_sec4
2878	- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView	2892	- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView
2879	{	2893	{
2880	[self _didFinishScrolling];	2894	[self _didFinishScrolling];
		2895
		2896	WebKit::RemoteScrollingCoordinatorProxy* coordinator = _page->scrollingCoordinatorProxy();
		2897	if (coordinator)
		2898	coordinator->scrollingTreeRootNodeIsScrollAnimationInProgressDidChange(false);
2881	}	2899	}
2882		2900
2883	- (void)_scrollViewDidInterruptDecelerating:(UIScrollView *)scrollView	2901	- (void)_scrollViewDidInterruptDecelerating:(UIScrollView *)scrollView

Lines 97-103 struct PrintInfo; a/Source/WebKit/UIProcess/API/Cocoa/WKWebViewInternal.h_sec1
- a/Source/WebKit/UIProcess/API/Cocoa/WKWebViewInternal.h -1 / +1 lines
97		97
98	- (RefPtr<WebKit::ViewSnapshot>)_takeViewSnapshot;	98	- (RefPtr<WebKit::ViewSnapshot>)_takeViewSnapshot;
99		99
100	- (void)_scrollToContentScrollPosition:(WebCore::FloatPoint)scrollPosition scrollOrigin:(WebCore::IntPoint)scrollOrigin;	100	- (void)_scrollToContentScrollPosition:(WebCore::FloatPoint)scrollPosition scrollOrigin:(WebCore::IntPoint)scrollOrigin animated:(BOOL)animated;
101	- (BOOL)_scrollToRect:(WebCore::FloatRect)targetRect origin:(WebCore::FloatPoint)origin minimumScrollDistance:(float)minimumScrollDistance;	101	- (BOOL)_scrollToRect:(WebCore::FloatRect)targetRect origin:(WebCore::FloatPoint)origin minimumScrollDistance:(float)minimumScrollDistance;
102	- (double)_initialScaleFactor;	102	- (double)_initialScaleFactor;
103	- (double)_contentZoomScale;	103	- (double)_contentZoomScale;

Lines 181-186 public: a/Source/WebKit/UIProcess/PageClient.h_sec1
- a/Source/WebKit/UIProcess/PageClient.h +2 lines
181	// Tell the view to scroll to the given position, and whether this was a programmatic scroll.	181	// Tell the view to scroll to the given position, and whether this was a programmatic scroll.
182	virtual void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin) = 0;	182	virtual void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin) = 0;
183		183
		184	virtual void requestScrollWithAnimation(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin) { }
		185
184	// Return the current scroll position (not necessarily the same as the WebCore scroll position, because of scaling, insets etc.)	186	// Return the current scroll position (not necessarily the same as the WebCore scroll position, because of scaling, insets etc.)
185	virtual WebCore::FloatPoint viewScrollPosition() = 0;	187	virtual WebCore::FloatPoint viewScrollPosition() = 0;
186		188

Lines 225-231 void RemoteLayerTreeDrawingAreaProxy::commitLayerTree(const RemoteLayerTreeTrans a/Source/WebKit/UIProcess/RemoteLayerTree/RemoteLayerTreeDrawingAreaProxy.mm_sec1
- a/Source/WebKit/UIProcess/RemoteLayerTree/RemoteLayerTreeDrawingAreaProxy.mm -1 / +1 lines
225	// Handle requested scroll position updates from the scrolling tree transaction after didCommitLayerTree()	225	// Handle requested scroll position updates from the scrolling tree transaction after didCommitLayerTree()
226	// has updated the view size based on the content size.	226	// has updated the view size based on the content size.
227	if (requestedScrollInfo.requestsScrollPositionUpdate)	227	if (requestedScrollInfo.requestsScrollPositionUpdate)
228	m_webPageProxy.requestScroll(requestedScrollInfo.requestedScrollPosition, layerTreeTransaction.scrollOrigin());	228	m_webPageProxy.requestScroll(requestedScrollInfo.requestedScrollPosition, layerTreeTransaction.scrollOrigin(), requestedScrollInfo.requestWithAnimation);
229	#endif // ENABLE(ASYNC_SCROLLING)	229	#endif // ENABLE(ASYNC_SCROLLING)
230		230
231	if (m_debugIndicatorLayerTreeHost) {	231	if (m_debugIndicatorLayerTreeHost) {



}

// This comes from the scrolling tree.
void RemoteScrollingCoordinatorProxy::scrollingTreeNodeDidScroll(ScrollingNodeID scrolledNodeID, const FloatPoint& newScrollPosition, const Optional<FloatPoint>& layoutViewportOrigin, ScrollingLayerPositionAction scrollingLayerPositionAction, bool instantScrollDidStopAnimation)
{
    // Scroll updates for the main frame are sent via WebPageProxy::updateVisibleContentRects()
    // so don't send them here.

    m_webPageProxy.scrollingNodeScrollViewDidScroll();
#endif

    if (m_scrollingTree->isHandlingProgrammaticScroll() && !instantScrollDidStopAnimation)
        return;

    m_webPageProxy.send(Messages::RemoteScrollingCoordinator::ScrollPositionChangedForNode(scrolledNodeID, newScrollPosition, scrollingLayerPositionAction == ScrollingLayerPositionAction::Sync));
}

void RemoteScrollingCoordinatorProxy::scrollingTreeNodeRequestsScroll(ScrollingNodeID scrolledNodeID, const FloatPoint& scrollPosition, bool representsProgrammaticScroll, bool withAnimation)
{
    if (scrolledNodeID == rootScrollingNodeID() && m_requestedScrollInfo) {
        m_requestedScrollInfo->requestsScrollPositionUpdate = true;
        m_requestedScrollInfo->requestIsProgrammaticScroll = representsProgrammaticScroll;
        m_requestedScrollInfo->requestWithAnimation = withAnimation;
        m_requestedScrollInfo->requestedScrollPosition = scrollPosition;
    }
}

void RemoteScrollingCoordinatorProxy::scrollingTreeNodeIsScrollAnimationInProgressDidChange(WebCore::ScrollingNodeID scrolledNodeID, bool isScrollAnimationInProgress)
{
    m_webPageProxy.send(Messages::RemoteScrollingCoordinator::scrollAnimationInProgressChangedForNode(scrolledNodeID, isScrollAnimationInProgress));
}

void RemoteScrollingCoordinatorProxy::scrollingTreeRootNodeIsScrollAnimationInProgressDidChange(bool isScrollAnimationInProgress)
{
    m_webPageProxy.send(Messages::RemoteScrollingCoordinator::scrollAnimationInProgressChangedForNode(rootScrollingNodeID(), isScrollAnimationInProgress));    
}


String RemoteScrollingCoordinatorProxy::scrollingTreeAsText() const
{
    if (m_scrollingTree)



    if (is<ScrollingTreeFrameScrollingNode>(node))
        layoutViewportOrigin = downcast<ScrollingTreeFrameScrollingNode>(node).layoutViewport().location();

    m_scrollingCoordinatorProxy.scrollingTreeNodeDidScroll(node.scrollingNodeID(), node.currentScrollPosition(), layoutViewportOrigin, scrollingLayerPositionAction, node.needsStopCurrentScrollAnimation() && !node.requestScrollWithAnimation());
}

void RemoteScrollingTree::scrollingTreeNodeRequestsScroll(ScrollingNodeID nodeID, const FloatPoint& scrollPosition, bool representsProgrammaticScroll, bool withAnimation)
{
    m_scrollingCoordinatorProxy.scrollingTreeNodeRequestsScroll(nodeID, scrollPosition, representsProgrammaticScroll, withAnimation);
}

Ref<ScrollingTreeNode> RemoteScrollingTree::createScrollingTreeNode(ScrollingNodeType nodeType, ScrollingNodeID nodeID)

    return ScrollingTreeFixedNode::create(*this, nodeID);
}

void RemoteScrollingTree::scrollingTreeNodeIsScrollAnimationInProgressDidChange(WebCore::ScrollingNodeID nodeID, bool isScrollAnimationInProgress)
{
    m_scrollingCoordinatorProxy.scrollingTreeNodeIsScrollAnimationInProgressDidChange(nodeID, isScrollAnimationInProgress);
}

void RemoteScrollingTree::currentSnapPointIndicesDidChange(ScrollingNodeID nodeID, unsigned horizontal, unsigned vertical)
{
    m_scrollingCoordinatorProxy.currentSnapPointIndicesDidChange(nodeID, horizontal, vertical);

Lines 52-58 public: a/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingTree.h_sec1
- a/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingTree.h -1 / +3 lines
52	const RemoteScrollingCoordinatorProxy& scrollingCoordinatorProxy() const { return m_scrollingCoordinatorProxy; }	52	const RemoteScrollingCoordinatorProxy& scrollingCoordinatorProxy() const { return m_scrollingCoordinatorProxy; }
53		53
54	void scrollingTreeNodeDidScroll(WebCore::ScrollingTreeScrollingNode&, WebCore::ScrollingLayerPositionAction = WebCore::ScrollingLayerPositionAction::Sync) override;	54	void scrollingTreeNodeDidScroll(WebCore::ScrollingTreeScrollingNode&, WebCore::ScrollingLayerPositionAction = WebCore::ScrollingLayerPositionAction::Sync) override;
55	void scrollingTreeNodeRequestsScroll(WebCore::ScrollingNodeID, const WebCore::FloatPoint& scrollPosition, bool representsProgrammaticScroll) override;	55	void scrollingTreeNodeRequestsScroll(WebCore::ScrollingNodeID, const WebCore::FloatPoint& scrollPosition, bool representsProgrammaticScroll, bool withAnimation = false) override;
		56
		57	void scrollingTreeNodeIsScrollAnimationInProgressDidChange(WebCore::ScrollingNodeID, bool isScrollAnimationInProgress) override;
56		58
57	void currentSnapPointIndicesDidChange(WebCore::ScrollingNodeID, unsigned horizontal, unsigned vertical) override;	59	void currentSnapPointIndicesDidChange(WebCore::ScrollingNodeID, unsigned horizontal, unsigned vertical) override;
58		60

Lines 57-62 public: a/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.h_sec1
- a/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.h +1 lines
57	void scrollDidEnd() const;	57	void scrollDidEnd() const;
58	void scrollViewWillStartPanGesture() const;	58	void scrollViewWillStartPanGesture() const;
59	void scrollViewDidScroll(const WebCore::FloatPoint& scrollOffset, bool inUserInteraction);	59	void scrollViewDidScroll(const WebCore::FloatPoint& scrollOffset, bool inUserInteraction);
		60	void scrollViewDidEndScrollingAnimation();
60		61
61	void currentSnapPointIndicesDidChange(unsigned horizontal, unsigned vertical) const;	62	void currentSnapPointIndicesDidChange(unsigned horizontal, unsigned vertical) const;
62	CALayer *scrollLayer() const { return m_scrollLayer.get(); }	63	CALayer *scrollLayer() const { return m_scrollLayer.get(); }

Lines 152-157 a/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm_sec1
- a/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm -4 / +39 lines
152	}	152	}
153	}	153	}
154		154
		155	- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView
		156	{
		157	_scrollingTreeNodeDelegate->scrollViewDidEndScrollingAnimation();
		158	}
		159
155	#if ENABLE(POINTER_EVENTS)	160	#if ENABLE(POINTER_EVENTS)
156	- (CGPoint)_scrollView:(UIScrollView )scrollView adjustedOffsetForOffset:(CGPoint)offset translation:(CGPoint)translation startPoint:(CGPoint)start locationInView:(CGPoint)locationInView horizontalVelocity:(inout double )hv verticalVelocity:(inout double *)vv	161	- (CGPoint)_scrollView:(UIScrollView )scrollView adjustedOffsetForOffset:(CGPoint)offset translation:(CGPoint)translation startPoint:(CGPoint)start locationInView:(CGPoint)locationInView horizontalVelocity:(inout double )hv verticalVelocity:(inout double *)vv
157	{	162	{
Lines 300-314 void ScrollingTreeScrollingNodeDelegateIOS::commitStateAfterChildren(const Scrol a/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm_sec2
300		305
301	if (scrollingStateNode.hasChangedProperty(ScrollingStateScrollingNode::RequestedScrollPosition)) {	306	if (scrollingStateNode.hasChangedProperty(ScrollingStateScrollingNode::RequestedScrollPosition)) {
302	auto scrollType = scrollingStateNode.requestedScrollPositionRepresentsProgrammaticScroll() ? ScrollType::Programmatic : ScrollType::User;	307	auto scrollType = scrollingStateNode.requestedScrollPositionRepresentsProgrammaticScroll() ? ScrollType::Programmatic : ScrollType::User;
303	scrollingNode().scrollTo(scrollingStateNode.requestedScrollPosition(), scrollType);	308	if (scrollingStateNode.requestedScrollPositionWithAnimation())
		309	scrollingNode().setRequestScrollWithAnimation(true);
		310	// If the scroll positions are not the same, there's a possibility that the scroll offset from the Web process has been overridden.
		311	// In this case, the scroll position need to be sent to the Web process.
		312	bool shouldSyncScrollPosition = scrollingStateNode.scrollPosition() != scrollingNode().currentScrollPosition();
		313	scrollingNode().scrollTo(scrollingStateNode.requestedScrollPosition(), scrollType, ScrollPositionClamp::ToContentEdges, shouldSyncScrollPosition);
304	}	314	}
305	}	315	}
306		316
307	void ScrollingTreeScrollingNodeDelegateIOS::repositionScrollingLayers()	317	void ScrollingTreeScrollingNodeDelegateIOS::repositionScrollingLayers()
308	{	318	{
309	BEGIN_BLOCK_OBJC_EXCEPTIONS	319	bool animationInProgress = scrollingNode().scrollAnimationInProgress();
310	[scrollView() setContentOffset:scrollingNode().currentScrollOffset()];	320	bool needToStopAnimation = scrollingNode().needsStopCurrentScrollAnimation();
311	END_BLOCK_OBJC_EXCEPTIONS	321	if (needToStopAnimation && animationInProgress) {
		322	BEGIN_BLOCK_OBJC_EXCEPTIONS
		323	[scrollView() setContentOffset:scrollView().contentOffset animated:NO];
		324	END_BLOCK_OBJC_EXCEPTIONS
		325	}
		326
		327	if (scrollingNode().requestScrollWithAnimation()) {
		328	BEGIN_BLOCK_OBJC_EXCEPTIONS
		329	[scrollView() setContentOffset:scrollingNode().currentScrollOffset() animated:YES];
		330	END_BLOCK_OBJC_EXCEPTIONS
		331
		332	scrollingNode().setScrollAnimationInProgress(true);
		333	} else if (!animationInProgress \|\| needToStopAnimation) {
		334	BEGIN_BLOCK_OBJC_EXCEPTIONS
		335	[scrollView() setContentOffset:scrollingNode().currentScrollOffset()];
		336	END_BLOCK_OBJC_EXCEPTIONS
		337	}
312	}	338	}
313		339
314	void ScrollingTreeScrollingNodeDelegateIOS::scrollWillStart() const	340	void ScrollingTreeScrollingNodeDelegateIOS::scrollWillStart() const
Lines 335-340 void ScrollingTreeScrollingNodeDelegateIOS::scrollViewDidScroll(const FloatPoint a/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm_sec3
335	scrollingNode().wasScrolledByDelegatedScrolling(scrollPosition, { }, inUserInteraction ? ScrollingLayerPositionAction::Sync : ScrollingLayerPositionAction::Set);	361	scrollingNode().wasScrolledByDelegatedScrolling(scrollPosition, { }, inUserInteraction ? ScrollingLayerPositionAction::Sync : ScrollingLayerPositionAction::Set);
336	}	362	}
337		363
		364	void ScrollingTreeScrollingNodeDelegateIOS::scrollViewDidEndScrollingAnimation()
		365	{
		366	auto& node = scrollingNode();
		367	if (!(node.requestScrollWithAnimation() && node.scrollAnimationInProgress())) {
		368	scrollingTree().scrollingTreeNodeIsScrollAnimationInProgressDidChange(node.scrollingNodeID(), false);
		369	node.setScrollAnimationInProgress(false);
		370	}
		371	}
		372
338	void ScrollingTreeScrollingNodeDelegateIOS::currentSnapPointIndicesDidChange(unsigned horizontal, unsigned vertical) const	373	void ScrollingTreeScrollingNodeDelegateIOS::currentSnapPointIndicesDidChange(unsigned horizontal, unsigned vertical) const
339	{	374	{
340	if (m_updatingFromStateNode)	375	if (m_updatingFromStateNode)

Lines 1731-1739 void WebPageProxy::setViewNeedsDisplay(const Region& region) a/Source/WebKit/UIProcess/WebPageProxy.cpp_sec1
- a/Source/WebKit/UIProcess/WebPageProxy.cpp -2 / +5 lines
1731	pageClient().setViewNeedsDisplay(region);	1731	pageClient().setViewNeedsDisplay(region);
1732	}	1732	}
1733		1733
1734	void WebPageProxy::requestScroll(const FloatPoint& scrollPosition, const IntPoint& scrollOrigin)	1734	void WebPageProxy::requestScroll(const FloatPoint& scrollPosition, const IntPoint& scrollOrigin, const bool withAnimation)
1735	{	1735	{
1736	pageClient().requestScroll(scrollPosition, scrollOrigin);	1736	if (withAnimation)
		1737	pageClient().requestScrollWithAnimation(scrollPosition, scrollOrigin);
		1738	else
		1739	pageClient().requestScroll(scrollPosition, scrollOrigin);
1737	}	1740	}
1738		1741
1739	WebCore::FloatPoint WebPageProxy::viewScrollPosition() const	1742	WebCore::FloatPoint WebPageProxy::viewScrollPosition() const

Lines 612-618 public: a/Source/WebKit/UIProcess/WebPageProxy.h_sec1
- a/Source/WebKit/UIProcess/WebPageProxy.h -1 / +1 lines
612	PageClient& pageClient() const;	612	PageClient& pageClient() const;
613		613
614	void setViewNeedsDisplay(const WebCore::Region&);	614	void setViewNeedsDisplay(const WebCore::Region&);
615	void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin);	615	void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin, bool withAnimation = false);
616		616
617	WebCore::FloatPoint viewScrollPosition() const;	617	WebCore::FloatPoint viewScrollPosition() const;
618		618

Lines 57-62 private: a/Source/WebKit/UIProcess/ios/PageClientImplIOS.h_sec1
- a/Source/WebKit/UIProcess/ios/PageClientImplIOS.h +1 lines
57	std::unique_ptr<DrawingAreaProxy> createDrawingAreaProxy(WebProcessProxy&) override;	57	std::unique_ptr<DrawingAreaProxy> createDrawingAreaProxy(WebProcessProxy&) override;
58	void setViewNeedsDisplay(const WebCore::Region&) override;	58	void setViewNeedsDisplay(const WebCore::Region&) override;
59	void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin) override;	59	void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin) override;
		60	void requestScrollWithAnimation(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin) override;
60	WebCore::FloatPoint viewScrollPosition() override;	61	WebCore::FloatPoint viewScrollPosition() override;
61	WebCore::IntSize viewSize() override;	62	WebCore::IntSize viewSize() override;
62	bool isViewWindowActive() override;	63	bool isViewWindowActive() override;

Lines 95-101 void PageClientImpl::setViewNeedsDisplay(const Region&) a/Source/WebKit/UIProcess/ios/PageClientImplIOS.mm_sec1
- a/Source/WebKit/UIProcess/ios/PageClientImplIOS.mm -1 / +6 lines
95		95
96	void PageClientImpl::requestScroll(const FloatPoint& scrollPosition, const IntPoint& scrollOrigin)	96	void PageClientImpl::requestScroll(const FloatPoint& scrollPosition, const IntPoint& scrollOrigin)
97	{	97	{
98	[m_webView _scrollToContentScrollPosition:scrollPosition scrollOrigin:scrollOrigin];	98	[m_webView _scrollToContentScrollPosition:scrollPosition scrollOrigin:scrollOrigin animated:NO];
		99	}
		100
		101	void PageClientImpl::requestScrollWithAnimation(const FloatPoint& scrollPosition, const IntPoint& scrollOrigin)
		102	{
		103	[m_webView _scrollToContentScrollPosition:scrollPosition scrollOrigin:scrollOrigin animated:YES];
99	}	104	}
100		105
101	WebCore::FloatPoint PageClientImpl::viewScrollPosition()	106	WebCore::FloatPoint PageClientImpl::viewScrollPosition()

Lines 73-78 private: a/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.h_sec1
- a/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.h +2 lines
73	void scrollPositionChangedForNode(WebCore::ScrollingNodeID, const WebCore::FloatPoint& scrollPosition, bool syncLayerPosition);	73	void scrollPositionChangedForNode(WebCore::ScrollingNodeID, const WebCore::FloatPoint& scrollPosition, bool syncLayerPosition);
74	void currentSnapPointIndicesChangedForNode(WebCore::ScrollingNodeID, unsigned horizontal, unsigned vertical);	74	void currentSnapPointIndicesChangedForNode(WebCore::ScrollingNodeID, unsigned horizontal, unsigned vertical);
75		75
		76	void scrollAnimationInProgressChangedForNode(WebCore::ScrollingNodeID, bool isScrollAnimationInProgress);
		77
76	WebPage* m_webPage;	78	WebPage* m_webPage;
77	};	79	};
78		80

Lines 25-30 a/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.messages.in_sec1
- a/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.messages.in +1 lines
25	messages -> RemoteScrollingCoordinator {	25	messages -> RemoteScrollingCoordinator {
26	ScrollPositionChangedForNode(uint64_t nodeID, WebCore::FloatPoint scrollPosition, bool syncLayerPosition);	26	ScrollPositionChangedForNode(uint64_t nodeID, WebCore::FloatPoint scrollPosition, bool syncLayerPosition);
27	CurrentSnapPointIndicesChangedForNode(uint64_t nodeID, unsigned horizontal, unsigned vertical);	27	CurrentSnapPointIndicesChangedForNode(uint64_t nodeID, unsigned horizontal, unsigned vertical);
		28	scrollAnimationInProgressChangedForNode(uint64_t nodeID, bool isScrollAnimationInProgress);
28	}	29	}
29		30
30	#endif // ENABLE(ASYNC_SCROLLING)	31	#endif // ENABLE(ASYNC_SCROLLING)

Lines 104-109 void RemoteScrollingCoordinator::currentSnapPointIndicesChangedForNode(Scrolling a/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.mm_sec1
- a/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.mm +5 lines
104	setActiveScrollSnapIndices(nodeID, horizontal, vertical);	104	setActiveScrollSnapIndices(nodeID, horizontal, vertical);
105	}	105	}
106		106
		107	void RemoteScrollingCoordinator::scrollAnimationInProgressChangedForNode(WebCore::ScrollingNodeID nodeID, bool isScrollAnimationInProgress)
		108	{
		109	setScrollAnimationInProgress(nodeID, isScrollAnimationInProgress);
		110	}
		111
107	} // namespace WebKit	112	} // namespace WebKit
108		113
109	#endif // ENABLE(ASYNC_SCROLLING)	114	#endif // ENABLE(ASYNC_SCROLLING)

Lines 186-191 a/Source/WebKitLegacy/mac/WebView/WebPreferenceKeysPrivate.h_sec1
- a/Source/WebKitLegacy/mac/WebView/WebPreferenceKeysPrivate.h +1 lines
186	#define WebKitDirectoryUploadEnabledPreferenceKey @"WebKitDirectoryUploadEnabled"	186	#define WebKitDirectoryUploadEnabledPreferenceKey @"WebKitDirectoryUploadEnabled"
187	#define WebKitVisualViewportAPIEnabledPreferenceKey @"WebKitVisualViewportAPIEnabled"	187	#define WebKitVisualViewportAPIEnabledPreferenceKey @"WebKitVisualViewportAPIEnabled"
188	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey @"WebKitCSSOMViewScrollingAPIEnabled"	188	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey @"WebKitCSSOMViewScrollingAPIEnabled"
		189	#define WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey @"WebKitCSSOMViewSmoothScrollingEnabled"
189	#define WebKitModernMediaControlsEnabledPreferenceKey @"WebKitModernMediaControlsEnabled"	190	#define WebKitModernMediaControlsEnabledPreferenceKey @"WebKitModernMediaControlsEnabled"
190	#define WebKitRemotePlaybackEnabledPreferenceKey @"WebKitRemotePlaybackEnabled"	191	#define WebKitRemotePlaybackEnabledPreferenceKey @"WebKitRemotePlaybackEnabled"
191	#define WebKitSubtleCryptoEnabledPreferenceKey @"WebKitSubtleCryptoEnabled"	192	#define WebKitSubtleCryptoEnabledPreferenceKey @"WebKitSubtleCryptoEnabled"



#endif

        @YES, WebKitCSSOMViewScrollingAPIEnabledPreferenceKey,
        @NO, WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey,
        @YES, WebKitNeedsStorageAccessFromFileURLsQuirkKey,
        @NO, WebKitAllowCrossOriginSubresourcesToAskForCredentialsKey,
#if ENABLE(MEDIA_STREAM)

    [self _setBoolValue:flag forKey:WebKitCSSOMViewScrollingAPIEnabledPreferenceKey];
}

- (BOOL)CSSOMViewSmoothScrollingEnabled
{
    return [self _boolValueForKey:WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey];
}

- (void)setCSSOMViewSmoothScrollingEnabled:(BOOL)flag
{
    [self _setBoolValue:flag forKey:WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey];
}

- (BOOL)webAnimationsEnabled
{
    return [self _boolValueForKey:WebKitWebAnimationsEnabledPreferenceKey];

Lines 626-631 extern NSString *WebPreferencesCacheModelChangedInternalNotification WEBKIT_DEPR a/Source/WebKitLegacy/mac/WebView/WebPreferencesPrivate.h_sec1
- a/Source/WebKitLegacy/mac/WebView/WebPreferencesPrivate.h +1 lines
626		626
627	@property (nonatomic) BOOL visualViewportAPIEnabled;	627	@property (nonatomic) BOOL visualViewportAPIEnabled;
628	@property (nonatomic) BOOL CSSOMViewScrollingAPIEnabled;	628	@property (nonatomic) BOOL CSSOMViewScrollingAPIEnabled;
		629	@property (nonatomic) BOOL CSSOMViewSmoothScrollingEnabled;
629	@property (nonatomic) BOOL largeImageAsyncDecodingEnabled;	630	@property (nonatomic) BOOL largeImageAsyncDecodingEnabled;
630	@property (nonatomic) BOOL animatedImageAsyncDecodingEnabled;	631	@property (nonatomic) BOOL animatedImageAsyncDecodingEnabled;
631	@property (nonatomic) BOOL javaScriptMarkupEnabled;	632	@property (nonatomic) BOOL javaScriptMarkupEnabled;

Lines 2992-2997 static bool needsSelfRetainWhileLoadingQuirk() a/Source/WebKitLegacy/mac/WebView/WebView.mm_sec1
- a/Source/WebKitLegacy/mac/WebView/WebView.mm +1 lines
2992	settings.setVisualViewportAPIEnabled([preferences visualViewportAPIEnabled]);	2992	settings.setVisualViewportAPIEnabled([preferences visualViewportAPIEnabled]);
2993	settings.setSyntheticEditingCommandsEnabled([preferences syntheticEditingCommandsEnabled]);	2993	settings.setSyntheticEditingCommandsEnabled([preferences syntheticEditingCommandsEnabled]);
2994	settings.setCSSOMViewScrollingAPIEnabled([preferences CSSOMViewScrollingAPIEnabled]);	2994	settings.setCSSOMViewScrollingAPIEnabled([preferences CSSOMViewScrollingAPIEnabled]);
		2995	settings.setCSSOMViewSmoothScrollingEnabled([preferences CSSOMViewSmoothScrollingEnabled]);
2995	settings.setMediaContentTypesRequiringHardwareSupport([preferences mediaContentTypesRequiringHardwareSupport]);	2996	settings.setMediaContentTypesRequiringHardwareSupport([preferences mediaContentTypesRequiringHardwareSupport]);
2996		2997
2997	switch ([preferences storageBlockingPolicy]) {	2998	switch ([preferences storageBlockingPolicy]) {

Lines 223-228 interface IWebPreferencesPrivate6 : IWebPreferencesPrivate5 a/Source/WebKitLegacy/win/Interfaces/IWebPreferencesPrivate.idl_sec1
- a/Source/WebKitLegacy/win/Interfaces/IWebPreferencesPrivate.idl +2 lines
223	HRESULT setVisualViewportAPIEnabled([in] BOOL enabled);	223	HRESULT setVisualViewportAPIEnabled([in] BOOL enabled);
224	HRESULT CSSOMViewScrollingAPIEnabled([out, retval] BOOL*);	224	HRESULT CSSOMViewScrollingAPIEnabled([out, retval] BOOL*);
225	HRESULT setCSSOMViewScrollingAPIEnabled([in] BOOL enabled);	225	HRESULT setCSSOMViewScrollingAPIEnabled([in] BOOL enabled);
		226	HRESULT CSSOMViewSmoothScrollingEnabled([out, retval] BOOL*);
		227	HRESULT setCSSOMViewSmoothScrollingEnabled([in] BOOL enabled);
226	HRESULT fetchAPIKeepAliveEnabled([out, retval] BOOL* enabled);	228	HRESULT fetchAPIKeepAliveEnabled([out, retval] BOOL* enabled);
227	HRESULT setFetchAPIKeepAliveEnabled([in] BOOL enabled);	229	HRESULT setFetchAPIKeepAliveEnabled([in] BOOL enabled);
228	HRESULT spatialNavigationEnabled([out, retval] BOOL *enabled);	230	HRESULT spatialNavigationEnabled([out, retval] BOOL *enabled);

Lines 207-212 a/Source/WebKitLegacy/win/WebPreferenceKeysPrivate.h_sec1
- a/Source/WebKitLegacy/win/WebPreferenceKeysPrivate.h +1 lines
207	#define WebKitServerTimingEnabledPreferenceKey "WebKitServerTimingEnabled"	207	#define WebKitServerTimingEnabledPreferenceKey "WebKitServerTimingEnabled"
208		208
209	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey "WebKitCSSOMViewScrollingAPIEnabled"	209	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey "WebKitCSSOMViewScrollingAPIEnabled"
		210	#define WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey "WebKitCSSOMViewSmoothScrollingEnabled"
210		211
211	#define WebKitResizeObserverEnabledPreferenceKey "WebKitResizeObserverEnabled"	212	#define WebKitResizeObserverEnabledPreferenceKey "WebKitResizeObserverEnabled"
212		213

Lines 337-342 void WebPreferences::initializeDefaultSettings() a/Source/WebKitLegacy/win/WebPreferences.cpp_sec1
- a/Source/WebKitLegacy/win/WebPreferences.cpp +16 lines
337		337
338	CFDictionaryAddValue(defaults, CFSTR(WebKitResizeObserverEnabledPreferenceKey), kCFBooleanFalse);	338	CFDictionaryAddValue(defaults, CFSTR(WebKitResizeObserverEnabledPreferenceKey), kCFBooleanFalse);
339		339
		340	CFDictionaryAddValue(defaults, CFSTR(WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey), kCFBooleanFalse);
		341
340	CFDictionaryAddValue(defaults, CFSTR(WebKitCoreMathMLEnabledPreferenceKey), kCFBooleanFalse);	342	CFDictionaryAddValue(defaults, CFSTR(WebKitCoreMathMLEnabledPreferenceKey), kCFBooleanFalse);
341		343
342	CFDictionaryAddValue(defaults, CFSTR(WebKitRequestIdleCallbackEnabledPreferenceKey), kCFBooleanFalse);	344	CFDictionaryAddValue(defaults, CFSTR(WebKitRequestIdleCallbackEnabledPreferenceKey), kCFBooleanFalse);
Lines 2280-2285 HRESULT WebPreferences::setCoreMathMLEnabled(BOOL enabled) a/Source/WebKitLegacy/win/WebPreferences.cpp_sec2
2280	setBoolValue(WebKitCoreMathMLEnabledPreferenceKey, enabled);	2282	setBoolValue(WebKitCoreMathMLEnabledPreferenceKey, enabled);
2281	return S_OK;	2283	return S_OK;
2282	}	2284	}
		2285
		2286	HRESULT WebPreferences::CSSOMViewSmoothScrollingEnabled(_Out_ BOOL* enabled)
		2287	{
		2288	if (!enabled)
		2289	return E_POINTER;
		2290	*enabled = boolValueForKey(WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey);
		2291	return S_OK;
		2292	}
		2293
		2294	HRESULT WebPreferences::setCSSOMViewSmoothScrollingEnabled(BOOL enabled)
		2295	{
		2296	setBoolValue(WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey, enabled);
		2297	return S_OK;
		2298	}
2283		2299
2284	HRESULT WebPreferences::requestIdleCallbackEnabled(_Out_ BOOL* enabled)	2300	HRESULT WebPreferences::requestIdleCallbackEnabled(_Out_ BOOL* enabled)
2285	{	2301	{

Lines 271-276 public: a/Source/WebKitLegacy/win/WebPreferences.h_sec1
- a/Source/WebKitLegacy/win/WebPreferences.h +2 lines
271	virtual HRESULT STDMETHODCALLTYPE setVisualViewportAPIEnabled(BOOL);	271	virtual HRESULT STDMETHODCALLTYPE setVisualViewportAPIEnabled(BOOL);
272	virtual HRESULT STDMETHODCALLTYPE CSSOMViewScrollingAPIEnabled(_Out_ BOOL*);	272	virtual HRESULT STDMETHODCALLTYPE CSSOMViewScrollingAPIEnabled(_Out_ BOOL*);
273	virtual HRESULT STDMETHODCALLTYPE setCSSOMViewScrollingAPIEnabled(BOOL);	273	virtual HRESULT STDMETHODCALLTYPE setCSSOMViewScrollingAPIEnabled(BOOL);
		274	virtual HRESULT STDMETHODCALLTYPE CSSOMViewSmoothScrollingEnabled(_Out_ BOOL*);
		275	virtual HRESULT STDMETHODCALLTYPE setCSSOMViewSmoothScrollingEnabled(BOOL);
274	virtual HRESULT STDMETHODCALLTYPE fetchAPIKeepAliveEnabled(_Out_ BOOL*);	276	virtual HRESULT STDMETHODCALLTYPE fetchAPIKeepAliveEnabled(_Out_ BOOL*);
275	virtual HRESULT STDMETHODCALLTYPE setFetchAPIKeepAliveEnabled(BOOL);	277	virtual HRESULT STDMETHODCALLTYPE setFetchAPIKeepAliveEnabled(BOOL);
276	virtual HRESULT STDMETHODCALLTYPE spatialNavigationEnabled(_Out_ BOOL*);	278	virtual HRESULT STDMETHODCALLTYPE spatialNavigationEnabled(_Out_ BOOL*);

Lines 5298-5303 HRESULT WebView::notifyPreferencesChanged(IWebNotification* notification) a/Source/WebKitLegacy/win/WebView.cpp_sec1
- a/Source/WebKitLegacy/win/WebView.cpp +5 lines
5298	return hr;	5298	return hr;
5299	settings.setCSSOMViewScrollingAPIEnabled(!!enabled);	5299	settings.setCSSOMViewScrollingAPIEnabled(!!enabled);
5300		5300
		5301	hr = prefsPrivate->CSSOMViewSmoothScrollingEnabled(&enabled);
		5302	if (FAILED(hr))
		5303	return hr;
		5304	settings.setCSSOMViewSmoothScrollingEnabled(!!enabled);
		5305
5301	hr = preferences->privateBrowsingEnabled(&enabled);	5306	hr = preferences->privateBrowsingEnabled(&enabled);
5302	if (FAILED(hr))	5307	if (FAILED(hr))
5303	return hr;	5308	return hr;



2019-11-28  Cathie Chen  <cathiechen@igalia.com>

        Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
        https://bugs.webkit.org/show_bug.cgi?id=188043

        Reviewed by NOBODY (OOPS!).

        Based on the patch by FrÃ©dÃ©ric Wang.

        * DumpRenderTree/TestOptions.cpp:
        (TestOptions::TestOptions): Parse CSSOMViewSmoothScrollingEnabled.
        * DumpRenderTree/TestOptions.h: Add CSSOMViewSmoothScrollingEnabled, disabled by default.
        * DumpRenderTree/mac/DumpRenderTree.mm:
        (setWebPreferencesForTestOptions): Set CSSOMViewSmoothScrollingEnabled from the test options.

2019-11-25  Kent Tamura  <tkent@chromium.org>

        Remove tkent@ from watchlist

Lines 121-126 TestOptions::TestOptions(const std::string& pathOrURL, const std::string& absolu a/Tools/DumpRenderTree/TestOptions.cpp_sec1
- a/Tools/DumpRenderTree/TestOptions.cpp +2 lines
121	adClickAttributionEnabled = parseBooleanTestHeaderValue(value);	121	adClickAttributionEnabled = parseBooleanTestHeaderValue(value);
122	else if (key == "experimental:ResizeObserverEnabled")	122	else if (key == "experimental:ResizeObserverEnabled")
123	enableResizeObserver = parseBooleanTestHeaderValue(value);	123	enableResizeObserver = parseBooleanTestHeaderValue(value);
		124	else if (key == "experimental:CSSOMViewSmoothScrollingEnabled")
		125	enableCSSOMViewSmoothScrolling = parseBooleanTestHeaderValue(value);
124	else if (key == "experimental:CoreMathMLEnabled")	126	else if (key == "experimental:CoreMathMLEnabled")
125	enableCoreMathML = parseBooleanTestHeaderValue(value);	127	enableCoreMathML = parseBooleanTestHeaderValue(value);
126	else if (key == "experimental:RequestIdleCallbackEnabled")	128	else if (key == "experimental:RequestIdleCallbackEnabled")

Lines 50-55 struct TestOptions { a/Tools/DumpRenderTree/TestOptions.h_sec1
- a/Tools/DumpRenderTree/TestOptions.h +1 lines
50	bool enableCSSLogical { false };	50	bool enableCSSLogical { false };
51	bool adClickAttributionEnabled { false };	51	bool adClickAttributionEnabled { false };
52	bool enableResizeObserver { false };	52	bool enableResizeObserver { false };
		53	bool enableCSSOMViewSmoothScrolling { false };
53	bool enableCoreMathML { false };	54	bool enableCoreMathML { false };
54	bool enableRequestIdleCallback { false };	55	bool enableRequestIdleCallback { false };
55	bool enableAsyncClipboardAPI { false };	56	bool enableAsyncClipboardAPI { false };

Lines 1027-1032 static void setWebPreferencesForTestOptions(const TestOptions& options) a/Tools/DumpRenderTree/mac/DumpRenderTree.mm_sec1
- a/Tools/DumpRenderTree/mac/DumpRenderTree.mm +1 lines
1027	preferences.CSSLogicalEnabled = options.enableCSSLogical;	1027	preferences.CSSLogicalEnabled = options.enableCSSLogical;
1028	preferences.adClickAttributionEnabled = options.adClickAttributionEnabled;	1028	preferences.adClickAttributionEnabled = options.adClickAttributionEnabled;
1029	preferences.resizeObserverEnabled = options.enableResizeObserver;	1029	preferences.resizeObserverEnabled = options.enableResizeObserver;
		1030	preferences.CSSOMViewSmoothScrollingEnabled = options.enableCSSOMViewSmoothScrolling;
1030	preferences.coreMathMLEnabled = options.enableCoreMathML;	1031	preferences.coreMathMLEnabled = options.enableCoreMathML;
1031	preferences.requestIdleCallbackEnabled = options.enableRequestIdleCallback;	1032	preferences.requestIdleCallbackEnabled = options.enableRequestIdleCallback;
1032	preferences.asyncClipboardAPIEnabled = options.enableAsyncClipboardAPI;	1033	preferences.asyncClipboardAPIEnabled = options.enableAsyncClipboardAPI;



2019-11-28  Cathie Chen  <cathiechen@igalia.com>

        Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
        https://bugs.webkit.org/show_bug.cgi?id=188043
        The scroll animation on iOS platform is using native scroll animation which need enable
        AsyncOverflowScrollingEnabled and AsyncFrameScrollingEnabled. In order to test properly,
        copy scroll-behavior test to fast/scrolling/ios/

        Reviewed by NOBODY (OOPS!).

        Based on the patch by FrÃ©dÃ©ric Wang.

        * fast/scrolling/ios/resources/scroll-behavior.js: Added.
        (observeScrolling):
        (waitForScrollEnd):
        (scrollNode):
        (scrollWindow):
        * fast/scrolling/ios/scroll-behavior-default-css-expected.txt: Added.
        * fast/scrolling/ios/scroll-behavior-default-css.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-default-css.html.
        * fast/scrolling/ios/scroll-behavior-element-expected.txt: Added.
        * fast/scrolling/ios/scroll-behavior-element.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-element.html.
        * fast/scrolling/ios/scroll-behavior-main-frame-root-expected.txt: Added.
        * fast/scrolling/ios/scroll-behavior-main-frame-root.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html.
        * fast/scrolling/ios/scroll-behavior-main-frame-window-expected.txt: Added.
        * fast/scrolling/ios/scroll-behavior-main-frame-window.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html.
        * fast/scrolling/ios/scroll-behavior-scrollintoview-nested-expected.txt: Added.
        * fast/scrolling/ios/scroll-behavior-scrollintoview-nested.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested.html.
        * fast/scrolling/ios/scroll-behavior-smooth-positions-expected.txt: Added.
        * fast/scrolling/ios/scroll-behavior-smooth-positions.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-smooth-positions.html.
        * fast/scrolling/ios/scroll-behavior-subframe-root-expected.txt: Added.
        * fast/scrolling/ios/scroll-behavior-subframe-root.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html.
        * fast/scrolling/ios/scroll-behavior-subframe-window-expected.txt: Added.
        * fast/scrolling/ios/scroll-behavior-subframe-window.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html.
        * platform/mac-wk1/TestExpectations: Skip these tests on WK1 as they don't work for now and
        are slow anyway.

2019-11-26  Alejandro G. Castro  <alex@igalia.com>

        [GTK][WPE] New tests crashing after added in the r251377



2019-11-28  Cathie Chen  <cathiechen@igalia.com>

        Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
        https://bugs.webkit.org/show_bug.cgi?id=188043

        Reviewed by NOBODY (OOPS!).

        Based on the patch by FrÃ©dÃ©ric Wang.

        Enable CSSOMViewSmoothScrollingEnabled on scroll behavior tests and update expectations.

        * web-platform-tests/css/cssom-view/scroll-behavior-default-css-expected.txt:
        * web-platform-tests/css/cssom-view/scroll-behavior-default-css.html:
        * web-platform-tests/css/cssom-view/scroll-behavior-element-expected.txt:
        * web-platform-tests/css/cssom-view/scroll-behavior-element.html:
        * web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root-expected.txt:
        * web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html:
        * web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window-expected.txt:
        * web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html:
        * web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested-expected.txt:
        * web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested.html:
        * web-platform-tests/css/cssom-view/scroll-behavior-smooth-positions.html:
        * web-platform-tests/css/cssom-view/scroll-behavior-subframe-root-expected.txt:
        * web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html:
        * web-platform-tests/css/cssom-view/scroll-behavior-subframe-window-expected.txt:
        * web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html:

2019-11-26  Manuel Rego Casasnovas  <rego@igalia.com>

        [css-grid] Avoid serializing [] in grid-template* specified values

        (@charset "windows-1250";):
        * web-platform-tests/css/css-syntax/charset/support/http-bogus-at-charset-windows-1250.bogus.css.headers: Added.
        * web-platform-tests/css/css-syntax/charset/support/http-bogus.bogus.css: Added.
        (#):
        * web-platform-tests/css/css-syntax/charset/support/http-bogus.bogus.css.headers: Added.
        * web-platform-tests/css/css-syntax/charset/support/http-windows-1250-at-charset-windows-1253.windows1250.css: Added.
        (@charset "windows-1253";):

        * web-platform-tests/css/css-syntax/charset/support/no-decl-ascii-only.css: Added.
        (#foo):
        * web-platform-tests/css/css-syntax/charset/support/no-decl.css: Added.
        (#):
        * web-platform-tests/css/css-syntax/charset/support/utf8-bom.css: Added.
        (ï»¿#):
        * web-platform-tests/css/css-syntax/charset/support/w3c-import.log: Added.
        * web-platform-tests/css/css-syntax/charset/w3c-import.log: Added.
        * web-platform-tests/css/css-syntax/charset/xml-stylesheet-page-windows-1251-charset-attribute-windows-1250-expected.txt: Added.



function observeScrolling(elements, callback) {
  if (!Array.isArray(elements))
      elements = [elements];
  var lastChangedFrame = 0;
  var lastLeft = new Map();
  var lastTop = new Map();
  elements.forEach((element) => {
    lastLeft.set(element, element.scrollLeft);
    lastTop.set(element, element.scrollTop);
  });
  function tick(frames) {
    // We requestAnimationFrame either for 500 frames or until 20 frames with
    // no change have been observed.
    if (frames >= 500 || frames - lastChangedFrame > 20) {
      callback(true);
    } else {
      var scrollHappened = elements.some((element) => {
        return element.scrollLeft != lastLeft.get(element) || element.scrollTop != lastTop.get(element);
      });
      if (scrollHappened) {
        lastChangedFrame = frames;
        elements.forEach((element) => {
          lastLeft.set(element, element.scrollLeft);
          lastTop.set(element, element.scrollTop);
        });
        callback(false);
      }
      requestAnimationFrame(tick.bind(null, frames + 1));
    }
  }
  tick(0);
}

function waitForScrollEnd(elements) {
  return new Promise((resolve) => {
    observeScrolling(elements, (done) => {
      if (done)
        resolve();
    });
  });
}

function resetScroll(scrollingElement) {
  // Try various methods to ensure the element position is reset immediately.
  scrollingElement.scrollLeft = 0;
  scrollingElement.scrollTop = 0;
  scrollingElement.scroll({left: 0, top: 0, behavior: "instant"});
}

function resetScrollForWindow(scrollingWindow) {
  // Try various methods to ensure the element position is reset immediately.
  scrollingWindow.document.scrollingElement.scrollLeft = 0;
  scrollingWindow.document.scrollingElement.scrollTop = 0;
  scrollingWindow.scroll({left: 0, top: 0, behavior: "instant"});
}

function setScrollBehavior(styledElement, className) {
  styledElement.classList.remove("autoBehavior", "smoothBehavior");
  styledElement.classList.add(className);
}

function scrollNode(scrollingElement, scrollFunction, behavior, elementToRevealLeft, elementToRevealTop) {
  var args = {};
  if (behavior)
    args.behavior = behavior;
  switch (scrollFunction) {
    case "scrollIntoView":
      args.inline = "start";
      args.block = "start";
      elementToReveal.scrollIntoView(args);
      break;
    default:
      args.left = elementToRevealLeft;
      args.top = elementToRevealTop;
      scrollingElement[scrollFunction](args);
      break;
  }
}

function scrollWindow(scrollingWindow, scrollFunction, behavior, elementToRevealLeft, elementToRevealTop) {
  var args = {};
  if (behavior)
    args.behavior = behavior;
  args.left = elementToRevealLeft;
  args.top = elementToRevealTop;
  scrollingWindow[scrollFunction](args);
}

Line 0 a/LayoutTests/fast/scrolling/ios/scroll-behavior-default-css-expected.txt_sec1
- a/LayoutTests/fast/scrolling/ios/scroll-behavior-default-css-expected.txt +4 lines
	1
	2	PASS Instant scrolling of an element with default scroll-behavior
	3	PASS Smooth scrolling of an element with default scroll-behavior
	4



<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true  internal:AsyncOverflowScrollingEnabled=true ] -->
<title>Testing default value of scroll-behavior</title>
<meta name="timeout" content="long"/>
<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#scrolling-box">
<script src="../../../resources/testharness.js"></script>
<script src="../../../resources/testharnessreport.js"></script>
<script src="resources/scroll-behavior.js"></script>
<style>
  .scrollable {
    overflow: auto;
    width: 400px;
    height: 200px;
  }
</style>
<div id="log">
</div>
<div id="overflowNode" class="scrollable">
  <div style="width: 2000px; height: 1000px; background: linear-gradient(135deg, red, green);">
    <span style="display: inline-block; width: 500px; height: 250px;"></span><span id="elementToReveal" style="display: inline-block; vertical-align: -15px; width: 10px; height: 15px; background: black;"></span>
  </div>
</div>
<script>
  var scrollingElement = overflowNode;
  var elementToRevealLeft = 500;
  var elementToRevealTop = 250;
  var scrollFunction = "scroll";

  promise_test(() => {
    resetScroll(scrollingElement);
    assert_equals(scrollingElement.scrollLeft, 0);
    assert_equals(scrollingElement.scrollTop, 0);
    scrollNode(scrollingElement, "scroll", "instant", elementToRevealLeft, elementToRevealTop);
    assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
    assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
    return new Promise((resolve) => { resolve(); });
  }, "Instant scrolling of an element with default scroll-behavior");

  promise_test(() => {
    resetScroll(scrollingElement);
    assert_equals(scrollingElement.scrollLeft, 0);
    assert_equals(scrollingElement.scrollTop, 0);
    scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
    assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
    assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
    return waitForScrollEnd(scrollingElement).then(() => {
      assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
      assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
    });
  }, "Smooth scrolling of an element with default scroll-behavior");
</script>




PASS Element with auto scroll-behavior ; scroll() with default behavior 
PASS Element with auto scroll-behavior ; scroll() with auto behavior 
PASS Element with auto scroll-behavior ; scroll() with instant behavior 
PASS Element with auto scroll-behavior ; scroll() with smooth behavior 
PASS Element with smooth scroll-behavior ; scroll() with default behavior 
PASS Element with smooth scroll-behavior ; scroll() with auto behavior 
PASS Element with smooth scroll-behavior ; scroll() with instant behavior 
PASS Element with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Element with auto scroll-behavior ; scrollTo() with default behavior 
PASS Element with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Element with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Element with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Element with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Element with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Element with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Element with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Element with auto scroll-behavior ; scrollBy() with default behavior 
PASS Element with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Element with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Element with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Element with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Element with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Element with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Element with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Element with auto scroll-behavior ; scrollIntoView() with default behavior 
PASS Element with auto scroll-behavior ; scrollIntoView() with auto behavior 
PASS Element with auto scroll-behavior ; scrollIntoView() with instant behavior 
PASS Element with auto scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Element with smooth scroll-behavior ; scrollIntoView() with default behavior 
PASS Element with smooth scroll-behavior ; scrollIntoView() with auto behavior 
PASS Element with smooth scroll-behavior ; scrollIntoView() with instant behavior 
PASS Element with smooth scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on an element with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on an element with an instant scrolling 




<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true  internal:AsyncOverflowScrollingEnabled=true ] -->
<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on an element</title>
<meta name="timeout" content="long"/>
<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#scrolling-box">
<script src="../../../resources/testharness.js"></script>
<script src="../../../resources/testharnessreport.js"></script>
<script src="resources/scroll-behavior.js"></script>
<style>
  .scrollable {
    overflow: auto;
    width: 400px;
    height: 200px;
  }
  .autoBehavior {
    scroll-behavior: auto;
  }
  .smoothBehavior {
    scroll-behavior: smooth;
  }
</style>
<div id="log">
</div>
<div id="overflowNode" class="scrollable">
  <div style="width: 2000px; height: 1000px; background: linear-gradient(135deg, red, green);">
    <span style="display: inline-block; width: 500px; height: 250px;"></span><span id="elementToReveal" style="display: inline-block; vertical-align: -15px; width: 10px; height: 15px; background: black;"></span>
  </div>
</div>
<script>
  var scrollingElement = overflowNode;
  var styledElement = overflowNode;
  var elementToRevealLeft = 500;
  var elementToRevealTop = 250;

  ["scroll", "scrollTo", "scrollBy", "scrollIntoView"].forEach((scrollFunction) => {
    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "autoBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
      assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
      assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
      return new Promise((resolve) => { resolve(); });
    }, `Element with auto scroll-behavior ; ${scrollFunction}() with default behavior`);

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "autoBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
      assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
      assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
      return new Promise((resolve) => { resolve(); });
    }, `Element with auto scroll-behavior ; ${scrollFunction}() with auto behavior`);

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "autoBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
      assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
      assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
      return new Promise((resolve) => { resolve(); });
    }, `Element with auto scroll-behavior ; ${scrollFunction}() with instant behavior`);

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "autoBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
      assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
      assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
      return waitForScrollEnd(scrollingElement).then(() => {
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
      });
    }, `Element with auto scroll-behavior ; ${scrollFunction}() with smooth behavior`);

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
      assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
      assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
      return waitForScrollEnd(scrollingElement).then(() => {
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
      });
    }, `Element with smooth scroll-behavior ; ${scrollFunction}() with default behavior`);

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
      assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
      assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
      return waitForScrollEnd(scrollingElement).then(() => {
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
      });
    }, `Element with smooth scroll-behavior ; ${scrollFunction}() with auto behavior`);

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
      assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
      assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
      return new Promise((resolve) => { resolve(); });
    }, `Element with smooth scroll-behavior ; ${scrollFunction}() with instant behavior`);

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
      assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
      assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
      return waitForScrollEnd(scrollingElement).then(() => {
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
      });
   }, `Element with smooth scroll-behavior ; ${scrollFunction}() with smooth behavior`);
  });

  promise_test(() => {
    resetScroll(scrollingElement);
    setScrollBehavior(styledElement, "smoothBehavior");
    assert_equals(scrollingElement.scrollLeft, 0);
    assert_equals(scrollingElement.scrollTop, 0);
    scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
    scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft / 2, elementToRevealTop / 2);
    return waitForScrollEnd(scrollingElement).then(() => {
      assert_equals(scrollingElement.scrollLeft, elementToRevealLeft / 2, "Final value of scrollLeft");
      assert_equals(scrollingElement.scrollTop, elementToRevealTop / 2, "Final value of scrollTop");
    });
  }, "Aborting an ongoing smooth scrolling on an element with another smooth scrolling");

  promise_test(() => {
    resetScroll(scrollingElement);
    setScrollBehavior(styledElement, "smoothBehavior");
    assert_equals(scrollingElement.scrollLeft, 0);
    assert_equals(scrollingElement.scrollTop, 0);
    scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
    scrollNode(scrollingElement, "scroll", "instant", 0, 0);
    return waitForScrollEnd(scrollingElement).then(() => {
      assert_equals(scrollingElement.scrollLeft, 0, "Final value of scrollLeft");
      assert_equals(scrollingElement.scrollTop, 0, "Final value of scrollTop");
    });
  }, "Aborting an ongoing smooth scrolling on an element with an instant scrolling");
</script>




PASS Page loaded 
PASS Main frame with auto scroll-behavior ; scroll() with default behavior 
PASS Main frame with auto scroll-behavior ; scroll() with auto behavior 
PASS Main frame with auto scroll-behavior ; scroll() with instant behavior 
PASS Main frame with auto scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with default behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollIntoView() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollIntoView() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollIntoView() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollIntoView() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollIntoView() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollIntoView() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on the main frame with an instant scrolling 




<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true  internal:AsyncOverflowScrollingEnabled=true ] -->
<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on the root of the main frame</title>
<meta name="timeout" content="long"/>
<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#scrolling-box">
<script src="../../../resources/testharness.js"></script>
<script src="../../../resources/testharnessreport.js"></script>
<script src="resources/scroll-behavior.js"></script>
<style>
  body {
    margin: 0;
  }
  .autoBehavior {
    scroll-behavior: auto;
  }
  .smoothBehavior {
    scroll-behavior: smooth;
  }
</style>
<div id="log">
</div>
<div id="pageContent" style="position: absolute; left: 0; top: 0;">
  <div id="elementToReveal" style="position: absolute; display: inline-block; width: 10px; height: 15px; background: black;"></div>
</div>
<script>
  var pageLoaded = async_test("Page loaded");
  var scrollingElement, styledElement, elementToRevealLeft, elementToRevealTop;
  window.addEventListener("load", pageLoaded.step_func_done(function() {
    scrollingElement = document.scrollingElement;
    styledElement = document.documentElement;
    pageContent.style.width = (10 + window.innerWidth) * 5 + "px";
    pageContent.style.height = (20 + window.innerHeight) * 6 + "px";
    elementToRevealLeft = (10 + window.innerWidth) * 3;
    elementToRevealTop = (20 + window.innerHeight) * 4;
    elementToReveal.style.left = elementToRevealLeft + "px";
    elementToReveal.style.top = elementToRevealTop + "px";

    add_completion_callback(() => { resetScroll(scrollingElement); });

    ["scroll", "scrollTo", "scrollBy", "scrollIntoView"].forEach((scrollFunction) => {
      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with default behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with auto behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with instant behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingElement).then(() => {
          assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with smooth behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingElement).then(() => {
          assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with default behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingElement).then(() => {
          assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with auto behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with instant behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingElement).then(() => {
          assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
        });
     }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with smooth behavior`);
    });

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
      scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft / 2, elementToRevealTop / 2);
      return waitForScrollEnd(scrollingElement).then(() => {
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft / 2, "Final value of scrollLeft");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop / 2, "Final value of scrollTop");
      });
    }, "Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling");

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
      scrollNode(scrollingElement, "scroll", "instant", 0, 0);
      return waitForScrollEnd(scrollingElement).then(() => {
        assert_equals(scrollingElement.scrollLeft, 0, "Final value of scrollLeft");
        assert_equals(scrollingElement.scrollTop, 0, "Final value of scrollTop");
    });
  }, "Aborting an ongoing smooth scrolling on the main frame with an instant scrolling");
  }));
</script>




PASS Page loaded 
PASS Main frame with auto scroll-behavior ; scroll() with default behavior 
PASS Main frame with auto scroll-behavior ; scroll() with auto behavior 
PASS Main frame with auto scroll-behavior ; scroll() with instant behavior 
PASS Main frame with auto scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with default behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on the main frame with an instant scrolling 




<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true  internal:AsyncOverflowScrollingEnabled=true ] -->
<title>Testing scrollOptions' behavior for Element.scroll* on the window of the main frame</title>
<meta name="timeout" content="long"/>
<meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1">
<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#scrolling-box">
<script src="../../../resources/testharness.js"></script>
<script src="../../../resources/testharnessreport.js"></script>
<script src="resources/scroll-behavior.js"></script>
<style>
  body {
    margin: 0;
  }
  .autoBehavior {
    scroll-behavior: auto;
  }
  .smoothBehavior {
    scroll-behavior: smooth;
  }
</style>
<div id="log">
</div>
<div id="pageContent" style="position: absolute; left: 0; top: 0;">
  <div id="elementToReveal" style="position: absolute; display: inline-block; width: 10px; height: 15px; background: black;"></div>
</div>
<script>
  var pageLoaded = async_test("Page loaded");
  var scrollingWindow, styledElement, elementToRevealLeft, elementToRevealTop;
  window.addEventListener("load", pageLoaded.step_func_done(function() {
    scrollingWindow = window;
    styledElement = document.documentElement;
    pageContent.style.width = (10 + window.innerWidth) * 5 + "px";
    pageContent.style.height = (20 + window.innerHeight) * 6 + "px";
    elementToRevealLeft = (10 + window.innerWidth) * 3;
    elementToRevealTop = (20 + window.innerHeight) * 4;
    elementToReveal.style.left = elementToRevealLeft + "px";
    elementToReveal.style.top = elementToRevealTop + "px";

    add_completion_callback(() => { resetScrollForWindow(window); });

    ["scroll", "scrollTo", "scrollBy"].forEach((scrollFunction) => {
      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with default behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with auto behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with instant behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingWindow.scrollX, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingWindow.scrollY, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
          assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with smooth behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingWindow.scrollX, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingWindow.scrollY, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
          assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with default behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingWindow.scrollX, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingWindow.scrollY, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
          assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with auto behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with instant behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingWindow.scrollX, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingWindow.scrollY, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
          assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Final value of scrollTop");
        });
     }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with smooth behavior`);
    });

    promise_test(() => {
      resetScrollForWindow(scrollingWindow);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingWindow.scrollX, 0);
      assert_equals(scrollingWindow.scrollY, 0);
      scrollWindow(scrollingWindow, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
      scrollWindow(scrollingWindow, "scroll", "smooth", elementToRevealLeft / 2, elementToRevealTop / 2);
      return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft / 2, "Final value of scrollLeft");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop / 2, "Final value of scrollTop");
      });
    }, "Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling");

    promise_test(() => {
      resetScrollForWindow(scrollingWindow);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingWindow.scrollX, 0);
      assert_equals(scrollingWindow.scrollY, 0);
      scrollWindow(scrollingWindow, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
      scrollWindow(scrollingWindow, "scroll", "instant", 0, 0);
      return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
        assert_equals(scrollingWindow.scrollX, 0, "Final value of scrollLeft");
        assert_equals(scrollingWindow.scrollY, 0, "Final value of scrollTop");
    });
  }, "Aborting an ongoing smooth scrolling on the main frame with an instant scrolling");
  }));
</script>

Line 0 a/LayoutTests/fast/scrolling/ios/scroll-behavior-scrollintoview-nested-expected.txt_sec1
- a/LayoutTests/fast/scrolling/ios/scroll-behavior-scrollintoview-nested-expected.txt +3 lines
	1
	2	PASS scrollIntoView with nested elements with different scroll-behavior
	3



<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true  internal:AsyncOverflowScrollingEnabled=true ] -->
<title>Testing scrollOptions' behavior with scrollIntoView for nested scrolling nodes</title>
<meta name="timeout" content="long"/>
<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#scrolling-box">
<script src="../../../resources/testharness.js"></script>
<script src="../../../resources/testharnessreport.js"></script>
<script src="resources/scroll-behavior.js"></script>
<style>
  .scrollable {
    overflow: auto;
    height: 200px;
  }
  .smoothBehavior {
    scroll-behavior: smooth;
  }
  .gradient {
    background: linear-gradient(135deg, red, green);
  }
</style>
<div id="log">
</div>
<div>
  <div class="scrollable smoothBehavior" style="width: 450px">
    <div class="gradient" style="width: 100px; height: 500px;"></div>
    <div class="scrollable smoothBehavior" style="width: 400px">
      <div class="gradient" style="width: 100px; height: 500px;"></div>
      <div class="scrollable" style="width: 350px">
        <div class="gradient" style="width: 100px; height: 500px;"></div>
        <div class="scrollable" style="width: 300px">
          <div class="gradient" style="width: 100px; height: 500px;"></div>
          <div class="scrollable smoothBehavior" style="width: 250px">
            <div class="gradient" style="width: 100px; height: 500px;"></div>
            <div class="scrollable" style="width: 200px">
              <div class="gradient" style="width: 100px; height: 500px;"></div>
              <div id="elementToReveal" style="width: 10px; height: 10px; background: black;"></div>
              <div class="gradient" style="width: 100px; height: 500px;"></div>
            </div>
            <div class="gradient" style="width: 100px; height: 500px;"></div>
          </div>
          <div class="gradient" style="width: 100px; height: 500px;"></div>
        </div>
      <div class="gradient" style="width: 100px; height: 500px;"></div>
      </div>
      <div class="gradient" style="width: 100px; height: 500px;"></div>
    </div>
  </div>
</div>
<script>
  // The CSSOM-View spec and implementations follow different algorithms (scrolls performed in parallel, as inner-to-outer sequence or as outer-to-inner sequence).
  // See https://github.com/w3c/csswg-drafts/issues/3127
  promise_test(() => {
    return new Promise(function(resolve, reject) {
      var divs = document.querySelectorAll(".scrollable");
      divs.forEach((scrollableDiv) => {
        resetScroll(scrollableDiv);
      });
      elementToReveal.scrollIntoView({inline: "start", block: "start", behavior: "auto"});
      var scrollTop = new Map();
      var isSmooth = new Map();
      divs.forEach((scrollableDiv) => {
        scrollTop.set(scrollableDiv, scrollableDiv.scrollTop);
        isSmooth.set(scrollableDiv, scrollableDiv.classList.contains("smoothBehavior"));
        // If scroll operations are not performed in parallel, scroll boxes with instant behavior might also need to wait for their predecessors.
        if (isSmooth.get(scrollableDiv))
          assert_less_than(scrollTop.get(scrollableDiv), 500, "Element with smooth behavior should not scroll immediately");
      });

      observeScrolling(Array.from(divs), function(done) {
        try {
          divs.forEach((scrollableDiv) => {
            assert_less_than_equal(scrollTop.get(scrollableDiv), scrollableDiv.scrollTop, "ScrollTop keeps increasing");
            if (!isSmooth.get(scrollableDiv))
              assert_any(assert_equals, scrollableDiv.scrollTop, [0, 500], "Element with instant behavior should jump to the final position");
            if (done)
              assert_equals(scrollableDiv.scrollTop, 500, "Final value of scrollTop");
            scrollTop.set(scrollableDiv, scrollableDiv.scrollTop);
          });
        } catch(e) {
          reject(e);
        }
        if (done)
          resolve();
      });
    });
  }, "scrollIntoView with nested elements with different scroll-behavior");
</script>




PASS Scroll positions when performing smooth scrolling from (0, 0) to (500, 250) using scroll()  
PASS Scroll positions when performing smooth scrolling from (1000, 0) to (500, 250) using scroll()  
PASS Scroll positions when performing smooth scrolling from (0, 500) to (500, 250) using scroll()  
PASS Scroll positions when performing smooth scrolling from (1000, 500) to (500, 250) using scroll()  
PASS Scroll positions when performing smooth scrolling from (0, 0) to (500, 250) using scrollTo()  
PASS Scroll positions when performing smooth scrolling from (1000, 0) to (500, 250) using scrollTo()  
PASS Scroll positions when performing smooth scrolling from (0, 500) to (500, 250) using scrollTo()  
PASS Scroll positions when performing smooth scrolling from (1000, 500) to (500, 250) using scrollTo()  
PASS Scroll positions when performing smooth scrolling from (0, 0) to (500, 250) using scrollBy()  
PASS Scroll positions when performing smooth scrolling from (1000, 0) to (500, 250) using scrollBy()  
PASS Scroll positions when performing smooth scrolling from (0, 500) to (500, 250) using scrollBy()  
PASS Scroll positions when performing smooth scrolling from (1000, 500) to (500, 250) using scrollBy()  
PASS Scroll positions when performing smooth scrolling from (0, 0) to (500, 250) using scrollIntoView()  
PASS Scroll positions when performing smooth scrolling from (1000, 0) to (500, 250) using scrollIntoView()  
PASS Scroll positions when performing smooth scrolling from (0, 500) to (500, 250) using scrollIntoView()  
PASS Scroll positions when performing smooth scrolling from (1000, 500) to (500, 250) using scrollIntoView()  
PASS Scroll positions when aborting a smooth scrolling with another smooth scrolling 
PASS Scroll positions when aborting a smooth scrolling with an instant scrolling 




<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true  internal:AsyncOverflowScrollingEnabled=true ] -->
<title>Testing scroll positions when scrolling an element with smooth behavior</title>
<meta name="timeout" content="long"/>
<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#scrolling-box">
<script src="../../../resources/testharness.js"></script>
<script src="../../../resources/testharnessreport.js"></script>
<script src="resources/scroll-behavior.js"></script>
<style>
  .scrollable {
    overflow: auto;
    width: 400px;
    height: 200px;
    scroll-behavior: smooth;
  }
</style>
<div id="log">
</div>
<div id="overflowNode" class="scrollable">
  <div style="width: 2000px; height: 1000px; background: linear-gradient(135deg, red, green);">
    <span style="display: inline-block; width: 500px; height: 250px;"></span><span id="elementToReveal" style="display: inline-block; vertical-align: -15px; width: 10px; height: 15px; background: black;"></span>
  </div>
</div>
<script>
  // For smooth behavior, evolution of scroll positions over time is not specified by CSSOM View.
  // This test relies on the minimal assumption that scroll position functions are monotonic.
  ["scroll", "scrollTo", "scrollBy", "scrollIntoView"].forEach(function(scrollFunction) {
    [{left:0, top:0}, {left:1000, top:0}, {left:0, top:500}, {left:1000, top:500}].forEach((initial) => {
      var finalLeft = 500;
      var finalTop = 250;
      promise_test(() => {
        return new Promise(function(resolve, reject) {
          scrollNode(overflowNode, "scroll", "instant", initial.left, initial.top);
          var oldLeft = overflowNode.scrollLeft;
          var oldTop = overflowNode.scrollTop;
          assert_equals(oldLeft, initial.left, "ScrollLeft should be at initial position");
          assert_equals(oldTop, initial.top, "ScrollTop should be at initial position");
          if (scrollFunction === "scrollBy")
            scrollNode(overflowNode, scrollFunction, "smooth", finalLeft - initial.left, finalTop - initial.top);
          else
            scrollNode(overflowNode, scrollFunction, "smooth", finalLeft, finalTop);
          observeScrolling(overflowNode, function(done) {
            try {
              var newLeft = overflowNode.scrollLeft;
              var newTop = overflowNode.scrollTop;
              assert_less_than_equal(Math.hypot(finalLeft - newLeft, finalTop - newTop), Math.hypot(finalLeft - oldLeft, finalTop - oldTop), "Scroll position should move towards the final position");
              if (done) {
                assert_equals(newLeft, finalLeft, "ScrollLeft should reach final position");
                assert_equals(newTop, finalTop, "ScrollTop should reach final position");
              }
              oldLeft = newLeft;
              oldTop = newTop;
            } catch(e) {
              reject(e);
            }
            if (done)
              resolve();
          });
        });
      }, `Scroll positions when performing smooth scrolling from (${initial.left}, ${initial.top}) to (${finalLeft}, ${finalTop}) using ${scrollFunction}() `);
    });
  });

  promise_test(() => {
    return new Promise(function(resolve, reject) {
      resetScroll(overflowNode);
      var initialScrollAborted = false;
      var scrollDirectionChanged = false;
      var oldLeft = overflowNode.scrollLeft;
      var oldTop = overflowNode.scrollTop;
      assert_equals(oldLeft, 0);
      assert_equals(oldTop, 0);
      scrollNode(overflowNode, "scroll", "smooth", 1500, 750);
      observeScrolling(overflowNode, function(done) {
        try {
          var newLeft = overflowNode.scrollLeft;
          var newTop = overflowNode.scrollTop;
          if (initialScrollAborted) {
            if (scrollDirectionChanged) {
              assert_greater_than_equal(oldLeft, newLeft, "ScrollLeft keeps decreasing");
              assert_greater_than_equal(oldTop, newTop, "ScrollTop keeps decreasing");
            } else
              scrollDirectionChanged = newLeft <= oldLeft && newTop <= oldTop;
          } else {
              assert_less_than_equal(oldLeft, newLeft, "ScrollLeft keeps increasing");
              assert_less_than_equal(oldTop, newTop, "ScrollTop keeps increasing");
              if (newLeft > 1000 && newTop > 500) {
                // Abort the initial scroll.
                initialScrollAborted = true;
                scrollNode(overflowNode, "scroll", "smooth", 500, 250);
                newLeft = overflowNode.scrollLeft;
                newTop = overflowNode.scrollTop;
              }
          }
          if (done) {
            assert_equals(newLeft, 500, "ScrollLeft should reach final position");
            assert_equals(newTop, 250, "ScrollTop should reach final position");
          }
          oldLeft = newLeft;
          oldTop = newTop;
        } catch(e) {
          reject(e);
        }
        if (done)
          resolve();
      });
    });
  }, "Scroll positions when aborting a smooth scrolling with another smooth scrolling");

  promise_test(() => {
    return new Promise(function(resolve, reject) {
      resetScroll(overflowNode);
      var initialScrollAborted = false;
      var oldLeft = overflowNode.scrollLeft;
      var oldTop = overflowNode.scrollTop;
      assert_equals(oldLeft, 0);
      assert_equals(oldTop, 0);
      scrollNode(overflowNode, "scroll", "smooth", 1500, 750);
      observeScrolling(overflowNode, function(done) {
        try {
          var newLeft = overflowNode.scrollLeft;
          var newTop = overflowNode.scrollTop;
          if (!initialScrollAborted) {
              assert_less_than_equal(oldLeft, newLeft, "ScrollLeft keeps increasing");
              assert_less_than_equal(oldTop, newTop, "ScrollTop keeps increasing");
              if (newLeft > 1000 && newTop > 500) {
                // Abort the initial scroll.
                initialScrollAborted = true;
                scrollNode(overflowNode, "scroll", "instant", 500, 250);
                newLeft = overflowNode.scrollLeft;
                newTop = overflowNode.scrollTop;
                assert_equals(newLeft, 500, "ScrollLeft should reach final position");
                assert_equals(newTop, 250, "ScrollTop should reach final position");
              }
          }
          if (done) {
            assert_equals(newLeft, 500, "ScrollLeft should stay at final position");
            assert_equals(newTop, 250, "ScrollTop should stay at final position");
          }
          oldLeft = newLeft;
          oldTop = newTop;
        } catch(e) {
          reject(e);
        }
        if (done)
          resolve();
      });
    });
  }, "Scroll positions when aborting a smooth scrolling with an instant scrolling");
</script>




PASS iframe loaded 
PASS Subframe with auto scroll-behavior ; scroll() with default behavior 
PASS Subframe with auto scroll-behavior ; scroll() with auto behavior 
PASS Subframe with auto scroll-behavior ; scroll() with instant behavior 
PASS Subframe with auto scroll-behavior ; scroll() with smooth behavior 
PASS Subframe with smooth scroll-behavior ; scroll() with default behavior 
PASS Subframe with smooth scroll-behavior ; scroll() with auto behavior 
PASS Subframe with smooth scroll-behavior ; scroll() with instant behavior 
PASS Subframe with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Subframe with auto scroll-behavior ; scrollTo() with default behavior 
PASS Subframe with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Subframe with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Subframe with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Subframe with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Subframe with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Subframe with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Subframe with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Subframe with auto scroll-behavior ; scrollBy() with default behavior 
PASS Subframe with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Subframe with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Subframe with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Subframe with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Subframe with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Subframe with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Subframe with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Subframe with auto scroll-behavior ; scrollIntoView() with default behavior 
PASS Subframe with auto scroll-behavior ; scrollIntoView() with auto behavior 
PASS Subframe with auto scroll-behavior ; scrollIntoView() with instant behavior 
PASS Subframe with auto scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Subframe with smooth scroll-behavior ; scrollIntoView() with default behavior 
PASS Subframe with smooth scroll-behavior ; scrollIntoView() with auto behavior 
PASS Subframe with smooth scroll-behavior ; scrollIntoView() with instant behavior 
PASS Subframe with smooth scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on a subframe with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on a subframe with an instant scrolling 




<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true  internal:AsyncOverflowScrollingEnabled=true internal:AsyncFrameScrollingEnabled=true ] -->
<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on the root of a subframe</title>
<meta name="timeout" content="long"/>
<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#scrolling-box">
<script src="../../../resources/testharness.js"></script>
<script src="../../../resources/testharnessreport.js"></script>
<script src="resources/scroll-behavior.js"></script>
<div id="log">
</div>
<iframe id="iframeNode" width="400px" height="200px" srcdoc="<!DOCTYPE>
<html>
  <style>
    body {
      margin: 0;
    }
    .autoBehavior {
      scroll-behavior: auto;
    }
    .smoothBehavior {
      scroll-behavior: smooth;
    }
  </style>
  <body>
    <div style='width: 2000px; height: 1000px; background: linear-gradient(135deg, red, green);'>
      <span style='display: inline-block; width: 500px; height: 250px;'></span><span id='elementToReveal' style='display: inline-block; vertical-align: -15px; width: 10px; height: 15px; background: black;'></span>
    </div>
  </body>
</html>">
</iframe>
<script>
  var iframeLoadTest = async_test("iframe loaded");
  var scrollingElement, styledElement, elementToReveal;
  var elementToRevealLeft = 500;
  var elementToRevealTop = 250;
  iframeNode.addEventListener("load", iframeLoadTest.step_func_done(() => {
    scrollingElement = iframeNode.contentDocument.scrollingElement;
    styledElement = iframeNode.contentDocument.documentElement;
    elementToReveal = iframeNode.contentDocument.getElementById("elementToReveal");

    ["scroll", "scrollTo", "scrollBy", "scrollIntoView"].forEach((scrollFunction) => {
      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Subframe with auto scroll-behavior ; ${scrollFunction}() with default behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Subframe with auto scroll-behavior ; ${scrollFunction}() with auto behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Subframe with auto scroll-behavior ; ${scrollFunction}() with instant behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingElement).then(() => {
          assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Subframe with auto scroll-behavior ; ${scrollFunction}() with smooth behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingElement).then(() => {
          assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Subframe with smooth scroll-behavior ; ${scrollFunction}() with default behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingElement).then(() => {
          assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Subframe with smooth scroll-behavior ; ${scrollFunction}() with auto behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Subframe with smooth scroll-behavior ; ${scrollFunction}() with instant behavior`);

      promise_test(() => {
        resetScroll(scrollingElement);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingElement.scrollLeft, 0);
        assert_equals(scrollingElement.scrollTop, 0);
        scrollNode(scrollingElement, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingElement.scrollLeft, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingElement.scrollTop, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingElement).then(() => {
          assert_equals(scrollingElement.scrollLeft, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingElement.scrollTop, elementToRevealTop, "Final value of scrollTop");
        });
     }, `Subframe with smooth scroll-behavior ; ${scrollFunction}() with smooth behavior`);
    });

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
      scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft / 2, elementToRevealTop / 2);
      return waitForScrollEnd(scrollingElement).then(() => {
        assert_equals(scrollingElement.scrollLeft, elementToRevealLeft / 2, "Final value of scrollLeft");
        assert_equals(scrollingElement.scrollTop, elementToRevealTop / 2, "Final value of scrollTop");
      });
    }, "Aborting an ongoing smooth scrolling on a subframe with another smooth scrolling");

    promise_test(() => {
      resetScroll(scrollingElement);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingElement.scrollLeft, 0);
      assert_equals(scrollingElement.scrollTop, 0);
      scrollNode(scrollingElement, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
      scrollNode(scrollingElement, "scroll", "instant", 0, 0);
      return waitForScrollEnd(scrollingElement).then(() => {
        assert_equals(scrollingElement.scrollLeft, 0, "Final value of scrollLeft");
        assert_equals(scrollingElement.scrollTop, 0, "Final value of scrollTop");
    });
  }, "Aborting an ongoing smooth scrolling on a subframe with an instant scrolling");
  }));
</script>




PASS iframe loaded 
PASS Main frame with auto scroll-behavior ; scroll() with default behavior 
PASS Main frame with auto scroll-behavior ; scroll() with auto behavior 
PASS Main frame with auto scroll-behavior ; scroll() with instant behavior 
PASS Main frame with auto scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with default behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on the main frame with an instant scrolling 




<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true  internal:AsyncOverflowScrollingEnabled=true internal:AsyncFrameScrollingEnabled=true ] -->
<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on the root of a subframe</title>
<meta name="timeout" content="long"/>
<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior">
<link rel="help" href="https://drafts.csswg.org/cssom-view/#scrolling-box">
<script src="../../../resources/testharness.js"></script>
<script src="../../../resources/testharnessreport.js"></script>
<script src="resources/scroll-behavior.js"></script>
<div id="log">
</div>
<iframe id="iframeNode" width="400px" height="200px" srcdoc="<!DOCTYPE>
<html>
  <style>
    body {
      margin: 0;
    }
    .autoBehavior {
      scroll-behavior: auto;
    }
    .smoothBehavior {
      scroll-behavior: smooth;
    }
  </style>
  <body>
    <div style='width: 2000px; height: 1000px; background: linear-gradient(135deg, red, green);'>
      <span style='display: inline-block; width: 500px; height: 250px;'></span><span id='elementToReveal' style='display: inline-block; vertical-align: -15px; width: 10px; height: 15px; background: black;'></span>
    </div>
  </body>
</html>">
</iframe>
<script>
  var iframeLoadTest = async_test("iframe loaded");
  var scrollingWindow, styledElement, elementToReveal;
  var elementToRevealLeft = 500;
  var elementToRevealTop = 250;
  iframeNode.addEventListener("load", iframeLoadTest.step_func_done(() => {
    scrollingWindow = iframeNode.contentWindow;
    styledElement = iframeNode.contentDocument.documentElement;
    elementToReveal = iframeNode.contentDocument.getElementById("elementToReveal");

    ["scroll", "scrollTo", "scrollBy"].forEach((scrollFunction) => {
      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with default behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with auto behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with instant behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "autoBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingWindow.scrollX, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingWindow.scrollY, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
          assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Main frame with auto scroll-behavior ; ${scrollFunction}() with smooth behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, null, elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingWindow.scrollX, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingWindow.scrollY, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
          assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with default behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "auto", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingWindow.scrollX, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingWindow.scrollY, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
          assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Final value of scrollTop");
        });
      }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with auto behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "instant", elementToRevealLeft, elementToRevealTop);
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Should set scrollLeft immediately");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Should set scrollTop immediately");
        return new Promise((resolve) => { resolve(); });
      }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with instant behavior`);

      promise_test(() => {
        resetScrollForWindow(scrollingWindow);
        setScrollBehavior(styledElement, "smoothBehavior");
        assert_equals(scrollingWindow.scrollX, 0);
        assert_equals(scrollingWindow.scrollY, 0);
        scrollWindow(scrollingWindow, scrollFunction, "smooth", elementToRevealLeft, elementToRevealTop);
        assert_less_than(scrollingWindow.scrollX, elementToRevealLeft, "Should not set scrollLeft immediately");
        assert_less_than(scrollingWindow.scrollY, elementToRevealTop, "Should not set scrollTop immediately");
        return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
          assert_equals(scrollingWindow.scrollX, elementToRevealLeft, "Final value of scrollLeft");
          assert_equals(scrollingWindow.scrollY, elementToRevealTop, "Final value of scrollTop");
        });
     }, `Main frame with smooth scroll-behavior ; ${scrollFunction}() with smooth behavior`);
    });

    promise_test(() => {
      resetScrollForWindow(scrollingWindow);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingWindow.scrollX, 0);
      assert_equals(scrollingWindow.scrollY, 0);
      scrollWindow(scrollingWindow, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
      scrollWindow(scrollingWindow, "scroll", "smooth", elementToRevealLeft / 2, elementToRevealTop / 2);
      return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
        assert_equals(scrollingWindow.scrollX, elementToRevealLeft / 2, "Final value of scrollLeft");
        assert_equals(scrollingWindow.scrollY, elementToRevealTop / 2, "Final value of scrollTop");
      });
    }, "Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling");

    promise_test(() => {
      resetScrollForWindow(scrollingWindow);
      setScrollBehavior(styledElement, "smoothBehavior");
      assert_equals(scrollingWindow.scrollX, 0);
      assert_equals(scrollingWindow.scrollY, 0);
      scrollWindow(scrollingWindow, "scroll", "smooth", elementToRevealLeft, elementToRevealTop);
      scrollWindow(scrollingWindow, "scroll", "instant", 0, 0);
      return waitForScrollEnd(scrollingWindow.document.scrollingElement).then(() => {
        assert_equals(scrollingWindow.scrollX, 0, "Final value of scrollLeft");
        assert_equals(scrollingWindow.scrollY, 0, "Final value of scrollTop");
    });
  }, "Aborting an ongoing smooth scrolling on the main frame with an instant scrolling");

  }));
</script>

Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/inheritance-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/inheritance-expected.txt -2 / +2 lines
1		1
2	FAIL Property scroll-behavior has initial value auto assert_true: scroll-behavior doesn't seem to be supported in the computed style expected true got false	2	PASS Property scroll-behavior has initial value auto
3	FAIL Property scroll-behavior does not inherit assert_true: expected true got false	3	PASS Property scroll-behavior does not inherit
4		4

Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-default-css-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-default-css-expected.txt -1 / +1 lines
1		1
2	PASS Instant scrolling of an element with default scroll-behavior	2	PASS Instant scrolling of an element with default scroll-behavior
3	FAIL Smooth scrolling of an element with default scroll-behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	3	PASS Smooth scrolling of an element with default scroll-behavior
4		4

Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-default-css.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-default-css.html -1 / +1 lines
1	<!DOCTYPE html>	1	<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true ] -->
2	<title>Testing default value of scroll-behavior</title>	2	<title>Testing default value of scroll-behavior</title>
3	<meta name="timeout" content="long"/>	3	<meta name="timeout" content="long"/>
4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">	4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">



PASS Element with auto scroll-behavior ; scroll() with default behavior 
PASS Element with auto scroll-behavior ; scroll() with auto behavior 
PASS Element with auto scroll-behavior ; scroll() with instant behavior 
PASS Element with auto scroll-behavior ; scroll() with smooth behavior 
PASS Element with smooth scroll-behavior ; scroll() with default behavior 
PASS Element with smooth scroll-behavior ; scroll() with auto behavior 
PASS Element with smooth scroll-behavior ; scroll() with instant behavior 
PASS Element with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Element with auto scroll-behavior ; scrollTo() with default behavior 
PASS Element with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Element with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Element with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Element with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Element with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Element with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Element with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Element with auto scroll-behavior ; scrollBy() with default behavior 
PASS Element with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Element with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Element with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Element with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Element with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Element with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Element with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Element with auto scroll-behavior ; scrollIntoView() with default behavior 
PASS Element with auto scroll-behavior ; scrollIntoView() with auto behavior 
PASS Element with auto scroll-behavior ; scrollIntoView() with instant behavior 
PASS Element with auto scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Element with smooth scroll-behavior ; scrollIntoView() with default behavior 
PASS Element with smooth scroll-behavior ; scrollIntoView() with auto behavior 
PASS Element with smooth scroll-behavior ; scrollIntoView() with instant behavior 
PASS Element with smooth scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on an element with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on an element with an instant scrolling 


Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-element.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-element.html -1 / +1 lines
1	<!DOCTYPE html>	1	<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true ] -->
2	<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on an element</title>	2	<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on an element</title>
3	<meta name="timeout" content="long"/>	3	<meta name="timeout" content="long"/>
4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">	4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">



PASS Main frame with auto scroll-behavior ; scroll() with default behavior 
PASS Main frame with auto scroll-behavior ; scroll() with auto behavior 
PASS Main frame with auto scroll-behavior ; scroll() with instant behavior 
PASS Main frame with auto scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with default behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollIntoView() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollIntoView() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollIntoView() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollIntoView() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollIntoView() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollIntoView() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on the main frame with an instant scrolling 


Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html -1 / +1 lines
1	<!DOCTYPE html>	1	<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true ] -->
2	<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on the root of the main frame</title>	2	<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on the root of the main frame</title>
3	<meta name="timeout" content="long"/>	3	<meta name="timeout" content="long"/>
4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">	4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">



PASS Main frame with auto scroll-behavior ; scroll() with default behavior 
PASS Main frame with auto scroll-behavior ; scroll() with auto behavior 
PASS Main frame with auto scroll-behavior ; scroll() with instant behavior 
PASS Main frame with auto scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with default behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on the main frame with an instant scrolling 


Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html -1 / +1 lines
1	<!DOCTYPE html>	1	<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true ] -->
2	<title>Testing scrollOptions' behavior for Element.scroll* on the window of the main frame</title>	2	<title>Testing scrollOptions' behavior for Element.scroll* on the window of the main frame</title>
3	<meta name="timeout" content="long"/>	3	<meta name="timeout" content="long"/>
4	<meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1">	4	<meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1">

Lines 1-3 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested-expected.txt -1 / +1 lines
1		1
2	FAIL scrollIntoView with nested elements with different scroll-behavior assert_less_than: Element with smooth behavior should not scroll immediately expected a number less than 500 but got 500	2	PASS scrollIntoView with nested elements with different scroll-behavior
3		3

Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested.html -1 / +1 lines
1	<!DOCTYPE html>	1	<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true ] -->
2	<title>Testing scrollOptions' behavior with scrollIntoView for nested scrolling nodes</title>	2	<title>Testing scrollOptions' behavior with scrollIntoView for nested scrolling nodes</title>
3	<meta name="timeout" content="long"/>	3	<meta name="timeout" content="long"/>
4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">	4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">

Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-smooth-positions.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-smooth-positions.html -1 / +1 lines
1	<!DOCTYPE html>	1	<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true ] -->
2	<title>Testing scroll positions when scrolling an element with smooth behavior</title>	2	<title>Testing scroll positions when scrolling an element with smooth behavior</title>
3	<meta name="timeout" content="long"/>	3	<meta name="timeout" content="long"/>
4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">	4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">



PASS Subframe with auto scroll-behavior ; scroll() with default behavior 
PASS Subframe with auto scroll-behavior ; scroll() with auto behavior 
PASS Subframe with auto scroll-behavior ; scroll() with instant behavior 
PASS Subframe with auto scroll-behavior ; scroll() with smooth behavior 
PASS Subframe with smooth scroll-behavior ; scroll() with default behavior 
PASS Subframe with smooth scroll-behavior ; scroll() with auto behavior 
PASS Subframe with smooth scroll-behavior ; scroll() with instant behavior 
PASS Subframe with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Subframe with auto scroll-behavior ; scrollTo() with default behavior 
PASS Subframe with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Subframe with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Subframe with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Subframe with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Subframe with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Subframe with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Subframe with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Subframe with auto scroll-behavior ; scrollBy() with default behavior 
PASS Subframe with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Subframe with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Subframe with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Subframe with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Subframe with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Subframe with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Subframe with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Subframe with auto scroll-behavior ; scrollIntoView() with default behavior 
PASS Subframe with auto scroll-behavior ; scrollIntoView() with auto behavior 
PASS Subframe with auto scroll-behavior ; scrollIntoView() with instant behavior 
PASS Subframe with auto scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Subframe with smooth scroll-behavior ; scrollIntoView() with default behavior 
PASS Subframe with smooth scroll-behavior ; scrollIntoView() with auto behavior 
PASS Subframe with smooth scroll-behavior ; scrollIntoView() with instant behavior 
PASS Subframe with smooth scroll-behavior ; scrollIntoView() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on a subframe with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on a subframe with an instant scrolling 


Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html -1 / +1 lines
1	<!DOCTYPE html>	1	<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true ] -->
2	<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on the root of a subframe</title>	2	<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on the root of a subframe</title>
3	<meta name="timeout" content="long"/>	3	<meta name="timeout" content="long"/>
4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">	4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">



PASS Main frame with auto scroll-behavior ; scroll() with default behavior 
PASS Main frame with auto scroll-behavior ; scroll() with auto behavior 
PASS Main frame with auto scroll-behavior ; scroll() with instant behavior 
PASS Main frame with auto scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with default behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scroll() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollTo() with smooth behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with auto scroll-behavior ; scrollBy() with smooth behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with default behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with auto behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with instant behavior 
PASS Main frame with smooth scroll-behavior ; scrollBy() with smooth behavior 
PASS Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling 
PASS Aborting an ongoing smooth scrolling on the main frame with an instant scrolling 


Lines 1-4 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html -1 / +1 lines
1	<!DOCTYPE html>	1	<!DOCTYPE html><!-- webkit-test-runner [ experimental:CSSOMViewSmoothScrollingEnabled=true ] -->
2	<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on the root of a subframe</title>	2	<title>Testing scrollOptions' behavior for Element.scroll* and scroll-behavior on the root of a subframe</title>
3	<meta name="timeout" content="long"/>	3	<meta name="timeout" content="long"/>
4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">	4	<link rel="author" title="FrÃ©dÃ©ric Wang" href="mailto:fwang@igalia.com">

Lines 744-749 webkit.org/b/189594 imported/w3c/web-platform-tests/css/css-animations/pending-s a/LayoutTests/platform/mac-wk1/TestExpectations_sec1
- a/LayoutTests/platform/mac-wk1/TestExpectations +7 lines
744		744
745	webkit.org/b/188070 imported/w3c/web-platform-tests/streams/piping/error-propagation-backward.html [ Pass Failure ]	745	webkit.org/b/188070 imported/w3c/web-platform-tests/streams/piping/error-propagation-backward.html [ Pass Failure ]
746		746
		747	# Tests for smooth scroll behavior do not all work and they are slow, so let's just skip them.
		748	webkit.org/b/191357 imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html [ Skip ]
		749	webkit.org/b/191357 imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html [ Skip ]
		750	webkit.org/b/191357 imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html [ Skip ]
		751	webkit.org/b/191357 imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html [ Skip ]
		752	webkit.org/b/191357 imported/w3c/web-platform-tests/css/cssom-view/inheritance.html [ Skip ]
		753
747	webkit.org/b/189908 imported/w3c/web-platform-tests/resource-timing/resource_timing.worker.html [ Failure ]	754	webkit.org/b/189908 imported/w3c/web-platform-tests/resource-timing/resource_timing.worker.html [ Failure ]
748		755
749	webkit.org/b/189756 [ Mojave+ ] compositing/filters/opacity-change-on-filtered-paints-into-ancestor.html [ Pass ImageOnlyFailure ]	756	webkit.org/b/189756 [ Mojave+ ] compositing/filters/opacity-change-on-filtered-paints-into-ancestor.html [ Pass ImageOnlyFailure ]

Return to Bug 188043

Lines 1641-1646 page/ResourceUsageOverlay.cpp a/Source/WebCore/Sources.txt_sec1
- a/Source/WebCore/Sources.txt +4 lines
1641	page/ResourceUsageThread.cpp	1641	page/ResourceUsageThread.cpp
1642	page/RuntimeEnabledFeatures.cpp	1642	page/RuntimeEnabledFeatures.cpp
1643	page/Screen.cpp	1643	page/Screen.cpp
		1644	page/ScrollBehavior.cpp
1644	page/SecurityOrigin.cpp	1645	page/SecurityOrigin.cpp
1645	page/SecurityOriginData.cpp	1646	page/SecurityOriginData.cpp
1646	page/SecurityPolicy.cpp	1647	page/SecurityPolicy.cpp
Lines 1746-1751 platform/RemoteCommandListener.cpp a/Source/WebCore/Sources.txt_sec2
1746	platform/RuntimeApplicationChecks.cpp	1747	platform/RuntimeApplicationChecks.cpp
1747	platform/SSLKeyGenerator.cpp	1748	platform/SSLKeyGenerator.cpp
1748	platform/ScrollAnimator.cpp	1749	platform/ScrollAnimator.cpp
		1750	platform/ScrollAnimationSmooth.cpp
1749	platform/ScrollView.cpp	1751	platform/ScrollView.cpp
1750	platform/ScrollableArea.cpp	1752	platform/ScrollableArea.cpp
1751	platform/Scrollbar.cpp	1753	platform/Scrollbar.cpp
Lines 3369-3376 JSSVGZoomAndPan.cpp a/Source/WebCore/Sources.txt_sec3
3369	JSSVGZoomEvent.cpp	3371	JSSVGZoomEvent.cpp
3370	JSScreen.cpp	3372	JSScreen.cpp
3371	JSScriptProcessorNode.cpp	3373	JSScriptProcessorNode.cpp
		3374	JSScrollBehavior.cpp
3372	JSScrollIntoViewOptions.cpp	3375	JSScrollIntoViewOptions.cpp
3373	JSScrollLogicalPosition.cpp	3376	JSScrollLogicalPosition.cpp
		3377	JSScrollOptions.cpp
3374	JSScrollToOptions.cpp	3378	JSScrollToOptions.cpp
3375	JSSecurityPolicyViolationEvent.cpp	3379	JSSecurityPolicyViolationEvent.cpp
3376	JSServiceWorker.cpp	3380	JSServiceWorker.cpp

Lines 3557-3562 a/Source/WebCore/css/CSSProperties.json_sec1
- a/Source/WebCore/css/CSSProperties.json +26 lines
3557	"url": "https://www.w3.org/TR/SVG/shapes.html"	3557	"url": "https://www.w3.org/TR/SVG/shapes.html"
3558	}	3558	}
3559	},	3559	},
		3560	"scroll-behavior": {
		3561	"values": [
		3562	"auto",
		3563	"smooth"
		3564	],
		3565	"specification": {
		3566	"category": "cssom-view",
		3567	"url": "https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior"
		3568	}
		3569	},
3560	"shape-rendering": {	3570	"shape-rendering": {
3561	"inherited": true,	3571	"inherited": true,
3562	"values": [	3572	"values": [
Lines 6489-6494 a/Source/WebCore/css/CSSProperties.json_sec2
6489	"url": "https://www.w3.org/TR/css-ui-4/#propdef-user-select"	6499	"url": "https://www.w3.org/TR/css-ui-4/#propdef-user-select"
6490	}	6500	}
6491	},	6501	},
		6502	"scroll-behavior": {
		6503	"values": [
		6504	"auto",
		6505	"smooth"
		6506	],
		6507	"codegen-properties": {
		6508	"converter": "SmoothScrolling",
		6509	"name-for-methods": "UseSmoothScrolling"
		6510	},
		6511	"status": {
		6512	"status": "experimental"
		6513	},
		6514	"specification": {
		6515	"url": "https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior"
		6516	}
		6517	},
6492	"scroll-padding": {	6518	"scroll-padding": {
6493	"codegen-properties": {	6519	"codegen-properties": {
6494	"enable-if": "ENABLE_CSS_SCROLL_SNAP",	6520	"enable-if": "ENABLE_CSS_SCROLL_SNAP",

Lines 1595-1601 double DOMWindow::devicePixelRatio() const a/Source/WebCore/page/DOMWindow.cpp_sec1
- a/Source/WebCore/page/DOMWindow.cpp -4 / +12 lines
1595		1595
1596	void DOMWindow::scrollBy(double x, double y) const	1596	void DOMWindow::scrollBy(double x, double y) const
1597	{	1597	{
1598	scrollBy({ x, y });	1598	scrollBy(ScrollToOptions(x, y));
1599	}	1599	}
1600		1600
1601	void DOMWindow::scrollBy(const ScrollToOptions& options) const	1601	void DOMWindow::scrollBy(const ScrollToOptions& options) const
Lines 1617-1626 void DOMWindow::scrollBy(const ScrollToOptions& options) const a/Source/WebCore/page/DOMWindow.cpp_sec2
1617		1617
1618	void DOMWindow::scrollTo(double x, double y, ScrollClamping clamping) const	1618	void DOMWindow::scrollTo(double x, double y, ScrollClamping clamping) const
1619	{	1619	{
1620	scrollTo({ x, y }, clamping);	1620	scrollTo(ScrollToOptions(x, y), clamping);
1621	}	1621	}
1622		1622
1623	void DOMWindow::scrollTo(const ScrollToOptions& options, ScrollClamping) const	1623	void DOMWindow::scrollTo(const ScrollToOptions& options, ScrollClamping clamping) const
1624	{	1624	{
1625	if (!isCurrentlyDisplayedInFrame())	1625	if (!isCurrentlyDisplayedInFrame())
1626	return;	1626	return;
Lines 1633-1644 void DOMWindow::scrollTo(const ScrollToOptions& options, ScrollClamping) const a/Source/WebCore/page/DOMWindow.cpp_sec3
1633	view->contentsScrollPosition().x(), view->contentsScrollPosition().y()	1633	view->contentsScrollPosition().x(), view->contentsScrollPosition().y()
1634	);	1634	);
1635		1635
1636	if (!scrollToOptions.left.value() && !scrollToOptions.top.value() && view->contentsScrollPosition() == IntPoint(0, 0))	1636	if (!view->isScrollInProgress() && !scrollToOptions.left.value() && !scrollToOptions.top.value() && view->contentsScrollPosition() == IntPoint(0, 0))
1637	return;	1637	return;
1638		1638
1639	document()->updateLayoutIgnorePendingStylesheets();	1639	document()->updateLayoutIgnorePendingStylesheets();
1640		1640
1641	IntPoint layoutPos(view->mapFromCSSToLayoutUnits(scrollToOptions.left.value()), view->mapFromCSSToLayoutUnits(scrollToOptions.top.value()));	1641	IntPoint layoutPos(view->mapFromCSSToLayoutUnits(scrollToOptions.left.value()), view->mapFromCSSToLayoutUnits(scrollToOptions.top.value()));
		1642
		1643	// FIXME: Should we use document()->scrollingElement()?
		1644	// See https://github.com/w3c/csswg-drafts/issues/2977
		1645	if (document()->documentElement() && useSmoothScrolling(scrollToOptions.behavior.valueOr(ScrollBehavior::Auto), *document()->documentElement())) {
		1646	view->scrollToOffsetWithAnimation(layoutPos, ScrollType::Programmatic, clamping);
		1647	return;
		1648	}
		1649
1642	view->setContentsScrollPosition(layoutPos);	1650	view->setContentsScrollPosition(layoutPos);
1643	}	1651	}
1644		1652

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +211 lines
		1	2019-11-28 Cathie Chen <cathiechen@igalia.com>
		2
		3	Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
		4	https://bugs.webkit.org/show_bug.cgi?id=188043
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Based on the patch by FrÃ©dÃ©ric Wang.
		9
		10	This patch introduces a programmatic smooth scrolling in WebKit from the CSSOM View
		11	specification [1]. To use this effect, web developers can pass a behavior parameter (auto,
		12	smooth, or instant) to Element.scroll, Element.scrollTo, Element.scrollBy,
		13	Element.scrollIntoView, Window.scroll, Window.scrollTo or Window.scrollBy [2]. When behavior
		14	is auto, the instant/smooth characteristic is actually taken from the value of a new CSS
		15	scroll-behavior property [3]. Both the new CSS and DOM behavior are protected by a runtime
		16	flag. The Element.scrollIntoView part will be refined later in bug 189907. The actual
		17	animation on non-iOS platforms, executed in the scrolling thread, relies on the existing
		18	ScrollAnimationSmooth. On iOS, it relies on UIScrollView's native scroll animation support
		19	and is executed in the UI process.
		20
		21	[1] https://drafts.csswg.org/cssom-view
		22	[2] https://drafts.csswg.org/cssom-view/#dictdef-scrolloptions
		23	[3] https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior
		24
		25	Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
		26
		27	Tests: imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-default-css.html
		28	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-element.html
		29	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html
		30	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html
		31	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested.html
		32	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-smooth-positions.html
		33	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html
		34	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html
		35	fast/scrolling/ios/scroll-behavior-default-css.html
		36	fast/scrolling/ios/scroll-behavior-element.html
		37	fast/scrolling/ios/scroll-behavior-main-frame-root.html
		38	fast/scrolling/ios/scroll-behavior-main-frame-window.html
		39	fast/scrolling/ios/scroll-behavior-scrollintoview-nested.html
		40	fast/scrolling/ios/scroll-behavior-smooth-positions.html
		41	fast/scrolling/ios/scroll-behavior-subframe-root.html
		42	fast/scrolling/ios/scroll-behavior-subframe-window.html
		43
		44	* CMakeLists.txt: Add IDL files for ScrollOptions and ScrollBehavior.
		45	* DerivedSources.make: Ditto.
		46	* Headers.cmake: Add headers for ScrollBehavor and ScrollOptions.
		47	* Sources.txt: Add ScrollBehavor and ScrollOptions implementation. Also build
		48	ScrollAnimationSmooth.cpp on all platforms.
		49	* SourcesGTK.txt: Remove ScrollAnimationSmooth.cpp since it is built on all platforms now.
		50	* WebCore.xcodeproj/project.pbxproj: Add files to the build system.
		51	* css/CSSComputedStyleDeclaration.cpp: Handle scroll-behavior.
		52	(WebCore::ComputedStyleExtractor::valueForPropertyInStyle):
		53	* css/CSSProperties.json: Add scroll-behavior.
		54	* css/CSSValueKeywords.in: Add keywords for scroll-behavior.
		55	* css/parser/CSSParserContext.cpp: Add runtime config for scroll-behavior.
		56	(WebCore::CSSParserContext::CSSParserContext):
		57	(WebCore::operator==):
		58	* css/parser/CSSParserContext.h: Ditto.
		59	(WebCore::CSSParserContextHash::hash):
		60	* css/parser/CSSParserFastPaths.cpp: Remove scroll-behavior templates. It is handled in the
		61	slow path since property can be disabled.
		62	(WebCore::CSSParserFastPaths::isValidKeywordPropertyAndValue):
		63	(WebCore::CSSParserFastPaths::isKeywordPropertyID):
		64	* css/parser/CSSPropertyParser.cpp:
65	(WebCore::consumeScrollBehavior):
66	(WebCore::CSSPropertyParser::parseSingleValue): Parse scroll-behavior (only if enabled).
67	* dom/Element.cpp:
68	(WebCore::Element::scrollIntoView): Pass scroll behavior, if any.
69	(WebCore::Element::scrollBy):
70	(WebCore::Element::scrollTo): Handle the case when scroll behavior is smooth.
71	(WebCore::Element::setScrollLeft): Handle the case when scroll behavior is smooth.
72	(WebCore::Element::setScrollTop): Handle the case when scroll behavior is smooth.
73	* page/DOMWindow.cpp:
74	(WebCore::DOMWindow::scrollBy const):
75	(WebCore::DOMWindow::scrollTo const): Handle the case when scroll behavior is smooth.
76	The optimization of cancel (0, 0) scrolling is skipped if an animated scroll is in progress.
77	Otherwise, the previous scroll won't be stopped by a follow-up scroll.
78	* page/FrameView.cpp:
79	(WebCore::FrameView::scrollToOffsetWithAnimation): Start an animated scroll.
80	* page/FrameView.h:
81	* page/ScrollBehavior.cpp: Added.
82	(WebCore::useSmoothScrolling): Helper funciton to determine the scroll behavior to apply to
83	an element from the CSS and DOM behavior.
84	* page/ScrollBehavior.h: Added.
85	* page/ScrollBehavior.idl: Added.
86	* page/ScrollIntoViewOptions.h: Make this class inherits from ScrollOption. Also remove
87	unnecessary forward declaration.
88	* page/ScrollIntoViewOptions.idl: Make this class inherits from ScrollOption.
89	* page/ScrollOptions.h: Added.
90	* page/ScrollOptions.idl: Added.
91	* page/ScrollToOptions.h: Make this struct inherits from ScrollOptions.
92	(WebCore::normalizeNonFiniteCoordinatesOrFallBackTo): Copy the current ScrollToOptions so
93	that the scroll behavior is preserved.
94	* page/ScrollToOptions.idl: Make this class inherit from ScrollOptions.
95	* page/Settings.yaml: New setting for CSSOM View smooth scrolling.
96	* page/scrolling/AsyncScrollingCoordinator.cpp:
97	(WebCore::AsyncScrollingCoordinator::requestScrollPositionUpdate): Add a flag to indicate if this is an animated scroll or not.
98	(WebCore::AsyncScrollingCoordinator::setScrollAnimationInProgress): Update the scroll animation status from the UI process.
99	* page/scrolling/AsyncScrollingCoordinator.h:
100	* page/scrolling/ScrollingStateScrollingNode.cpp:
101	(WebCore::ScrollingStateScrollingNode::ScrollingStateScrollingNode): Add m_requestedScrollPositionWithAnimation to indicate it's animated.
102	(WebCore::ScrollingStateScrollingNode::setRequestedScrollPosition): Ditto.
103	(WebCore::ScrollingStateScrollingNode::dumpProperties const): Ditto.
104	* page/scrolling/ScrollingStateScrollingNode.h:
105	(WebCore::ScrollingStateScrollingNode::requestedScrollPositionWithAnimation const): Ditto.
106	* page/scrolling/ScrollingTree.h:
107	(WebCore::ScrollingTree::scrollingTreeNodeRequestsScroll): Add withAnimation.
108	(WebCore::ScrollingTree::scrollingTreeNodeIsScrollAnimationInProgressDidChange): Update the scroll animation status.
109	* page/scrolling/ScrollingTreeScrollingNode.cpp:
110	(WebCore::ScrollingTreeScrollingNode::commitStateAfterChildren): Add a flag to indicate the scroll is animated or not.
111	(WebCore::ScrollingTreeScrollingNode::scrollTo): If needSyncScrollPosition is true, send the scroll position to the Web process, even if the scroll position doesn't change.
112	Maintain the status of m_stopScrollAnimation and m_requestScrollWithAnimation.
113	(WebCore::ScrollingTreeScrollingNode::currentScrollPositionChanged): Animated scroll won't change the scroll position immediately, so don't notify the scrolling info now.
114	(WebCore::ScrollingTreeScrollingNode::setRequestScrollWithAnimation): m_requestScrollWithAnimation indicates that this is an animated scroll request.
115	(WebCore::ScrollingTreeScrollingNode::requestScrollWithAnimation const): Ditto.
116	(WebCore::ScrollingTreeScrollingNode::setScrollAnimationInProgress): Maintain the scroll animation status.
117	(WebCore::ScrollingTreeScrollingNode::scrollAnimationInProgress const): Ditto.
118	(WebCore::ScrollingTreeScrollingNode::setNeedsStopCurrentScrollAnimation): If the Node is performing a scroll animation, the previous scroll animation should stop first.
119	(WebCore::ScrollingTreeScrollingNode::needsStopCurrentScrollAnimation const): Ditto.
120	* page/scrolling/ScrollingTreeScrollingNode.h:
121	* platform/ScrollAnimation.h:
122	(WebCore::ScrollAnimation::scroll): Function to animate scrolling to a specified position.
123	(WebCore::ScrollAnimation::isScrollInProgress const):
124	* platform/ScrollAnimationKinetic.cpp:
125	(WebCore::ScrollAnimationKinetic::isScrollInProgress const):
126	* platform/ScrollAnimationKinetic.h:
127	* platform/ScrollAnimationSmooth.cpp: Build this file on all platforms. Add a
128	smoothFactorForProgrammaticScroll parameter to slow down the smooth scrolling.
129	(WebCore::ScrollAnimationSmooth::scroll):
130	(WebCore::ScrollAnimationSmooth::updatePerAxisData): Scale the time parameters of the
131	animation so that it looks smoother.
132	* platform/ScrollAnimationSmooth.h: Declare the class on all platforms.
133	* platform/ScrollAnimator.cpp:
134	(WebCore::ScrollAnimator::ScrollAnimator): Initialize animation member for programmatic scrolling.
135	(WebCore::ScrollAnimator::isScrollInProgress const): For now, only claims scroll is in
136	progress if smooth programmatic scroll is in progress.
137	(WebCore::ScrollAnimator::scrollToOffset): Animate scrolling to the specified position.
138	(WebCore::ScrollAnimator::cancelAnimations): Copy logic from ScrollAnimationSmooth.cpp.
139	(WebCore::ScrollAnimator::serviceScrollAnimations): Ditto.
140	(WebCore::ScrollAnimator::willEndLiveResize): Ditto.
141	(WebCore::ScrollAnimator::didAddVerticalScrollbar): Ditto.
142	(WebCore::ScrollAnimator::didAddHorizontalScrollbar): Ditto.
143	* platform/ScrollAnimator.h: New animation member for smooth programmatic scrolling.
144	* platform/ScrollTypes.h: Add ScrollBehaviorType to indicate it's instant or smooth scroll.
145	Add ScrollBehaviorStatus to indicate the status of scrolling.
146	* platform/ScrollView.cpp:
147	(WebCore::ScrollView::setScrollPosition): Follow the CSSOM View spec: If a scroll is in
148	progress, we interrupt it and continue the scroll call (even when we are at the final
149	position).
150	* platform/ScrollableArea.cpp:
151	(WebCore::ScrollableArea::ScrollableArea): Add m_currentScrollBehaviorType.
152	(WebCore::ScrollableArea::isScrollInProgress): Helper function to check whether scroll
153	animation is in progress on the animator. Using the m_currentScrollBehaviorStatus,
154	if it's WebAnimationTimerStarted and m_scrollAnimator does not exist we don't construct it.
155	(WebCore::ScrollableArea::isWebScrollAnimationInProgress): Check if the m_scrollAnimator of
156	the Web process is performing a scroll animation.
157	(WebCore::ScrollableArea::scrollToOffsetWithAnimation):
158	(WebCore::ScrollableArea::setScrollOffsetFromInternals):
159	(WebCore::ScrollableArea::setScrollOffsetFromAnimation): To avoid iterate calling,
160	move the requestScrollPositionUpdate(position) checking out of setScrollOffsetFromAnimation().
161	* platform/ScrollableArea.h:
162	(WebCore::ScrollableArea::currentScrollBehaviorStatus const): Maintain currentScrollBehaviorStatus.
163	(WebCore::ScrollableArea::setScrollBehaviorStatus):
164	(WebCore::ScrollableArea::currentScrollBehaviorType const): Maintain currentScrollBehaviorType.
165	(WebCore::ScrollableArea::setCurrentScrollBehaviorType):
166	* platform/generic/ScrollAnimatorGeneric.cpp:
167	(WebCore::ScrollAnimatorGeneric::updatePosition):
168	* platform/mac/ScrollAnimatorMac.mm:
169	(WebCore::ScrollAnimatorMac::cancelAnimations): Call parent member to handle programmatic scrolling.
170	* rendering/RenderBox.cpp:
171	(WebCore::RenderBox::setScrollLeft): Add flag to indicate animated or not.
172	(WebCore::RenderBox::setScrollTop): Ditto.
173	(WebCore::RenderBox::setScrollPosition):
174	* rendering/RenderBox.h:
175	* rendering/RenderLayer.cpp:
176	(WebCore::RenderLayer::scrollToXPosition): Ditto.
177	(WebCore::RenderLayer::scrollToYPosition): Ditto.
178	(WebCore::RenderLayer::scrollToPosition):
179	(WebCore::RenderLayer::scrollToOffset): Follow the CSSOM View spec: If a scroll is in
180	progress, we interrupt it and continue the scroll call (even when we are at the final
181	position). It's ScrollBehaviorType::Instant scroll.
182	(WebCore::RenderLayer::requestScrollPositionUpdate):
183	(WebCore::RenderLayer::scrollToOffsetWithAnimation): Ditto. This is similar to scrollToOffset
184	but animates the scroll. It's ScrollBehaviorType::Smooth scroll.
185	(WebCore::RenderLayer::scrollTo):
186	(WebCore::RenderLayer::scrollRectToVisible): Again don't do an early return if scroll is in
187	progress. We call scrollToOffsetWithAnimation instead of scrollToOffset when appropriate.
188	Note that this function may not work well for several nested scroll boxes with at least one
189	element with smooth behavior. It will handled in bug Follow.
190	* rendering/RenderLayer.h: Add scroll behavior to ScrollTectToVisibleOptions.
191	* rendering/RenderListBox.cpp:
192	(WebCore::RenderListBox::setScrollLeft): Add animated flag.
193	(WebCore::RenderListBox::setScrollTop): Ditto.
194	* rendering/RenderListBox.h:
195	* rendering/RenderTextControlSingleLine.cpp:
196	(WebCore::RenderTextControlSingleLine::setScrollLeft):
197	(WebCore::RenderTextControlSingleLine::setScrollTop):
198	* rendering/RenderTextControlSingleLine.h:
199	* rendering/style/RenderStyle.h: Handle 'smooth scrolling' boolean data.
200	(WebCore::RenderStyle::useSmoothScrolling const):
201	(WebCore::RenderStyle::setUseSmoothScrolling):
202	(WebCore::RenderStyle::initialUseSmoothScrolling):
203	* rendering/style/StyleRareNonInheritedData.cpp: Ditto.
204	(WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
205	(WebCore::StyleRareNonInheritedData::operator== const):
206	* rendering/style/StyleRareNonInheritedData.h: Ditto.
207	* style/StyleBuilderConverter.h:
208	(WebCore::Style::BuilderConverter::convertSmoothScrolling):
209	* testing/Internals.cpp:
210	(WebCore::Internals::unconstrainedScrollTo):
211
1	2019-11-26 Manuel Rego Casasnovas <rego@igalia.com>	212	2019-11-26 Manuel Rego Casasnovas <rego@igalia.com>
2		213
3	[css-grid] Avoid serializing [] in grid-template-* specified values	214	[css-grid] Avoid serializing [] in grid-template-* specified values

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +57 lines
		1	2019-11-28 Cathie Chen <cathiechen@igalia.com>
		2
		3	Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
		4	https://bugs.webkit.org/show_bug.cgi?id=188043
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Based on the patch by FrÃ©dÃ©ric Wang.
		9
		10	Add CSSOM smooth scrolling as an experimental feature. On ios platform, use native animated scrolling
		11	interfaces to performance smooth scroll and send the scroll position to the Web process.
		12
		13	* Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp: Deal with requestedScrollPositionWithAnimation encode and decode.
		14	(ArgumentCoder<ScrollingStateScrollingNode>::encode):
		15	(ArgumentCoder<ScrollingStateScrollingNode>::decode):
		16	(WebKit::dump):
		17	* Shared/WebPreferences.yaml:
		18	* UIProcess/API/Cocoa/WKWebView.mm:
		19	(pointsEqualInRoundToDevicePixel): Help function to check if two float points are not equal but in the same device pixel.
		20	(-[WKWebView _scrollToContentScrollPosition:scrollOrigin:animated:]): Add animated flag to start a animated scroll if needed.
		21	(-[WKWebView scrollViewDidEndScrollingAnimation:]): Send sroll end message to the Web process.
		22	* UIProcess/API/Cocoa/WKWebViewInternal.h:
		23	* UIProcess/PageClient.h:
		24	(WebKit::PageClient::requestScrollWithAnimation): Provide interface for animated scrolling.
		25	* UIProcess/RemoteLayerTree/RemoteLayerTreeDrawingAreaProxy.mm:
		26	(WebKit::RemoteLayerTreeDrawingAreaProxy::commitLayerTree): Add animated flag.
		27	* UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp:
		28	(WebKit::RemoteScrollingCoordinatorProxy::scrollingTreeNodeDidScroll): Sync the scroll position to the Web process.
		29	(WebKit::RemoteScrollingCoordinatorProxy::scrollingTreeNodeRequestsScroll): Add animated scrolling info to m_requestedScrollInfo.
		30	(WebKit::RemoteScrollingCoordinatorProxy::scrollingTreeNodeIsScrollAnimationInProgressDidChange): Sync scrollAnimationInProgress to the Web process.
		31	(WebKit::RemoteScrollingCoordinatorProxy::scrollingTreeRootNodeIsScrollAnimationInProgressDidChange): Ditto. It's specific to the root node.
		32	* UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.h:
		33	* UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp:
		34	(WebKit::RemoteScrollingTree::scrollingTreeNodeDidScroll): Add animated info.
		35	(WebKit::RemoteScrollingTree::scrollingTreeNodeRequestsScroll): Ditto.
		36	(WebKit::RemoteScrollingTree::scrollingTreeNodeIsScrollAnimationInProgressDidChange): Ditto.
		37	* UIProcess/RemoteLayerTree/RemoteScrollingTree.h:
		38	* UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.h:
		39	* UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm:
		40	(-[WKScrollingNodeScrollViewDelegate scrollViewDidEndScrollingAnimation:]): Send scoll end info to the Web process.
		41	(WebKit::ScrollingTreeScrollingNodeDelegateIOS::commitStateAfterChildren): If the scroll position of the Web process isn't equal to the UI process,
		42	the scroll position should be synchronized, even there's no scrolling performed in the UI process.
		43	(WebKit::ScrollingTreeScrollingNodeDelegateIOS::repositionScrollingLayers): Calling the native animated scrolling interface for smooth scroll.
		44	If there's a scroll animation performing, it should be stopped first, then start a new scrolling.
		45	(WebKit::ScrollingTreeScrollingNodeDelegateIOS::scrollViewDidEndScrollingAnimation): Sync scroll end info to the Web process.
		46	* UIProcess/WebPageProxy.cpp:
		47	(WebKit::WebPageProxy::requestScroll): To call different functions for smooth and instant scroll.
		48	* UIProcess/WebPageProxy.h:
		49	* UIProcess/ios/PageClientImplIOS.h:
		50	* UIProcess/ios/PageClientImplIOS.mm:
		51	(WebKit::PageClientImpl::requestScroll):
		52	(WebKit::PageClientImpl::requestScrollWithAnimation):
		53	* WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.h:
		54	* WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.messages.in:
		55	* WebProcess/WebPage/RemoteLayerTree/RemoteScrollingCoordinator.mm:
		56	(WebKit::RemoteScrollingCoordinator::scrollAnimationInProgressChangedForNode):
		57
1	2019-11-26 Carlos Garcia Campos <cgarcia@igalia.com>	58	2019-11-26 Carlos Garcia Campos <cgarcia@igalia.com>
2		59
3	Unreviewed. Update OptionsGTK.cmake and NEWS for 2.27.3 release	60	Unreviewed. Update OptionsGTK.cmake and NEWS for 2.27.3 release

Lines 1-3 a/Source/WebKitLegacy/mac/ChangeLog_sec1
- a/Source/WebKitLegacy/mac/ChangeLog +18 lines
		1	2019-11-28 Cathie Chen <cathiechen@igalia.com>
		2
		3	Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
		4	https://bugs.webkit.org/show_bug.cgi?id=188043
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Based on the patch by FrÃ©dÃ©ric Wang.
		9
		10	* WebView/WebPreferenceKeysPrivate.h: Handle CSSOMViewSmoothScrolling by.
		11	* WebView/WebPreferences.mm:
		12	([WebPreferences initialize]): Disable CSSOMViewSmoothScrolling by default.
		13	(-[WebPreferences CSSOMViewSmoothScrollingEnabled]): Getter.
		14	(-[WebPreferences setCSSOMViewSmoothScrollingEnabled:]): Setter.
		15	* WebView/WebPreferencesPrivate.h:
		16	* WebView/WebView.mm:
		17	(-[WebView _preferencesChanged:]):
		18
1	2019-11-21 Daniel Bates <dabates@apple.com>	19	2019-11-21 Daniel Bates <dabates@apple.com>
2		20
3	Remove unneeded code that annotated DOMHTMLElement as conforming to UITextInputTraits protocol	21	Remove unneeded code that annotated DOMHTMLElement as conforming to UITextInputTraits protocol

Lines 1-3 a/Source/WebKitLegacy/win/ChangeLog_sec1
- a/Source/WebKitLegacy/win/ChangeLog +19 lines
		1	2019-11-28 Cathie Chen <cathiechen@igalia.com>
		2
		3	Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
		4	https://bugs.webkit.org/show_bug.cgi?id=188043
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Based on the patch by FrÃ©dÃ©ric Wang.
		9
		10	* Interfaces/IWebPreferencesPrivate.idl: Handle smooth scrolling option.
		11	* WebPreferenceKeysPrivate.h: Ditto.
		12	* WebPreferences.cpp: Ditto.
		13	(WebPreferences::initializeDefaultSettings):
		14	(WebPreferences::CSSOMViewSmoothScrollingEnabled):
		15	(WebPreferences::setCSSOMViewSmoothScrollingEnabled):
		16	* WebPreferences.h: Ditto.
		17	* WebView.cpp: Ditto.
		18	(WebView::notifyPreferencesChanged):
		19
1	2019-10-31 Ryosuke Niwa <rniwa@webkit.org>	20	2019-10-31 Ryosuke Niwa <rniwa@webkit.org>
2		21
3	Windows build fix attempt after r251798.	22	Windows build fix attempt after r251798.

Lines 958-965 set(WebCore_NON_SVG_IDL_FILES a/Source/WebCore/CMakeLists.txt_sec1
- a/Source/WebCore/CMakeLists.txt +2 lines
958	page/ResizeObserverCallback.idl	958	page/ResizeObserverCallback.idl
959	page/ResizeObserverEntry.idl	959	page/ResizeObserverEntry.idl
960	page/Screen.idl	960	page/Screen.idl
		961	page/ScrollBehavior.idl
961	page/ScrollIntoViewOptions.idl	962	page/ScrollIntoViewOptions.idl
962	page/ScrollLogicalPosition.idl	963	page/ScrollLogicalPosition.idl
		964	page/ScrollOptions.idl
963	page/ScrollToOptions.idl	965	page/ScrollToOptions.idl
964	page/ShareData.idl	966	page/ShareData.idl
965	page/UndoItem.idl	967	page/UndoItem.idl

Lines 912-919 JS_BINDING_IDLS = \ a/Source/WebCore/DerivedSources.make_sec1
- a/Source/WebCore/DerivedSources.make +2 lines
912	$(WebCore)/page/ResizeObserverCallback.idl \	912	$(WebCore)/page/ResizeObserverCallback.idl \
913	$(WebCore)/page/ResizeObserverEntry.idl \	913	$(WebCore)/page/ResizeObserverEntry.idl \
914	$(WebCore)/page/Screen.idl \	914	$(WebCore)/page/Screen.idl \
		915	$(WebCore)/page/ScrollBehavior.idl \
915	$(WebCore)/page/ScrollIntoViewOptions.idl \	916	$(WebCore)/page/ScrollIntoViewOptions.idl \
916	$(WebCore)/page/ScrollLogicalPosition.idl \	917	$(WebCore)/page/ScrollLogicalPosition.idl \
		918	$(WebCore)/page/ScrollOptions.idl \
917	$(WebCore)/page/ScrollToOptions.idl \	919	$(WebCore)/page/ScrollToOptions.idl \
918	$(WebCore)/page/ShareData.idl \	920	$(WebCore)/page/ShareData.idl \
919	$(WebCore)/page/UndoItem.idl \	921	$(WebCore)/page/UndoItem.idl \

Lines 818-825 set(WebCore_PRIVATE_FRAMEWORK_HEADERS a/Source/WebCore/Headers.cmake_sec1
- a/Source/WebCore/Headers.cmake +2 lines
818	page/RemoteFrame.h	818	page/RemoteFrame.h
819	page/RenderingUpdateScheduler.h	819	page/RenderingUpdateScheduler.h
820	page/RuntimeEnabledFeatures.h	820	page/RuntimeEnabledFeatures.h
		821	page/ScrollBehavior.h
821	page/ScrollIntoViewOptions.h	822	page/ScrollIntoViewOptions.h
822	page/ScrollLogicalPosition.h	823	page/ScrollLogicalPosition.h
		824	page/ScrollOptions.h
823	page/ScrollToOptions.h	825	page/ScrollToOptions.h
824	page/SecurityOrigin.h	826	page/SecurityOrigin.h
825	page/SecurityOriginData.h	827	page/SecurityOriginData.h

Lines 75-80 CSSParserContext::CSSParserContext(const Document& document, const URL& sheetBas a/Source/WebCore/css/parser/CSSParserContext.cpp_sec1
- a/Source/WebCore/css/parser/CSSParserContext.cpp +2 lines
75	attachmentEnabled = RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled();	75	attachmentEnabled = RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled();
76	#endif	76	#endif
77	deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();	77	deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();
		78	scrollBehaviorEnabled = document.settings().CSSOMViewSmoothScrollingEnabled();
78	useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;	79	useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;
79	}	80	}
80		81
Lines 99-104 bool operator==(const CSSParserContext& a, const CSSParserContext& b) a/Source/WebCore/css/parser/CSSParserContext.cpp_sec2
99	&& a.attachmentEnabled == b.attachmentEnabled	100	&& a.attachmentEnabled == b.attachmentEnabled
100	#endif	101	#endif
101	&& a.deferredCSSParserEnabled == b.deferredCSSParserEnabled	102	&& a.deferredCSSParserEnabled == b.deferredCSSParserEnabled
		103	&& a.scrollBehaviorEnabled == b.scrollBehaviorEnabled
102	&& a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin	104	&& a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin
103	&& a.useSystemAppearance == b.useSystemAppearance;	105	&& a.useSystemAppearance == b.useSystemAppearance;
104	}	106	}

Lines 65-70 public: a/Source/WebCore/css/parser/CSSParserContext.h_sec1
- a/Source/WebCore/css/parser/CSSParserContext.h -1 / +3 lines
65	bool attachmentEnabled { false };	65	bool attachmentEnabled { false };
66	#endif	66	#endif
67	bool deferredCSSParserEnabled { false };	67	bool deferredCSSParserEnabled { false };
		68	bool scrollBehaviorEnabled { false };
68		69
69	// This is only needed to support getMatchedCSSRules.	70	// This is only needed to support getMatchedCSSRules.
70	bool hasDocumentSecurityOrigin { false };	71	bool hasDocumentSecurityOrigin { false };
Lines 116-122 struct CSSParserContextHash { a/Source/WebCore/css/parser/CSSParserContext.h_sec2
116	#if ENABLE(ATTACHMENT_ELEMENT)	117	#if ENABLE(ATTACHMENT_ELEMENT)
117	& key.attachmentEnabled << 11	118	& key.attachmentEnabled << 11
118	#endif	119	#endif
119	& key.mode << 12; // Keep this last.	120	& key.scrollBehaviorEnabled << 12
		121	& key.mode << 13; // Keep this last.
120	hash ^= WTF::intHash(bits);	122	hash ^= WTF::intHash(bits);
121	return hash;	123	return hash;
122	}	124	}

Lines 636-645 bool CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyID propertyId a/Source/WebCore/css/parser/CSSParserFastPaths.cpp_sec1
- a/Source/WebCore/css/parser/CSSParserFastPaths.cpp -5 lines
636	\|\| valueID == CSSValueSticky \|\| valueID == CSSValueWebkitSticky;	636	\|\| valueID == CSSValueSticky \|\| valueID == CSSValueWebkitSticky;
637	case CSSPropertyResize: // none \| both \| horizontal \| vertical \| auto	637	case CSSPropertyResize: // none \| both \| horizontal \| vertical \| auto
638	return valueID == CSSValueNone \|\| valueID == CSSValueBoth \|\| valueID == CSSValueHorizontal \|\| valueID == CSSValueVertical \|\| valueID == CSSValueAuto;	638	return valueID == CSSValueNone \|\| valueID == CSSValueBoth \|\| valueID == CSSValueHorizontal \|\| valueID == CSSValueVertical \|\| valueID == CSSValueAuto;
639	// FIXME-NEWPARSER: Investigate this property.
640	// case CSSPropertyScrollBehavior: // auto \| smooth
641	// ASSERT(RuntimeEnabledFeatures::cssomSmoothScrollEnabled());
642	// return valueID == CSSValueAuto \|\| valueID == CSSValueSmooth;
643	case CSSPropertyShapeRendering:	639	case CSSPropertyShapeRendering:
644	return valueID == CSSValueAuto \|\| valueID == CSSValueOptimizeSpeed \|\| valueID == CSSValueCrispedges \|\| valueID == CSSValueGeometricPrecision;	640	return valueID == CSSValueAuto \|\| valueID == CSSValueOptimizeSpeed \|\| valueID == CSSValueCrispedges \|\| valueID == CSSValueGeometricPrecision;
645	case CSSPropertyStrokeLinejoin:	641	case CSSPropertyStrokeLinejoin:
Lines 939-945 bool CSSParserFastPaths::isKeywordPropertyID(CSSPropertyID propertyId) a/Source/WebCore/css/parser/CSSParserFastPaths.cpp_sec2
939	// case CSSPropertyFontKerning:	935	// case CSSPropertyFontKerning:
940	// case CSSPropertyHyphens:	936	// case CSSPropertyHyphens:
941	// case CSSPropertyOverflowAnchor:	937	// case CSSPropertyOverflowAnchor:
942	// case CSSPropertyScrollBehavior:
943	// case CSSPropertyScrollSnapType:	938	// case CSSPropertyScrollSnapType:
944	// case CSSPropertyTextAlignLast:	939	// case CSSPropertyTextAlignLast:
945	// case CSSPropertyTextCombineUpright:	940	// case CSSPropertyTextCombineUpright:

Lines 2389-2394 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj +26 lines
2389	83407FC11E8D9C1700E048D3 /* VisibilityChangeClient.h in Headers / = {isa = PBXBuildFile; fileRef = 83407FC01E8D9C1200E048D3 / VisibilityChangeClient.h */; settings = {ATTRIBUTES = (Private, ); }; };	2389	83407FC11E8D9C1700E048D3 /* VisibilityChangeClient.h in Headers / = {isa = PBXBuildFile; fileRef = 83407FC01E8D9C1200E048D3 / VisibilityChangeClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
2390	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8D4 / JSScrollLogicalPosition.h */; };	2390	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8D4 / JSScrollLogicalPosition.h */; };
2391	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8E5 / JSScrollIntoViewOptions.h */; };	2391	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8E5 / JSScrollIntoViewOptions.h */; };
		2392	834476EF1DA5BC5E002B6EB0 /* JSScrollBehavior.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8D4 / JSScrollBehavior.h */; };
		2393	834476EF1DA5BC5E002B6EC1 /* JSScrollOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8E5 / JSScrollOptions.h */; };
2392	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8F6 / JSScrollToOptions.h */; };	2394	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8F6 / JSScrollToOptions.h */; };
2393	8348BFAC1B85729800912F36 /* ClassCollection.h in Headers / = {isa = PBXBuildFile; fileRef = 8348BFAA1B85729500912F36 / ClassCollection.h */; };	2395	8348BFAC1B85729800912F36 /* ClassCollection.h in Headers / = {isa = PBXBuildFile; fileRef = 8348BFAA1B85729500912F36 / ClassCollection.h */; };
2394	834DFAD01F7DAE5D00C2725B /* SharedStringHash.h in Headers / = {isa = PBXBuildFile; fileRef = 834DFACC1F7DAE5600C2725B / SharedStringHash.h */; settings = {ATTRIBUTES = (Private, ); }; };	2396	834DFAD01F7DAE5D00C2725B /* SharedStringHash.h in Headers / = {isa = PBXBuildFile; fileRef = 834DFACC1F7DAE5600C2725B / SharedStringHash.h */; settings = {ATTRIBUTES = (Private, ); }; };
Lines 2443-2448 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
2443	83C45B8E1DC2B68A008871BA /* ValidationBubble.h in Headers / = {isa = PBXBuildFile; fileRef = 83C45B8D1DC2B67C008871BA / ValidationBubble.h */; settings = {ATTRIBUTES = (Private, ); }; };	2445	83C45B8E1DC2B68A008871BA /* ValidationBubble.h in Headers / = {isa = PBXBuildFile; fileRef = 83C45B8D1DC2B67C008871BA / ValidationBubble.h */; settings = {ATTRIBUTES = (Private, ); }; };
2444	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355424 / ScrollLogicalPosition.h */; settings = {ATTRIBUTES = (Private, ); }; };	2446	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355424 / ScrollLogicalPosition.h */; settings = {ATTRIBUTES = (Private, ); }; };
2445	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355435 / ScrollIntoViewOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };	2447	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355435 / ScrollIntoViewOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
		2448	83C5795D1DA5C301006FAC86 /* ScrollBehavior.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356424 / ScrollBehavior.h */; settings = {ATTRIBUTES = (Private, ); }; };
		2449	83C5795D1DA5C301006FAC97 /* ScrollOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356435 / ScrollOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
2446	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356446 / ScrollToOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };	2450	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356446 / ScrollToOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
2447	83D35AEC1C7187FA00F70D5A /* XMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AEA1C7187ED00F70D5A / XMLHttpRequestEventTarget.h */; };	2451	83D35AEC1C7187FA00F70D5A /* XMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AEA1C7187ED00F70D5A / XMLHttpRequestEventTarget.h */; };
2448	83D35AF21C718D9000F70D5A /* JSXMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AF01C718D8400F70D5A / JSXMLHttpRequestEventTarget.h */; };	2452	83D35AF21C718D9000F70D5A /* JSXMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AF01C718D8400F70D5A / JSXMLHttpRequestEventTarget.h */; };
Lines 10132-10140 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
10132	834DFACE1F7DAE5700C2725B /* SharedStringHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedStringHash.cpp; sourceTree = "<group>"; };	10136	834DFACE1F7DAE5700C2725B /* SharedStringHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedStringHash.cpp; sourceTree = "<group>"; };
10133	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollLogicalPosition.h; sourceTree = "<group>"; };	10137	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollLogicalPosition.h; sourceTree = "<group>"; };
10134	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollIntoViewOptions.h; sourceTree = "<group>"; };	10138	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollIntoViewOptions.h; sourceTree = "<group>"; };
		10139	8350C3E71DA59B6200356424 /* ScrollBehavior.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollBehavior.h; sourceTree = "<group>"; };
		10140	8350C3E71DA59B6200356434 /* ScrollBehavior.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollBehavior.cpp; sourceTree = "<group>"; };
		10141	8350C3E71DA59B6200356435 /* ScrollOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollOptions.h; sourceTree = "<group>"; };
10135	8350C3E71DA59B6200356446 /* ScrollToOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollToOptions.h; sourceTree = "<group>"; };	10142	8350C3E71DA59B6200356446 /* ScrollToOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollToOptions.h; sourceTree = "<group>"; };
10136	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollLogicalPosition.idl; sourceTree = "<group>"; };	10143	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollLogicalPosition.idl; sourceTree = "<group>"; };
10137	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollIntoViewOptions.idl; sourceTree = "<group>"; };	10144	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollIntoViewOptions.idl; sourceTree = "<group>"; };
		10145	8350C3E81DA59B6200356424 /* ScrollBehavior.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollBehavior.idl; sourceTree = "<group>"; };
		10146	8350C3E81DA59B6200356435 /* ScrollOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollOptions.idl; sourceTree = "<group>"; };
10138	8350C3E81DA59B6200356446 /* ScrollToOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollToOptions.idl; sourceTree = "<group>"; };	10147	8350C3E81DA59B6200356446 /* ScrollToOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollToOptions.idl; sourceTree = "<group>"; };
10139	83520C7D1A71BFCC006BD2AA /* CSSFontFamily.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontFamily.h; sourceTree = "<group>"; };	10148	83520C7D1A71BFCC006BD2AA /* CSSFontFamily.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontFamily.h; sourceTree = "<group>"; };
10140	835657C61ECAB0E800CDE72D /* JSDOMMatrixInit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMMatrixInit.cpp; sourceTree = "<group>"; };	10149	835657C61ECAB0E800CDE72D /* JSDOMMatrixInit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMMatrixInit.cpp; sourceTree = "<group>"; };
Lines 10256-10264 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
10256	83E959E11B8BC22B004D9385 /* NativeNodeFilter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeNodeFilter.h; sourceTree = "<group>"; };	10265	83E959E11B8BC22B004D9385 /* NativeNodeFilter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeNodeFilter.h; sourceTree = "<group>"; };
10257	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollLogicalPosition.cpp; sourceTree = "<group>"; };	10266	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollLogicalPosition.cpp; sourceTree = "<group>"; };
10258	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollIntoViewOptions.cpp; sourceTree = "<group>"; };	10267	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollIntoViewOptions.cpp; sourceTree = "<group>"; };
		10268	83E9B3001DA5A51E00FFE8D4 /* JSScrollBehavior.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollBehavior.cpp; sourceTree = "<group>"; };
		10269	83E9B3001DA5A51E00FFE8E5 /* JSScrollOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollOptions.cpp; sourceTree = "<group>"; };
10259	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollToOptions.cpp; sourceTree = "<group>"; };	10270	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollToOptions.cpp; sourceTree = "<group>"; };

Lines 56-61 ScrollingStateScrollingNode::ScrollingStateScrollingNode(const ScrollingStateScr a/Source/WebCore/page/scrolling/ScrollingStateScrollingNode.cpp_sec1
- a/Source/WebCore/page/scrolling/ScrollingStateScrollingNode.cpp -1 / +6 lines
56	#endif	56	#endif
57	, m_scrollableAreaParameters(stateNode.scrollableAreaParameters())	57	, m_scrollableAreaParameters(stateNode.scrollableAreaParameters())
58	, m_requestedScrollPositionRepresentsProgrammaticScroll(stateNode.requestedScrollPositionRepresentsProgrammaticScroll())	58	, m_requestedScrollPositionRepresentsProgrammaticScroll(stateNode.requestedScrollPositionRepresentsProgrammaticScroll())
		59	, m_requestedScrollPositionWithAnimation(stateNode.requestedScrollPositionWithAnimation())
59	, m_isMonitoringWheelEvents(stateNode.isMonitoringWheelEvents())	60	, m_isMonitoringWheelEvents(stateNode.isMonitoringWheelEvents())
60	{	61	{
61	if (hasChangedProperty(ScrollContainerLayer))	62	if (hasChangedProperty(ScrollContainerLayer))
Lines 219-228 void ScrollingStateScrollingNode::setScrollableAreaParameters(const ScrollableAr a/Source/WebCore/page/scrolling/ScrollingStateScrollingNode.cpp_sec2
219	setPropertyChanged(ScrollableAreaParams);	220	setPropertyChanged(ScrollableAreaParams);
220	}	221	}
221		222
222	void ScrollingStateScrollingNode::setRequestedScrollPosition(const FloatPoint& requestedScrollPosition, bool representsProgrammaticScroll)	223	void ScrollingStateScrollingNode::setRequestedScrollPosition(const FloatPoint& requestedScrollPosition, bool representsProgrammaticScroll, bool requestedWithAnimation)
223	{	224	{
224	m_requestedScrollPosition = requestedScrollPosition;	225	m_requestedScrollPosition = requestedScrollPosition;
225	m_requestedScrollPositionRepresentsProgrammaticScroll = representsProgrammaticScroll;	226	m_requestedScrollPositionRepresentsProgrammaticScroll = representsProgrammaticScroll;
		227	m_requestedScrollPositionWithAnimation = requestedWithAnimation;
226	setPropertyChanged(RequestedScrollPosition);	228	setPropertyChanged(RequestedScrollPosition);
227	}	229	}
228		230
Lines 314-319 void ScrollingStateScrollingNode::dumpProperties(TextStream& ts, ScrollingStateT a/Source/WebCore/page/scrolling/ScrollingStateScrollingNode.cpp_sec3
314	if (m_requestedScrollPositionRepresentsProgrammaticScroll)	316	if (m_requestedScrollPositionRepresentsProgrammaticScroll)
315	ts.dumpProperty("requested scroll position represents programmatic scroll", m_requestedScrollPositionRepresentsProgrammaticScroll);	317	ts.dumpProperty("requested scroll position represents programmatic scroll", m_requestedScrollPositionRepresentsProgrammaticScroll);
316		318
		319	if (m_requestedScrollPositionWithAnimation)
		320	ts.dumpProperty("requested scroll position with animation", m_requestedScrollPositionWithAnimation);
		321
317	if (!m_parentRelativeScrollableRect.isEmpty())	322	if (!m_parentRelativeScrollableRect.isEmpty())
318	ts.dumpProperty("parent relative scrollable rect", m_parentRelativeScrollableRect);	323	ts.dumpProperty("parent relative scrollable rect", m_parentRelativeScrollableRect);
319		324

Lines 832-838 void Element::scrollIntoView(Optional<Variant<bool, ScrollIntoViewOptions>>&& ar a/Source/WebCore/dom/Element.cpp_sec1
- a/Source/WebCore/dom/Element.cpp -12 / +28 lines
832	bool insideFixed;	832	bool insideFixed;
833	LayoutRect absoluteBounds = renderer()->absoluteAnchorRect(&insideFixed);	833	LayoutRect absoluteBounds = renderer()->absoluteAnchorRect(&insideFixed);
834		834
835	// FIXME(webkit.org/b/188043): Support ScrollBehavior.
836	ScrollIntoViewOptions options;	835	ScrollIntoViewOptions options;
837	if (arg) {	836	if (arg) {
838	auto value = arg.value();	837	auto value = arg.value();
Lines 851-857 void Element::scrollIntoView(Optional<Variant<bool, ScrollIntoViewOptions>>&& ar a/Source/WebCore/dom/Element.cpp_sec2
851	SelectionRevealMode::Reveal,	850	SelectionRevealMode::Reveal,
852	isHorizontal ? alignX : alignY,	851	isHorizontal ? alignX : alignY,
853	isHorizontal ? alignY : alignX,	852	isHorizontal ? alignY : alignX,
854	ShouldAllowCrossOriginScrolling::No	853	ShouldAllowCrossOriginScrolling::No,
		854	options.behavior.valueOr(ScrollBehavior::Auto)
855	};	855	};
856	renderer()->scrollRectToVisible(absoluteBounds, insideFixed, visibleOptions);	856	renderer()->scrollRectToVisible(absoluteBounds, insideFixed, visibleOptions);
857	}	857	}
Lines 912-918 void Element::scrollBy(const ScrollToOptions& options) a/Source/WebCore/dom/Element.cpp_sec3
912		912
913	void Element::scrollBy(double x, double y)	913	void Element::scrollBy(double x, double y)
914	{	914	{
915	scrollBy({ x, y });	915	scrollBy(ScrollToOptions(x, y));
916	}	916	}
917		917
918	void Element::scrollTo(const ScrollToOptions& options, ScrollClamping clamping)	918	void Element::scrollTo(const ScrollToOptions& options, ScrollClamping clamping)
Lines 948-960 void Element::scrollTo(const ScrollToOptions& options, ScrollClamping clamping) a/Source/WebCore/dom/Element.cpp_sec4
948	adjustForAbsoluteZoom(renderer->scrollLeft(), *renderer),	948	adjustForAbsoluteZoom(renderer->scrollLeft(), *renderer),
949	adjustForAbsoluteZoom(renderer->scrollTop(), *renderer)	949	adjustForAbsoluteZoom(renderer->scrollTop(), *renderer)
950	);	950	);
951	renderer->setScrollLeft(clampToInteger(scrollToOptions.left.value() * renderer->style().effectiveZoom()), ScrollType::Programmatic, clamping);	951	IntPoint scrollPosition(
952	renderer->setScrollTop(clampToInteger(scrollToOptions.top.value() * renderer->style().effectiveZoom()), ScrollType::Programmatic, clamping);	952	clampToInteger(scrollToOptions.left.value() * renderer->style().effectiveZoom()),
		953	clampToInteger(scrollToOptions.top.value() * renderer->style().effectiveZoom())
		954	);
		955	bool animated = useSmoothScrolling(scrollToOptions.behavior.valueOr(ScrollBehavior::Auto), *this);
		956	renderer->setScrollPosition(scrollPosition, ScrollType::Programmatic, animated, clamping);
953	}	957	}
954		958
955	void Element::scrollTo(double x, double y)	959	void Element::scrollTo(double x, double y)
956	{	960	{
957	scrollTo({ x, y });	961	scrollTo(ScrollToOptions(x, y));
958	}	962	}
959		963
960	void Element::scrollByUnits(int units, ScrollGranularity granularity)	964	void Element::scrollByUnits(int units, ScrollGranularity granularity)
Lines 1288-1300 void Element::setScrollLeft(int newLeft) a/Source/WebCore/dom/Element.cpp_sec5
1288	document().updateLayoutIgnorePendingStylesheets();	1292	document().updateLayoutIgnorePendingStylesheets();
1289		1293
1290	if (document().scrollingElement() == this) {	1294	if (document().scrollingElement() == this) {
1291	if (auto* frame = documentFrameWithNonNullView())	1295	if (auto* frame = documentFrameWithNonNullView()) {
1292	frame->view()->setScrollPosition(IntPoint(static_cast<int>(newLeft * frame->pageZoomFactor() * frame->frameScaleFactor()), frame->view()->scrollY()));	1296	// FIXME: Should we use document()->scrollingElement()?
		1297	// See https://github.com/w3c/csswg-drafts/issues/2977
		1298	bool animated = document().documentElement() && useSmoothScrolling(ScrollBehavior::Auto, *document().documentElement());
		1299	frame->view()->setScrollPosition(IntPoint(static_cast<int>(newLeft * frame->pageZoomFactor() * frame->frameScaleFactor()), frame->view()->scrollY()), animated);
		1300	}
1293	return;	1301	return;
1294	}	1302	}
1295		1303
1296	if (auto* renderer = renderBox()) {	1304	if (auto* renderer = renderBox()) {
1297	renderer->setScrollLeft(static_cast<int>(newLeft * renderer->style().effectiveZoom()), ScrollType::Programmatic);	1305	int effectiveLeft = clampToInteger(newLeft * renderer->style().effectiveZoom());
		1306	bool animated = useSmoothScrolling(ScrollBehavior::Auto, *this);
		1307	renderer->setScrollLeft(effectiveLeft, ScrollType::Programmatic, animated, ScrollClamping::Clamped);
1298	if (auto* scrollableArea = renderer->layer())	1308	if (auto* scrollableArea = renderer->layer())
1299	scrollableArea->setScrollShouldClearLatchedState(true);	1309	scrollableArea->setScrollShouldClearLatchedState(true);
1300	}	1310	}
Lines 1305-1317 void Element::setScrollTop(int newTop) a/Source/WebCore/dom/Element.cpp_sec6
1305	document().updateLayoutIgnorePendingStylesheets();	1315	document().updateLayoutIgnorePendingStylesheets();
1306		1316
1307	if (document().scrollingElement() == this) {	1317	if (document().scrollingElement() == this) {
1308	if (auto* frame = documentFrameWithNonNullView())	1318	if (auto* frame = documentFrameWithNonNullView()) {
1309	frame->view()->setScrollPosition(IntPoint(frame->view()->scrollX(), static_cast<int>(newTop * frame->pageZoomFactor() * frame->frameScaleFactor())));	1319	// FIXME: Should we use document()->scrollingElement()?
		1320	// See https://github.com/w3c/csswg-drafts/issues/2977
		1321	bool animated = document().documentElement() && useSmoothScrolling(ScrollBehavior::Auto, *document().documentElement());
		1322	frame->view()->setScrollPosition(IntPoint(frame->view()->scrollX(), static_cast<int>(newTop * frame->pageZoomFactor() * frame->frameScaleFactor())), animated);
		1323	}
1310	return;	1324	return;
1311	}	1325	}
1312		1326
1313	if (auto* renderer = renderBox()) {	1327	if (auto* renderer = renderBox()) {
1314	renderer->setScrollTop(static_cast<int>(newTop * renderer->style().effectiveZoom()), ScrollType::Programmatic);	1328	int effectiveTop = clampToInteger(newTop * renderer->style().effectiveZoom());
		1329	bool animated = useSmoothScrolling(ScrollBehavior::Auto, *this);
		1330	renderer->setScrollTop(effectiveTop, ScrollType::Programmatic, animated, ScrollClamping::Clamped);
1315	if (auto* scrollableArea = renderer->layer())	1331	if (auto* scrollableArea = renderer->layer())
1316	scrollableArea->setScrollShouldClearLatchedState(true);	1332	scrollableArea->setScrollShouldClearLatchedState(true);
1317	}	1333	}

Line 0 a/Source/WebCore/page/ScrollBehavior.cpp_sec1
- a/Source/WebCore/page/ScrollBehavior.cpp +54 lines
	1	/*
	2	* Copyright (C) 2019 Igalia S.L. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	#include "config.h"
	27	#include "ScrollBehavior.h"
	28
	29	#include "Element.h"
	30	#include "RenderElement.h"
	31	#include "RenderStyle.h"
	32	#include "Settings.h"
	33
	34	namespace WebCore {
	35
	36	bool useSmoothScrolling(ScrollBehavior behavior, Element& associatedElement)
	37	{
	38	if (!associatedElement.document().settings().CSSOMViewSmoothScrollingEnabled() \|\| !associatedElement.renderer())
	39	return false;
	40
	41	// https://drafts.csswg.org/cssom-view/#scrolling
	42	switch (behavior) {
	43	case ScrollBehavior::Auto:
	44	return associatedElement.renderer()->style().useSmoothScrolling();
	45	case ScrollBehavior::Instant:
	46	return false;
	47	case ScrollBehavior::Smooth:
	48	return true;
	49	}
	50	ASSERT_NOT_REACHED();
	51	return false;
	52	}
	53
	54	} // namespace WebCore

Line 0 a/Source/WebCore/page/ScrollBehavior.h_sec1
- a/Source/WebCore/page/ScrollBehavior.h +40 lines
	1	/*
	2	* Copyright (C) 2019 Igalia S.L. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	#pragma once
	27
	28	namespace WebCore {
	29
	30	class Element;
	31
	32	enum class ScrollBehavior : uint8_t {
	33	Auto = 0,
	34	Instant,
	35	Smooth
	36	};
	37
	38	bool useSmoothScrolling(ScrollBehavior, Element& associatedElement);
	39
	40	} // namespace WebCore

Line 0 a/Source/WebCore/page/ScrollBehavior.idl_sec1
- a/Source/WebCore/page/ScrollBehavior.idl +26 lines
	1	/*
	2	* Copyright (C) 2019 Igalia S.L. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	enum ScrollBehavior { "auto", "instant", "smooth" };

Lines 20-31 a/Source/WebCore/page/ScrollIntoViewOptions.h_sec1
- a/Source/WebCore/page/ScrollIntoViewOptions.h -3 / +2 lines
20	#pragma once	20	#pragma once
21		21
22	#include "ScrollLogicalPosition.h"	22	#include "ScrollLogicalPosition.h"
		23	#include "ScrollOptions.h"
23		24
24	namespace WebCore {	25	namespace WebCore {
25		26
26	class Element;	27	struct ScrollIntoViewOptions : ScrollOptions {
27
28	struct ScrollIntoViewOptions {
29	Optional<ScrollLogicalPosition> blockPosition { ScrollLogicalPosition::Start };	28	Optional<ScrollLogicalPosition> blockPosition { ScrollLogicalPosition::Start };
30	Optional<ScrollLogicalPosition> inlinePosition { ScrollLogicalPosition::Nearest };	29	Optional<ScrollLogicalPosition> inlinePosition { ScrollLogicalPosition::Nearest };
31	};	30	};

Lines 17-24 a/Source/WebCore/page/ScrollIntoViewOptions.idl_sec1
- a/Source/WebCore/page/ScrollIntoViewOptions.idl -2 / +1 lines
17	* Boston, MA 02110-1301, USA.	17	* Boston, MA 02110-1301, USA.
18	*/	18	*/
19		19
20	// FIXME(webkit.org/b/188043): Support ScrollBehavior.	20	dictionary ScrollIntoViewOptions : ScrollOptions {
21	dictionary ScrollIntoViewOptions {
22	[ImplementedAs=blockPosition] ScrollLogicalPosition block = "start";	21	[ImplementedAs=blockPosition] ScrollLogicalPosition block = "start";
23	[ImplementedAs=inlinePosition] ScrollLogicalPosition inline = "nearest";	22	[ImplementedAs=inlinePosition] ScrollLogicalPosition inline = "nearest";
24	};	23	};

Line 0 a/Source/WebCore/page/ScrollOptions.h_sec1
- a/Source/WebCore/page/ScrollOptions.h +36 lines
	1	/*
	2	* Copyright (C) 2019 Igalia S.L. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	#pragma once
	27
	28	#include "ScrollBehavior.h"
	29
	30	namespace WebCore {
	31
	32	struct ScrollOptions {
	33	Optional<ScrollBehavior> behavior { ScrollBehavior::Auto };
	34	};
	35
	36	} // namespace WebCore

Line 0 a/Source/WebCore/page/ScrollOptions.idl_sec1
- a/Source/WebCore/page/ScrollOptions.idl +28 lines
	1	/*
	2	* Copyright (C) 2019 Igalia S.L. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	dictionary ScrollOptions {
	27	ScrollBehavior behavior = "auto";
	28	};

Lines 28-41 a/Source/WebCore/page/ScrollToOptions.h_sec1
- a/Source/WebCore/page/ScrollToOptions.h -2 / +9 lines
28		28
29	#pragma once	29	#pragma once
30		30
		31	#include "ScrollOptions.h"
31	#include <cmath>	32	#include <cmath>
32	#include <wtf/Optional.h>	33	#include <wtf/Optional.h>
33		34
34	namespace WebCore {	35	namespace WebCore {
35		36
36	struct ScrollToOptions {	37	struct ScrollToOptions : ScrollOptions {
37	Optional<double> left;	38	Optional<double> left;
38	Optional<double> top;	39	Optional<double> top;
		40
		41	ScrollToOptions() = default;
		42	ScrollToOptions(double x, double y)
		43	: left(x)
		44	, top(y)
		45	{ }
39	};	46	};
40		47
41	inline double normalizeNonFiniteValueOrFallBackTo(Optional<double> value, double fallbackValue)	48	inline double normalizeNonFiniteValueOrFallBackTo(Optional<double> value, double fallbackValue)
Lines 47-53 inline double normalizeNonFiniteValueOrFallBackTo(Optional<double> value, double a/Source/WebCore/page/ScrollToOptions.h_sec2
47	// FIXME(https://webkit.org/b/88339): Consider using FloatPoint or DoublePoint for fallback and return values.	54	// FIXME(https://webkit.org/b/88339): Consider using FloatPoint or DoublePoint for fallback and return values.
48	inline ScrollToOptions normalizeNonFiniteCoordinatesOrFallBackTo(const ScrollToOptions& value, double x, double y)	55	inline ScrollToOptions normalizeNonFiniteCoordinatesOrFallBackTo(const ScrollToOptions& value, double x, double y)
49	{	56	{
50	ScrollToOptions options;	57	ScrollToOptions options = value;
51	options.left = normalizeNonFiniteValueOrFallBackTo(value.left, x);	58	options.left = normalizeNonFiniteValueOrFallBackTo(value.left, x);
52	options.top = normalizeNonFiniteValueOrFallBackTo(value.top, y);	59	options.top = normalizeNonFiniteValueOrFallBackTo(value.top, y);
53	return options;	60	return options;

Lines 26-33 a/Source/WebCore/page/ScrollToOptions.idl_sec1
- a/Source/WebCore/page/ScrollToOptions.idl -2 / +1 lines
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	// FIXME(webkit.org/b/188043): Support ScrollBehavior.	29	dictionary ScrollToOptions : ScrollOptions {
30	dictionary ScrollToOptions {
31	unrestricted double left;	30	unrestricted double left;
32	unrestricted double top;	31	unrestricted double top;
33	};	32	};

Lines 248-254 bool AsyncScrollingCoordinator::requestScrollPositionUpdate(ScrollableArea& scro a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp_sec1
- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp -2 / +44 lines
248		248
249	bool inBackForwardCache = frameView->frame().document()->backForwardCacheState() != Document::NotInBackForwardCache;	249	bool inBackForwardCache = frameView->frame().document()->backForwardCacheState() != Document::NotInBackForwardCache;
250	bool inProgrammaticScroll = scrollableArea.currentScrollType() == ScrollType::Programmatic;	250	bool inProgrammaticScroll = scrollableArea.currentScrollType() == ScrollType::Programmatic;
251	if (inProgrammaticScroll \|\| inBackForwardCache)	251	bool animated = false;
		252
		253	#if PLATFORM(IOS_FAMILY)
		254	animated = scrollableArea.currentScrollBehaviorType() == ScrollBehaviorType::Smooth;
		255	#endif
		256
		257	// The scroll position of animated scrolling will be set from the the UI process. So it shouldn't be set now.
		258	if (!animated && (inProgrammaticScroll \|\| inBackForwardCache))
252	updateScrollPositionAfterAsyncScroll(scrollingNodeID, scrollPosition, { }, ScrollType::Programmatic, ScrollingLayerPositionAction::Set);	259	updateScrollPositionAfterAsyncScroll(scrollingNodeID, scrollPosition, { }, ScrollType::Programmatic, ScrollingLayerPositionAction::Set);
253		260
254	// If this frame view's document is being put into the back/forward cache, we don't want to update our	261	// If this frame view's document is being put into the back/forward cache, we don't want to update our
Lines 260-266 bool AsyncScrollingCoordinator::requestScrollPositionUpdate(ScrollableArea& scro a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp_sec2
260	if (!stateNode)	267	if (!stateNode)
261	return false;	268	return false;
262		269
263	stateNode->setRequestedScrollPosition(scrollPosition, inProgrammaticScroll);	270	#if PLATFORM(IOS_FAMILY)
		271	if (animated)
		272	scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::InUINativeAnimation);
		273	else
		274	scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
		275	#else
		276	// If web scroll animation is in progress, this is set by scroll animator, otherwise, the animation should stop first.
		277	if (!scrollableArea.isWebScrollAnimationInProgress())
		278	scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
		279	#endif
		280
		281	stateNode->setRequestedScrollPosition(scrollPosition, inProgrammaticScroll, animated);
264	return true;	282	return true;
265	}	283	}
266		284
Lines 291-296 void AsyncScrollingCoordinator::scheduleUpdateScrollPositionAfterAsyncScroll(Scr a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp_sec3
291	m_updateNodeScrollPositionTimer.startOneShot(0_s);	309	m_updateNodeScrollPositionTimer.startOneShot(0_s);
292	}	310	}
293		311
		312	void AsyncScrollingCoordinator::setScrollAnimationInProgress(ScrollingNodeID nodeID, bool isScrollAnimationInProgress)
		313	{
		314	ASSERT(isMainThread());
		315
		316	if (!m_page)
		317	return;
		318
		319	auto* frameView = frameViewForScrollingNode(nodeID);
		320	if (!frameView)
		321	return;
		322
		323	if (nodeID == frameView->scrollingNodeID()) {
		324	if (!isScrollAnimationInProgress)
		325	frameView->setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
		326	return;
		327	}
		328
		329	// Overflow-scroll area.
		330	if (auto* scrollableArea = frameView->scrollableAreaForScrollLayerID(nodeID)) {
		331	if (!isScrollAnimationInProgress)
		332	scrollableArea->setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
		333	}
		334	}
		335
294	void AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired()	336	void AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired()
295	{	337	{
296	updateScrollPositionAfterAsyncScroll(m_scheduledScrollUpdate.nodeID, m_scheduledScrollUpdate.scrollPosition, m_scheduledScrollUpdate.layoutViewportOrigin, ScrollType::User, m_scheduledScrollUpdate.updateLayerPositionAction);	338	updateScrollPositionAfterAsyncScroll(m_scheduledScrollUpdate.nodeID, m_scheduledScrollUpdate.scrollPosition, m_scheduledScrollUpdate.layoutViewportOrigin, ScrollType::User, m_scheduledScrollUpdate.updateLayerPositionAction);

Lines 111-117 public: a/Source/WebCore/page/scrolling/ScrollingStateScrollingNode.h_sec1
- a/Source/WebCore/page/scrolling/ScrollingStateScrollingNode.h -1 / +3 lines
111		111
112	const FloatPoint& requestedScrollPosition() const { return m_requestedScrollPosition; }	112	const FloatPoint& requestedScrollPosition() const { return m_requestedScrollPosition; }
113	bool requestedScrollPositionRepresentsProgrammaticScroll() const { return m_requestedScrollPositionRepresentsProgrammaticScroll; }	113	bool requestedScrollPositionRepresentsProgrammaticScroll() const { return m_requestedScrollPositionRepresentsProgrammaticScroll; }
114	WEBCORE_EXPORT void setRequestedScrollPosition(const FloatPoint&, bool representsProgrammaticScroll);	114	bool requestedScrollPositionWithAnimation() const { return m_requestedScrollPositionWithAnimation; }
		115	WEBCORE_EXPORT void setRequestedScrollPosition(const FloatPoint&, bool representsProgrammaticScroll, bool requestedWithAnimation = false);
115		116
116	bool isMonitoringWheelEvents() const { return m_isMonitoringWheelEvents; }	117	bool isMonitoringWheelEvents() const { return m_isMonitoringWheelEvents; }
117	WEBCORE_EXPORT void setIsMonitoringWheelEvents(bool);	118	WEBCORE_EXPORT void setIsMonitoringWheelEvents(bool);
Lines 171-176 private: a/Source/WebCore/page/scrolling/ScrollingStateScrollingNode.h_sec2
171	ScrollableAreaParameters m_scrollableAreaParameters;	172	ScrollableAreaParameters m_scrollableAreaParameters;
172		173
173	bool m_requestedScrollPositionRepresentsProgrammaticScroll { false };	174	bool m_requestedScrollPositionRepresentsProgrammaticScroll { false };
		175	bool m_requestedScrollPositionWithAnimation { false };
174	bool m_isMonitoringWheelEvents { false };	176	bool m_isMonitoringWheelEvents { false };
175	};	177	};
176		178

Lines 32-47 namespace WebCore { a/Source/WebCore/platform/ScrollAnimation.h_sec1
- a/Source/WebCore/platform/ScrollAnimation.h +3 lines
32		32
33	class FloatPoint;	33	class FloatPoint;
34	class ScrollableArea;	34	class ScrollableArea;
		35	enum class ScrollClamping : uint8_t;
35		36
36	class ScrollAnimation {	37	class ScrollAnimation {
37	WTF_MAKE_FAST_ALLOCATED;	38	WTF_MAKE_FAST_ALLOCATED;
38	public:	39	public:
39	virtual ~ScrollAnimation() { };	40	virtual ~ScrollAnimation() { };
40	virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float /* step /, float / multiplier */) { return true; };	41	virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float /* step /, float / multiplier */) { return true; };
		42	virtual void scroll(const FloatPoint&) { };
41	virtual void stop() = 0;	43	virtual void stop() = 0;
42	virtual void updateVisibleLengths() { };	44	virtual void updateVisibleLengths() { };
43	virtual void setCurrentPosition(const FloatPoint&) { };	45	virtual void setCurrentPosition(const FloatPoint&) { };
44	virtual void serviceAnimation() { };	46	virtual void serviceAnimation() { };
		47	virtual bool isScrollInProgress() const { return false; }
45		48
46	protected:	49	protected:
47	ScrollAnimation(ScrollableArea& scrollableArea)	50	ScrollAnimation(ScrollableArea& scrollableArea)

Lines 27-40 a/Source/WebCore/platform/ScrollAnimationSmooth.h_sec1
- a/Source/WebCore/platform/ScrollAnimationSmooth.h -4 / +4 lines
27		27
28	#include "ScrollAnimation.h"	28	#include "ScrollAnimation.h"
29		29
30	#if ENABLE(SMOOTH_SCROLLING)
31
32	#include "Timer.h"	30	#include "Timer.h"
33		31
34	namespace WebCore {	32	namespace WebCore {
35		33
36	class FloatPoint;	34	class FloatPoint;
37	class ScrollableArea;	35	class ScrollableArea;
		36	enum class ScrollClamping : uint8_t;
38		37
39	class ScrollAnimationSmooth final: public ScrollAnimation {	38	class ScrollAnimationSmooth final: public ScrollAnimation {
40	public:	39	public:
Lines 51-59 public: a/Source/WebCore/platform/ScrollAnimationSmooth.h_sec2
51		50
52	private:	51	private:
53	bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier) override;	52	bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier) override;
		53	void scroll(const FloatPoint&) override;
54	void stop() override;	54	void stop() override;
55	void updateVisibleLengths() override;	55	void updateVisibleLengths() override;
56	void setCurrentPosition(const FloatPoint&) override;	56	void setCurrentPosition(const FloatPoint&) override;
		57	bool isScrollInProgress() const override { return animationTimerActive(); }
57		58
58	struct PerAxisData {	59	struct PerAxisData {
59	PerAxisData() = delete;	60	PerAxisData() = delete;
Lines 89-95 private: a/Source/WebCore/platform/ScrollAnimationSmooth.h_sec3
89	int visibleLength { 0 };	90	int visibleLength { 0 };
90	};	91	};
91		92
92	bool updatePerAxisData(PerAxisData&, ScrollGranularity, float delta, float minScrollPosition, float maxScrollPosition);	93	bool updatePerAxisData(PerAxisData&, ScrollGranularity, float delta, float minScrollPosition, float maxScrollPosition, double smoothFactor = 1);
93	bool animateScroll(PerAxisData&, MonotonicTime currentTime);	94	bool animateScroll(PerAxisData&, MonotonicTime currentTime);
94		95
95	void requestAnimationTimerFired();	96	void requestAnimationTimerFired();
Lines 108-111 private: a/Source/WebCore/platform/ScrollAnimationSmooth.h_sec4
108		109
109	} // namespace WebCore	110	} // namespace WebCore
110		111
111	#endif // ENABLE(SMOOTH_SCROLLING)

Lines 35-40 a/Source/WebCore/platform/ScrollAnimator.cpp_sec1
- a/Source/WebCore/platform/ScrollAnimator.cpp +57 lines
35	#include "FloatPoint.h"	35	#include "FloatPoint.h"
36	#include "LayoutSize.h"	36	#include "LayoutSize.h"
37	#include "PlatformWheelEvent.h"	37	#include "PlatformWheelEvent.h"
		38	#include "ScrollAnimationSmooth.h"
38	#include "ScrollableArea.h"	39	#include "ScrollableArea.h"
39	#include <algorithm>	40	#include <algorithm>
40		41
Lines 52-62 ScrollAnimator::ScrollAnimator(ScrollableArea& scrollableArea) a/Source/WebCore/platform/ScrollAnimator.cpp_sec2
52	#if ENABLE(CSS_SCROLL_SNAP) \|\| ENABLE(RUBBER_BANDING)	53	#if ENABLE(CSS_SCROLL_SNAP) \|\| ENABLE(RUBBER_BANDING)
53	, m_scrollController(*this)	54	, m_scrollController(*this)
54	#endif	55	#endif
		56	, m_animationProgrammaticScroll(makeUnique<ScrollAnimationSmooth>(scrollableArea, m_currentPosition, [this](FloatPoint&& position) {
		57	auto previousScrollType = m_scrollableArea.currentScrollType();
		58	m_scrollableArea.setCurrentScrollType(ScrollType::Programmatic);
		59	bool updated = m_scrollableArea.requestScrollPositionUpdate(roundedIntPoint(position));
		60	m_scrollableArea.setCurrentScrollType(previousScrollType);
		61	if (updated)
		62	return;
		63
		64	FloatSize delta = position - m_currentPosition;
		65	m_currentPosition = WTFMove(position);
		66	notifyPositionChanged(delta);
		67	}))
55	{	68	{
56	}	69	}
57		70
58	ScrollAnimator::~ScrollAnimator() = default;	71	ScrollAnimator::~ScrollAnimator() = default;
59		72
		73	bool ScrollAnimator::isScrollInProgress() const
		74	{
		75	// FIXME (TODO): This should also take into account animations in derived classes.
		76	return m_animationProgrammaticScroll->isScrollInProgress();
		77	}
		78
60	bool ScrollAnimator::scroll(ScrollbarOrientation orientation, ScrollGranularity, float step, float multiplier)	79	bool ScrollAnimator::scroll(ScrollbarOrientation orientation, ScrollGranularity, float step, float multiplier)
61	{	80	{
62	FloatPoint currentPosition = this->currentPosition();	81	FloatPoint currentPosition = this->currentPosition();
Lines 75-80 bool ScrollAnimator::scroll(ScrollbarOrientation orientation, ScrollGranularity, a/Source/WebCore/platform/ScrollAnimator.cpp_sec3
75	return true;	94	return true;
76	}	95	}
77		96
		97	void ScrollAnimator::scrollToOffset(const FloatPoint& offset)
		98	{
		99	m_animationProgrammaticScroll->setCurrentPosition(m_currentPosition);
		100	auto newPosition = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));
		101	m_animationProgrammaticScroll->scroll(newPosition);
		102	m_scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::WebAnimationTimerStarted);
		103	}
		104
78	void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping)	105	void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping)
79	{	106	{
80	FloatPoint newPositon = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));	107	FloatPoint newPositon = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));
Lines 245-248 void ScrollAnimator::removeWheelEventTestCompletionDeferralForReason(WheelEventT a/Source/WebCore/platform/ScrollAnimator.cpp_sec4
245	}	272	}
246	#endif	273	#endif
247		274
		275	void ScrollAnimator::cancelAnimations()
		276	{
		277	#if !USE(REQUEST_ANIMATION_FRAME_TIMER)
		278	m_animationProgrammaticScroll->stop();
		279	#endif
		280	m_scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
		281	}
		282
		283	void ScrollAnimator::serviceScrollAnimations()
		284	{
		285	#if !USE(REQUEST_ANIMATION_FRAME_TIMER)
		286	m_animationProgrammaticScroll->serviceAnimation();
		287	#endif
		288	}
		289
		290	void ScrollAnimator::willEndLiveResize()
		291	{
		292	m_animationProgrammaticScroll->updateVisibleLengths();
		293	}
		294
		295	void ScrollAnimator::didAddVerticalScrollbar(Scrollbar*)
		296	{
		297	m_animationProgrammaticScroll->updateVisibleLengths();
		298	}
		299
		300	void ScrollAnimator::didAddHorizontalScrollbar(Scrollbar*)
		301	{
		302	m_animationProgrammaticScroll->updateVisibleLengths();
		303	}
		304
248	} // namespace WebCore	305	} // namespace WebCore

Lines 54-59 enum class ScrollPositionClamp : uint8_t { a/Source/WebCore/platform/ScrollTypes.h_sec1
- a/Source/WebCore/platform/ScrollTypes.h +13 lines
54	ToContentEdges,	54	ToContentEdges,
55	};	55	};
56		56
		57	enum class ScrollBehaviorType : uint8_t {
		58	Instant,
		59	Smooth,
		60	};
		61
		62	enum class ScrollBehaviorStatus : uint8_t {
		63	NotInAnimation,
		64	WebAnimationTimerStarted,
		65	#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
		66	InUINativeAnimation,
		67	#endif
		68	};
		69
57	inline ScrollDirection logicalToPhysical(ScrollLogicalDirection direction, bool isVertical, bool isFlipped)	70	inline ScrollDirection logicalToPhysical(ScrollLogicalDirection direction, bool isVertical, bool isFlipped)
58	{	71	{
59	switch (direction) {	72	switch (direction) {

Lines 71-76 ScrollableArea::ScrollableArea() a/Source/WebCore/platform/ScrollableArea.cpp_sec1
- a/Source/WebCore/platform/ScrollableArea.cpp -5 / +31 lines
71	, m_scrollOriginChanged(false)	71	, m_scrollOriginChanged(false)
72	, m_currentScrollType(static_cast<unsigned>(ScrollType::User))	72	, m_currentScrollType(static_cast<unsigned>(ScrollType::User))
73	, m_scrollShouldClearLatchedState(false)	73	, m_scrollShouldClearLatchedState(false)
		74	#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
		75	, m_currentScrollBehaviorType(static_cast<unsigned>(ScrollBehaviorType::Instant))
		76	#endif
74	{	77	{
75	}	78	}
76		79
Lines 104-109 float ScrollableArea::adjustScrollStepForFixedContent(float step, ScrollbarOrien a/Source/WebCore/platform/ScrollableArea.cpp_sec2
104	return step;	107	return step;
105	}	108	}
106		109
		110	bool ScrollableArea::isScrollInProgress()
		111	{
		112	if (m_currentScrollBehaviorStatus == ScrollBehaviorStatus::WebAnimationTimerStarted) {
		113	if (!(m_scrollAnimator && scrollAnimator().isScrollInProgress()))
		114	m_currentScrollBehaviorStatus = ScrollBehaviorStatus::NotInAnimation;
		115	}
		116	return m_currentScrollBehaviorStatus != ScrollBehaviorStatus::NotInAnimation;
		117	}
		118
		119	bool ScrollableArea::isWebScrollAnimationInProgress()
		120	{
		121	if (m_currentScrollBehaviorStatus == ScrollBehaviorStatus::WebAnimationTimerStarted) {
		122	if (!(m_scrollAnimator && scrollAnimator().isScrollInProgress()))
		123	m_currentScrollBehaviorStatus = ScrollBehaviorStatus::NotInAnimation;
		124	}
		125	return m_currentScrollBehaviorStatus == ScrollBehaviorStatus::WebAnimationTimerStarted;
		126	}
		127
107	bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)	128	bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
108	{	129	{
109	ScrollbarOrientation orientation;	130	ScrollbarOrientation orientation;
Lines 142-147 bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granula a/Source/WebCore/platform/ScrollableArea.cpp_sec3
142	return scrollAnimator().scroll(orientation, granularity, step, multiplier);	163	return scrollAnimator().scroll(orientation, granularity, step, multiplier);
143	}	164	}
144		165
		166	void ScrollableArea::scrollToOffsetWithAnimation(const FloatPoint& offset, ScrollClamping)
		167	{
		168	LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffset " << offset);
		169	scrollAnimator().scrollToOffset(offset);
		170	}
		171
145	void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping clamping)	172	void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping clamping)
146	{	173	{
147	LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffsetWithoutAnimation " << offset);	174	LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffsetWithoutAnimation " << offset);
Lines 221-236 bool ScrollableArea::handleTouchEvent(const PlatformTouchEvent& touchEvent) a/Source/WebCore/platform/ScrollableArea.cpp_sec4
221	// NOTE: Only called from Internals for testing.	248	// NOTE: Only called from Internals for testing.
222	void ScrollableArea::setScrollOffsetFromInternals(const ScrollOffset& offset)	249	void ScrollableArea::setScrollOffsetFromInternals(const ScrollOffset& offset)
223	{	250	{
		251	if (requestScrollPositionUpdate(scrollPositionFromOffset(offset)))
		252	return;
		253
224	setScrollOffsetFromAnimation(offset);	254	setScrollOffsetFromAnimation(offset);
225	}	255	}
226		256
227	void ScrollableArea::setScrollOffsetFromAnimation(const ScrollOffset& offset)	257	void ScrollableArea::setScrollOffsetFromAnimation(const ScrollOffset& offset)
228	{	258	{
229	ScrollPosition position = scrollPositionFromOffset(offset);	259	scrollPositionChanged(scrollPositionFromOffset(offset));
230	if (requestScrollPositionUpdate(position))
231	return;
232
233	scrollPositionChanged(position);
234	}	260	}
235		261
236	void ScrollableArea::willStartLiveResize()	262	void ScrollableArea::willStartLiveResize()

Lines 581-600 static void setupWheelEventMonitor(RenderLayer& layer) a/Source/WebCore/rendering/RenderBox.cpp_sec1
- a/Source/WebCore/rendering/RenderBox.cpp -4 / +12 lines
581	layer.scrollAnimator().setWheelEventTestMonitor(page.wheelEventTestMonitor());	581	layer.scrollAnimator().setWheelEventTestMonitor(page.wheelEventTestMonitor());
582	}	582	}
583		583
584	void RenderBox::setScrollLeft(int newLeft, ScrollType scrollType, ScrollClamping clamping)	584	void RenderBox::setScrollLeft(int newLeft, ScrollType scrollType, bool animated, ScrollClamping clamping)
585	{	585	{
586	if (!hasOverflowClip() \|\| !layer())	586	if (!hasOverflowClip() \|\| !layer())
587	return;	587	return;
588	setupWheelEventMonitor(*layer());	588	setupWheelEventMonitor(*layer());
589	layer()->scrollToXPosition(newLeft, scrollType, clamping);	589	layer()->scrollToXPosition(newLeft, scrollType, animated, clamping);
590	}	590	}
591		591
592	void RenderBox::setScrollTop(int newTop, ScrollType scrollType, ScrollClamping clamping)	592	void RenderBox::setScrollTop(int newTop, ScrollType scrollType, bool animated, ScrollClamping clamping)
593	{	593	{
594	if (!hasOverflowClip() \|\| !layer())	594	if (!hasOverflowClip() \|\| !layer())
595	return;	595	return;
596	setupWheelEventMonitor(*layer());	596	setupWheelEventMonitor(*layer());
597	layer()->scrollToYPosition(newTop, scrollType, clamping);	597	layer()->scrollToYPosition(newTop, scrollType, animated, clamping);
		598	}
		599
		600	void RenderBox::setScrollPosition(const ScrollPosition& position, ScrollType scrollType, bool animated, ScrollClamping clamping)
		601	{
		602	if (!hasOverflowClip() \|\| !layer())
		603	return;
		604	setupWheelEventMonitor(*layer());
		605	layer()->scrollToPosition(position, scrollType, animated, clamping);
598	}	606	}
599		607
600	void RenderBox::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const	608	void RenderBox::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const

Lines 247-254 public: a/Source/WebCore/rendering/RenderBox.h_sec1
- a/Source/WebCore/rendering/RenderBox.h -2 / +3 lines
247	virtual int scrollTop() const;	247	virtual int scrollTop() const;
248	virtual int scrollWidth() const;	248	virtual int scrollWidth() const;
249	virtual int scrollHeight() const;	249	virtual int scrollHeight() const;
250	virtual void setScrollLeft(int, ScrollType, ScrollClamping = ScrollClamping::Clamped);	250	virtual void setScrollLeft(int, ScrollType, bool animated = false, ScrollClamping = ScrollClamping::Clamped);
251	virtual void setScrollTop(int, ScrollType, ScrollClamping = ScrollClamping::Clamped);	251	virtual void setScrollTop(int, ScrollType, bool animated = false, ScrollClamping = ScrollClamping::Clamped);
		252	void setScrollPosition(const ScrollPosition&, ScrollType, bool animated = false, ScrollClamping = ScrollClamping::Clamped);
252		253
253	LayoutUnit marginTop() const override { return m_marginBox.top(); }	254	LayoutUnit marginTop() const override { return m_marginBox.top(); }
254	LayoutUnit marginBottom() const override { return m_marginBox.bottom(); }	255	LayoutUnit marginBottom() const override { return m_marginBox.bottom(); }

Lines 116-121 a/Source/WebCore/rendering/RenderLayer.cpp_sec1
- a/Source/WebCore/rendering/RenderLayer.cpp -15 / +75 lines
116	#include "ScaleTransformOperation.h"	116	#include "ScaleTransformOperation.h"
117	#include "ScriptDisallowedScope.h"	117	#include "ScriptDisallowedScope.h"
118	#include "ScrollAnimator.h"	118	#include "ScrollAnimator.h"
		119	#include "ScrollBehavior.h"
119	#include "Scrollbar.h"	120	#include "Scrollbar.h"
120	#include "ScrollbarTheme.h"	121	#include "ScrollbarTheme.h"
121	#include "ScrollingCoordinator.h"	122	#include "ScrollingCoordinator.h"
Lines 2547-2562 void RenderLayer::applyPostLayoutScrollPositionIfNeeded() a/Source/WebCore/rendering/RenderLayer.cpp_sec2
2547	m_postLayoutScrollPosition = WTF::nullopt;	2548	m_postLayoutScrollPosition = WTF::nullopt;
2548	}	2549	}
2549		2550
2550	void RenderLayer::scrollToXPosition(int x, ScrollType scrollType, ScrollClamping clamping)	2551	void RenderLayer::scrollToXPosition(int x, ScrollType scrollType, bool animated, ScrollClamping clamping)
2551	{	2552	{
2552	ScrollPosition position(x, m_scrollPosition.y());	2553	ScrollPosition position(x, m_scrollPosition.y());
2553	scrollToOffset(scrollOffsetFromPosition(position), scrollType, clamping);	2554	scrollToPosition(position, scrollType, animated, clamping);
2554	}	2555	}
2555		2556
2556	void RenderLayer::scrollToYPosition(int y, ScrollType scrollType, ScrollClamping clamping)	2557	void RenderLayer::scrollToYPosition(int y, ScrollType scrollType, bool animated, ScrollClamping clamping)
2557	{	2558	{
2558	ScrollPosition position(m_scrollPosition.x(), y);	2559	ScrollPosition position(m_scrollPosition.x(), y);
2559	scrollToOffset(scrollOffsetFromPosition(position), scrollType, clamping);	2560	scrollToPosition(position, scrollType, animated, clamping);
		2561	}
		2562
		2563	void RenderLayer::scrollToPosition(const ScrollPosition& position, ScrollType scrollType, bool animated, ScrollClamping clamping)
		2564	{
		2565	if (animated)
		2566	scrollToOffsetWithAnimation(scrollOffsetFromPosition(position), scrollType, clamping);
		2567	else
		2568	scrollToOffset(scrollOffsetFromPosition(position), scrollType, clamping);
2560	}	2569	}
2561		2570
2562	ScrollOffset RenderLayer::clampScrollOffset(const ScrollOffset& scrollOffset) const	2571	ScrollOffset RenderLayer::clampScrollOffset(const ScrollOffset& scrollOffset) const
Lines 2566-2588 ScrollOffset RenderLayer::clampScrollOffset(const ScrollOffset& scrollOffset) co a/Source/WebCore/rendering/RenderLayer.cpp_sec3
2566		2575
2567	void RenderLayer::scrollToOffset(const ScrollOffset& scrollOffset, ScrollType scrollType, ScrollClamping clamping)	2576	void RenderLayer::scrollToOffset(const ScrollOffset& scrollOffset, ScrollType scrollType, ScrollClamping clamping)
2568	{	2577	{
		2578	#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
		2579	setCurrentScrollBehaviorType(ScrollBehaviorType::Instant);
		2580	#endif
		2581	if (isWebScrollAnimationInProgress())
		2582	scrollAnimator().cancelAnimations();
		2583
2569	ScrollOffset clampedScrollOffset = clamping == ScrollClamping::Clamped ? clampScrollOffset(scrollOffset) : scrollOffset;	2584	ScrollOffset clampedScrollOffset = clamping == ScrollClamping::Clamped ? clampScrollOffset(scrollOffset) : scrollOffset;
2570	if (clampedScrollOffset == this->scrollOffset())	2585	if (clampedScrollOffset == this->scrollOffset()) {
		2586	#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
		2587	// If UIScrollView is performing a scroll animation, the scroll offset of the Web process might be overridden.
		2588	// So we need to call requestScrollPositionUpdate here and let it be checked on the UI process.
		2589	// If the scroll offset on the UI process is different, the correct scroll offset needs to sync back to the Web process.
		2590	if (currentScrollBehaviorStatus() == ScrollBehaviorStatus::InUINativeAnimation)
		2591	requestScrollPositionUpdate(scrollPositionFromOffset(clampedScrollOffset));
		2592	#endif
2571	return;	2593	return;
		2594	}
2572		2595
2573	auto previousScrollType = currentScrollType();	2596	auto previousScrollType = currentScrollType();
2574	setCurrentScrollType(scrollType);	2597	setCurrentScrollType(scrollType);
2575		2598
2576	bool handled = false;	2599	bool handled = false;
2577	#if ENABLE(ASYNC_SCROLLING)	2600	#if ENABLE(ASYNC_SCROLLING)
2578	if (ScrollingCoordinator* scrollingCoordinator = page().scrollingCoordinator())	2601	handled = requestScrollPositionUpdate(scrollPositionFromOffset(clampedScrollOffset));
2579	handled = scrollingCoordinator->requestScrollPositionUpdate(*this, scrollPositionFromOffset(clampedScrollOffset));
2580	#endif	2602	#endif
2581		2603
2582	if (!handled)	2604	if (!handled)
2583	scrollToOffsetWithoutAnimation(clampedScrollOffset, clamping);	2605	scrollToOffsetWithoutAnimation(clampedScrollOffset, clamping);
2584		2606
2585	setCurrentScrollType(previousScrollType);	2607	setCurrentScrollType(previousScrollType);
		2608	setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation);
		2609	}
		2610
		2611	bool RenderLayer::requestScrollPositionUpdate(const ScrollPosition& position)
		2612	{
		2613	#if ENABLE(ASYNC_SCROLLING)
		2614	if (ScrollingCoordinator* scrollingCoordinator = page().scrollingCoordinator())
		2615	return scrollingCoordinator->requestScrollPositionUpdate(*this, position);
		2616	#endif
		2617	return false;
		2618	}
		2619
		2620	void RenderLayer::scrollToOffsetWithAnimation(const ScrollOffset& offset, ScrollType scrollType, ScrollClamping clamping)
		2621	{
		2622	auto previousScrollType = currentScrollType();
		2623	setCurrentScrollType(scrollType);
		2624
		2625	#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)
		2626	setCurrentScrollBehaviorType(ScrollBehaviorType::Smooth);
		2627	if (requestScrollPositionUpdate(scrollPositionFromOffset(offset))) {
		2628	setCurrentScrollType(previousScrollType);
		2629	return;
		2630	}
		2631	#endif
		2632
		2633	ScrollOffset newScrollOffset = clamping == ScrollClamping::Clamped ? clampScrollOffset(offset) : offset;
		2634	if (isWebScrollAnimationInProgress())
		2635	scrollAnimator().cancelAnimations();
		2636	if (newScrollOffset != this->scrollOffset())
		2637	ScrollableArea::scrollToOffsetWithAnimation(newScrollOffset);
		2638	setCurrentScrollType(previousScrollType);
2586	}	2639	}
2587		2640
2588	void RenderLayer::scrollTo(const ScrollPosition& position)	2641	void RenderLayer::scrollTo(const ScrollPosition& position)
Lines 2617-2623 void RenderLayer::scrollTo(const ScrollPosition& position) a/Source/WebCore/rendering/RenderLayer.cpp_sec4
2617	#endif	2670	#endif
2618	}	2671	}
2619		2672
2620	if (m_scrollPosition == newPosition) {	2673	if (m_scrollPosition == newPosition && !isScrollInProgress()) {
2621	// FIXME: Nothing guarantees we get a scrollTo() with an unchanged position at the end of a user gesture.	2674	// FIXME: Nothing guarantees we get a scrollTo() with an unchanged position at the end of a user gesture.
2622	// The ScrollingCoordinator probably needs to message the main thread when a gesture ends.	2675	// The ScrollingCoordinator probably needs to message the main thread when a gesture ends.
2623	if (requiresScrollPositionReconciliation()) {	2676	if (requiresScrollPositionReconciliation()) {
Lines 2762-2771 void RenderLayer::scrollRectToVisible(const LayoutRect& absoluteRect, bool insid a/Source/WebCore/rendering/RenderLayer.cpp_sec5
2762	LayoutRect revealRect = getRectToExpose(layerBounds, localExposeRect, insideFixed, options.alignX, options.alignY);	2815	LayoutRect revealRect = getRectToExpose(layerBounds, localExposeRect, insideFixed, options.alignX, options.alignY);
2763		2816
2764	ScrollOffset clampedScrollOffset = clampScrollOffset(scrollOffset() + toIntSize(roundedIntRect(revealRect).location()));	2817	ScrollOffset clampedScrollOffset = clampScrollOffset(scrollOffset() + toIntSize(roundedIntRect(revealRect).location()));
2765	if (clampedScrollOffset != scrollOffset()) {	2818	if (isScrollInProgress() \|\| clampedScrollOffset != scrollOffset()) {
2766	ScrollOffset oldScrollOffset = scrollOffset();	2819	ScrollOffset oldScrollOffset = scrollOffset();
2767	scrollToOffset(clampedScrollOffset);	2820	bool animated = (box->element() && useSmoothScrolling(options.behavior, *box->element()));
2768	IntSize scrollOffsetDifference = scrollOffset() - oldScrollOffset;	2821	scrollToPosition(scrollPositionFromOffset(clampedScrollOffset), ScrollType::Programmatic, animated);
		2822	IntSize scrollOffsetDifference = clampedScrollOffset - oldScrollOffset;
2769	localExposeRect.move(-scrollOffsetDifference);	2823	localExposeRect.move(-scrollOffsetDifference);
2770	newRect = LayoutRect(box->localToAbsoluteQuad(FloatQuad(FloatRect(localExposeRect)), UseTransforms).boundingBox());	2824	newRect = LayoutRect(box->localToAbsoluteQuad(FloatQuad(FloatRect(localExposeRect)), UseTransforms).boundingBox());
2771	}	2825	}
Lines 2785-2794 void RenderLayer::scrollRectToVisible(const LayoutRect& absoluteRect, bool insid a/Source/WebCore/rendering/RenderLayer.cpp_sec6
2785	LayoutRect viewRect = frameView.visibleContentRect(LegacyIOSDocumentVisibleRect);	2839	LayoutRect viewRect = frameView.visibleContentRect(LegacyIOSDocumentVisibleRect);
2786	LayoutRect exposeRect = getRectToExpose(viewRect, absoluteRect, insideFixed, options.alignX, options.alignY);	2840	LayoutRect exposeRect = getRectToExpose(viewRect, absoluteRect, insideFixed, options.alignX, options.alignY);
2787		2841
2788	IntPoint scrollOffset(roundedIntPoint(exposeRect.location()));	2842	IntPoint scrollPosition(roundedIntPoint(exposeRect.location()));
2789	// Adjust offsets if they're outside of the allowable range.	2843	// Adjust offsets if they're outside of the allowable range.
2790	scrollOffset = scrollOffset.constrainedBetween(IntPoint(), IntPoint(frameView.contentsSize()));	2844	scrollPosition = scrollPosition.constrainedBetween(IntPoint(), IntPoint(frameView.contentsSize()));
2791	frameView.setScrollPosition(scrollOffset);	2845	// FIXME: Should we use contentDocument()->scrollingElement()?
		2846	// See https://github.com/w3c/csswg-drafts/issues/2977
		2847	bool animated = ownerElement->contentDocument() && ownerElement->contentDocument()->documentElement() && useSmoothScrolling(options.behavior, *ownerElement->contentDocument()->documentElement());
		2848	frameView.setScrollPosition(scrollPosition, animated);
2792		2849
2793	if (options.shouldAllowCrossOriginScrolling == ShouldAllowCrossOriginScrolling::Yes \|\| frameView.safeToPropagateScrollToParent()) {	2850	if (options.shouldAllowCrossOriginScrolling == ShouldAllowCrossOriginScrolling::Yes \|\| frameView.safeToPropagateScrollToParent()) {
2794	parentLayer = ownerElement->renderer()->enclosingLayer();	2851	parentLayer = ownerElement->renderer()->enclosingLayer();
Lines 2827-2833 void RenderLayer::scrollRectToVisible(const LayoutRect& absoluteRect, bool insid a/Source/WebCore/rendering/RenderLayer.cpp_sec7
2827	// Avoid scrolling to the rounded value of revealRect.location() if we don't actually need to scroll	2884	// Avoid scrolling to the rounded value of revealRect.location() if we don't actually need to scroll
2828	if (revealRect != viewRect) {	2885	if (revealRect != viewRect) {
2829	ScrollOffset clampedScrollPosition = roundedIntPoint(revealRect.location()).constrainedBetween(minScrollPosition, maxScrollPosition);	2886	ScrollOffset clampedScrollPosition = roundedIntPoint(revealRect.location()).constrainedBetween(minScrollPosition, maxScrollPosition);
2830	frameView.setScrollPosition(clampedScrollPosition);	2887	// FIXME: Should we use document()->scrollingElement()?
		2888	// See https://github.com/w3c/csswg-drafts/issues/2977
		2889	bool animated = renderer().document().documentElement() && useSmoothScrolling(options.behavior, *renderer().document().documentElement());
		2890	frameView.setScrollPosition(clampedScrollPosition, animated);
2831	}	2891	}
2832		2892
2833	// This is the outermost view of a web page, so after scrolling this view we	2893	// This is the outermost view of a web page, so after scrolling this view we