Attachment #354319 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-06  Rob Buis  <rbuis@igalia.com>

        Some minor X-Content-Type-Options parsing issues



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-05  Zan Dobersek  <zdobersek@igalia.com>

        [WPE] Remove BackingStore, BackingStoreCairo implementation files from 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-02  Daniel Bates  <dabates@apple.com>

        [iOS] WebKit should dispatch DOM events when a modifier key is pressed



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



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

platform/RuntimeApplicationChecks.cpp
platform/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 3704-3709 RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec2
3704	return cssValuePool.createIdentifierValue(CSSValueAuto);	3705	return cssValuePool.createIdentifierValue(CSSValueAuto);
3705	return cssValuePool.createIdentifierValue(CSSValueTouch);	3706	return cssValuePool.createIdentifierValue(CSSValueTouch);
3706	#endif	3707	#endif
		3708	case CSSPropertyScrollBehavior:
		3709	if (!style.useSmoothScrolling())
		3710	return cssValuePool.createIdentifierValue(CSSValueAuto);
		3711	return cssValuePool.createIdentifierValue(CSSValueSmooth);
3707	case CSSPropertyPerspective:	3712	case CSSPropertyPerspective:
3708	if (!style.hasPerspective())	3713	if (!style.hasPerspective())
3709	return cssValuePool.createIdentifierValue(CSSValueNone);	3714	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 117-122 public: a/Source/WebCore/css/StyleBuilderConverter.h_sec1
- a/Source/WebCore/css/StyleBuilderConverter.h +6 lines
117	#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)	117	#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
118	static bool convertOverflowScrolling(StyleResolver&, const CSSValue&);	118	static bool convertOverflowScrolling(StyleResolver&, const CSSValue&);
119	#endif	119	#endif
		120	static bool convertSmoothScrolling(StyleResolver&, const CSSValue&);
120	static FontFeatureSettings convertFontFeatureSettings(StyleResolver&, const CSSValue&);	121	static FontFeatureSettings convertFontFeatureSettings(StyleResolver&, const CSSValue&);
121	static FontSelectionValue convertFontWeightFromValue(const CSSValue&);	122	static FontSelectionValue convertFontWeightFromValue(const CSSValue&);
122	static FontSelectionValue convertFontStretchFromValue(const CSSValue&);	123	static FontSelectionValue convertFontStretchFromValue(const CSSValue&);
Lines 1305-1310 inline bool StyleBuilderConverter::convertOverflowScrolling(StyleResolver&, cons a/Source/WebCore/css/StyleBuilderConverter.h_sec2
1305	}	1306	}
1306	#endif	1307	#endif
1307		1308
		1309	inline bool StyleBuilderConverter::convertSmoothScrolling(StyleResolver&, const CSSValue& value)
		1310	{
		1311	return downcast<CSSPrimitiveValue>(value).valueID() == CSSValueSmooth;
		1312	}
		1313
