Attachment #354320 for bug #188043

View Details Raw Unified Return to Bug 188043

| Differences between

and this patch



2018-11-09  Frederic Wang  <fwang@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!).

        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 relies on the existing ScrollAnimationSmooth.

        [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

        * CMakeLists.txt: Add IDL files for ScrollOptions and ScrollBehavior.
        * DerivedSources.make: Ditto.
        * 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/StyleBuilderConverter.h:
        (WebCore::StyleBuilderConverter::convertSmoothScrolling): New function to convert
        scroll-behavior into a "is smooth" boolean.
        * 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::CSSPropertyParser::parseSingleValue): Parse scroll-behavior (only if enabled).
        * dom/Element.cpp:
        (WebCore::Element::scrollIntoView): Pass scroll behavior, if any.
        (WebCore::Element::scrollBy): Use fromCoordinates helper function.
        (WebCore::Element::scrollTo): Handle the case when scroll behavior is smooth. Use
        fromCoordinates helper function.
        * page/DOMWindow.cpp:
        (WebCore::DOMWindow::scrollBy const): Use fromCoordinates helper function.
        (WebCore::DOMWindow::scrollTo const): Use fromCoordinates helper function. Handle the case
        when scroll behavior is smooth. The optimization when scroll position is (0, 0) is skipped
        when a scroll is in progress, otherwise such a scroll can't be cancelled by a follow-up
        scroll.
        * 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::fromCoordinates): New helper function to generate a ScrollToOptions with undefined
        behavior. This is necessary to replace curly brace { x, y } declarations now that there is
        an extra behavior member from the parent class.
        (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.
        * 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/ScrollAnimatorMac.mm:
        (WebCore::ScrollAnimatorSmooth::cancelAnimations): Call parent member to handle programmatic scrolling.
        * platform/ScrollAnimatorSmooth.cpp:
        (WebCore::ScrollAnimatorSmooth::scroll): Call parent member to handle programmatic scrolling.
        (WebCore::ScrollAnimatorSmooth::cancelAnimations): Ditto.
        (WebCore::ScrollAnimatorSmooth::serviceScrollAnimations): Ditto.
        (WebCore::ScrollAnimatorSmooth::willEndLiveResize): Ditto.
        (WebCore::ScrollAnimatorSmooth::didAddVerticalScrollbar): Ditto.
        (WebCore::ScrollAnimatorSmooth::didAddHorizontalScrollbar): Ditto.
        * 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::isScrollInProgress const): Helper function to check whether scroll
        is in progress on the animator. If m_scrollAnimator does not exist we don't construct it.
        (WebCore::ScrollableArea::scrollToOffsetWithAnimation):
        * platform/ScrollableArea.h:
        * rendering/RenderBox.cpp:
        (WebCore::RenderBox::scrollToPositionWithAnimation): Similar to setScrollTop/setScrollLeft
        but animate the scrolling.
        * rendering/RenderBox.h:
        * rendering/RenderLayer.cpp:
        (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).
        (WebCore::RenderLayer::scrollToOffsetWithAnimation): Ditto. This is similar to scrollToOffset
        but animates the scroll.
        (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/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.
        * testing/Internals.cpp:
        (WebCore::Internals::unconstrainedScrollTo): Use fromCoordinates helper function.

2018-11-08  Said Abou-Hallawa  <sabouhallawa@apple.com>

        Add an SPI to allow WebView clients to add additional supported image formats



2018-11-06  Frederic Wang  <fwang@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!).

        Add CSSOM smooth scrolling as an experimental feature.

        * Shared/WebPreferences.yaml:

2018-11-08  Wenson Hsieh  <wenson_hsieh@apple.com>

        Unreviewed, try to fix the 32-bit macOS build



2018-11-07  Frederic Wang  <fwang@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!).

        * WebView/WebPreferenceKeysPrivate.h: Handle CSSOMViewSmoothScrolling by.
        * WebView/WebPreferencesPrivate.h: Ditto.
        * WebView/WebView.mm:
        (-[WebView _preferencesChanged:]): Ditto.

        * WebView/WebPreferences.mm:
        (+[WebPreferences initialize]): Disable CSSOMViewSmoothScrolling by default.
        (-[WebPreferences CSSOMViewSmoothScrollingEnabled]): Getter.
        (-[WebPreferences setCSSOMViewSmoothScrollingEnabled:]): Setter.

2018-11-08  Megan Gardner  <megan_gardner@apple.com>

        Adopt Reveal Framework to replace Lookup



2018-11-07  Frederic Wang  <fwang@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!).

        * 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):

2018-11-01  Sihui Liu  <sihui_liu@apple.com>

        Add a storage limit for IndexedDB



    page/PerformanceTiming.idl
    page/RemoteDOMWindow.idl
    page/Screen.idl
    page/ScrollBehavior.idl
    page/ScrollIntoViewOptions.idl
    page/ScrollLogicalPosition.idl
    page/ScrollOptions.idl
    page/ScrollToOptions.idl
    page/ShareData.idl
    page/VisualViewport.idl



    $(WebCore)/page/PerformanceTiming.idl \
    $(WebCore)/page/RemoteDOMWindow.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/UserMessageHandler.idl \



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

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

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

Lines 56-62 page/scrolling/coordinatedgraphics/ScrollingStateNodeCoordinatedGraphics.cpp a/Source/WebCore/SourcesGTK.txt_sec1
- a/Source/WebCore/SourcesGTK.txt -1 lines
56	page/scrolling/generic/ScrollingThreadGeneric.cpp	56	page/scrolling/generic/ScrollingThreadGeneric.cpp
57		57
58	platform/ScrollAnimationKinetic.cpp	58	platform/ScrollAnimationKinetic.cpp
59	platform/ScrollAnimationSmooth.cpp
60	platform/UserAgentQuirks.cpp	59	platform/UserAgentQuirks.cpp
61		60
62	platform/geoclue/GeolocationProviderGeoclue.cpp	61	platform/geoclue/GeolocationProviderGeoclue.cpp

Lines 382-387 static const CSSPropertyID computedProperties[] = { a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec1
- a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp +5 lines
382	#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)	382	#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
383	CSSPropertyWebkitOverflowScrolling,	383	CSSPropertyWebkitOverflowScrolling,
384	#endif	384	#endif
		385	CSSPropertyScrollBehavior,
385	CSSPropertyPerspective,	386	CSSPropertyPerspective,
386	CSSPropertyPerspectiveOrigin,	387	CSSPropertyPerspectiveOrigin,
387	CSSPropertyWebkitPrintColorAdjust,	388	CSSPropertyWebkitPrintColorAdjust,
Lines 3707-3712 RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec2
3707	return cssValuePool.createIdentifierValue(CSSValueAuto);	3708	return cssValuePool.createIdentifierValue(CSSValueAuto);
3708	return cssValuePool.createIdentifierValue(CSSValueTouch);	3709	return cssValuePool.createIdentifierValue(CSSValueTouch);
3709	#endif	3710	#endif
		3711	case CSSPropertyScrollBehavior:
		3712	if (!style.useSmoothScrolling())
		3713	return cssValuePool.createIdentifierValue(CSSValueAuto);
		3714	return cssValuePool.createIdentifierValue(CSSValueSmooth);
3710	case CSSPropertyPerspective:	3715	case CSSPropertyPerspective:
3711	if (!style.hasPerspective())	3716	if (!style.hasPerspective())
3712	return cssValuePool.createIdentifierValue(CSSValueNone);	3717	return cssValuePool.createIdentifierValue(CSSValueNone);



                "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 1357-1362 scroll-position a/Source/WebCore/css/CSSValueKeywords.in_sec1
- a/Source/WebCore/css/CSSValueKeywords.in +4 lines
1357	manipulation	1357	manipulation
1358	#endif	1358	#endif
1359		1359
		1360	// scroll-behavior
		1361	// auto
		1362	smooth
		1363
1360	// hanging-punctuation	1364	// hanging-punctuation
1361	allow-end	1365	allow-end
1362	first	1366	first

Lines 120-125 public: a/Source/WebCore/css/StyleBuilderConverter.h_sec1
- a/Source/WebCore/css/StyleBuilderConverter.h +6 lines
120	#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)	120	#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
121	static bool convertOverflowScrolling(StyleResolver&, const CSSValue&);	121	static bool convertOverflowScrolling(StyleResolver&, const CSSValue&);
122	#endif	122	#endif
		123	static bool convertSmoothScrolling(StyleResolver&, const CSSValue&);
123	static FontFeatureSettings convertFontFeatureSettings(StyleResolver&, const CSSValue&);	124	static FontFeatureSettings convertFontFeatureSettings(StyleResolver&, const CSSValue&);
124	static FontSelectionValue convertFontWeightFromValue(const CSSValue&);	125	static FontSelectionValue convertFontWeightFromValue(const CSSValue&);
125	static FontSelectionValue convertFontStretchFromValue(const CSSValue&);	126	static FontSelectionValue convertFontStretchFromValue(const CSSValue&);
Lines 1354-1359 inline bool StyleBuilderConverter::convertOverflowScrolling(StyleResolver&, cons a/Source/WebCore/css/StyleBuilderConverter.h_sec2
1354	}	1355	}
1355	#endif	1356	#endif
1356		1357
		1358	inline bool StyleBuilderConverter::convertSmoothScrolling(StyleResolver&, const CSSValue& value)
		1359	{
		1360	return downcast<CSSPrimitiveValue>(value).valueID() == CSSValueSmooth;
		1361	}
		1362
1357	inline SVGLengthValue StyleBuilderConverter::convertSVGLengthValue(StyleResolver&, const CSSValue& value)	1363	inline SVGLengthValue StyleBuilderConverter::convertSVGLengthValue(StyleResolver&, const CSSValue& value)
1358	{	1364	{
1359	return SVGLengthValue::fromCSSPrimitiveValue(downcast<CSSPrimitiveValue>(value));	1365	return SVGLengthValue::fromCSSPrimitiveValue(downcast<CSSPrimitiveValue>(value));



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

#if PLATFORM(IOS_FAMILY)

        && 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 };

            & key.constantPropertiesEnabled                 << 6
            & key.colorFilterEnabled                        << 7
            & key.deferredCSSParserEnabled                  << 8
            & key.scrollBehaviorEnabled                     << 9
            & key.hasDocumentSecurityOrigin                 << 10
            & key.useSystemAppearance                       << 11
#if ENABLE(ATTACHMENT_ELEMENT)
            & key.attachmentEnabled                         << 12
#endif
            & key.mode                                      << 13; // Keep this last.
        hash ^= WTF::intHash(bits);
        return hash;
    }



        return valueID == CSSValueStatic || valueID == CSSValueRelative || valueID == CSSValueAbsolute || valueID == CSSValueFixed || 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 2326-2331 static RefPtr<CSSValueList> consumeScrollSnapType(CSSParserTokenRange& range) a/Source/WebCore/css/parser/CSSPropertyParser.cpp_sec1
- a/Source/WebCore/css/parser/CSSPropertyParser.cpp +12 lines
2326		2326
2327	#endif	2327	#endif
2328		2328
		2329	static RefPtr<CSSPrimitiveValue> consumeScrollBehavior(CSSParserTokenRange& range)
		2330	{
		2331	auto valueID = range.peek().id();
		2332	if (valueID != CSSValueAuto && valueID != CSSValueSmooth)
		2333	return nullptr;
		2334	return consumeIdent(range);
		2335	}
		2336
2329	static RefPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParserMode cssParserMode)	2337	static RefPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParserMode cssParserMode)
2330	{	2338	{
2331	RefPtr<CSSPrimitiveValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);	2339	RefPtr<CSSPrimitiveValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
Lines 4015-4020 RefPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID property, CSS a/Source/WebCore/css/parser/CSSPropertyParser.cpp_sec2
4015	case CSSPropertyScrollSnapType:	4023	case CSSPropertyScrollSnapType:
4016	return consumeScrollSnapType(m_range);	4024	return consumeScrollSnapType(m_range);
4017	#endif	4025	#endif
		4026	case CSSPropertyScrollBehavior:
		4027	if (!m_context.scrollBehaviorEnabled)
		4028	return nullptr;
		4029	return consumeScrollBehavior(m_range);
4018	case CSSPropertyClip:	4030	case CSSPropertyClip:
4019	return consumeClip(m_range, m_context.mode);	4031	return consumeClip(m_range, m_context.mode);
4020	#if ENABLE(TOUCH_EVENTS)	4032	#if ENABLE(TOUCH_EVENTS)



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

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

            options.blockPosition = ScrollLogicalPosition::End;
    }

    ScrollRectToVisibleOptions scrollRectToVisibleOptions {
        SelectionRevealMode::Reveal,
        toScrollAlignment(options.inlinePosition, false),
        toScrollAlignment(options.blockPosition, true),
        ShouldAllowCrossOriginScrolling::No,
    };
    if (options.behavior)
        scrollRectToVisibleOptions.behavior = options.behavior.value();
    renderer()->scrollRectToVisible(absoluteBounds, insideFixed, scrollRectToVisibleOptions);
}

void Element::scrollIntoView(bool alignToTop) 


void Element::scrollBy(double x, double y)
{
    scrollBy(fromCoordinates(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())
    );
    if (useSmoothScrolling(scrollToOptions.behavior.value_or(ScrollBehavior::Auto), *this)) {
        renderer->scrollToPositionWithAnimation(scrollPosition, clamping);
        return;
    }
    renderer->setScrollLeft(scrollPosition.x(), clamping);
    renderer->setScrollTop(scrollPosition.y(), clamping);
}

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

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




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

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


void DOMWindow::scrollTo(double x, double y, ScrollClamping clamping) const
{
    return scrollTo(fromCoordinates(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.value_or(ScrollBehavior::Auto), *document()->documentElement())) {
        view->scrollToOffsetWithAnimation(layoutPos, clamping);
        return;
    }
    view->setContentsScrollPosition(layoutPos);
}




/*
 * Copyright (C) 2018 Igalia S.L.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#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) 2018 Igalia S.L.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#pragma once

namespace WebCore {

class Element;

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

bool useSmoothScrolling(ScrollBehavior, Element& associatedElement);

} // namespace WebCore



/*
 * Copyright (C) 2018 Igalia S.L.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

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



#pragma once

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

namespace WebCore {

struct ScrollIntoViewOptions : ScrollOptions {

struct ScrollIntoViewOptions {
    std::optional<ScrollLogicalPosition> blockPosition { ScrollLogicalPosition::Start };
    std::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) 2018 Igalia S.L.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#pragma once

#include "ScrollBehavior.h"

namespace WebCore {

struct ScrollOptions {
    std::optional<ScrollBehavior> behavior { ScrollBehavior::Auto };
};

} // namespace WebCore



/*
 * Copyright (C) 2018 Igalia S.L.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

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




#pragma once

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

namespace WebCore {

struct ScrollToOptions : ScrollOptions {
    std::optional<double> left;
    std::optional<double> top;
};

inline ScrollToOptions fromCoordinates(double x, double y)
{
    ScrollToOptions options;
    options.left = x;
    options.top = y;
    return options;
};

inline double normalizeNonFiniteValueOrFallBackTo(std::optional<double> value, double fallbackValue)
{
    // Normalize non-finite values (https://drafts.csswg.org/cssom-view/#normalize-non-finite-values).

// 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 554-559 visualViewportAPIEnabled: a/Source/WebCore/page/Settings.yaml_sec1
- a/Source/WebCore/page/Settings.yaml +3 lines
554	CSSOMViewScrollingAPIEnabled:	554	CSSOMViewScrollingAPIEnabled:
555	initial: false	555	initial: false
556		556
		557	CSSOMViewSmoothScrollingEnabled:
		558	initial: false
		559
557	inputEventsEnabled:	560	inputEventsEnabled:
558	initial: true	561	initial: true
559		562




class FloatPoint;
class ScrollableArea;
enum class ScrollClamping;

class ScrollAnimation {
public:
    virtual ~ScrollAnimation() { };
    virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float /* step */, float /* multiplier */) { return true; };
    virtual void scroll(const FloatPoint&, ScrollClamping) { };
    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 163-166 void ScrollAnimationKinetic::animationTimerFired() a/Source/WebCore/platform/ScrollAnimationKinetic.cpp_sec1
- a/Source/WebCore/platform/ScrollAnimationKinetic.cpp +5 lines
163	m_notifyPositionChangedFunction(FloatPoint(m_position));	163	m_notifyPositionChangedFunction(FloatPoint(m_position));
164	}	164	}
165		165
		166	bool ScrollAnimationKinetic::isScrollInProgress() const
		167	{
		168	return m_animationTimer.isActive();
		169	}
		170