1308	inline SVGLengthValue StyleBuilderConverter::convertSVGLengthValue(StyleResolver&, const CSSValue& value)	1314	inline SVGLengthValue StyleBuilderConverter::convertSVGLengthValue(StyleResolver&, const CSSValue& value)
1309	{	1315	{
1310	return SVGLengthValue::fromCSSPrimitiveValue(downcast<CSSPrimitiveValue>(value));	1316	return SVGLengthValue::fromCSSPrimitiveValue(downcast<CSSPrimitiveValue>(value));



    constantPropertiesEnabled = document.settings().constantPropertiesEnabled();
    colorFilterEnabled = document.settings().colorFilterEnabled();
    deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();
    scrollBehaviorEnabled = document.settings().CSSOMViewSmoothScrollingEnabled();
    useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;

#if PLATFORM(IOS_FAMILY)

        && a.constantPropertiesEnabled == b.constantPropertiesEnabled
        && a.colorFilterEnabled == b.colorFilterEnabled
        && a.deferredCSSParserEnabled == b.deferredCSSParserEnabled
        && a.scrollBehaviorEnabled == b.scrollBehaviorEnabled
        && a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin
        && a.useSystemAppearance == b.useSystemAppearance;
}



    bool constantPropertiesEnabled { false };
    bool colorFilterEnabled { false };
    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
            & key.mode                                      << 12; // 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 3971-3976 RefPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID property, CSS a/Source/WebCore/css/parser/CSSPropertyParser.cpp_sec2
3971	case CSSPropertyScrollSnapType:	3979	case CSSPropertyScrollSnapType:
3972	return consumeScrollSnapType(m_range);	3980	return consumeScrollSnapType(m_range);
3973	#endif	3981	#endif
		3982	case CSSPropertyScrollBehavior:
		3983	if (!m_context.scrollBehaviorEnabled)
		3984	return nullptr;
		3985	return consumeScrollBehavior(m_range);
3974	case CSSPropertyClip:	3986	case CSSPropertyClip:
3975	return consumeClip(m_range, m_context.mode);	3987	return consumeClip(m_range, m_context.mode);
3976	#if ENABLE(TOUCH_EVENTS)	3988	#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 729-734 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec1
- a/Source/WebCore/rendering/style/RenderStyle.h +6 lines
729	bool useTouchOverflowScrolling() const { return m_rareInheritedData->useTouchOverflowScrolling; }	729	bool useTouchOverflowScrolling() const { return m_rareInheritedData->useTouchOverflowScrolling; }
730	#endif	730	#endif
731		731
		732	bool useSmoothScrolling() const { return m_rareNonInheritedData->useSmoothScrolling; }
		733
732	#if ENABLE(TEXT_AUTOSIZING)	734	#if ENABLE(TEXT_AUTOSIZING)
733	TextSizeAdjustment textSizeAdjust() const { return m_rareInheritedData->textSizeAdjust; }	735	TextSizeAdjustment textSizeAdjust() const { return m_rareInheritedData->textSizeAdjust; }
734	#endif	736	#endif
Lines 1238-1243 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec2
1238	void setUseTouchOverflowScrolling(bool v) { SET_VAR(m_rareInheritedData, useTouchOverflowScrolling, v); }	1240	void setUseTouchOverflowScrolling(bool v) { SET_VAR(m_rareInheritedData, useTouchOverflowScrolling, v); }
1239	#endif	1241	#endif
1240		1242
		1243	void setUseSmoothScrolling(bool v) { SET_VAR(m_rareNonInheritedData, useSmoothScrolling, v); }
		1244
1241	#if ENABLE(TEXT_AUTOSIZING)	1245	#if ENABLE(TEXT_AUTOSIZING)
1242	void setTextSizeAdjust(TextSizeAdjustment adjustment) { SET_VAR(m_rareInheritedData, textSizeAdjust, adjustment); }	1246	void setTextSizeAdjust(TextSizeAdjustment adjustment) { SET_VAR(m_rareInheritedData, textSizeAdjust, adjustment); }
1243	#endif	1247	#endif
Lines 1666-1671 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec3
1666	static bool initialUseTouchOverflowScrolling() { return false; }	1670	static bool initialUseTouchOverflowScrolling() { return false; }
1667	#endif	1671	#endif
1668		1672
		1673	static bool initialUseSmoothScrolling() { return false; }
		1674
1669	#if ENABLE(DASHBOARD_SUPPORT)	1675	#if ENABLE(DASHBOARD_SUPPORT)
1670	static const Vector<StyleDashboardRegion>& initialDashboardRegions();	1676	static const Vector<StyleDashboardRegion>& initialDashboardRegions();
1671	static const Vector<StyleDashboardRegion>& noneDashboardRegions();	1677	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 1644-1650 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
1644	if (!document \|\| !document->view())	1644	if (!document \|\| !document->view())
1645	return Exception { InvalidAccessError };	1645	return Exception { InvalidAccessError };
1646		1646
1647	element.scrollTo({ x, y }, ScrollClamping::Unclamped);	1647	element.scrollTo(fromCoordinates(x, y), ScrollClamping::Unclamped);
1648	return { };	1648	return { };
1649	}	1649	}
1650		1650



#   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-05  Jonathan Bedard  <jbedard@apple.com>

        webkitpy: Generalize trailing SDK specifier (Part 1)

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-06  Frederic Wang  <fwang@igalia.com>

        Overlay with -webkit-overflow-scrolling:touch doesn't become scrollable after added text makes it taller



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-06  Rob Buis  <rbuis@igalia.com>

        Some minor X-Content-Type-Options parsing issues

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

Return to Bug 188043

Lines 6227-6232 a/Source/WebCore/css/CSSProperties.json_sec1
- a/Source/WebCore/css/CSSProperties.json +16 lines
6227	"url": "https://www.w3.org/TR/css-ui-4/#propdef-user-select"	6227	"url": "https://www.w3.org/TR/css-ui-4/#propdef-user-select"
6228	}	6228	}
6229	},	6229	},
		6230	"scroll-behavior": {
		6231	"values": [
		6232	"auto",
		6233	"smooth"
		6234	],
		6235	"codegen-properties": {
		6236	"converter": "SmoothScrolling",
		6237	"name-for-methods": "UseSmoothScrolling"
		6238	},
		6239	"status": {
		6240	"status": "experimental"
		6241	},
		6242	"specification": {
		6243	"url": "https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior"
		6244	}
		6245	},
6230	"scroll-padding": {	6246	"scroll-padding": {
6231	"codegen-properties": {	6247	"codegen-properties": {
6232	"enable-if": "ENABLE_CSS_SCROLL_SNAP",	6248	"enable-if": "ENABLE_CSS_SCROLL_SNAP",

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 1181-1187 VideoQualityIncludesDisplayCompositingEnabled: a/Source/WebKit/Shared/WebPreferences.yaml_sec1
- a/Source/WebKit/Shared/WebPreferences.yaml -1 / +7 lines
1181	# DEFAULT_EXPERIMENTAL_FEATURES_ENABLED (for features that are ready for	1181	# DEFAULT_EXPERIMENTAL_FEATURES_ENABLED (for features that are ready for
1182	# wider testing).	1182	# wider testing).
1183		1183
1184
1185	SpringTimingFunctionEnabled:	1184	SpringTimingFunctionEnabled:
1186	type: bool	1185	type: bool
1187	defaultValue: DEFAULT_EXPERIMENTAL_FEATURES_ENABLED	1186	defaultValue: DEFAULT_EXPERIMENTAL_FEATURES_ENABLED
Lines 1228-1233 CSSOMViewScrollingAPIEnabled: a/Source/WebKit/Shared/WebPreferences.yaml_sec2
1228	humanReadableDescription: "Implement standard behavior for scrollLeft, scrollTop, scrollWidth, scrollHeight, scrollTo, scrollBy and scrollingElement."	1227	humanReadableDescription: "Implement standard behavior for scrollLeft, scrollTop, scrollWidth, scrollHeight, scrollTo, scrollBy and scrollingElement."
1229	category: experimental	1228	category: experimental
1230		1229
		1230	CSSOMViewSmoothScrollingEnabled:
		1231	type: bool
		1232	defaultValue: false
		1233	humanReadableName: "CSSOM View Smooth Scrolling"
		1234	humanReadableDescription: "Enable DOM API and CSS property for 'smooth' scroll behavior"
		1235	category: experimental
		1236
1231	WebAnimationsEnabled:	1237	WebAnimationsEnabled:
1232	type: bool	1238	type: bool
1233	defaultValue: true	1239	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-06 Rob Buis <rbuis@igalia.com>	152	2018-11-06 Rob Buis <rbuis@igalia.com>
2		153
3	Some minor X-Content-Type-Options parsing issues	154	Some minor X-Content-Type-Options parsing issues

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-05 Zan Dobersek <zdobersek@igalia.com>	12	2018-11-05 Zan Dobersek <zdobersek@igalia.com>
2		13
3	[WPE] Remove BackingStore, BackingStoreCairo implementation files from build	14	[WPE] Remove BackingStore, BackingStoreCairo implementation files from 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-02 Daniel Bates <dabates@apple.com>	18	2018-11-02 Daniel Bates <dabates@apple.com>
2		19
3	[iOS] WebKit should dispatch DOM events when a modifier key is pressed	20	[iOS] WebKit should dispatch DOM events when a modifier key is pressed

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 870-877 set(WebCore_NON_SVG_IDL_FILES a/Source/WebCore/CMakeLists.txt_sec1
- a/Source/WebCore/CMakeLists.txt +2 lines
870	page/PerformanceTiming.idl	870	page/PerformanceTiming.idl
871	page/RemoteDOMWindow.idl	871	page/RemoteDOMWindow.idl
872	page/Screen.idl	872	page/Screen.idl
		873	page/ScrollBehavior.idl
873	page/ScrollIntoViewOptions.idl	874	page/ScrollIntoViewOptions.idl
874	page/ScrollLogicalPosition.idl	875	page/ScrollLogicalPosition.idl
		876	page/ScrollOptions.idl
875	page/ScrollToOptions.idl	877	page/ScrollToOptions.idl
876	page/ShareData.idl	878	page/ShareData.idl
877	page/VisualViewport.idl	879	page/VisualViewport.idl

Lines 831-838 JS_BINDING_IDLS = \ a/Source/WebCore/DerivedSources.make_sec1
- a/Source/WebCore/DerivedSources.make +2 lines
831	$(WebCore)/page/PerformanceTiming.idl \	831	$(WebCore)/page/PerformanceTiming.idl \
832	$(WebCore)/page/RemoteDOMWindow.idl \	832	$(WebCore)/page/RemoteDOMWindow.idl \
833	$(WebCore)/page/Screen.idl \	833	$(WebCore)/page/Screen.idl \
		834	$(WebCore)/page/ScrollBehavior.idl \
834	$(WebCore)/page/ScrollIntoViewOptions.idl \	835	$(WebCore)/page/ScrollIntoViewOptions.idl \
835	$(WebCore)/page/ScrollLogicalPosition.idl \	836	$(WebCore)/page/ScrollLogicalPosition.idl \
		837	$(WebCore)/page/ScrollOptions.idl \
836	$(WebCore)/page/ScrollToOptions.idl \	838	$(WebCore)/page/ScrollToOptions.idl \
837	$(WebCore)/page/UserMessageHandler.idl \	839	$(WebCore)/page/UserMessageHandler.idl \
838	$(WebCore)/page/UserMessageHandlersNamespace.idl \	840	$(WebCore)/page/UserMessageHandlersNamespace.idl \

Lines 1459-1464 page/ResourceUsageOverlay.cpp a/Source/WebCore/Sources.txt_sec1
- a/Source/WebCore/Sources.txt +4 lines
1459	page/ResourceUsageThread.cpp	1459	page/ResourceUsageThread.cpp
1460	page/RuntimeEnabledFeatures.cpp	1460	page/RuntimeEnabledFeatures.cpp
1461	page/Screen.cpp	1461	page/Screen.cpp
		1462	page/ScrollBehavior.cpp
1462	page/SecurityOrigin.cpp	1463	page/SecurityOrigin.cpp
1463	page/SecurityOriginData.cpp	1464	page/SecurityOriginData.cpp
1464	page/SecurityPolicy.cpp	1465	page/SecurityPolicy.cpp
Lines 1555-1560 platform/RemoteCommandListener.cpp a/Source/WebCore/Sources.txt_sec2
1555	platform/RuntimeApplicationChecks.cpp	1556	platform/RuntimeApplicationChecks.cpp
1556	platform/SchemeRegistry.cpp	1557	platform/SchemeRegistry.cpp
1557	platform/ScrollAnimator.cpp	1558	platform/ScrollAnimator.cpp
		1559	platform/ScrollAnimationSmooth.cpp
1558	platform/ScrollView.cpp	1560	platform/ScrollView.cpp
1559	platform/ScrollableArea.cpp	1561	platform/ScrollableArea.cpp
1560	platform/Scrollbar.cpp	1562	platform/Scrollbar.cpp
Lines 3130-3137 JSSVGZoomEvent.cpp a/Source/WebCore/Sources.txt_sec3
3130	JSScreen.cpp	3132	JSScreen.cpp
3131	JSScreenLuminance.cpp	3133	JSScreenLuminance.cpp
3132	JSScriptProcessorNode.cpp	3134	JSScriptProcessorNode.cpp
		3135	JSScrollBehavior.cpp
3133	JSScrollIntoViewOptions.cpp	3136	JSScrollIntoViewOptions.cpp
3134	JSScrollLogicalPosition.cpp	3137	JSScrollLogicalPosition.cpp
		3138	JSScrollOptions.cpp
3135	JSScrollToOptions.cpp	3139	JSScrollToOptions.cpp
3136	JSSecurityPolicyViolationEvent.cpp	3140	JSSecurityPolicyViolationEvent.cpp
3137	JSServiceWorker.cpp	3141	JSServiceWorker.cpp

Lines 2369-2374 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj +28 lines
2369	83407FC11E8D9C1700E048D3 /* VisibilityChangeClient.h in Headers / = {isa = PBXBuildFile; fileRef = 83407FC01E8D9C1200E048D3 / VisibilityChangeClient.h */; settings = {ATTRIBUTES = (Private, ); }; };	2369	83407FC11E8D9C1700E048D3 /* VisibilityChangeClient.h in Headers / = {isa = PBXBuildFile; fileRef = 83407FC01E8D9C1200E048D3 / VisibilityChangeClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
2370	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8D4 / JSScrollLogicalPosition.h */; };	2370	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8D4 / JSScrollLogicalPosition.h */; };
2371	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8E5 / JSScrollIntoViewOptions.h */; };	2371	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFD8E5 / JSScrollIntoViewOptions.h */; };
		2372	834476EF1DA5BC5E002B6EB0 /* JSScrollBehavior.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8D4 / JSScrollBehavior.h */; };
		2373	834476EF1DA5BC5E002B6EC1 /* JSScrollOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8E5 / JSScrollOptions.h */; };