166	} // namespace WebCore	171	} // 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, ScrollClamping)
{
    // FIXME: Consider clamping?
    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;

class ScrollAnimationSmooth final: public ScrollAnimation {
public:


private:
    bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier) override;
    void scroll(const FloatPoint&, ScrollClamping) 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)

Lines 35-40 a/Source/WebCore/platform/ScrollAnimator.cpp_sec1
- a/Source/WebCore/platform/ScrollAnimator.cpp +48 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(std::make_unique<ScrollAnimationSmooth>(scrollableArea, m_currentPosition, [this](FloatPoint&& position) {
		57	FloatSize delta = position - m_currentPosition;
		58	m_currentPosition = WTFMove(position);
		59	notifyPositionChanged(delta);
		60	}))
55	{	61	{
56	}	62	}
57		63
58	ScrollAnimator::~ScrollAnimator() = default;	64	ScrollAnimator::~ScrollAnimator() = default;
59		65
		66	bool ScrollAnimator::isScrollInProgress() const
		67	{
		68	// FIXME (TODO): This should also take into account animations in derived classes.
		69	return m_animationProgrammaticScroll->isScrollInProgress();
		70	}
		71
60	bool ScrollAnimator::scroll(ScrollbarOrientation orientation, ScrollGranularity, float step, float multiplier)	72	bool ScrollAnimator::scroll(ScrollbarOrientation orientation, ScrollGranularity, float step, float multiplier)
61	{	73	{
62	FloatPoint currentPosition = this->currentPosition();	74	FloatPoint currentPosition = this->currentPosition();
Lines 75-80 bool ScrollAnimator::scroll(ScrollbarOrientation orientation, ScrollGranularity, a/Source/WebCore/platform/ScrollAnimator.cpp_sec3
75	return true;	87	return true;
76	}	88	}
77		89
		90	void ScrollAnimator::scrollToOffset(const FloatPoint& offset, ScrollClamping clamping)
		91	{
		92	m_animationProgrammaticScroll->setCurrentPosition(m_currentPosition);
		93	auto newPosition = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));
		94	m_animationProgrammaticScroll->scroll(newPosition, clamping);
		95	}
		96
78	void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping)	97	void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping)
79	{	98	{
80	FloatPoint newPositon = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));	99	FloatPoint newPositon = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));
Lines 245-248 void ScrollAnimator::removeTestDeferralForReason(WheelEventTestTrigger::Scrollab a/Source/WebCore/platform/ScrollAnimator.cpp_sec4
245	}	264	}
246	#endif	265	#endif
247		266
		267	void ScrollAnimator::cancelAnimations()
		268	{
		269	#if !USE(REQUEST_ANIMATION_FRAME_TIMER)
		270	m_animationProgrammaticScroll->stop();
		271	#endif
		272	}
		273
		274	void ScrollAnimator::serviceScrollAnimations()
		275	{
		276	#if !USE(REQUEST_ANIMATION_FRAME_TIMER)
		277	m_animationProgrammaticScroll->serviceAnimation();
		278	#endif
		279	}
		280
		281	void ScrollAnimator::willEndLiveResize()
		282	{
		283	m_animationProgrammaticScroll->updateVisibleLengths();
		284	}
		285
		286	void ScrollAnimator::didAddVerticalScrollbar(Scrollbar*)
		287	{
		288	m_animationProgrammaticScroll->updateVisibleLengths();
		289	}
		290
		291	void ScrollAnimator::didAddHorizontalScrollbar(Scrollbar*)
		292	{
		293	m_animationProgrammaticScroll->updateVisibleLengths();
		294	}
		295
248	} // namespace WebCore	296	} // namespace WebCore




class FloatPoint;
class PlatformTouchEvent;
class ScrollAnimation;
class ScrollableArea;
class Scrollbar;
class WheelEventTestTrigger;

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

    void scrollToOffset(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
    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 setWheelEventTestTrigger(RefPtr<WheelEventTestTrigger>&& testTrigger) { m_wheelEventTestTrigger = testTrigger; }
#if (ENABLE(CSS_SCROLL_SNAP) || ENABLE(RUBBER_BANDING)) && PLATFORM(MAC)

    ScrollController m_scrollController;
#endif
    FloatPoint m_currentPosition;

    std::unique_ptr<ScrollAnimation> m_animationProgrammaticScroll;
};

} // namespace WebCore



    if (!m_scrollableArea.scrollAnimatorEnabled())
        return ScrollAnimator::scroll(orientation, granularity, step, multiplier);

    m_animation->setCurrentPosition(m_currentPosition);
    return m_animation->scroll(orientation, granularity, step, multiplier);
}


#if !USE(REQUEST_ANIMATION_FRAME_TIMER)
void ScrollAnimatorSmooth::cancelAnimations()
{
    ScrollAnimator::cancelAnimations();
    m_animation->stop();
}

void ScrollAnimatorSmooth::serviceScrollAnimations()
{
    ScrollAnimator::serviceScrollAnimations();
    m_animation->serviceAnimation();
}
#endif

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

void ScrollAnimatorSmooth::didAddVerticalScrollbar(Scrollbar* scrollbar)
{
    ScrollAnimator::didAddVerticalScrollbar(scrollbar);
    m_animation->updateVisibleLengths();
}

void ScrollAnimatorSmooth::didAddHorizontalScrollbar(Scrollbar* scrollbar)
{
    ScrollAnimator::didAddHorizontalScrollbar(scrollbar);
    m_animation->updateVisibleLengths();
}


Lines 501-509 void ScrollView::setScrollPosition(const ScrollPosition& scrollPosition) a/Source/WebCore/platform/ScrollView.cpp_sec1
- a/Source/WebCore/platform/ScrollView.cpp -1 / +5 lines
501		501
502	ScrollPosition newScrollPosition = !delegatesScrolling() ? adjustScrollPositionWithinRange(scrollPosition) : scrollPosition;	502	ScrollPosition newScrollPosition = !delegatesScrolling() ? adjustScrollPositionWithinRange(scrollPosition) : scrollPosition;
503		503
504	if ((!delegatesScrolling() \|\| !inProgrammaticScroll()) && newScrollPosition == this->scrollPosition())	504	bool scrollInProgress = isScrollInProgress();
		505	if ((!delegatesScrolling() \|\| !inProgrammaticScroll()) && !scrollInProgress && newScrollPosition == this->scrollPosition())
505	return;	506	return;
506		507
		508	if (scrollInProgress)
		509	scrollAnimator().cancelAnimations();
		510
507	if (requestScrollPositionUpdate(newScrollPosition))	511	if (requestScrollPositionUpdate(newScrollPosition))
508	return;	512	return;
509		513

Lines 100-105 float ScrollableArea::adjustScrollStepForFixedContent(float step, ScrollbarOrien a/Source/WebCore/platform/ScrollableArea.cpp_sec1
- a/Source/WebCore/platform/ScrollableArea.cpp +11 lines
100	return step;	100	return step;
101	}	101	}
102		102
		103	bool ScrollableArea::isScrollInProgress() const
		104	{
		105	return m_scrollAnimator && scrollAnimator().isScrollInProgress();
		106	}
		107
103	bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)	108	bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
104	{	109	{
105	ScrollbarOrientation orientation;	110	ScrollbarOrientation orientation;
Lines 138-143 bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granula a/Source/WebCore/platform/ScrollableArea.cpp_sec2
138	return scrollAnimator().scroll(orientation, granularity, step, multiplier);	143	return scrollAnimator().scroll(orientation, granularity, step, multiplier);
139	}	144	}
140		145
		146	void ScrollableArea::scrollToOffsetWithAnimation(const FloatPoint& offset, ScrollClamping clamping)
		147	{
		148	LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffset " << offset);
		149	scrollAnimator().scrollToOffset(offset, clamping);
		150	}
		151
141	void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping clamping)	152	void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping clamping)
142	{	153	{
143	LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffsetWithoutAnimation " << offset);	154	LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffsetWithoutAnimation " << offset);




class ScrollableArea : public CanMakeWeakPtr<ScrollableArea> {
public:
    WEBCORE_EXPORT bool isScrollInProgress() const;
    WEBCORE_EXPORT bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
    WEBCORE_EXPORT void scrollToOffsetWithAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
    WEBCORE_EXPORT void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
    void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);


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

Lines 586-591 void RenderBox::setScrollTop(int newTop, ScrollClamping clamping) a/Source/WebCore/rendering/RenderBox.cpp_sec1
- a/Source/WebCore/rendering/RenderBox.cpp +8 lines
586	layer()->scrollToYPosition(newTop, clamping);	586	layer()->scrollToYPosition(newTop, clamping);
587	}	587	}
588		588
		589	void RenderBox::scrollToPositionWithAnimation(ScrollPosition scrollPosition, ScrollClamping clamping)
		590	{
		591	if (!hasOverflowClip() \|\| !layer())
		592	return;
		593	setupWheelEventTestTrigger(*layer());
		594	layer()->scrollToOffsetWithAnimation(scrollPosition, clamping);
		595	}
		596