2372	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8F6 / JSScrollToOptions.h */; };	2374	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 83E9B3011DA5A51E00FFE8F6 / JSScrollToOptions.h */; };
2373	8348BFAC1B85729800912F36 /* ClassCollection.h in Headers / = {isa = PBXBuildFile; fileRef = 8348BFAA1B85729500912F36 / ClassCollection.h */; };	2375	8348BFAC1B85729800912F36 /* ClassCollection.h in Headers / = {isa = PBXBuildFile; fileRef = 8348BFAA1B85729500912F36 / ClassCollection.h */; };
2374	834DFAD01F7DAE5D00C2725B /* SharedStringHash.h in Headers / = {isa = PBXBuildFile; fileRef = 834DFACC1F7DAE5600C2725B / SharedStringHash.h */; settings = {ATTRIBUTES = (Private, ); }; };	2376	834DFAD01F7DAE5D00C2725B /* SharedStringHash.h in Headers / = {isa = PBXBuildFile; fileRef = 834DFACC1F7DAE5600C2725B / SharedStringHash.h */; settings = {ATTRIBUTES = (Private, ); }; };
Lines 2443-2448 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
2443	83C45B8E1DC2B68A008871BA /* ValidationBubble.h in Headers / = {isa = PBXBuildFile; fileRef = 83C45B8D1DC2B67C008871BA / ValidationBubble.h */; settings = {ATTRIBUTES = (Private, ); }; };	2445	83C45B8E1DC2B68A008871BA /* ValidationBubble.h in Headers / = {isa = PBXBuildFile; fileRef = 83C45B8D1DC2B67C008871BA / ValidationBubble.h */; settings = {ATTRIBUTES = (Private, ); }; };
2444	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355424 / ScrollLogicalPosition.h */; settings = {ATTRIBUTES = (Private, ); }; };	2446	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355424 / ScrollLogicalPosition.h */; settings = {ATTRIBUTES = (Private, ); }; };
2445	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355435 / ScrollIntoViewOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };	2447	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200355435 / ScrollIntoViewOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
		2448	83C5795D1DA5C301006FAC86 /* ScrollBehavior.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356424 / ScrollBehavior.h */; settings = {ATTRIBUTES = (Private, ); }; };
		2449	83C5795D1DA5C301006FAC97 /* ScrollOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356435 / ScrollOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
2446	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356446 / ScrollToOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };	2450	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 8350C3E71DA59B6200356446 / ScrollToOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
2447	83D35AEC1C7187FA00F70D5A /* XMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AEA1C7187ED00F70D5A / XMLHttpRequestEventTarget.h */; };	2451	83D35AEC1C7187FA00F70D5A /* XMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AEA1C7187ED00F70D5A / XMLHttpRequestEventTarget.h */; };
2448	83D35AF21C718D9000F70D5A /* JSXMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AF01C718D8400F70D5A / JSXMLHttpRequestEventTarget.h */; };	2452	83D35AF21C718D9000F70D5A /* JSXMLHttpRequestEventTarget.h in Headers / = {isa = PBXBuildFile; fileRef = 83D35AF01C718D8400F70D5A / JSXMLHttpRequestEventTarget.h */; };
Lines 9959-9964 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
9959	834DFACE1F7DAE5700C2725B /* SharedStringHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedStringHash.cpp; sourceTree = "<group>"; };	9963	834DFACE1F7DAE5700C2725B /* SharedStringHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedStringHash.cpp; sourceTree = "<group>"; };
9960	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollLogicalPosition.h; sourceTree = "<group>"; };	9964	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollLogicalPosition.h; sourceTree = "<group>"; };
9961	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollIntoViewOptions.h; sourceTree = "<group>"; };	9965	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollIntoViewOptions.h; sourceTree = "<group>"; };
		9966	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollIntoViewOptions.idl; sourceTree = "<group>"; };
		9967	8350C3E71DA59B6200356424 /* ScrollBehavior.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollBehavior.h; sourceTree = "<group>"; };
		9968	8350C3E71DA59B6200356434 /* ScrollBehavior.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollBehavior.cpp; sourceTree = "<group>"; };
		9969	8350C3E81DA59B6200356424 /* ScrollBehavior.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollBehavior.idl; sourceTree = "<group>"; };
		9970	8350C3E71DA59B6200356435 /* ScrollOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollOptions.h; sourceTree = "<group>"; };
		9971	8350C3E81DA59B6200356435 /* ScrollOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollOptions.idl; sourceTree = "<group>"; };
9962	8350C3E71DA59B6200356446 /* ScrollToOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollToOptions.h; sourceTree = "<group>"; };	9972	8350C3E71DA59B6200356446 /* ScrollToOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollToOptions.h; sourceTree = "<group>"; };
9963	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollLogicalPosition.idl; sourceTree = "<group>"; };	9973	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollLogicalPosition.idl; sourceTree = "<group>"; };
9964	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollIntoViewOptions.idl; sourceTree = "<group>"; };	9974	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ScrollIntoViewOptions.idl; sourceTree = "<group>"; };
Lines 10100-10105 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
10100	83E959E11B8BC22B004D9385 /* NativeNodeFilter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeNodeFilter.h; sourceTree = "<group>"; };	10110	83E959E11B8BC22B004D9385 /* NativeNodeFilter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeNodeFilter.h; sourceTree = "<group>"; };
10101	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollLogicalPosition.cpp; sourceTree = "<group>"; };	10111	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollLogicalPosition.cpp; sourceTree = "<group>"; };
10102	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollIntoViewOptions.cpp; sourceTree = "<group>"; };	10112	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollIntoViewOptions.cpp; sourceTree = "<group>"; };
		10113	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollIntoViewOptions.h; sourceTree = "<group>"; };
		10114	83E9B3001DA5A51E00FFE8D4 /* JSScrollBehavior.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollBehavior.cpp; sourceTree = "<group>"; };
		10115	83E9B3011DA5A51E00FFE8D4 /* JSScrollBehavior.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollBehavior.h; sourceTree = "<group>"; };
		10116	83E9B3001DA5A51E00FFE8E5 /* JSScrollOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollOptions.cpp; sourceTree = "<group>"; };
		10117	83E9B3011DA5A51E00FFE8E5 /* JSScrollOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollOptions.h; sourceTree = "<group>"; };
10103	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollToOptions.cpp; sourceTree = "<group>"; };	10118	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSScrollToOptions.cpp; sourceTree = "<group>"; };
10104	83E9B3011DA5A51E00FFD8D4 /* JSScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollLogicalPosition.h; sourceTree = "<group>"; };	10119	83E9B3011DA5A51E00FFD8D4 /* JSScrollLogicalPosition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollLogicalPosition.h; sourceTree = "<group>"; };
10105	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollIntoViewOptions.h; sourceTree = "<group>"; };	10120	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSScrollIntoViewOptions.h; sourceTree = "<group>"; };
Lines 19914-19923 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec5
19914	BCEC01BA0C274DAC009F4EC9 /* Screen.cpp */,	19929	BCEC01BA0C274DAC009F4EC9 /* Screen.cpp */,
19915	BCEC01BB0C274DAC009F4EC9 /* Screen.h */,	19930	BCEC01BB0C274DAC009F4EC9 /* Screen.h */,
19916	BCEC01BC0C274DAC009F4EC9 /* Screen.idl */,	19931	BCEC01BC0C274DAC009F4EC9 /* Screen.idl */,
		19932	8350C3E71DA59B6200356434 /* ScrollBehavior.cpp */,
		19933	8350C3E71DA59B6200356424 /* ScrollBehavior.h */,
		19934	8350C3E81DA59B6200356424 /* ScrollBehavior.idl */,