589	void RenderBox::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const	597	void RenderBox::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
590	{	598	{
591	rects.append(snappedIntRect(accumulatedOffset, size()));	599	rects.append(snappedIntRect(accumulatedOffset, size()));

Lines 245-250 public: a/Source/WebCore/rendering/RenderBox.h_sec1
- a/Source/WebCore/rendering/RenderBox.h +1 lines
245	virtual int scrollHeight() const;	245	virtual int scrollHeight() const;
246	virtual void setScrollLeft(int, ScrollClamping = ScrollClamping::Clamped);	246	virtual void setScrollLeft(int, ScrollClamping = ScrollClamping::Clamped);
247	virtual void setScrollTop(int, ScrollClamping = ScrollClamping::Clamped);	247	virtual void setScrollTop(int, ScrollClamping = ScrollClamping::Clamped);
		248	void scrollToPositionWithAnimation(ScrollPosition, ScrollClamping = ScrollClamping::Clamped);
248		249
249	LayoutUnit marginTop() const override { return m_marginBox.top(); }	250	LayoutUnit marginTop() const override { return m_marginBox.top(); }
250	LayoutUnit marginBottom() const override { return m_marginBox.bottom(); }	251	LayoutUnit marginBottom() const override { return m_marginBox.bottom(); }

Lines 114-119 a/Source/WebCore/rendering/RenderLayer.cpp_sec1
- a/Source/WebCore/rendering/RenderLayer.cpp -5 / +34 lines
114	#include "ScaleTransformOperation.h"	114	#include "ScaleTransformOperation.h"
115	#include "ScriptDisallowedScope.h"	115	#include "ScriptDisallowedScope.h"
116	#include "ScrollAnimator.h"	116	#include "ScrollAnimator.h"
		117	#include "ScrollBehavior.h"
117	#include "Scrollbar.h"	118	#include "Scrollbar.h"
118	#include "ScrollbarTheme.h"	119	#include "ScrollbarTheme.h"
119	#include "ScrollingCoordinator.h"	120	#include "ScrollingCoordinator.h"
Lines 2288-2297 ScrollOffset RenderLayer::clampScrollOffset(const ScrollOffset& scrollOffset) co a/Source/WebCore/rendering/RenderLayer.cpp_sec2
2288	void RenderLayer::scrollToOffset(const ScrollOffset& scrollOffset, ScrollClamping clamping)	2289	void RenderLayer::scrollToOffset(const ScrollOffset& scrollOffset, ScrollClamping clamping)
2289	{	2290	{
2290	ScrollOffset newScrollOffset = clamping == ScrollClamping::Clamped ? clampScrollOffset(scrollOffset) : scrollOffset;	2291	ScrollOffset newScrollOffset = clamping == ScrollClamping::Clamped ? clampScrollOffset(scrollOffset) : scrollOffset;
2291	if (newScrollOffset != this->scrollOffset())	2292	bool scrollInProgress = isScrollInProgress();
		2293	if (scrollInProgress)
		2294	scrollAnimator().cancelAnimations();
		2295	if (scrollInProgress \|\| newScrollOffset != this->scrollOffset())
2292	scrollToOffsetWithoutAnimation(newScrollOffset, clamping);	2296	scrollToOffsetWithoutAnimation(newScrollOffset, clamping);
2293	}	2297	}
2294		2298
		2299	void RenderLayer::scrollToOffsetWithAnimation(const ScrollOffset& scrollOffset, ScrollClamping clamping)
		2300	{
		2301	ScrollOffset newScrollOffset = clamping == ScrollClamping::Clamped ? clampScrollOffset(scrollOffset) : scrollOffset;
		2302	bool scrollInProgress = isScrollInProgress();
		2303	if (scrollInProgress)
		2304	scrollAnimator().cancelAnimations();
		2305	if (scrollInProgress \|\| newScrollOffset != this->scrollOffset())
		2306	ScrollableArea::scrollToOffsetWithAnimation(newScrollOffset, clamping);
		2307	}
		2308
2295	void RenderLayer::scrollTo(const ScrollPosition& position)	2309	void RenderLayer::scrollTo(const ScrollPosition& position)
2296	{	2310	{
2297	RenderBox* box = renderBox();	2311	RenderBox* box = renderBox();
Lines 2431-2436 bool RenderLayer::allowsCurrentScroll() const a/Source/WebCore/rendering/RenderLayer.cpp_sec3
2431		2445
2432	void RenderLayer::scrollRectToVisible(const LayoutRect& absoluteRect, bool insideFixed, const ScrollRectToVisibleOptions& options)	2446	void RenderLayer::scrollRectToVisible(const LayoutRect& absoluteRect, bool insideFixed, const ScrollRectToVisibleOptions& options)
2433	{	2447	{
		2448	// FIXME (https://webkit.org/b/189907): Make this work with nested scrollable boxes when a smooth scrolling must be performed.
2434	LOG_WITH_STREAM(Scrolling, stream << "Layer " << this << " scrollRectToVisible " << absoluteRect);	2449	LOG_WITH_STREAM(Scrolling, stream << "Layer " << this << " scrollRectToVisible " << absoluteRect);
2435		2450
2436	RenderLayer* parentLayer = nullptr;	2451	RenderLayer* parentLayer = nullptr;
Lines 2453-2461 void RenderLayer::scrollRectToVisible(const LayoutRect& absoluteRect, bool insid a/Source/WebCore/rendering/RenderLayer.cpp_sec4
2453	LayoutRect revealRect = getRectToExpose(layerBounds, localExposeRect, insideFixed, options.alignX, options.alignY);	2468	LayoutRect revealRect = getRectToExpose(layerBounds, localExposeRect, insideFixed, options.alignX, options.alignY);
2454		2469
2455	ScrollOffset clampedScrollOffset = clampScrollOffset(scrollOffset() + toIntSize(roundedIntRect(revealRect).location()));	2470	ScrollOffset clampedScrollOffset = clampScrollOffset(scrollOffset() + toIntSize(roundedIntRect(revealRect).location()));
2456	if (clampedScrollOffset != scrollOffset()) {	2471	if (isScrollInProgress() \|\| clampedScrollOffset != scrollOffset()) {
2457	ScrollOffset oldScrollOffset = scrollOffset();	2472	ScrollOffset oldScrollOffset = scrollOffset();
2458	scrollToOffset(clampedScrollOffset);	2473	if (box->element() && useSmoothScrolling(options.behavior, *box->element()))
		2474	scrollToOffsetWithAnimation(clampedScrollOffset);
		2475	else
		2476	scrollToOffset(clampedScrollOffset);
2459	IntSize scrollOffsetDifference = scrollOffset() - oldScrollOffset;	2477	IntSize scrollOffsetDifference = scrollOffset() - oldScrollOffset;
2460	localExposeRect.move(-scrollOffsetDifference);	2478	localExposeRect.move(-scrollOffsetDifference);
2461	newRect = LayoutRect(box->localToAbsoluteQuad(FloatQuad(FloatRect(localExposeRect)), UseTransforms).boundingBox());	2479	newRect = LayoutRect(box->localToAbsoluteQuad(FloatQuad(FloatRect(localExposeRect)), UseTransforms).boundingBox());
Lines 2479-2485 void RenderLayer::scrollRectToVisible(const LayoutRect& absoluteRect, bool insid a/Source/WebCore/rendering/RenderLayer.cpp_sec5
2479	IntPoint scrollOffset(roundedIntPoint(exposeRect.location()));	2497	IntPoint scrollOffset(roundedIntPoint(exposeRect.location()));
2480	// Adjust offsets if they're outside of the allowable range.	2498	// Adjust offsets if they're outside of the allowable range.
2481	scrollOffset = scrollOffset.constrainedBetween(IntPoint(), IntPoint(frameView.contentsSize()));	2499	scrollOffset = scrollOffset.constrainedBetween(IntPoint(), IntPoint(frameView.contentsSize()));
2482	frameView.setScrollPosition(scrollOffset);	2500	// FIXME: Should we use contentDocument()->scrollingElement()?
		2501	// See https://github.com/w3c/csswg-drafts/issues/2977
		2502	if (ownerElement->contentDocument() && ownerElement->contentDocument()->documentElement() && useSmoothScrolling(options.behavior, *ownerElement->contentDocument()->documentElement()))
		2503	frameView.scrollToOffsetWithAnimation(scrollOffset);
		2504	else
		2505	frameView.setScrollPosition(scrollOffset);
2483		2506
2484	if (options.shouldAllowCrossOriginScrolling == ShouldAllowCrossOriginScrolling::Yes \|\| frameView.safeToPropagateScrollToParent()) {	2507	if (options.shouldAllowCrossOriginScrolling == ShouldAllowCrossOriginScrolling::Yes \|\| frameView.safeToPropagateScrollToParent()) {
2485	parentLayer = ownerElement->renderer()->enclosingLayer();	2508	parentLayer = ownerElement->renderer()->enclosingLayer();
Lines 2504-2510 void RenderLayer::scrollRectToVisible(const LayoutRect& absoluteRect, bool insid a/Source/WebCore/rendering/RenderLayer.cpp_sec6
2504		2527
2505	LayoutRect revealRect = getRectToExpose(viewRect, targetRect, insideFixed, options.alignX, options.alignY);	2528	LayoutRect revealRect = getRectToExpose(viewRect, targetRect, insideFixed, options.alignX, options.alignY);
2506		2529
2507	frameView.setScrollPosition(roundedIntPoint(revealRect.location()));	2530	IntPoint scrollOffset(roundedIntPoint(revealRect.location()));
		2531	// FIXME: Should we use document()->scrollingElement()?
		2532	// See https://github.com/w3c/csswg-drafts/issues/2977
		2533	if (renderer().document().documentElement() && useSmoothScrolling(options.behavior, *renderer().document().documentElement()))
		2534	frameView.scrollToOffsetWithAnimation(scrollOffset);
		2535	else
		2536	frameView.setScrollPosition(scrollOffset);
2508		2537
2509	// This is the outermost view of a web page, so after scrolling this view we	2538	// This is the outermost view of a web page, so after scrolling this view we
2510	// scroll its container by calling Page::scrollRectIntoView.	2539	// scroll its container by calling Page::scrollRectIntoView.



#include "PaintInfo.h"
#include "RenderBox.h"
#include "RenderPtr.h"
#include "ScrollBehavior.h"
#include "ScrollableArea.h"
#include <memory>
#include <wtf/WeakPtr.h>

    const ScrollAlignment& alignX { ScrollAlignment::alignCenterIfNeeded };
    const ScrollAlignment& alignY { ScrollAlignment::alignCenterIfNeeded };
    ShouldAllowCrossOriginScrolling shouldAllowCrossOriginScrolling { ShouldAllowCrossOriginScrolling::No };
    ScrollBehavior behavior { ScrollBehavior::Auto };
};

class RenderLayer final : public ScrollableArea {

    void scrollByRecursively(const IntSize& delta, ScrollableArea** scrolledArea = nullptr);

    WEBCORE_EXPORT void scrollToOffset(const ScrollOffset&, ScrollClamping = ScrollClamping::Clamped);
    WEBCORE_EXPORT void scrollToOffsetWithAnimation(const ScrollOffset&, ScrollClamping = ScrollClamping::Clamped);
    void scrollToXOffset(int x, ScrollClamping clamping = ScrollClamping::Clamped) { scrollToOffset(ScrollOffset(x, scrollOffset().y()), clamping); }
    void scrollToYOffset(int y, ScrollClamping clamping = ScrollClamping::Clamped) { scrollToOffset(ScrollOffset(scrollOffset().x(), y), clamping); }


Lines 737-742 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec1
- a/Source/WebCore/rendering/style/RenderStyle.h +6 lines
737	bool useTouchOverflowScrolling() const { return m_rareInheritedData->useTouchOverflowScrolling; }	737	bool useTouchOverflowScrolling() const { return m_rareInheritedData->useTouchOverflowScrolling; }
738	#endif	738	#endif
739		739
		740	bool useSmoothScrolling() const { return m_rareNonInheritedData->useSmoothScrolling; }
		741
740	#if ENABLE(TEXT_AUTOSIZING)	742	#if ENABLE(TEXT_AUTOSIZING)
741	TextSizeAdjustment textSizeAdjust() const { return m_rareInheritedData->textSizeAdjust; }	743	TextSizeAdjustment textSizeAdjust() const { return m_rareInheritedData->textSizeAdjust; }
742	#endif	744	#endif
Lines 1250-1255 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec2
1250	void setUseTouchOverflowScrolling(bool v) { SET_VAR(m_rareInheritedData, useTouchOverflowScrolling, v); }	1252	void setUseTouchOverflowScrolling(bool v) { SET_VAR(m_rareInheritedData, useTouchOverflowScrolling, v); }
1251	#endif	1253	#endif
1252		1254
		1255	void setUseSmoothScrolling(bool v) { SET_VAR(m_rareNonInheritedData, useSmoothScrolling, v); }
		1256
1253	#if ENABLE(TEXT_AUTOSIZING)	1257	#if ENABLE(TEXT_AUTOSIZING)
1254	void setTextSizeAdjust(TextSizeAdjustment adjustment) { SET_VAR(m_rareInheritedData, textSizeAdjust, adjustment); }	1258	void setTextSizeAdjust(TextSizeAdjustment adjustment) { SET_VAR(m_rareInheritedData, textSizeAdjust, adjustment); }
1255	#endif	1259	#endif
Lines 1682-1687 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec3
1682	static bool initialUseTouchOverflowScrolling() { return false; }	1686	static bool initialUseTouchOverflowScrolling() { return false; }
1683	#endif	1687	#endif
1684		1688
		1689	static bool initialUseSmoothScrolling() { return false; }
		1690
1685	#if ENABLE(DASHBOARD_SUPPORT)	1691	#if ENABLE(DASHBOARD_SUPPORT)
1686	static const Vector<StyleDashboardRegion>& initialDashboardRegions();	1692	static const Vector<StyleDashboardRegion>& initialDashboardRegions();
1687	static const Vector<StyleDashboardRegion>& noneDashboardRegions();	1693	static const Vector<StyleDashboardRegion>& noneDashboardRegions();



#if ENABLE(TOUCH_EVENTS)
    , touchAction(static_cast<unsigned>(RenderStyle::initialTouchAction()))
#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(TOUCH_EVENTS)
    , touchAction(o.touchAction)
#endif
    , useSmoothScrolling(o.useSmoothScrolling)
    , pageSizeType(o.pageSizeType)
    , transformStyle3D(o.transformStyle3D)
    , backfaceVisibility(o.backfaceVisibility)

#if ENABLE(TOUCH_EVENTS)
        && touchAction == o.touchAction
#endif
        && useSmoothScrolling == o.useSmoothScrolling
#if ENABLE(CSS_COMPOSITING)
        && effectiveBlendMode == o.effectiveBlendMode
        && isolation == o.isolation

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

Lines 1645-1651 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
1645	if (!document \|\| !document->view())	1645	if (!document \|\| !document->view())
1646	return Exception { InvalidAccessError };	1646	return Exception { InvalidAccessError };
1647		1647
1648	element.scrollTo({ x, y }, ScrollClamping::Unclamped);	1648	element.scrollTo(fromCoordinates(x, y), ScrollClamping::Unclamped);
1649	return { };	1649	return { };
1650	}	1650	}
1651		1651



#   DEFAULT_EXPERIMENTAL_FEATURES_ENABLED (for features that are ready for
#   wider testing).


SpringTimingFunctionEnabled:
  type: bool
  defaultValue: DEFAULT_EXPERIMENTAL_FEATURES_ENABLED

  humanReadableDescription: "Implement standard behavior for scrollLeft, scrollTop, scrollWidth, scrollHeight, scrollTo, scrollBy and scrollingElement."
  category: experimental

CSSOMViewSmoothScrollingEnabled:
  type: bool
  defaultValue: false
  humanReadableName: "CSSOM View Smooth Scrolling"
  humanReadableDescription: "Enable DOM API and CSS property for 'smooth' scroll behavior"
  category: experimental

WebAnimationsEnabled:
  type: bool
  defaultValue: true

Lines 183-188 a/Source/WebKitLegacy/mac/WebView/WebPreferenceKeysPrivate.h_sec1
- a/Source/WebKitLegacy/mac/WebView/WebPreferenceKeysPrivate.h +1 lines
183	#define WebKitVisualViewportEnabledPreferenceKey @"WebKitVisualViewportEnabled"	183	#define WebKitVisualViewportEnabledPreferenceKey @"WebKitVisualViewportEnabled"
184	#define WebKitVisualViewportAPIEnabledPreferenceKey @"WebKitVisualViewportAPIEnabled"	184	#define WebKitVisualViewportAPIEnabledPreferenceKey @"WebKitVisualViewportAPIEnabled"
185	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey @"WebKitCSSOMViewScrollingAPIEnabled"	185	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey @"WebKitCSSOMViewScrollingAPIEnabled"
		186	#define WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey @"WebKitCSSOMViewSmoothScrollingEnabled"
186	#define WebKitModernMediaControlsEnabledPreferenceKey @"WebKitModernMediaControlsEnabled"	187	#define WebKitModernMediaControlsEnabledPreferenceKey @"WebKitModernMediaControlsEnabled"
187	#define WebKitSubtleCryptoEnabledPreferenceKey @"WebKitSubtleCryptoEnabled"	188	#define WebKitSubtleCryptoEnabledPreferenceKey @"WebKitSubtleCryptoEnabled"
188	#define WebKitMediaDevicesEnabledPreferenceKey @"WebKitMediaDevicesEnabled"	189	#define WebKitMediaDevicesEnabledPreferenceKey @"WebKitMediaDevicesEnabled"



        [NSNumber numberWithBool:NO], WebKitVisualViewportAPIEnabledPreferenceKey,

        [NSNumber numberWithBool:NO], WebKitCSSOMViewScrollingAPIEnabledPreferenceKey,
        [NSNumber numberWithBool:NO], WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey,
        [NSNumber numberWithBool:YES], WebKitNeedsStorageAccessFromFileURLsQuirkKey,
        [NSNumber numberWithBool: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 588-593 extern NSString *WebPreferencesCacheModelChangedInternalNotification WEBKIT_DEPR a/Source/WebKitLegacy/mac/WebView/WebPreferencesPrivate.h_sec1
- a/Source/WebKitLegacy/mac/WebView/WebPreferencesPrivate.h +1 lines
588	@property (nonatomic) BOOL visualViewportEnabled;	588	@property (nonatomic) BOOL visualViewportEnabled;
589	@property (nonatomic) BOOL visualViewportAPIEnabled;	589	@property (nonatomic) BOOL visualViewportAPIEnabled;
590	@property (nonatomic) BOOL CSSOMViewScrollingAPIEnabled;	590	@property (nonatomic) BOOL CSSOMViewScrollingAPIEnabled;
		591	@property (nonatomic) BOOL CSSOMViewSmoothScrollingEnabled;
591	@property (nonatomic) BOOL largeImageAsyncDecodingEnabled;	592	@property (nonatomic) BOOL largeImageAsyncDecodingEnabled;
592	@property (nonatomic) BOOL animatedImageAsyncDecodingEnabled;	593	@property (nonatomic) BOOL animatedImageAsyncDecodingEnabled;
593	@property (nonatomic) BOOL javaScriptMarkupEnabled;	594	@property (nonatomic) BOOL javaScriptMarkupEnabled;

Lines 2950-2955 static bool needsSelfRetainWhileLoadingQuirk() a/Source/WebKitLegacy/mac/WebView/WebView.mm_sec1
- a/Source/WebKitLegacy/mac/WebView/WebView.mm +1 lines
2950	settings.setVisualViewportEnabled([preferences visualViewportEnabled]);	2950	settings.setVisualViewportEnabled([preferences visualViewportEnabled]);
2951	settings.setVisualViewportAPIEnabled([preferences visualViewportAPIEnabled]);	2951	settings.setVisualViewportAPIEnabled([preferences visualViewportAPIEnabled]);
2952	settings.setCSSOMViewScrollingAPIEnabled([preferences CSSOMViewScrollingAPIEnabled]);	2952	settings.setCSSOMViewScrollingAPIEnabled([preferences CSSOMViewScrollingAPIEnabled]);
		2953	settings.setCSSOMViewSmoothScrollingEnabled([preferences CSSOMViewSmoothScrollingEnabled]);
2953	settings.setMediaContentTypesRequiringHardwareSupport([preferences mediaContentTypesRequiringHardwareSupport]);	2954	settings.setMediaContentTypesRequiringHardwareSupport([preferences mediaContentTypesRequiringHardwareSupport]);
2954		2955
2955	switch ([preferences storageBlockingPolicy]) {	2956	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 205-208 a/Source/WebKitLegacy/win/WebPreferenceKeysPrivate.h_sec1
- a/Source/WebKitLegacy/win/WebPreferenceKeysPrivate.h +1 lines
205	#define WebKitServerTimingEnabledPreferenceKey "WebKitServerTimingEnabled"	205	#define WebKitServerTimingEnabledPreferenceKey "WebKitServerTimingEnabled"
206		206
207	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey "WebKitCSSOMViewScrollingAPIEnabled"	207	#define WebKitCSSOMViewScrollingAPIEnabledPreferenceKey "WebKitCSSOMViewScrollingAPIEnabled"
		208	#define WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey "WebKitCSSOMViewSmoothScrollingEnabled"
208		209

Lines 329-334 void WebPreferences::initializeDefaultSettings() a/Source/WebKitLegacy/win/WebPreferences.cpp_sec1
- a/Source/WebKitLegacy/win/WebPreferences.cpp +16 lines
329		329
330	CFDictionaryAddValue(defaults, CFSTR(WebKitCSSOMViewScrollingAPIEnabledPreferenceKey), kCFBooleanFalse);	330	CFDictionaryAddValue(defaults, CFSTR(WebKitCSSOMViewScrollingAPIEnabledPreferenceKey), kCFBooleanFalse);
331		331
		332	CFDictionaryAddValue(defaults, CFSTR(WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey), kCFBooleanFalse);
		333
332	defaultSettings = defaults;	334	defaultSettings = defaults;
333	}	335	}
334		336
Lines 2199-2204 HRESULT WebPreferences::setCSSOMViewScrollingAPIEnabled(BOOL enabled) a/Source/WebKitLegacy/win/WebPreferences.cpp_sec2
2199	return S_OK;	2201	return S_OK;
2200	}	2202	}
2201		2203
		2204	HRESULT WebPreferences::CSSOMViewSmoothScrollingEnabled(_Out_ BOOL* enabled)
		2205	{
		2206	if (!enabled)
		2207	return E_POINTER;
		2208	*enabled = boolValueForKey(WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey);
		2209	return S_OK;
		2210	}
		2211
		2212	HRESULT WebPreferences::setCSSOMViewSmoothScrollingEnabled(BOOL enabled)
		2213	{
		2214	setBoolValue(WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey, enabled);
		2215	return S_OK;
		2216	}
		2217
2202	HRESULT WebPreferences::setApplicationId(BSTR applicationId)	2218	HRESULT WebPreferences::setApplicationId(BSTR applicationId)
2203	{	2219	{
2204	m_applicationId = String(applicationId).createCFString();	2220	m_applicationId = String(applicationId).createCFString();

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 5284-5289 HRESULT WebView::notifyPreferencesChanged(IWebNotification* notification) a/Source/WebKitLegacy/win/WebView.cpp_sec1
- a/Source/WebKitLegacy/win/WebView.cpp +5 lines
5284	return hr;	5284	return hr;
5285	settings.setCSSOMViewScrollingAPIEnabled(!!enabled);	5285	settings.setCSSOMViewScrollingAPIEnabled(!!enabled);
5286		5286
		5287	hr = prefsPrivate->CSSOMViewSmoothScrollingEnabled(&enabled);
		5288	if (FAILED(hr))
		5289	return hr;
		5290	settings.setCSSOMViewSmoothScrollingEnabled(!!enabled);
		5291
5287	hr = preferences->privateBrowsingEnabled(&enabled);	5292	hr = preferences->privateBrowsingEnabled(&enabled);
5288	if (FAILED(hr))	5293	if (FAILED(hr))
5289	return hr;	5294	return hr;



2018-11-06  Frederic Wang  <fwang@igalia.com>

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

        * 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.

2018-11-08  Said Abou-Hallawa  <sabouhallawa@apple.com>

onal supported image formats

Lines 109-114 TestOptions::TestOptions(const std::string& pathOrURL, const std::string& absolu a/Tools/DumpRenderTree/TestOptions.cpp_sec1
- a/Tools/DumpRenderTree/TestOptions.cpp +2 lines
109	jscOptions = value;	109	jscOptions = value;
110	else if (key == "experimental:WebGPUEnabled")	110	else if (key == "experimental:WebGPUEnabled")
111	enableWebGPU = parseBooleanTestHeaderValue(value);	111	enableWebGPU = parseBooleanTestHeaderValue(value);
		112	else if (key == "experimental:CSSOMViewSmoothScrollingEnabled")
		113	enableCSSOMViewSmoothScrolling = parseBooleanTestHeaderValue(value);
112	pairStart = pairEnd + 1;	114	pairStart = pairEnd + 1;
113	}	115	}
114	}	116	}

Lines 45-50 struct TestOptions { a/Tools/DumpRenderTree/TestOptions.h_sec1
- a/Tools/DumpRenderTree/TestOptions.h +1 lines
45	bool enableColorFilter { false };	45	bool enableColorFilter { false };
46	bool enableSelectionAcrossShadowBoundaries { true };	46	bool enableSelectionAcrossShadowBoundaries { true };
47	bool enableWebGPU { false };	47	bool enableWebGPU { false };
		48	bool enableCSSOMViewSmoothScrolling { false };
48	std::string jscOptions;	49	std::string jscOptions;
49		50
50	TestOptions(const std::string& pathOrURL, const std::string& absolutePath);	51	TestOptions(const std::string& pathOrURL, const std::string& absolutePath);

Lines 1012-1017 static void setWebPreferencesForTestOptions(const TestOptions& options) a/Tools/DumpRenderTree/mac/DumpRenderTree.mm_sec1
- a/Tools/DumpRenderTree/mac/DumpRenderTree.mm +1 lines
1012	preferences.colorFilterEnabled = options.enableColorFilter;	1012	preferences.colorFilterEnabled = options.enableColorFilter;
1013	preferences.selectionAcrossShadowBoundariesEnabled = options.enableSelectionAcrossShadowBoundaries;	1013	preferences.selectionAcrossShadowBoundariesEnabled = options.enableSelectionAcrossShadowBoundaries;
1014	preferences.webGPUEnabled = options.enableWebGPU;	1014	preferences.webGPUEnabled = options.enableWebGPU;
		1015	preferences.CSSOMViewSmoothScrollingEnabled = options.enableCSSOMViewSmoothScrolling;
1015	}	1016	}
1016		1017
1017	// Called once on DumpRenderTree startup.	1018	// Called once on DumpRenderTree startup.



2018-11-07  Frederic Wang  <fwang@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!).

        * platform/mac-wk1/TestExpectations: Skip these tests on WK1 as they don't work for now and
        are slow anyway.

2018-11-08  Megan Gardner  <megan_gardner@apple.com>

        Adopt Reveal Framework to replace Lookup



2018-11-06  Frederic Wang  <fwang@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!).

        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:

2018-11-08  Andy Estes  <aestes@apple.com>

        [Payment Request] Update web platform tests

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	<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-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 / +3 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	FAIL scrollIntoView with nested elements with different scroll-behavior assert_equals: Element with instant behavior should jump to the final position expected 0 but got 1000
		3
		4	assert_equals: Element with instant behavior should jump to the final position expected 500 but got 1000
3		5

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 640-645 imported/w3c/web-platform-tests/css/css-properties-values-api/ [ Skip ] a/LayoutTests/platform/mac-wk1/TestExpectations_sec1
- a/LayoutTests/platform/mac-wk1/TestExpectations +6 lines
640	css-custom-properties-api [ Skip ]	640	css-custom-properties-api [ Skip ]
641	css-dark-mode [ Skip ]	641	css-dark-mode [ Skip ]
642		642
		643	# Tests for smooth scroll behavior do not all work and they are slow, so let's just skip them.
		644	webkit.org/b/191357 imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html [ Skip ]
		645	webkit.org/b/191357 imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html [ Skip ]
		646	webkit.org/b/191357 imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html [ Skip ]
		647	webkit.org/b/191357 imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html [ Skip ]
		648
643	webkit.org/b/189908 imported/w3c/web-platform-tests/resource-timing/resource_timing.worker.html [ Failure ]	649	webkit.org/b/189908 imported/w3c/web-platform-tests/resource-timing/resource_timing.worker.html [ Failure ]
644		650
645	webkit.org/b/189756 [ Mojave+ ] compositing/filters/opacity-change-on-filtered-paints-into-ancestor.html [ Pass ImageOnlyFailure ]	651	webkit.org/b/189756 [ Mojave+ ] compositing/filters/opacity-change-on-filtered-paints-into-ancestor.html [ Pass ImageOnlyFailure ]

Return to Bug 188043

Lines 6257-6262 a/Source/WebCore/css/CSSProperties.json_sec1
- a/Source/WebCore/css/CSSProperties.json +16 lines
6257	"url": "https://www.w3.org/TR/css-ui-4/#propdef-user-select"	6257	"url": "https://www.w3.org/TR/css-ui-4/#propdef-user-select"
6258	}	6258	}
6259	},	6259	},
		6260	"scroll-behavior": {
		6261	"values": [
		6262	"auto",
		6263	"smooth"
		6264	],
		6265	"codegen-properties": {
		6266	"converter": "SmoothScrolling",
		6267	"name-for-methods": "UseSmoothScrolling"
		6268	},
		6269	"status": {
		6270	"status": "experimental"
		6271	},
		6272	"specification": {
		6273	"url": "https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior"
		6274	}
		6275	},
6260	"scroll-padding": {	6276	"scroll-padding": {
6261	"codegen-properties": {	6277	"codegen-properties": {
6262	"enable-if": "ENABLE_CSS_SCROLL_SNAP",	6278	"enable-if": "ENABLE_CSS_SCROLL_SNAP",

Lines 621-630 bool CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyID propertyId a/Source/WebCore/css/parser/CSSParserFastPaths.cpp_sec1
- a/Source/WebCore/css/parser/CSSParserFastPaths.cpp -5 lines
621	return valueID == CSSValueStatic \|\| valueID == CSSValueRelative \|\| valueID == CSSValueAbsolute \|\| valueID == CSSValueFixed \|\| valueID == CSSValueWebkitSticky;	621	return valueID == CSSValueStatic \|\| valueID == CSSValueRelative \|\| valueID == CSSValueAbsolute \|\| valueID == CSSValueFixed \|\| valueID == CSSValueWebkitSticky;
622	case CSSPropertyResize: // none \| both \| horizontal \| vertical \| auto	622	case CSSPropertyResize: // none \| both \| horizontal \| vertical \| auto
623	return valueID == CSSValueNone \|\| valueID == CSSValueBoth \|\| valueID == CSSValueHorizontal \|\| valueID == CSSValueVertical \|\| valueID == CSSValueAuto;	623	return valueID == CSSValueNone \|\| valueID == CSSValueBoth \|\| valueID == CSSValueHorizontal \|\| valueID == CSSValueVertical \|\| valueID == CSSValueAuto;
624	// FIXME-NEWPARSER: Investigate this property.
625	// case CSSPropertyScrollBehavior: // auto \| smooth
626	// ASSERT(RuntimeEnabledFeatures::cssomSmoothScrollEnabled());
627	// return valueID == CSSValueAuto \|\| valueID == CSSValueSmooth;
628	case CSSPropertyShapeRendering:	624	case CSSPropertyShapeRendering:
629	return valueID == CSSValueAuto \|\| valueID == CSSValueOptimizeSpeed \|\| valueID == CSSValueCrispedges \|\| valueID == CSSValueGeometricPrecision;	625	return valueID == CSSValueAuto \|\| valueID == CSSValueOptimizeSpeed \|\| valueID == CSSValueCrispedges \|\| valueID == CSSValueGeometricPrecision;
630	case CSSPropertyStrokeLinejoin:	626	case CSSPropertyStrokeLinejoin:
Lines 926-932 bool CSSParserFastPaths::isKeywordPropertyID(CSSPropertyID propertyId) a/Source/WebCore/css/parser/CSSParserFastPaths.cpp_sec2
926	// case CSSPropertyFontKerning:	922	// case CSSPropertyFontKerning:
927	// case CSSPropertyHyphens:	923	// case CSSPropertyHyphens:
928	// case CSSPropertyOverflowAnchor:	924	// case CSSPropertyOverflowAnchor:
929	// case CSSPropertyScrollBehavior:
930	// case CSSPropertyScrollSnapType:	925	// case CSSPropertyScrollSnapType:
931	// case CSSPropertyTextAlignLast:	926	// case CSSPropertyTextAlignLast:
932	// case CSSPropertyTextCombineUpright:	927	// case CSSPropertyTextCombineUpright:

Lines 1542-1548 double DOMWindow::devicePixelRatio() const a/Source/WebCore/page/DOMWindow.cpp_sec1
- a/Source/WebCore/page/DOMWindow.cpp -4 / +10 lines
1542		1542
1543	void DOMWindow::scrollBy(double x, double y) const	1543	void DOMWindow::scrollBy(double x, double y) const
1544	{	1544	{
1545	scrollBy({ x, y });	1545	return scrollBy(fromCoordinates(x, y));
1546	}	1546	}
1547		1547
1548	void DOMWindow::scrollBy(const ScrollToOptions& options) const	1548	void DOMWindow::scrollBy(const ScrollToOptions& options) const
Lines 1564-1573 void DOMWindow::scrollBy(const ScrollToOptions& options) const a/Source/WebCore/page/DOMWindow.cpp_sec2
1564		1564
1565	void DOMWindow::scrollTo(double x, double y, ScrollClamping clamping) const	1565	void DOMWindow::scrollTo(double x, double y, ScrollClamping clamping) const
1566	{	1566	{
1567	scrollTo({ x, y }, clamping);	1567	return scrollTo(fromCoordinates(x, y), clamping);
1568	}	1568	}
1569		1569
1570	void DOMWindow::scrollTo(const ScrollToOptions& options, ScrollClamping) const	1570	void DOMWindow::scrollTo(const ScrollToOptions& options, ScrollClamping clamping) const
1571	{	1571	{
1572	if (!isCurrentlyDisplayedInFrame())	1572	if (!isCurrentlyDisplayedInFrame())
1573	return;	1573	return;
Lines 1580-1591 void DOMWindow::scrollTo(const ScrollToOptions& options, ScrollClamping) const a/Source/WebCore/page/DOMWindow.cpp_sec3
1580	view->contentsScrollPosition().x(), view->contentsScrollPosition().y()	1580	view->contentsScrollPosition().x(), view->contentsScrollPosition().y()
1581	);	1581	);
1582		1582
1583	if (!scrollToOptions.left.value() && !scrollToOptions.top.value() && view->contentsScrollPosition() == IntPoint(0, 0))	1583	if (!view->isScrollInProgress() && !scrollToOptions.left.value() && !scrollToOptions.top.value() && view->contentsScrollPosition() == IntPoint(0, 0))
1584	return;	1584	return;
1585		1585
1586	document()->updateLayoutIgnorePendingStylesheets();	1586	document()->updateLayoutIgnorePendingStylesheets();
1587		1587
1588	IntPoint layoutPos(view->mapFromCSSToLayoutUnits(scrollToOptions.left.value()), view->mapFromCSSToLayoutUnits(scrollToOptions.top.value()));	1588	IntPoint layoutPos(view->mapFromCSSToLayoutUnits(scrollToOptions.left.value()), view->mapFromCSSToLayoutUnits(scrollToOptions.top.value()));
		1589	// FIXME: Should we use document()->scrollingElement()?
		1590	// See https://github.com/w3c/csswg-drafts/issues/2977
		1591	if (document()->documentElement() && useSmoothScrolling(scrollToOptions.behavior.value_or(ScrollBehavior::Auto), *document()->documentElement())) {
		1592	view->scrollToOffsetWithAnimation(layoutPos, clamping);
		1593	return;
		1594	}
1589	view->setContentsScrollPosition(layoutPos);	1595	view->setContentsScrollPosition(layoutPos);
1590	}	1596	}
1591		1597

Lines 1190-1196 VideoQualityIncludesDisplayCompositingEnabled: a/Source/WebKit/Shared/WebPreferences.yaml_sec1
- a/Source/WebKit/Shared/WebPreferences.yaml -1 / +7 lines
1190	# DEFAULT_EXPERIMENTAL_FEATURES_ENABLED (for features that are ready for	1190	# DEFAULT_EXPERIMENTAL_FEATURES_ENABLED (for features that are ready for
1191	# wider testing).	1191	# wider testing).
1192		1192
1193
1194	SpringTimingFunctionEnabled:	1193	SpringTimingFunctionEnabled:
1195	type: bool	1194	type: bool
1196	defaultValue: DEFAULT_EXPERIMENTAL_FEATURES_ENABLED	1195	defaultValue: DEFAULT_EXPERIMENTAL_FEATURES_ENABLED
Lines 1237-1242 CSSOMViewScrollingAPIEnabled: a/Source/WebKit/Shared/WebPreferences.yaml_sec2
1237	humanReadableDescription: "Implement standard behavior for scrollLeft, scrollTop, scrollWidth, scrollHeight, scrollTo, scrollBy and scrollingElement."	1236	humanReadableDescription: "Implement standard behavior for scrollLeft, scrollTop, scrollWidth, scrollHeight, scrollTo, scrollBy and scrollingElement."
1238	category: experimental	1237	category: experimental
1239		1238
		1239	CSSOMViewSmoothScrollingEnabled:
		1240	type: bool
		1241	defaultValue: false
		1242	humanReadableName: "CSSOM View Smooth Scrolling"
		1243	humanReadableDescription: "Enable DOM API and CSS property for 'smooth' scroll behavior"
		1244	category: experimental
		1245
1240	WebAnimationsEnabled:	1246	WebAnimationsEnabled:
1241	type: bool	1247	type: bool
1242	defaultValue: true	1248	defaultValue: true

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +151 lines
		1	2018-11-09 Frederic Wang <fwang@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	This patch introduces a programmatic smooth scrolling in WebKit from the CSSOM View
		9	specification [1]. To use this effect, web developers can pass a behavior parameter (auto,
		10	smooth, or instant) to Element.scroll, Element.scrollTo, Element.scrollBy,
		11	Element.scrollIntoView, Window.scroll, Window.scrollTo or Window.scrollBy [2]. When behavior
		12	is auto, the instant/smooth characteristic is actually taken from the value of a new CSS
		13	scroll-behavior property [3]. Both the new CSS and DOM behavior are protected by a runtime
		14	flag. The Element.scrollIntoView part will be refined later in bug 189907. The actual
		15	animation relies on the existing ScrollAnimationSmooth.
		16
		17	[1] https://drafts.csswg.org/cssom-view
		18	[2] https://drafts.csswg.org/cssom-view/#dictdef-scrolloptions
		19	[3] https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior
		20
		21	Add support for ScrollOptions' ScrollBehavior and CSS scroll-behavior properties
		22
		23	Tests: imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-default-css.html
		24	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-element.html
		25	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html
		26	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html
		27	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested.html
		28	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-smooth-positions.html
		29	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html
		30	imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html
		31
		32	* CMakeLists.txt: Add IDL files for ScrollOptions and ScrollBehavior.
		33	* DerivedSources.make: Ditto.
		34	* Sources.txt: Add ScrollBehavor and ScrollOptions implementation. Also build
		35	ScrollAnimationSmooth.cpp on all platforms.
		36	* SourcesGTK.txt: Remove ScrollAnimationSmooth.cpp since it is built on all platforms now.
		37	* WebCore.xcodeproj/project.pbxproj: Add files to the build system.
		38	* css/CSSComputedStyleDeclaration.cpp: Handle scroll-behavior.
		39	(WebCore::ComputedStyleExtractor::valueForPropertyinStyle):
		40	* css/CSSProperties.json: Add scroll-behavior.
		41	* css/CSSValueKeywords.in: Add keywords for scroll-behavior.
		42	* css/StyleBuilderConverter.h:
		43	(WebCore::StyleBuilderConverter::convertSmoothScrolling): New function to convert
		44	scroll-behavior into a "is smooth" boolean.
		45	* css/parser/CSSParserContext.cpp: Add runtime config for scroll-behavior.
		46	(WebCore::CSSParserContext::CSSParserContext):
		47	(WebCore::operator==):
		48	* css/parser/CSSParserContext.h: Ditto.
		49	(WebCore::CSSParserContextHash::hash):
		50	* css/parser/CSSParserFastPaths.cpp: Remove scroll-behavior templates. It is handled in the
		51	slow path since property can be disabled.
		52	(WebCore::CSSParserFastPaths::isValidKeywordPropertyAndValue):
		53	(WebCore::CSSParserFastPaths::isKeywordPropertyID):
		54	* css/parser/CSSPropertyParser.cpp:
		55	(WebCore::CSSPropertyParser::parseSingleValue): Parse scroll-behavior (only if enabled).
		56	* dom/Element.cpp:
		57	(WebCore::Element::scrollIntoView): Pass scroll behavior, if any.
		58	(WebCore::Element::scrollBy): Use fromCoordinates helper function.
		59	(WebCore::Element::scrollTo): Handle the case when scroll behavior is smooth. Use
		60	fromCoordinates helper function.
		61	* page/DOMWindow.cpp:
		62	(WebCore::DOMWindow::scrollBy const): Use fromCoordinates helper function.
		63	(WebCore::DOMWindow::scrollTo const): Use fromCoordinates helper function. Handle the case
		64	when scroll behavior is smooth. The optimization when scroll position is (0, 0) is skipped
65	when a scroll is in progress, otherwise such a scroll can't be cancelled by a follow-up
66	scroll.
67	* page/ScrollBehavior.cpp: Added.
68	(WebCore::useSmoothScrolling): Helper funciton to determine the scroll behavior to apply to
69	an element from the CSS and DOM behavior.
70	* page/ScrollBehavior.h: Added.
71	* page/ScrollBehavior.idl: Added.
72	* page/ScrollIntoViewOptions.h: Make this class inherits from ScrollOption. Also remove
73	unnecessary forward declaration.
74	* page/ScrollIntoViewOptions.idl: Make this class inherits from ScrollOption.
75	* page/ScrollOptions.h: Added.
76	* page/ScrollOptions.idl: Added.
77	* page/ScrollToOptions.h: Make this struct inherits from ScrollOptions.
78	(WebCore::fromCoordinates): New helper function to generate a ScrollToOptions with undefined
79	behavior. This is necessary to replace curly brace { x, y } declarations now that there is
80	an extra behavior member from the parent class.
81	(WebCore::normalizeNonFiniteCoordinatesOrFallBackTo): Copy the current ScrollToOptions so
82	that the scroll behavior is preserved.
83	* page/ScrollToOptions.idl: Make this class inherit from ScrollOptions.
84	* page/Settings.yaml: New setting for CSSOM View smooth scrolling.
85	* platform/ScrollAnimation.h:
86	(WebCore::ScrollAnimation::scroll): Function to animate scrolling to a specified position.
87	(WebCore::ScrollAnimation::isScrollInProgress const):
88	* platform/ScrollAnimationKinetic.cpp:
89	(WebCore::ScrollAnimationKinetic::isScrollInProgress const):
90	* platform/ScrollAnimationKinetic.h:
91	* platform/ScrollAnimationSmooth.cpp: Build this file on all platforms. Add a
92	smoothFactorForProgrammaticScroll parameter to slow down the smooth scrolling.
93	(WebCore::ScrollAnimationSmooth::scroll):
94	(WebCore::ScrollAnimationSmooth::updatePerAxisData): Scale the time parameters of the
95	animation so that it looks smoother.
96	* platform/ScrollAnimationSmooth.h: Declare the class on all platforms.
97	* platform/ScrollAnimator.cpp:
98	(WebCore::ScrollAnimator::ScrollAnimator): Initialize animation member for programmatic scrolling.
99	(WebCore::ScrollAnimator::isScrollInProgress const): For now, only claims scroll is in
100	progress if smooth programmatic scroll is in progress.
101	(WebCore::ScrollAnimator::scrollToOffset): Animate scrolling to the specified position.
102	(WebCore::ScrollAnimator::cancelAnimations): Copy logic from ScrollAnimationSmooth.cpp.
103	(WebCore::ScrollAnimator::serviceScrollAnimations): Ditto.
104	(WebCore::ScrollAnimator::willEndLiveResize): Ditto.
105	(WebCore::ScrollAnimator::didAddVerticalScrollbar): Ditto.
106	(WebCore::ScrollAnimator::didAddHorizontalScrollbar): Ditto.
107	* platform/ScrollAnimator.h: New animation member for smooth programmatic scrolling.
108	* platform/ScrollAnimatorMac.mm:
109	(WebCore::ScrollAnimatorSmooth::cancelAnimations): Call parent member to handle programmatic scrolling.
110	* platform/ScrollAnimatorSmooth.cpp:
111	(WebCore::ScrollAnimatorSmooth::scroll): Call parent member to handle programmatic scrolling.
112	(WebCore::ScrollAnimatorSmooth::cancelAnimations): Ditto.
113	(WebCore::ScrollAnimatorSmooth::serviceScrollAnimations): Ditto.
114	(WebCore::ScrollAnimatorSmooth::willEndLiveResize): Ditto.
115	(WebCore::ScrollAnimatorSmooth::didAddVerticalScrollbar): Ditto.
116	(WebCore::ScrollAnimatorSmooth::didAddHorizontalScrollbar): Ditto.
117	* platform/ScrollView.cpp:
118	(WebCore::ScrollView::setScrollPosition): Follow the CSSOM View spec: If a scroll is in
119	progress, we interrupt it and continue the scroll call (even when we are at the final
120	position).
121	* platform/ScrollableArea.cpp:
122	(WebCore::ScrollableArea::isScrollInProgress const): Helper function to check whether scroll
123	is in progress on the animator. If m_scrollAnimator does not exist we don't construct it.
124	(WebCore::ScrollableArea::scrollToOffsetWithAnimation):
125	* platform/ScrollableArea.h:
126	* rendering/RenderBox.cpp:
127	(WebCore::RenderBox::scrollToPositionWithAnimation): Similar to setScrollTop/setScrollLeft
128	but animate the scrolling.
129	* rendering/RenderBox.h:
130	* rendering/RenderLayer.cpp:
131	(WebCore::RenderLayer::scrollToOffset): Follow the CSSOM View spec: If a scroll is in
132	progress, we interrupt it and continue the scroll call (even when we are at the final
133	position).
134	(WebCore::RenderLayer::scrollToOffsetWithAnimation): Ditto. This is similar to scrollToOffset
135	but animates the scroll.
136	(WebCore::RenderLayer::scrollRectToVisible): Again don't do an early return if scroll is in
137	progress. We call scrollToOffsetWithAnimation instead of scrollToOffset when appropriate.
138	Note that this function may not work well for several nested scroll boxes with at least one
139	element with smooth behavior. It will handled in bug Follow.
140	* rendering/RenderLayer.h: Add scroll behavior to ScrollTectToVisibleOptions.
141	* rendering/style/RenderStyle.h: Handle 'smooth scrolling' boolean data.
142	(WebCore::RenderStyle::useSmoothScrolling const):
143	(WebCore::RenderStyle::setUseSmoothScrolling):
144	(WebCore::RenderStyle::initialUseSmoothScrolling):
145	* rendering/style/StyleRareNonInheritedData.cpp: Ditto.
146	(WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
147	(WebCore::StyleRareNonInheritedData::operator== const):
148	* rendering/style/StyleRareNonInheritedData.h: Ditto.
149	* testing/Internals.cpp:
150	(WebCore::Internals::unconstrainedScrollTo): Use fromCoordinates helper function.
151
1	2018-11-08 Said Abou-Hallawa <sabouhallawa@apple.com>	152	2018-11-08 Said Abou-Hallawa <sabouhallawa@apple.com>
2		153
3	Add an SPI to allow WebView clients to add additional supported image formats	154	Add an SPI to allow WebView clients to add additional supported image formats

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +11 lines
		1	2018-11-06 Frederic Wang <fwang@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	Add CSSOM smooth scrolling as an experimental feature.
		9
		10	* Shared/WebPreferences.yaml:
		11
1	2018-11-08 Wenson Hsieh <wenson_hsieh@apple.com>	12	2018-11-08 Wenson Hsieh <wenson_hsieh@apple.com>
2		13
3	Unreviewed, try to fix the 32-bit macOS build	14	Unreviewed, try to fix the 32-bit macOS build

Lines 1-3 a/Source/WebKitLegacy/mac/ChangeLog_sec1
- a/Source/WebKitLegacy/mac/ChangeLog +17 lines
		1	2018-11-07 Frederic Wang <fwang@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	* WebView/WebPreferenceKeysPrivate.h: Handle CSSOMViewSmoothScrolling by.
		9	* WebView/WebPreferencesPrivate.h: Ditto.
		10	* WebView/WebView.mm:
		11	(-[WebView _preferencesChanged:]): Ditto.
		12
		13	* WebView/WebPreferences.mm:
		14	(+[WebPreferences initialize]): Disable CSSOMViewSmoothScrolling by default.
		15	(-[WebPreferences CSSOMViewSmoothScrollingEnabled]): Getter.
		16	(-[WebPreferences setCSSOMViewSmoothScrollingEnabled:]): Setter.
		17
1	2018-11-08 Megan Gardner <megan_gardner@apple.com>	18	2018-11-08 Megan Gardner <megan_gardner@apple.com>
2		19
3	Adopt Reveal Framework to replace Lookup	20	Adopt Reveal Framework to replace Lookup

Lines 1-3 a/Source/WebKitLegacy/win/ChangeLog_sec1
- a/Source/WebKitLegacy/win/ChangeLog +17 lines
		1	2018-11-07 Frederic Wang <fwang@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	* Interfaces/IWebPreferencesPrivate.idl: Handle smooth scrolling option.
		9	* WebPreferenceKeysPrivate.h: Ditto.
		10	* WebPreferences.cpp: Ditto.
		11	(WebPreferences::initializeDefaultSettings):
		12	(WebPreferences::CSSOMViewSmoothScrollingEnabled):
		13	(WebPreferences::setCSSOMViewSmoothScrollingEnabled):
		14	* WebPreferences.h: Ditto.
		15	* WebView.cpp: Ditto.
		16	(WebView::notifyPreferencesChanged):
		17
1	2018-11-01 Sihui Liu <sihui_liu@apple.com>	18	2018-11-01 Sihui Liu <sihui_liu@apple.com>
2		19
3	Add a storage limit for IndexedDB	20	Add a storage limit for IndexedDB

Lines 887-894 set(WebCore_NON_SVG_IDL_FILES a/Source/WebCore/CMakeLists.txt_sec1
- a/Source/WebCore/CMakeLists.txt +2 lines
887	page/PerformanceTiming.idl	887	page/PerformanceTiming.idl
888	page/RemoteDOMWindow.idl	888	page/RemoteDOMWindow.idl
889	page/Screen.idl	889	page/Screen.idl
		890	page/ScrollBehavior.idl
890	page/ScrollIntoViewOptions.idl	891	page/ScrollIntoViewOptions.idl
891	page/ScrollLogicalPosition.idl	892	page/ScrollLogicalPosition.idl
		893	page/ScrollOptions.idl
892	page/ScrollToOptions.idl	894	page/ScrollToOptions.idl
893	page/ShareData.idl	895	page/ShareData.idl
894	page/VisualViewport.idl	896	page/VisualViewport.idl

Lines 843-850 JS_BINDING_IDLS = \ a/Source/WebCore/DerivedSources.make_sec1
- a/Source/WebCore/DerivedSources.make +2 lines
843	$(WebCore)/page/PerformanceTiming.idl \	843	$(WebCore)/page/PerformanceTiming.idl \
844	$(WebCore)/page/RemoteDOMWindow.idl \	844	$(WebCore)/page/RemoteDOMWindow.idl \
845	$(WebCore)/page/Screen.idl \	845	$(WebCore)/page/Screen.idl \
		846	$(WebCore)/page/ScrollBehavior.idl \
846	$(WebCore)/page/ScrollIntoViewOptions.idl \	847	$(WebCore)/page/ScrollIntoViewOptions.idl \
847	$(WebCore)/page/ScrollLogicalPosition.idl \	848	$(WebCore)/page/ScrollLogicalPosition.idl \
		849	$(WebCore)/page/ScrollOptions.idl \
848	$(WebCore)/page/ScrollToOptions.idl \	850	$(WebCore)/page/ScrollToOptions.idl \
849	$(WebCore)/page/ShareData.idl \	851	$(WebCore)/page/ShareData.idl \
850	$(WebCore)/page/UserMessageHandler.idl \	852	$(WebCore)/page/UserMessageHandler.idl \

Lines 1463-1468 page/ResourceUsageOverlay.cpp a/Source/WebCore/Sources.txt_sec1
- a/Source/WebCore/Sources.txt +4 lines
1463	page/ResourceUsageThread.cpp	1463	page/ResourceUsageThread.cpp
1464	page/RuntimeEnabledFeatures.cpp	1464	page/RuntimeEnabledFeatures.cpp
1465	page/Screen.cpp	1465	page/Screen.cpp
		1466	page/ScrollBehavior.cpp
1466	page/SecurityOrigin.cpp	1467	page/SecurityOrigin.cpp
1467	page/SecurityOriginData.cpp	1468	page/SecurityOriginData.cpp
1468	page/SecurityPolicy.cpp	1469	page/SecurityPolicy.cpp
Lines 1561-1566 platform/RuntimeApplicationChecks.cpp a/Source/WebCore/Sources.txt_sec2
1561	platform/SSLKeyGenerator.cpp	1562	platform/SSLKeyGenerator.cpp
1562	platform/SchemeRegistry.cpp	1563	platform/SchemeRegistry.cpp
1563	platform/ScrollAnimator.cpp	1564	platform/ScrollAnimator.cpp
		1565	platform/ScrollAnimationSmooth.cpp
1564	platform/ScrollView.cpp	1566	platform/ScrollView.cpp
1565	platform/ScrollableArea.cpp	1567	platform/ScrollableArea.cpp
1566	platform/Scrollbar.cpp	1568	platform/Scrollbar.cpp
Lines 3141-3148 JSSVGZoomEvent.cpp a/Source/WebCore/Sources.txt_sec3
3141	JSScreen.cpp	3143	JSScreen.cpp
3142	JSScreenLuminance.cpp	3144	JSScreenLuminance.cpp
3143	JSScriptProcessorNode.cpp	3145	JSScriptProcessorNode.cpp
		3146	JSScrollBehavior.cpp
3144	JSScrollIntoViewOptions.cpp	3147	JSScrollIntoViewOptions.cpp
3145	JSScrollLogicalPosition.cpp	3148	JSScrollLogicalPosition.cpp
		3149	JSScrollOptions.cpp
3146	JSScrollToOptions.cpp	3150	JSScrollToOptions.cpp
3147	JSSecurityPolicyViolationEvent.cpp	3151	JSSecurityPolicyViolationEvent.cpp
3148	JSServiceWorker.cpp	3152	JSServiceWorker.cpp

Lines 2381-2386 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj +28 lines
2381	83407FC11E8D9C1700E048D3 /* VisibilityChangeClient.h in Headers / = {isa = PBXBuildFile; fileRef = 83407FC01E8D9C1200E048D3 / VisibilityChangeClient.h */; settings = {ATTRIBUTES = (Private, ); }; };	2381	83407FC11E8D9C1700E048D3 /* VisibilityChangeClient.h in Headers / = {isa = PBXBuildFile; fileRef = 83407FC01E8D9C1200E048D3 / VisibilityChangeClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
2382	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8D4 / JSScrollLogicalPosition.h */; };	2382	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8D4 / JSScrollLogicalPosition.h */; };
2383	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8E5 / JSScrollIntoViewOptions.h */; };	2383	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8E5 / JSScrollIntoViewOptions.h */; };
		2384	834476EF1DA5BC5E002B6EB0 /* JSScrollBehavior.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8D4 / JSScrollBehavior.h */; };
		2385	834476EF1DA5BC5E002B6EC1 /* JSScrollOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8E5 / JSScrollOptions.h */; };
2384	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8F6 / JSScrollToOptions.h */; };	2386	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8F6 / JSScrollToOptions.h */; };
2385	8348BFAC1B85729800912F36 /* ClassCollection.h in Headers / = {isa = PBXBuildFile; fileRef = 8348BFAA1B85729500912F36 / ClassCollection.h */; };	2387	8348BFAC1B85729800912F36 /* ClassCollection.h in Headers / = {isa = PBXBuildFile; fileRef = 8348BFAA1B85729500912F36 / ClassCollection.h */; };
2386	834DFAD01F7DAE5D00C2725B /* SharedStringHash.h in Headers / = {isa = PBXBuildFile; fileRef = 834DFACC1F7DAE5600C2725B / SharedStringHash.h */; settings = {ATTRIBUTES = (Private, ); }; };	2388	834DFAD01F7DAE5D00C2725B /* SharedStringHash.h in Headers / = {isa = PBXBuildFile; fileRef = 834DFACC1F7DAE5600C2725B / SharedStringHash.h */; settings = {ATTRIBUTES = (Private, ); }; };
Lines 2455-2460 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
2455	83C45B8E1DC2B68A008871BA /* ValidationBubble.h in Headers / = {isa = PBXBuildFile; fileRef = 83C45B8D1DC2B67C008871BA / ValidationBubble.h */; settings = {ATTRIBUTES = (Private, ); }; };	2457	83C45B8E1DC2B68A008871BA /* ValidationBubble.h in Headers / = {isa = PBXBuildFile; fileRef = 83C45B8D1DC2B67C008871BA / ValidationBubble.h */; settings = {ATTRIBUTES = (Private, ); }; };
2456	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355424 / ScrollLogicalPosition.h */; settings = {ATTRIBUTES = (Private, ); }; };	2458	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355424 / ScrollLogicalPosition.h */; settings = {ATTRIBUTES = (Private, ); }; };
2457	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355435 / ScrollIntoViewOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };	2459	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355435 / ScrollIntoViewOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
		2460	83C5795D1DA5C301006FAC86 /* ScrollBehavior.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356424 / ScrollBehavior.h */; settings = {ATTRIBUTES = (Private, ); }; };
		2461	83C5795D1DA5C301006FAC97 /* ScrollOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356435 / ScrollOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
2458	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356446 / ScrollToOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };	2462	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356446 / ScrollToOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
2459	83D35AEC1C7187FA00F70D5A /* XMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AEA1C7187ED00F70D5A / XMLHttpRequestEventTarget.h */; };	2463	83D35AEC1C7187FA00F70D5A /* XMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AEA1C7187ED00F70D5A / XMLHttpRequestEventTarget.h */; };
2460	83D35AF21C718D9000F70D5A /* JSXMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AF01C718D8400F70D5A / JSXMLHttpRequestEventTarget.h */; };	2464	83D35AF21C718D9000F70D5A /* JSXMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AF01C718D8400F70D5A / JSXMLHttpRequestEventTarget.h */; };
Lines 9993-9998 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
9993	834DFACE1F7DAE5700C2725B /* SharedStringHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedStringHash.cpp; sourceTree = "<group>"; };	9997	834DFACE1F7DAE5700C2725B /* SharedStringHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedStringHash.cpp; sourceTree = "<group>"; };
9994	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollLogicalPosition.h; sourceTree = "<group>"; };	9998	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollLogicalPosition.h; sourceTree = "<group>"; };
9995	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollIntoViewOptions.h; sourceTree = "<group>"; };	9999	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollIntoViewOptions.h; sourceTree = "<group>"; };
		10000	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollIntoViewOptions.idl; sourceTree = "<group>"; };
		10001	8350C3E71DA59B6200356424 /* ScrollBehavior.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollBehavior.h; sourceTree = "<group>"; };
		10002	8350C3E71DA59B6200356434 /* ScrollBehavior.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollBehavior.cpp; sourceTree = "<group>"; };
		10003	8350C3E81DA59B6200356424 /* ScrollBehavior.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollBehavior.idl; sourceTree = "<group>"; };
		10004	8350C3E71DA59B6200356435 /* ScrollOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollOptions.h; sourceTree = "<group>"; };
		10005	8350C3E81DA59B6200356435 /* ScrollOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollOptions.idl; sourceTree = "<group>"; };
9996	8350C3E71DA59B6200356446 /* ScrollToOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollToOptions.h; sourceTree = "<group>"; };	10006	8350C3E71DA59B6200356446 /* ScrollToOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollToOptions.h; sourceTree = "<group>"; };
9997	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollLogicalPosition.idl; sourceTree = "<group>"; };	10007	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollLogicalPosition.idl; sourceTree = "<group>"; };
9998	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollIntoViewOptions.idl; sourceTree = "<group>"; };	10008	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollIntoViewOptions.idl; sourceTree = "<group>"; };
Lines 10134-10139 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
10134	83E959E11B8BC22B004D9385 /* NativeNodeFilter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeNodeFilter.h; sourceTree = "<group>"; };	10144	83E959E11B8BC22B004D9385 /* NativeNodeFilter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeNodeFilter.h; sourceTree = "<group>"; };
10135	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollLogicalPosition.cpp; sourceTree = "<group>"; };	10145	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollLogicalPosition.cpp; sourceTree = "<group>"; };
10136	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollIntoViewOptions.cpp; sourceTree = "<group>"; };	10146	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollIntoViewOptions.cpp; sourceTree = "<group>"; };
		10147	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollIntoViewOptions.h; sourceTree = "<group>"; };
		10148	83E9B3001DA5A51E00FFE8D4 /* JSScrollBehavior.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollBehavior.cpp; sourceTree = "<group>"; };
		10149	83E9B3011DA5A51E00FFE8D4 /* JSScrollBehavior.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollBehavior.h; sourceTree = "<group>"; };
		10150	83E9B3001DA5A51E00FFE8E5 /* JSScrollOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollOptions.cpp; sourceTree = "<group>"; };
		10151	83E9B3011DA5A51E00FFE8E5 /* JSScrollOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollOptions.h; sourceTree = "<group>"; };
10137	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollToOptions.cpp; sourceTree = "<group>"; };	10152	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollToOptions.cpp; sourceTree = "<group>"; };
10138	83E9B3011DA5A51E00FFD8D4 /* JSScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollLogicalPosition.h; sourceTree = "<group>"; };	10153	83E9B3011DA5A51E00FFD8D4 /* JSScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollLogicalPosition.h; sourceTree = "<group>"; };
10139	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollIntoViewOptions.h; sourceTree = "<group>"; };	10154	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollIntoViewOptions.h; sourceTree = "<group>"; };
Lines 19998-20007 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec5
19998	BCEC01BA0C274DAC009F4EC9 /* Screen.cpp */,	20013	BCEC01BA0C274DAC009F4EC9 /* Screen.cpp */,
19999	BCEC01BB0C274DAC009F4EC9 /* Screen.h */,	20014	BCEC01BB0C274DAC009F4EC9 /* Screen.h */,
20000	BCEC01BC0C274DAC009F4EC9 /* Screen.idl */,	20015	BCEC01BC0C274DAC009F4EC9 /* Screen.idl */,
		20016	8350C3E71DA59B6200356434 /* ScrollBehavior.cpp */,
		20017	8350C3E71DA59B6200356424 /* ScrollBehavior.h */,
		20018	8350C3E81DA59B6200356424 /* ScrollBehavior.idl */,