19917	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */,	19935	8350C3E71DA59B6200355435 /* ScrollIntoViewOptions.h */,
19918	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */,	19936	8350C3E81DA59B6200355435 /* ScrollIntoViewOptions.idl */,
19919	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */,	19937	8350C3E71DA59B6200355424 /* ScrollLogicalPosition.h */,
19920	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */,	19938	8350C3E81DA59B6200355424 /* ScrollLogicalPosition.idl */,
		19939	8350C3E71DA59B6200356435 /* ScrollOptions.h */,
		19940	8350C3E81DA59B6200356435 /* ScrollOptions.idl */,
19921	8350C3E71DA59B6200356446 /* ScrollToOptions.h */,	19941	8350C3E71DA59B6200356446 /* ScrollToOptions.h */,
19922	8350C3E81DA59B6200356446 /* ScrollToOptions.idl */,	19942	8350C3E81DA59B6200356446 /* ScrollToOptions.idl */,
19923	BCD0E0F70E972C3500265DEA /* SecurityOrigin.cpp */,	19943	BCD0E0F70E972C3500265DEA /* SecurityOrigin.cpp */,
Lines 24680-24689 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec6
24680	46C376612085176D00C73829 /* JSRemoteDOMWindow.h */,	24700	46C376612085176D00C73829 /* JSRemoteDOMWindow.h */,
24681	BCEC01C00C274DDD009F4EC9 /* JSScreen.cpp */,	24701	BCEC01C00C274DDD009F4EC9 /* JSScreen.cpp */,
24682	BCEC01C10C274DDD009F4EC9 /* JSScreen.h */,	24702	BCEC01C10C274DDD009F4EC9 /* JSScreen.h */,
		24703	83E9B3001DA5A51E00FFE8D4 /* JSScrollBehavior.cpp */,
		24704	83E9B3011DA5A51E00FFE8D4 /* JSScrollBehavior.h */,