20001	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */,	20019	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */,
20002	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */,	20020	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */,
20003	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */,	20021	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */,
20004	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */,	20022	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */,
		20023	8350C3E71DA59B6200356435 /* ScrollOptions.h */,
		20024	8350C3E81DA59B6200356435 /* ScrollOptions.idl */,
20005	8350C3E71DA59B6200356446 /* ScrollToOptions.h */,	20025	8350C3E71DA59B6200356446 /* ScrollToOptions.h */,
20006	8350C3E81DA59B6200356446 /* ScrollToOptions.idl */,	20026	8350C3E81DA59B6200356446 /* ScrollToOptions.idl */,
20007	BCD0E0F70E972C3500265DEA /* SecurityOrigin.cpp */,	20027	BCD0E0F70E972C3500265DEA /* SecurityOrigin.cpp */,
Lines 24762-24771 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec6
24762	46C376612085176D00C73829 /* JSRemoteDOMWindow.h */,	24782	46C376612085176D00C73829 /* JSRemoteDOMWindow.h */,
24763	BCEC01C00C274DDD009F4EC9 /* JSScreen.cpp */,	24783	BCEC01C00C274DDD009F4EC9 /* JSScreen.cpp */,
24764	BCEC01C10C274DDD009F4EC9 /* JSScreen.h */,	24784	BCEC01C10C274DDD009F4EC9 /* JSScreen.h */,
		24785	83E9B3001DA5A51E00FFE8D4 /* JSScrollBehavior.cpp */,
		24786	83E9B3011DA5A51E00FFE8D4 /* JSScrollBehavior.h */,