24683	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */,	24705	83E9B3001DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.cpp */,
24684	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */,	24706	83E9B3011DA5A51E00FFD8E5 /* JSScrollIntoViewOptions.h */,
24685	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */,	24707	83E9B3001DA5A51E00FFD8D4 /* JSScrollLogicalPosition.cpp */,
24686	83E9B3011DA5A51E00FFD8D4 /* JSScrollLogicalPosition.h */,	24708	83E9B3011DA5A51E00FFD8D4 /* JSScrollLogicalPosition.h */,
		24709	83E9B3001DA5A51E00FFE8E5 /* JSScrollOptions.cpp */,
		24710	83E9B3011DA5A51E00FFE8E5 /* JSScrollOptions.h */,
24687	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */,	24711	83E9B3001DA5A51E00FFE8F6 /* JSScrollToOptions.cpp */,
24688	83E9B3011DA5A51E00FFE8F6 /* JSScrollToOptions.h */,	24712	83E9B3011DA5A51E00FFE8F6 /* JSScrollToOptions.h */,
24689	7C73FB0F191EF6F4007DE061 /* JSUserMessageHandler.cpp */,	24713	7C73FB0F191EF6F4007DE061 /* JSUserMessageHandler.cpp */,
Lines 29567-29574 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec7
29567	5E2C436C1BCF071E0001E2BC /* JSRTCTrackEvent.h in Headers */,	29591	5E2C436C1BCF071E0001E2BC /* JSRTCTrackEvent.h in Headers */,
29568	BCEC01C30C274DDD009F4EC9 /* JSScreen.h in Headers */,	29592	BCEC01C30C274DDD009F4EC9 /* JSScreen.h in Headers */,
29569	FDA15ECE12B03F61003A583A /* JSScriptProcessorNode.h in Headers */,	29593	FDA15ECE12B03F61003A583A /* JSScriptProcessorNode.h in Headers */,
		29594	834476EF1DA5BC5E002B6EB0 /* JSScrollBehavior.h in Headers */,