24765	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */,	24787	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */,
24766	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */,	24788	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */,
24767	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */,	24789	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */,
24768	83E9B3011DA5A51E00FFD8D4 /* JSScrollLogicalPosition.h */,	24790	83E9B3011DA5A51E00FFD8D4 /* JSScrollLogicalPosition.h */,
		24791	83E9B3001DA5A51E00FFE8E5 /* JSScrollOptions.cpp */,
		24792	83E9B3011DA5A51E00FFE8E5 /* JSScrollOptions.h */,
24769	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */,	24793	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */,
24770	83E9B3011DA5A51E00FFE8F6 /* JSScrollToOptions.h */,	24794	83E9B3011DA5A51E00FFE8F6 /* JSScrollToOptions.h */,
24771	7C73FB0F191EF6F4007DE061 /* JSUserMessageHandler.cpp */,	24795	7C73FB0F191EF6F4007DE061 /* JSUserMessageHandler.cpp */,
Lines 29680-29687 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec7
29680	5E2C436C1BCF071E0001E2BC /* JSRTCTrackEvent.h in Headers */,	29704	5E2C436C1BCF071E0001E2BC /* JSRTCTrackEvent.h in Headers */,
29681	BCEC01C30C274DDD009F4EC9 /* JSScreen.h in Headers */,	29705	BCEC01C30C274DDD009F4EC9 /* JSScreen.h in Headers */,
29682	FDA15ECE12B03F61003A583A /* JSScriptProcessorNode.h in Headers */,	29706	FDA15ECE12B03F61003A583A /* JSScriptProcessorNode.h in Headers */,
		29707	834476EF1DA5BC5E002B6EB0 /* JSScrollBehavior.h in Headers */,
29683	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers */,	29708	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers */,
29684	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers */,	29709	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers */,
		29710	834476EF1DA5BC5E002B6EC1 /* JSScrollOptions.h in Headers */,
29685	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers */,	29711	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers */,
29686	CED06AD11C77754800FDFAF1 /* JSSecurityPolicyViolationEvent.h in Headers */,	29712	CED06AD11C77754800FDFAF1 /* JSSecurityPolicyViolationEvent.h in Headers */,
29687	5182C2561F3143CD0059BA7C /* JSServiceWorker.h in Headers */,	29713	5182C2561F3143CD0059BA7C /* JSServiceWorker.h in Headers */,
Lines 30847-30852 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec8
30847	44C991860F3D1EBE00586670 /* ScrollbarThemeIOS.h in Headers */,	30873	44C991860F3D1EBE00586670 /* ScrollbarThemeIOS.h in Headers */,
30848	BC8B853E0E7C7F1100AB6984 /* ScrollbarThemeMac.h in Headers */,	30874	BC8B853E0E7C7F1100AB6984 /* ScrollbarThemeMac.h in Headers */,
30849	0FE71406142170B800DB33BA /* ScrollbarThemeMock.h in Headers */,	30875	0FE71406142170B800DB33BA /* ScrollbarThemeMock.h in Headers */,
		30876	83C5795D1DA5C301006FAC86 /* ScrollBehavior.h in Headers */,
30850	1AA84F05143BA7BD0051D153 /* ScrollController.h in Headers */,	30877	1AA84F05143BA7BD0051D153 /* ScrollController.h in Headers */,
30851	0F605AED15F94848004DF0C0 /* ScrollingConstraints.h in Headers */,	30878	0F605AED15F94848004DF0C0 /* ScrollingConstraints.h in Headers */,
30852	1AF62EE814DA22A70041556C /* ScrollingCoordinator.h in Headers */,	30879	1AF62EE814DA22A70041556C /* ScrollingCoordinator.h in Headers */,
Lines 30877-30882 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec9
30877	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers */,	30904	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers */,
30878	7AAFE8D019CB8672000F56D8 /* ScrollLatchingState.h in Headers */,	30905	7AAFE8D019CB8672000F56D8 /* ScrollLatchingState.h in Headers */,
30879	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers */,	30906	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers */,
		30907	83C5795D1DA5C301006FAC97 /* ScrollOptions.h in Headers */,
30880	F478755419983AFF0024A287 /* ScrollSnapAnimatorState.h in Headers */,	30908	F478755419983AFF0024A287 /* ScrollSnapAnimatorState.h in Headers */,
30881	F46729281E0DE68500ACC3D8 /* ScrollSnapOffsetsInfo.h in Headers */,	30909	F46729281E0DE68500ACC3D8 /* ScrollSnapOffsetsInfo.h in Headers */,
30882	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers */,	30910	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers */,

Lines 73-78 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
73	attachmentEnabled = RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled();	73	attachmentEnabled = RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled();
74	#endif	74	#endif
75	deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();	75	deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();
		76	scrollBehaviorEnabled = document.settings().CSSOMViewSmoothScrollingEnabled();
76	useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;	77	useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;
77		78
78	#if PLATFORM(IOS_FAMILY)	79	#if PLATFORM(IOS_FAMILY)
Lines 102-107 bool operator==(const CSSParserContext& a, const CSSParserContext& b) a/Source/WebCore/css/parser/CSSParserContext.cpp_sec2
102	&& a.attachmentEnabled == b.attachmentEnabled	103	&& a.attachmentEnabled == b.attachmentEnabled
103	#endif	104	#endif
104	&& a.deferredCSSParserEnabled == b.deferredCSSParserEnabled	105	&& a.deferredCSSParserEnabled == b.deferredCSSParserEnabled
		106	&& a.scrollBehaviorEnabled == b.scrollBehaviorEnabled
105	&& a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin	107	&& a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin
106	&& a.useSystemAppearance == b.useSystemAppearance;	108	&& a.useSystemAppearance == b.useSystemAppearance;
107	}	109	}

Lines 59-64 public: a/Source/WebCore/css/parser/CSSParserContext.h_sec1
- a/Source/WebCore/css/parser/CSSParserContext.h -4 / +6 lines
59	bool attachmentEnabled { false };	59	bool attachmentEnabled { false };
60	#endif	60	#endif
61	bool deferredCSSParserEnabled { false };	61	bool deferredCSSParserEnabled { false };
		62	bool scrollBehaviorEnabled { false };
62		63
63	// This is only needed to support getMatchedCSSRules.	64	// This is only needed to support getMatchedCSSRules.
64	bool hasDocumentSecurityOrigin { false };	65	bool hasDocumentSecurityOrigin { false };
Lines 99-110 struct CSSParserContextHash { a/Source/WebCore/css/parser/CSSParserContext.h_sec2
99	& key.constantPropertiesEnabled << 6	100	& key.constantPropertiesEnabled << 6
100	& key.colorFilterEnabled << 7	101	& key.colorFilterEnabled << 7
101	& key.deferredCSSParserEnabled << 8	102	& key.deferredCSSParserEnabled << 8
102	& key.hasDocumentSecurityOrigin << 9	103	& key.scrollBehaviorEnabled << 9
103	& key.useSystemAppearance << 10	104	& key.hasDocumentSecurityOrigin << 10
		105	& key.useSystemAppearance << 11
104	#if ENABLE(ATTACHMENT_ELEMENT)	106	#if ENABLE(ATTACHMENT_ELEMENT)
105	& key.attachmentEnabled << 11	107	& key.attachmentEnabled << 12
106	#endif	108	#endif
107	& key.mode << 12; // Keep this last.	109	& key.mode << 13; // Keep this last.
108	hash ^= WTF::intHash(bits);	110	hash ^= WTF::intHash(bits);
109	return hash;	111	return hash;
110	}	112	}

Lines 681-687 void Element::scrollIntoView(std::optional<Variant<bool, ScrollIntoViewOptions>> a/Source/WebCore/dom/Element.cpp_sec1
- a/Source/WebCore/dom/Element.cpp -8 / +21 lines
681	bool insideFixed;	681	bool insideFixed;
682	LayoutRect absoluteBounds = renderer()->absoluteAnchorRect(&insideFixed);	682	LayoutRect absoluteBounds = renderer()->absoluteAnchorRect(&insideFixed);
683		683
684	// FIXME(webkit.org/b/188043): Support ScrollBehavior.
685	ScrollIntoViewOptions options;	684	ScrollIntoViewOptions options;
686	if (arg) {	685	if (arg) {
687	auto value = arg.value();	686	auto value = arg.value();
Lines 691-699 void Element::scrollIntoView(std::optional<Variant<bool, ScrollIntoViewOptions>> a/Source/WebCore/dom/Element.cpp_sec2
691	options.blockPosition = ScrollLogicalPosition::End;	690	options.blockPosition = ScrollLogicalPosition::End;
692	}	691	}
693		692
694	ScrollAlignment alignX = toScrollAlignment(options.inlinePosition, false);	693	ScrollRectToVisibleOptions scrollRectToVisibleOptions {
695	ScrollAlignment alignY = toScrollAlignment(options.blockPosition, true);	694	SelectionRevealMode::Reveal,
696	renderer()->scrollRectToVisible(absoluteBounds, insideFixed, { SelectionRevealMode::Reveal, alignX, alignY, ShouldAllowCrossOriginScrolling::No });	695	toScrollAlignment(options.inlinePosition, false),
		696	toScrollAlignment(options.blockPosition, true),
		697	ShouldAllowCrossOriginScrolling::No,
		698	};
		699	if (options.behavior)
		700	scrollRectToVisibleOptions.behavior = options.behavior.value();
		701	renderer()->scrollRectToVisible(absoluteBounds, insideFixed, scrollRectToVisibleOptions);
697	}	702	}
698		703
699	void Element::scrollIntoView(bool alignToTop)	704	void Element::scrollIntoView(bool alignToTop)
Lines 752-758 void Element::scrollBy(const ScrollToOptions& options) a/Source/WebCore/dom/Element.cpp_sec3
752		757
753	void Element::scrollBy(double x, double y)	758	void Element::scrollBy(double x, double y)
754	{	759	{
755	scrollBy({ x, y });	760	scrollBy(fromCoordinates(x, y));
756	}	761	}
757		762
758	void Element::scrollTo(const ScrollToOptions& options, ScrollClamping clamping)	763	void Element::scrollTo(const ScrollToOptions& options, ScrollClamping clamping)
Lines 788-800 void Element::scrollTo(const ScrollToOptions& options, ScrollClamping clamping) a/Source/WebCore/dom/Element.cpp_sec4
788	adjustForAbsoluteZoom(renderer->scrollLeft(), *renderer),	793	adjustForAbsoluteZoom(renderer->scrollLeft(), *renderer),
789	adjustForAbsoluteZoom(renderer->scrollTop(), *renderer)	794	adjustForAbsoluteZoom(renderer->scrollTop(), *renderer)
790	);	795	);
791	renderer->setScrollLeft(clampToInteger(scrollToOptions.left.value() * renderer->style().effectiveZoom()), clamping);	796	IntPoint scrollPosition(
792	renderer->setScrollTop(clampToInteger(scrollToOptions.top.value() * renderer->style().effectiveZoom()), clamping);	797	clampToInteger(scrollToOptions.left.value() * renderer->style().effectiveZoom()),
		798	clampToInteger(scrollToOptions.top.value() * renderer->style().effectiveZoom())
		799	);
		800	if (useSmoothScrolling(scrollToOptions.behavior.value_or(ScrollBehavior::Auto), *this)) {
		801	renderer->scrollToPositionWithAnimation(scrollPosition, clamping);
		802	return;
		803	}
		804	renderer->setScrollLeft(scrollPosition.x(), clamping);
		805	renderer->setScrollTop(scrollPosition.y(), clamping);
793	}	806	}
794		807
795	void Element::scrollTo(double x, double y)	808	void Element::scrollTo(double x, double y)
796	{	809	{
797	scrollTo({ x, y });	810	scrollTo(fromCoordinates(x, y));
798	}	811	}
799		812
800	void Element::scrollByUnits(int units, ScrollGranularity granularity)	813	void Element::scrollByUnits(int units, ScrollGranularity granularity)

Line 0 a/Source/WebCore/page/ScrollBehavior.cpp_sec1
- a/Source/WebCore/page/ScrollBehavior.cpp +48 lines
	1	/*
	2	* Copyright (C) 2018 Igalia S.L.
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Library General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Library General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Library General Public License
	15	* along with this library; see the file COPYING.LIB. If not, write to
	16	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	17	* Boston, MA 02110-1301, USA.
	18	*/
	19
	20	#include "config.h"
	21	#include "ScrollBehavior.h"
	22
	23	#include "Element.h"
	24	#include "RenderElement.h"
	25	#include "RenderStyle.h"
	26	#include "Settings.h"
	27
	28	namespace WebCore {
	29
	30	bool useSmoothScrolling(ScrollBehavior behavior, Element& associatedElement)
	31	{
	32	if (!associatedElement.document().settings().CSSOMViewSmoothScrollingEnabled() \|\| !associatedElement.renderer())
	33	return false;
	34
	35	// https://drafts.csswg.org/cssom-view/#scrolling
	36	switch (behavior) {
	37	case ScrollBehavior::Auto:
	38	return associatedElement.renderer()->style().useSmoothScrolling();
	39	case ScrollBehavior::Instant:
	40	return false;
	41	case ScrollBehavior::Smooth:
	42	return true;
	43	}
	44	ASSERT_NOT_REACHED();
	45	return false;
	46	}
	47
	48	} // namespace WebCore

Line 0 a/Source/WebCore/page/ScrollBehavior.h_sec1
- a/Source/WebCore/page/ScrollBehavior.h +34 lines
	1	/*
	2	* Copyright (C) 2018 Igalia S.L.
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Library General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Library General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Library General Public License
	15	* along with this library; see the file COPYING.LIB. If not, write to
	16	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	17	* Boston, MA 02110-1301, USA.
	18	*/
	19
	20	#pragma once
	21
	22	namespace WebCore {
	23
	24	class Element;
	25
	26	enum class ScrollBehavior : uint8_t {
	27	Auto = 0,
	28	Instant,
	29	Smooth
	30	};
	31
	32	bool useSmoothScrolling(ScrollBehavior, Element& associatedElement);
	33
	34	} // namespace WebCore

Line 0 a/Source/WebCore/page/ScrollBehavior.idl_sec1
- a/Source/WebCore/page/ScrollBehavior.idl +20 lines
	1	/*
	2	* Copyright (C) 2018 Igalia S.L.
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Library General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Library General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Library General Public License
	15	* along with this library; see the file COPYING.LIB. If not, write to
	16	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	17	* Boston, MA 02110-1301, USA.
	18	*/
	19
	20	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	std::optional<ScrollLogicalPosition> blockPosition { ScrollLogicalPosition::Start };	28	std::optional<ScrollLogicalPosition> blockPosition { ScrollLogicalPosition::Start };
30	std::optional<ScrollLogicalPosition> inlinePosition { ScrollLogicalPosition::Nearest };	29	std::optional<ScrollLogicalPosition> inlinePosition { ScrollLogicalPosition::Nearest };
31	};	30	};

Line 0 a/Source/WebCore/page/ScrollOptions.h_sec1
- a/Source/WebCore/page/ScrollOptions.h +30 lines
	1	/*
	2	* Copyright (C) 2018 Igalia S.L.
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Library General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Library General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Library General Public License
	15	* along with this library; see the file COPYING.LIB. If not, write to
	16	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	17	* Boston, MA 02110-1301, USA.
	18	*/
	19
	20	#pragma once
	21
	22	#include "ScrollBehavior.h"
	23
	24	namespace WebCore {
	25
	26	struct ScrollOptions {
	27	std::optional<ScrollBehavior> behavior { ScrollBehavior::Auto };
	28	};
	29
	30	} // namespace WebCore

Line 0 a/Source/WebCore/page/ScrollOptions.idl_sec1
- a/Source/WebCore/page/ScrollOptions.idl +22 lines
	1	/*
	2	* Copyright (C) 2018 Igalia S.L.
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Library General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Library General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Library General Public License
	15	* along with this library; see the file COPYING.LIB. If not, write to
	16	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	17	* Boston, MA 02110-1301, USA.
	18	*/
	19
	20	dictionary ScrollOptions {
	21	ScrollBehavior behavior = "auto";
	22	};

Lines 28-43 a/Source/WebCore/page/ScrollToOptions.h_sec1
- a/Source/WebCore/page/ScrollToOptions.h -2 / +11 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	std::optional<double> left;	38	std::optional<double> left;
38	std::optional<double> top;	39	std::optional<double> top;
39	};	40	};
40		41
		42	inline ScrollToOptions fromCoordinates(double x, double y)
		43	{
		44	ScrollToOptions options;
		45	options.left = x;
		46	options.top = y;
		47	return options;
		48	};
		49