29570	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers */,	29595	834476EF1DA5BC5E002B5EC1 /* JSScrollIntoViewOptions.h in Headers */,
29571	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers */,	29596	834476EF1DA5BC5E002B5EB0 /* JSScrollLogicalPosition.h in Headers */,
		29597	834476EF1DA5BC5E002B6EC1 /* JSScrollOptions.h in Headers */,
29572	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers */,	29598	834476EF1DA5BC5E002B6ED2 /* JSScrollToOptions.h in Headers */,
29573	CED06AD11C77754800FDFAF1 /* JSSecurityPolicyViolationEvent.h in Headers */,	29599	CED06AD11C77754800FDFAF1 /* JSSecurityPolicyViolationEvent.h in Headers */,
29574	5182C2561F3143CD0059BA7C /* JSServiceWorker.h in Headers */,	29600	5182C2561F3143CD0059BA7C /* JSServiceWorker.h in Headers */,
Lines 30732-30737 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec8
30732	44C991860F3D1EBE00586670 /* ScrollbarThemeIOS.h in Headers */,	30758	44C991860F3D1EBE00586670 /* ScrollbarThemeIOS.h in Headers */,
30733	BC8B853E0E7C7F1100AB6984 /* ScrollbarThemeMac.h in Headers */,	30759	BC8B853E0E7C7F1100AB6984 /* ScrollbarThemeMac.h in Headers */,
30734	0FE71406142170B800DB33BA /* ScrollbarThemeMock.h in Headers */,	30760	0FE71406142170B800DB33BA /* ScrollbarThemeMock.h in Headers */,
		30761	83C5795D1DA5C301006FAC86 /* ScrollBehavior.h in Headers */,
30735	1AA84F05143BA7BD0051D153 /* ScrollController.h in Headers */,	30762	1AA84F05143BA7BD0051D153 /* ScrollController.h in Headers */,
30736	0F605AED15F94848004DF0C0 /* ScrollingConstraints.h in Headers */,	30763	0F605AED15F94848004DF0C0 /* ScrollingConstraints.h in Headers */,
30737	1AF62EE814DA22A70041556C /* ScrollingCoordinator.h in Headers */,	30764	1AF62EE814DA22A70041556C /* ScrollingCoordinator.h in Headers */,
Lines 30762-30767 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec9
30762	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers */,	30789	83C5795D1DA5C301006F9C97 /* ScrollIntoViewOptions.h in Headers */,
30763	7AAFE8D019CB8672000F56D8 /* ScrollLatchingState.h in Headers */,	30790	7AAFE8D019CB8672000F56D8 /* ScrollLatchingState.h in Headers */,
30764	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers */,	30791	83C5795D1DA5C301006F9C86 /* ScrollLogicalPosition.h in Headers */,
		30792	83C5795D1DA5C301006FAC97 /* ScrollOptions.h in Headers */,