41	inline double normalizeNonFiniteValueOrFallBackTo(std::optional<double> value, double fallbackValue)	50	inline double normalizeNonFiniteValueOrFallBackTo(std::optional<double> value, double fallbackValue)
42	{	51	{
43	// Normalize non-finite values (https://drafts.csswg.org/cssom-view/#normalize-non-finite-values).	52	// Normalize non-finite values (https://drafts.csswg.org/cssom-view/#normalize-non-finite-values).
Lines 47-53 inline double normalizeNonFiniteValueOrFallBackTo(std::optional<double> value, d a/Source/WebCore/page/ScrollToOptions.h_sec2
47	// FIXME(https://webkit.org/b/88339): Consider using FloatPoint or DoublePoint for fallback and return values.	56	// 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)	57	inline ScrollToOptions normalizeNonFiniteCoordinatesOrFallBackTo(const ScrollToOptions& value, double x, double y)
49	{	58	{
50	ScrollToOptions options;	59	ScrollToOptions options = value;
51	options.left = normalizeNonFiniteValueOrFallBackTo(value.left, x);	60	options.left = normalizeNonFiniteValueOrFallBackTo(value.left, x);
52	options.top = normalizeNonFiniteValueOrFallBackTo(value.top, y);	61	options.top = normalizeNonFiniteValueOrFallBackTo(value.top, y);
53	return options;	62	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 32-46 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;
35		36
36	class ScrollAnimation {	37	class ScrollAnimation {
37	public:	38	public:
38	virtual ~ScrollAnimation() { };	39	virtual ~ScrollAnimation() { };
39	virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float /* step /, float / multiplier */) { return true; };	40	virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float /* step /, float / multiplier */) { return true; };
		41	virtual void scroll(const FloatPoint&, ScrollClamping) { };
40	virtual void stop() = 0;	42	virtual void stop() = 0;
41	virtual void updateVisibleLengths() { };	43	virtual void updateVisibleLengths() { };
42	virtual void setCurrentPosition(const FloatPoint&) { };	44	virtual void setCurrentPosition(const FloatPoint&) { };
43	virtual void serviceAnimation() { };	45	virtual void serviceAnimation() { };
		46	virtual bool isScrollInProgress() const { return false; }
44		47
45	protected:	48	protected:
46	ScrollAnimation(ScrollableArea& scrollableArea)	49	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;
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&, ScrollClamping) 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 63-68 bool ScrollAnimatorSmooth::scroll(ScrollbarOrientation orientation, ScrollGranul a/Source/WebCore/platform/ScrollAnimatorSmooth.cpp_sec1
- a/Source/WebCore/platform/ScrollAnimatorSmooth.cpp -2 / +8 lines
63	if (!m_scrollableArea.scrollAnimatorEnabled())	63	if (!m_scrollableArea.scrollAnimatorEnabled())
64	return ScrollAnimator::scroll(orientation, granularity, step, multiplier);	64	return ScrollAnimator::scroll(orientation, granularity, step, multiplier);
65		65
		66	m_animation->setCurrentPosition(m_currentPosition);
66	return m_animation->scroll(orientation, granularity, step, multiplier);	67	return m_animation->scroll(orientation, granularity, step, multiplier);
67	}	68	}
68		69
Lines 79-105 void ScrollAnimatorSmooth::scrollToOffsetWithoutAnimation(const FloatPoint& offs a/Source/WebCore/platform/ScrollAnimatorSmooth.cpp_sec2
79	#if !USE(REQUEST_ANIMATION_FRAME_TIMER)	80	#if !USE(REQUEST_ANIMATION_FRAME_TIMER)
80	void ScrollAnimatorSmooth::cancelAnimations()	81	void ScrollAnimatorSmooth::cancelAnimations()
81	{	82	{
		83	ScrollAnimator::cancelAnimations();
82	m_animation->stop();	84	m_animation->stop();
83	}	85	}
84		86
85	void ScrollAnimatorSmooth::serviceScrollAnimations()	87	void ScrollAnimatorSmooth::serviceScrollAnimations()
86	{	88	{
		89	ScrollAnimator::serviceScrollAnimations();
87	m_animation->serviceAnimation();	90	m_animation->serviceAnimation();
88	}	91	}
89	#endif	92	#endif
90		93
91	void ScrollAnimatorSmooth::willEndLiveResize()	94	void ScrollAnimatorSmooth::willEndLiveResize()
92	{	95	{
		96	ScrollAnimator::willEndLiveResize();
93	m_animation->updateVisibleLengths();	97	m_animation->updateVisibleLengths();
94	}	98	}
95		99
96	void ScrollAnimatorSmooth::didAddVerticalScrollbar(Scrollbar*)	100	void ScrollAnimatorSmooth::didAddVerticalScrollbar(Scrollbar* scrollbar)
97	{	101	{
		102	ScrollAnimator::didAddVerticalScrollbar(scrollbar);
98	m_animation->updateVisibleLengths();	103	m_animation->updateVisibleLengths();
99	}	104	}
100		105
101	void ScrollAnimatorSmooth::didAddHorizontalScrollbar(Scrollbar*)	106	void ScrollAnimatorSmooth::didAddHorizontalScrollbar(Scrollbar* scrollbar)
102	{	107	{
		108	ScrollAnimator::didAddHorizontalScrollbar(scrollbar);
103	m_animation->updateVisibleLengths();	109	m_animation->updateVisibleLengths();
104	}	110	}
105		111

Lines 50-56 typedef IntPoint ScrollOffset; a/Source/WebCore/platform/ScrollableArea.h_sec1
- a/Source/WebCore/platform/ScrollableArea.h +2 lines
50		50
51	class ScrollableArea : public CanMakeWeakPtr<ScrollableArea> {	51	class ScrollableArea : public CanMakeWeakPtr<ScrollableArea> {
52	public:	52	public:
		53	WEBCORE_EXPORT bool isScrollInProgress() const;
53	WEBCORE_EXPORT bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);	54	WEBCORE_EXPORT bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
		55	WEBCORE_EXPORT void scrollToOffsetWithAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
54	WEBCORE_EXPORT void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);	56	WEBCORE_EXPORT void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
55	void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);	57	void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);
56		58

Lines 50-55 a/Source/WebCore/rendering/RenderLayer.h_sec1
- a/Source/WebCore/rendering/RenderLayer.h +3 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 125-130 struct ScrollRectToVisibleOptions { a/Source/WebCore/rendering/RenderLayer.h_sec2
125	const ScrollAlignment& alignX { ScrollAlignment::alignCenterIfNeeded };	126	const ScrollAlignment& alignX { ScrollAlignment::alignCenterIfNeeded };
126	const ScrollAlignment& alignY { ScrollAlignment::alignCenterIfNeeded };	127	const ScrollAlignment& alignY { ScrollAlignment::alignCenterIfNeeded };
127	ShouldAllowCrossOriginScrolling shouldAllowCrossOriginScrolling { ShouldAllowCrossOriginScrolling::No };	128	ShouldAllowCrossOriginScrolling shouldAllowCrossOriginScrolling { ShouldAllowCrossOriginScrolling::No };
		129	ScrollBehavior behavior { ScrollBehavior::Auto };
128	};	130	};
129		131
130	class RenderLayer final : public ScrollableArea {	132	class RenderLayer final : public ScrollableArea {
Lines 287-292 public: a/Source/WebCore/rendering/RenderLayer.h_sec3
287	void scrollByRecursively(const IntSize& delta, ScrollableArea** scrolledArea = nullptr);	289	void scrollByRecursively(const IntSize& delta, ScrollableArea** scrolledArea = nullptr);
288		290
289	WEBCORE_EXPORT void scrollToOffset(const ScrollOffset&, ScrollClamping = ScrollClamping::Clamped);	291	WEBCORE_EXPORT void scrollToOffset(const ScrollOffset&, ScrollClamping = ScrollClamping::Clamped);
		292	WEBCORE_EXPORT void scrollToOffsetWithAnimation(const ScrollOffset&, ScrollClamping = ScrollClamping::Clamped);
290	void scrollToXOffset(int x, ScrollClamping clamping = ScrollClamping::Clamped) { scrollToOffset(ScrollOffset(x, scrollOffset().y()), clamping); }	293	void scrollToXOffset(int x, ScrollClamping clamping = ScrollClamping::Clamped) { scrollToOffset(ScrollOffset(x, scrollOffset().y()), clamping); }
291	void scrollToYOffset(int y, ScrollClamping clamping = ScrollClamping::Clamped) { scrollToOffset(ScrollOffset(scrollOffset().x(), y), clamping); }	294	void scrollToYOffset(int y, ScrollClamping clamping = ScrollClamping::Clamped) { scrollToOffset(ScrollOffset(scrollOffset().x(), y), clamping); }
292		295

Lines 657-662 public: a/Source/WebKitLegacy/mac/WebView/WebPreferences.mm_sec1
- a/Source/WebKitLegacy/mac/WebView/WebPreferences.mm +11 lines
657	[NSNumber numberWithBool:NO], WebKitVisualViewportAPIEnabledPreferenceKey,	657	[NSNumber numberWithBool:NO], WebKitVisualViewportAPIEnabledPreferenceKey,
658		658
659	[NSNumber numberWithBool:NO], WebKitCSSOMViewScrollingAPIEnabledPreferenceKey,	659	[NSNumber numberWithBool:NO], WebKitCSSOMViewScrollingAPIEnabledPreferenceKey,
		660	[NSNumber numberWithBool:NO], WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey,
660	[NSNumber numberWithBool:YES], WebKitNeedsStorageAccessFromFileURLsQuirkKey,	661	[NSNumber numberWithBool:YES], WebKitNeedsStorageAccessFromFileURLsQuirkKey,
661	[NSNumber numberWithBool:NO], WebKitAllowCrossOriginSubresourcesToAskForCredentialsKey,	662	[NSNumber numberWithBool:NO], WebKitAllowCrossOriginSubresourcesToAskForCredentialsKey,
662	#if ENABLE(MEDIA_STREAM)	663	#if ENABLE(MEDIA_STREAM)
Lines 3107-3112 static NSString *classIBCreatorID = nil; a/Source/WebKitLegacy/mac/WebView/WebPreferences.mm_sec2
3107	[self _setBoolValue:flag forKey:WebKitCSSOMViewScrollingAPIEnabledPreferenceKey];	3108	[self _setBoolValue:flag forKey:WebKitCSSOMViewScrollingAPIEnabledPreferenceKey];
3108	}	3109	}
3109		3110
		3111	- (BOOL)CSSOMViewSmoothScrollingEnabled
		3112	{
		3113	return [self _boolValueForKey:WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey];
		3114	}
		3115
		3116	- (void)setCSSOMViewSmoothScrollingEnabled:(BOOL)flag
		3117	{
		3118	[self _setBoolValue:flag forKey:WebKitCSSOMViewSmoothScrollingEnabledPreferenceKey];
		3119	}
		3120
3110	- (BOOL)webAnimationsEnabled	3121	- (BOOL)webAnimationsEnabled
3111	{	3122	{
3112	return [self _boolValueForKey:WebKitWebAnimationsEnabledPreferenceKey];	3123	return [self _boolValueForKey:WebKitWebAnimationsEnabledPreferenceKey];

Lines 1-3 a/Tools/ChangeLog_sec1
- a/Tools/ChangeLog +11 lines
		1	2018-11-06 Frederic Wang <fwang@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	* DumpRenderTree/TestOptions.cpp:
		7	(TestOptions::TestOptions): Parse CSSOMViewSmoothScrollingEnabled.
		8	* DumpRenderTree/TestOptions.h: Add CSSOMViewSmoothScrollingEnabled, disabled by default.
		9	* DumpRenderTree/mac/DumpRenderTree.mm:
		10	(setWebPreferencesForTestOptions): Set CSSOMViewSmoothScrollingEnabled from the test options.
		11
1	2018-11-08 Said Abou-Hallawa <sabouhallawa@apple.com>	12	2018-11-08 Said Abou-Hallawa <sabouhallawa@apple.com>
2		13
3	onal supported image formats	14	onal supported image formats

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +10 lines
		1	2018-11-07 Frederic Wang <fwang@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	* platform/mac-wk1/TestExpectations: Skip these tests on WK1 as they don't work for now and
		9	are slow anyway.
		10
1	2018-11-08 Megan Gardner <megan_gardner@apple.com>	11	2018-11-08 Megan Gardner <megan_gardner@apple.com>
2		12
3	Adopt Reveal Framework to replace Lookup	13	Adopt Reveal Framework to replace Lookup

Lines 1-3 a/LayoutTests/imported/w3c/ChangeLog_sec1
- a/LayoutTests/imported/w3c/ChangeLog +25 lines
		1	2018-11-06 Frederic Wang <fwang@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	Enable CSSOMViewSmoothScrollingEnabled on scroll behavior tests and update expectations.
		9
		10	* web-platform-tests/css/cssom-view/scroll-behavior-default-css-expected.txt:
		11	* web-platform-tests/css/cssom-view/scroll-behavior-default-css.html:
		12	* web-platform-tests/css/cssom-view/scroll-behavior-element-expected.txt:
		13	* web-platform-tests/css/cssom-view/scroll-behavior-element.html:
		14	* web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root-expected.txt:
		15	* web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root.html:
		16	* web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window-expected.txt:
		17	* web-platform-tests/css/cssom-view/scroll-behavior-main-frame-window.html:
		18	* web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested-expected.txt:
		19	* web-platform-tests/css/cssom-view/scroll-behavior-scrollintoview-nested.html:
		20	* web-platform-tests/css/cssom-view/scroll-behavior-smooth-positions.html:
		21	* web-platform-tests/css/cssom-view/scroll-behavior-subframe-root-expected.txt:
		22	* web-platform-tests/css/cssom-view/scroll-behavior-subframe-root.html:
		23	* web-platform-tests/css/cssom-view/scroll-behavior-subframe-window-expected.txt:
		24	* web-platform-tests/css/cssom-view/scroll-behavior-subframe-window.html:
		25
1	2018-11-08 Andy Estes <aestes@apple.com>	26	2018-11-08 Andy Estes <aestes@apple.com>
2		27
3	[Payment Request] Update web platform tests	28	[Payment Request] Update web platform tests

Lines 2-36 a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-element-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-element-expected.txt -16 / +16 lines
2	PASS Element with auto scroll-behavior ; scroll() with default behavior	2	PASS Element with auto scroll-behavior ; scroll() with default behavior
3	PASS Element with auto scroll-behavior ; scroll() with auto behavior	3	PASS Element with auto scroll-behavior ; scroll() with auto behavior
4	PASS Element with auto scroll-behavior ; scroll() with instant behavior	4	PASS Element with auto scroll-behavior ; scroll() with instant behavior
5	FAIL Element with auto scroll-behavior ; scroll() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	5	PASS Element with auto scroll-behavior ; scroll() with smooth behavior
6	FAIL Element with smooth scroll-behavior ; scroll() with default behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	6	PASS Element with smooth scroll-behavior ; scroll() with default behavior
7	FAIL Element with smooth scroll-behavior ; scroll() with auto behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	7	PASS Element with smooth scroll-behavior ; scroll() with auto behavior
8	PASS Element with smooth scroll-behavior ; scroll() with instant behavior	8	PASS Element with smooth scroll-behavior ; scroll() with instant behavior
9	FAIL Element with smooth scroll-behavior ; scroll() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	9	PASS Element with smooth scroll-behavior ; scroll() with smooth behavior
10	PASS Element with auto scroll-behavior ; scrollTo() with default behavior	10	PASS Element with auto scroll-behavior ; scrollTo() with default behavior
11	PASS Element with auto scroll-behavior ; scrollTo() with auto behavior	11	PASS Element with auto scroll-behavior ; scrollTo() with auto behavior
12	PASS Element with auto scroll-behavior ; scrollTo() with instant behavior	12	PASS Element with auto scroll-behavior ; scrollTo() with instant behavior
13	FAIL Element with auto scroll-behavior ; scrollTo() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	13	PASS Element with auto scroll-behavior ; scrollTo() with smooth behavior
14	FAIL Element with smooth scroll-behavior ; scrollTo() with default behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	14	PASS Element with smooth scroll-behavior ; scrollTo() with default behavior
15	FAIL Element with smooth scroll-behavior ; scrollTo() with auto behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	15	PASS Element with smooth scroll-behavior ; scrollTo() with auto behavior
16	PASS Element with smooth scroll-behavior ; scrollTo() with instant behavior	16	PASS Element with smooth scroll-behavior ; scrollTo() with instant behavior
17	FAIL Element with smooth scroll-behavior ; scrollTo() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	17	PASS Element with smooth scroll-behavior ; scrollTo() with smooth behavior
18	PASS Element with auto scroll-behavior ; scrollBy() with default behavior	18	PASS Element with auto scroll-behavior ; scrollBy() with default behavior
19	PASS Element with auto scroll-behavior ; scrollBy() with auto behavior	19	PASS Element with auto scroll-behavior ; scrollBy() with auto behavior
20	PASS Element with auto scroll-behavior ; scrollBy() with instant behavior	20	PASS Element with auto scroll-behavior ; scrollBy() with instant behavior
21	FAIL Element with auto scroll-behavior ; scrollBy() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	21	PASS Element with auto scroll-behavior ; scrollBy() with smooth behavior
22	FAIL Element with smooth scroll-behavior ; scrollBy() with default behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	22	PASS Element with smooth scroll-behavior ; scrollBy() with default behavior
23	FAIL Element with smooth scroll-behavior ; scrollBy() with auto behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	23	PASS Element with smooth scroll-behavior ; scrollBy() with auto behavior
24	PASS Element with smooth scroll-behavior ; scrollBy() with instant behavior	24	PASS Element with smooth scroll-behavior ; scrollBy() with instant behavior
25	FAIL Element with smooth scroll-behavior ; scrollBy() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	25	PASS Element with smooth scroll-behavior ; scrollBy() with smooth behavior
26	PASS Element with auto scroll-behavior ; scrollIntoView() with default behavior	26	PASS Element with auto scroll-behavior ; scrollIntoView() with default behavior
27	PASS Element with auto scroll-behavior ; scrollIntoView() with auto behavior	27	PASS Element with auto scroll-behavior ; scrollIntoView() with auto behavior
28	PASS Element with auto scroll-behavior ; scrollIntoView() with instant behavior	28	PASS Element with auto scroll-behavior ; scrollIntoView() with instant behavior
29	FAIL Element with auto scroll-behavior ; scrollIntoView() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	29	PASS Element with auto scroll-behavior ; scrollIntoView() with smooth behavior
30	FAIL Element with smooth scroll-behavior ; scrollIntoView() with default behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	30	PASS Element with smooth scroll-behavior ; scrollIntoView() with default behavior
31	FAIL Element with smooth scroll-behavior ; scrollIntoView() with auto behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	31	PASS Element with smooth scroll-behavior ; scrollIntoView() with auto behavior
32	PASS Element with smooth scroll-behavior ; scrollIntoView() with instant behavior	32	PASS Element with smooth scroll-behavior ; scrollIntoView() with instant behavior
33	FAIL Element with smooth scroll-behavior ; scrollIntoView() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 500 but got 500	33	PASS Element with smooth scroll-behavior ; scrollIntoView() with smooth behavior
34	PASS Aborting an ongoing smooth scrolling on an element with another smooth scrolling	34	PASS Aborting an ongoing smooth scrolling on an element with another smooth scrolling
35	PASS Aborting an ongoing smooth scrolling on an element with an instant scrolling	35	PASS Aborting an ongoing smooth scrolling on an element with an instant scrolling
36		36

Lines 3-37 PASS Page loaded a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/cssom-view/scroll-behavior-main-frame-root-expected.txt -16 / +16 lines
3	PASS Main frame with auto scroll-behavior ; scroll() with default behavior	3	PASS Main frame with auto scroll-behavior ; scroll() with default behavior
4	PASS Main frame with auto scroll-behavior ; scroll() with auto behavior	4	PASS Main frame with auto scroll-behavior ; scroll() with auto behavior
5	PASS Main frame with auto scroll-behavior ; scroll() with instant behavior	5	PASS Main frame with auto scroll-behavior ; scroll() with instant behavior
6	FAIL Main frame with auto scroll-behavior ; scroll() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	6	PASS Main frame with auto scroll-behavior ; scroll() with smooth behavior
7	FAIL Main frame with smooth scroll-behavior ; scroll() with default behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	7	PASS Main frame with smooth scroll-behavior ; scroll() with default behavior
8	FAIL Main frame with smooth scroll-behavior ; scroll() with auto behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	8	PASS Main frame with smooth scroll-behavior ; scroll() with auto behavior
9	PASS Main frame with smooth scroll-behavior ; scroll() with instant behavior	9	PASS Main frame with smooth scroll-behavior ; scroll() with instant behavior
10	FAIL Main frame with smooth scroll-behavior ; scroll() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	10	PASS Main frame with smooth scroll-behavior ; scroll() with smooth behavior
11	PASS Main frame with auto scroll-behavior ; scrollTo() with default behavior	11	PASS Main frame with auto scroll-behavior ; scrollTo() with default behavior
12	PASS Main frame with auto scroll-behavior ; scrollTo() with auto behavior	12	PASS Main frame with auto scroll-behavior ; scrollTo() with auto behavior
13	PASS Main frame with auto scroll-behavior ; scrollTo() with instant behavior	13	PASS Main frame with auto scroll-behavior ; scrollTo() with instant behavior
14	FAIL Main frame with auto scroll-behavior ; scrollTo() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	14	PASS Main frame with auto scroll-behavior ; scrollTo() with smooth behavior
15	FAIL Main frame with smooth scroll-behavior ; scrollTo() with default behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	15	PASS Main frame with smooth scroll-behavior ; scrollTo() with default behavior
16	FAIL Main frame with smooth scroll-behavior ; scrollTo() with auto behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	16	PASS Main frame with smooth scroll-behavior ; scrollTo() with auto behavior
17	PASS Main frame with smooth scroll-behavior ; scrollTo() with instant behavior	17	PASS Main frame with smooth scroll-behavior ; scrollTo() with instant behavior
18	FAIL Main frame with smooth scroll-behavior ; scrollTo() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	18	PASS Main frame with smooth scroll-behavior ; scrollTo() with smooth behavior
19	PASS Main frame with auto scroll-behavior ; scrollBy() with default behavior	19	PASS Main frame with auto scroll-behavior ; scrollBy() with default behavior
20	PASS Main frame with auto scroll-behavior ; scrollBy() with auto behavior	20	PASS Main frame with auto scroll-behavior ; scrollBy() with auto behavior
21	PASS Main frame with auto scroll-behavior ; scrollBy() with instant behavior	21	PASS Main frame with auto scroll-behavior ; scrollBy() with instant behavior
22	FAIL Main frame with auto scroll-behavior ; scrollBy() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	22	PASS Main frame with auto scroll-behavior ; scrollBy() with smooth behavior
23	FAIL Main frame with smooth scroll-behavior ; scrollBy() with default behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	23	PASS Main frame with smooth scroll-behavior ; scrollBy() with default behavior
24	FAIL Main frame with smooth scroll-behavior ; scrollBy() with auto behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	24	PASS Main frame with smooth scroll-behavior ; scrollBy() with auto behavior
25	PASS Main frame with smooth scroll-behavior ; scrollBy() with instant behavior	25	PASS Main frame with smooth scroll-behavior ; scrollBy() with instant behavior
26	FAIL Main frame with smooth scroll-behavior ; scrollBy() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	26	PASS Main frame with smooth scroll-behavior ; scrollBy() with smooth behavior
27	PASS Main frame with auto scroll-behavior ; scrollIntoView() with default behavior	27	PASS Main frame with auto scroll-behavior ; scrollIntoView() with default behavior
28	PASS Main frame with auto scroll-behavior ; scrollIntoView() with auto behavior	28	PASS Main frame with auto scroll-behavior ; scrollIntoView() with auto behavior
29	PASS Main frame with auto scroll-behavior ; scrollIntoView() with instant behavior	29	PASS Main frame with auto scroll-behavior ; scrollIntoView() with instant behavior
30	FAIL Main frame with auto scroll-behavior ; scrollIntoView() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	30	PASS Main frame with auto scroll-behavior ; scrollIntoView() with smooth behavior
31	FAIL Main frame with smooth scroll-behavior ; scrollIntoView() with default behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	31	PASS Main frame with smooth scroll-behavior ; scrollIntoView() with default behavior
32	FAIL Main frame with smooth scroll-behavior ; scrollIntoView() with auto behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	32	PASS Main frame with smooth scroll-behavior ; scrollIntoView() with auto behavior
33	PASS Main frame with smooth scroll-behavior ; scrollIntoView() with instant behavior	33	PASS Main frame with smooth scroll-behavior ; scrollIntoView() with instant behavior
34	FAIL Main frame with smooth scroll-behavior ; scrollIntoView() with smooth behavior assert_less_than: Should not set scrollLeft immediately expected a number less than 2430 but got 2430	34	PASS Main frame with smooth scroll-behavior ; scrollIntoView() with smooth behavior
35	PASS Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling	35	PASS Aborting an ongoing smooth scrolling on the main frame with another smooth scrolling
36	PASS Aborting an ongoing smooth scrolling on the main frame with an instant scrolling	36	PASS Aborting an ongoing smooth scrolling on the main frame with an instant scrolling
37		37