30765	F478755419983AFF0024A287 /* ScrollSnapAnimatorState.h in Headers */,	30793	F478755419983AFF0024A287 /* ScrollSnapAnimatorState.h in Headers */,
30766	F46729281E0DE68500ACC3D8 /* ScrollSnapOffsetsInfo.h in Headers */,	30794	F46729281E0DE68500ACC3D8 /* ScrollSnapOffsetsInfo.h in Headers */,
30767	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers */,	30795	83C5795D1DA5C301006FACA8 /* ScrollToOptions.h in Headers */,

Lines 69-74 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
69	constantPropertiesEnabled = document.settings().constantPropertiesEnabled();	69	constantPropertiesEnabled = document.settings().constantPropertiesEnabled();
70	colorFilterEnabled = document.settings().colorFilterEnabled();	70	colorFilterEnabled = document.settings().colorFilterEnabled();
71	deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();	71	deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();
		72	scrollBehaviorEnabled = document.settings().CSSOMViewSmoothScrollingEnabled();
72	useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;	73	useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;
73		74
74	#if PLATFORM(IOS_FAMILY)	75	#if PLATFORM(IOS_FAMILY)
Lines 95-100 bool operator==(const CSSParserContext& a, const CSSParserContext& b) a/Source/WebCore/css/parser/CSSParserContext.cpp_sec2
95	&& a.constantPropertiesEnabled == b.constantPropertiesEnabled	96	&& a.constantPropertiesEnabled == b.constantPropertiesEnabled
96	&& a.colorFilterEnabled == b.colorFilterEnabled	97	&& a.colorFilterEnabled == b.colorFilterEnabled
97	&& a.deferredCSSParserEnabled == b.deferredCSSParserEnabled	98	&& a.deferredCSSParserEnabled == b.deferredCSSParserEnabled
		99	&& a.scrollBehaviorEnabled == b.scrollBehaviorEnabled
98	&& a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin	100	&& a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin
99	&& a.useSystemAppearance == b.useSystemAppearance;	101	&& a.useSystemAppearance == b.useSystemAppearance;
100	}	102	}

Lines 56-61 public: a/Source/WebCore/css/parser/CSSParserContext.h_sec1
- a/Source/WebCore/css/parser/CSSParserContext.h -3 / +5 lines
56	bool constantPropertiesEnabled { false };	56	bool constantPropertiesEnabled { false };
57	bool colorFilterEnabled { false };	57	bool colorFilterEnabled { false };
58	bool deferredCSSParserEnabled { false };	58	bool deferredCSSParserEnabled { false };
		59	bool scrollBehaviorEnabled { false };
59		60
60	// This is only needed to support getMatchedCSSRules.	61	// This is only needed to support getMatchedCSSRules.
61	bool hasDocumentSecurityOrigin { false };	62	bool hasDocumentSecurityOrigin { false };
Lines 96-104 struct CSSParserContextHash { a/Source/WebCore/css/parser/CSSParserContext.h_sec2
96	& key.constantPropertiesEnabled << 6	97	& key.constantPropertiesEnabled << 6
97	& key.colorFilterEnabled << 7	98	& key.colorFilterEnabled << 7
98	& key.deferredCSSParserEnabled << 8	99	& key.deferredCSSParserEnabled << 8
99	& key.hasDocumentSecurityOrigin << 9	100	& key.scrollBehaviorEnabled << 9
100	& key.useSystemAppearance << 10	101	& key.hasDocumentSecurityOrigin << 10
101	& key.mode << 11; // Keep this last.	102	& key.useSystemAppearance << 11
		103	& key.mode << 12; // Keep this last.
102	hash ^= WTF::intHash(bits);	104	hash ^= WTF::intHash(bits);
103	return hash;	105	return hash;
104	}	106	}

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 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-05 Jonathan Bedard <jbedard@apple.com>	12	2018-11-05 Jonathan Bedard <jbedard@apple.com>
2		13
3	webkitpy: Generalize trailing SDK specifier (Part 1)	14	webkitpy: Generalize trailing SDK specifier (Part 1)

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-06 Frederic Wang <fwang@igalia.com>	11	2018-11-06 Frederic Wang <fwang@igalia.com>
2		12
3	Overlay with -webkit-overflow-scrolling:touch doesn't become scrollable after added text makes it taller	13	Overlay with -webkit-overflow-scrolling:touch doesn't become scrollable after added text makes it taller

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-06 Rob Buis <rbuis@igalia.com>	26	2018-11-06 Rob Buis <rbuis@igalia.com>
2		27
3	Some minor X-Content-Type-Options parsing issues	28	Some minor X-Content-Type-Options parsing issues

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