ChangeLog

2017-03-06  Simon Fraser  <simon.fraser@apple.com>

        Add support for history.scrollRestoration

        https://bugs.webkit.org/show_bug.cgi?id=147782

        rdar://problem/22614568

        Reviewed by NOBODY (OOPS!).

        Add Mac support for history.scrollRestoration, per spec:

        <https://html.spec.whatwg.org/multipage/browsers.html#dom-history-scroll-restoration>

        This is a new attribute on the History interface. On setting, sets the "shouldRestoreScrollPosition"

        state on the current history item, and the getter returns that state. pushState() inherits the

        state from the current item.

        HistoryController::restoreScrollPositionAndViewState() consults this state, and if set to "manual"

        ("don't restore) it just uses the current scroll position (we need something to pass to

        setPageScaleFactor() so can't just avoid the restoration).

        FrameLoader::scrollToFragmentWithParentBoundary() also needs to consult the historyItem

        to know if it's OK to scroll to a fragment, on back/forward same-document loads.

        Tests: fast/history/history-scroll-restoration-attribute.html

               fast/history/history-scroll-restoration.html

        * history/HistoryItem.cpp:

        (WebCore::HistoryItem::HistoryItem):

        (WebCore::HistoryItem::shouldRestoreScrollPosition):

        (WebCore::HistoryItem::setShouldRestoreScrollPosition):

        * history/HistoryItem.h:

        * loader/FrameLoader.cpp:

        (WebCore::FrameLoader::loadInSameDocument):

        (WebCore::itemAllowsScrollRestoration):

        (WebCore::isSameDocumentReload):

        (WebCore::FrameLoader::scrollToFragmentWithParentBoundary):

        (WebCore::FrameLoader::continueLoadAfterNavigationPolicy):

        * loader/FrameLoader.h:

        * loader/HistoryController.cpp:

        (WebCore::HistoryController::restoreScrollPositionAndViewState):

        (WebCore::HistoryController::goToItem):

        (WebCore::HistoryController::pushState):

        (WebCore::HistoryController::replaceState):

        * page/History.cpp:

        (WebCore::History::scrollRestoration):

        (WebCore::History::setScrollRestoration):

        * page/History.h:

        * page/History.idl:

2017-03-04  Myles C. Maxfield  <mmaxfield@apple.com>

        Update CSSFontSelector's matching algorithm to understand ranges

Source/WebKit2/ChangeLog

2017-03-07  Simon Fraser  <simon.fraser@apple.com>

        Add support for history.scrollRestoration

        https://bugs.webkit.org/show_bug.cgi?id=147782

        rdar://problem/22614568

        Reviewed by NOBODY (OOPS!).

        Need to send shouldRestoreScrollPosition to the UI process in SessionState,

        WKWebView now stores _unobscuredCenterToRestore and _scrollOffsetToRestore as

        std::optionals, and they will be nullopt if scroll restoration should not happen.

        ViewGestureControllerIOS also needs knowledge of whether scroll restoration will

        happen, and compares UI-process scroll position vs. the position at snapshot time

        to know if the snapshot should be shown (this prevents showing a misleading snapshot

        when swiping back on a navigation where scroll restoration is disabled).

        * Shared/SessionState.cpp:

        (WebKit::FrameState::encode):

        (WebKit::FrameState::decode):

        * Shared/SessionState.h:

        * Shared/WebBackForwardListItem.h:

        (WebKit::WebBackForwardListItem::pageState):

        * UIProcess/API/Cocoa/WKWebView.mm:

        (-[WKWebView _processDidExit]):

        (-[WKWebView _didCommitLayerTree:]):

        (-[WKWebView _restorePageScrollPosition:scrollOrigin:previousObscuredInset:scale:]):

        (-[WKWebView _restorePageStateToUnobscuredCenter:scale:]):

        * UIProcess/API/Cocoa/WKWebViewInternal.h:

        * UIProcess/API/gtk/PageClientImpl.cpp:

        (WebKit::PageClientImpl::viewScrollPosition):

        * UIProcess/API/gtk/PageClientImpl.h:

        * UIProcess/PageClient.h:

        * UIProcess/WebPageProxy.cpp:

        (WebKit::WebPageProxy::viewScrollPosition):

        * UIProcess/WebPageProxy.h:

        * UIProcess/WebPageProxy.messages.in:

        * UIProcess/ios/PageClientImplIOS.h:

        * UIProcess/ios/PageClientImplIOS.mm:

        (WebKit::PageClientImpl::viewScrollPosition):

        (WebKit::PageClientImpl::restorePageState):

        (WebKit::PageClientImpl::restorePageCenterAndScale):

        * UIProcess/ios/ViewGestureControllerIOS.mm:

        (WebKit::ViewGestureController::beginSwipeGesture):

        * UIProcess/ios/WebPageProxyIOS.mm:

        (WebKit::WebPageProxy::restorePageState):

        (WebKit::WebPageProxy::restorePageCenterAndScale):

        * UIProcess/mac/PageClientImpl.h:

        * UIProcess/mac/PageClientImpl.mm:

        (WebKit::PageClientImpl::viewScrollPosition):

        * UIProcess/mac/ViewSnapshotStore.h:

        (WebKit::ViewSnapshot::setViewScrollPosition):

        (WebKit::ViewSnapshot::viewScrollPosition):

        * UIProcess/mac/ViewSnapshotStore.mm:

        (WebKit::ViewSnapshotStore::recordSnapshot):

        * WebProcess/WebCoreSupport/SessionStateConversion.cpp:

        (WebKit::toFrameState):

        (WebKit::applyFrameState):

        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:

        (WebKit::WebFrameLoaderClient::restoreViewState):

        * WebProcess/WebPage/ios/WebPageIOS.mm:

        (WebKit::WebPage::restorePageState):

2017-03-04  Eric Carlson  <eric.carlson@apple.com>

        [iOS] The web process should inherit application state from UI process

Source/WebCore/history/HistoryItem.cpp

@@static void defaultNotifyHistoryItemChanged(HistoryItem*)

WEBCORE_EXPORT void (*notifyHistoryItemChanged)(HistoryItem*) = defaultNotifyHistoryItemChanged;

HistoryItem::HistoryItem()

    : m_pageScaleFactor(0)

    , m_lastVisitWasFailure(false)

    , m_isTargetItem(false)

    , m_itemSequenceNumber(generateSequenceNumber())

59 : m_itemSequenceNumber(generateSequenceNumber())

    , m_documentSequenceNumber(generateSequenceNumber())

    , m_pruningReason(PruningReason::None)

{

@@HistoryItem::HistoryItem(const String& urlString, const String& title)

    : m_urlString(urlString)

    , m_originalURLString(urlString)

    , m_title(title)

    , m_pageScaleFactor(0)

    , m_lastVisitWasFailure(false)

    , m_isTargetItem(false)

    , m_itemSequenceNumber(generateSequenceNumber())

    , m_documentSequenceNumber(generateSequenceNumber())

    , m_pruningReason(PruningReason::None)

@@HistoryItem::HistoryItem(const String& urlString, const String& title, const Str

    , m_title(title)

    , m_displayTitle(alternateTitle)

    , m_pageScaleFactor(0)

88 , m_lastVisitWasFailure(false)

89 , m_isTargetItem(false)

    , m_itemSequenceNumber(generateSequenceNumber())

    , m_documentSequenceNumber(generateSequenceNumber())

    , m_pruningReason(PruningReason::None)

@@void HistoryItem::clearScrollPosition()

    m_scrollPosition = IntPoint();

}

bool HistoryItem::shouldRestoreScrollPosition() const

{

    return m_shouldRestoreScrollPosition;

}

void HistoryItem::setShouldRestoreScrollPosition(bool shouldRestore)

{

    m_shouldRestoreScrollPosition = shouldRestore;

}

float HistoryItem::pageScaleFactor() const

{

    return m_pageScaleFactor;

Source/WebCore/history/HistoryItem.h

@@public:

    WEBCORE_EXPORT const IntPoint& scrollPosition() const;

    WEBCORE_EXPORT void setScrollPosition(const IntPoint&);

    void clearScrollPosition();

    WEBCORE_EXPORT bool shouldRestoreScrollPosition() const;

    WEBCORE_EXPORT void setShouldRestoreScrollPosition(bool);

    
    WEBCORE_EXPORT float pageScaleFactor() const;

    WEBCORE_EXPORT void setPageScaleFactor(float);

@@private:

    String m_displayTitle;

    IntPoint m_scrollPosition;

218 float m_pageScaleFactor;

221 float m_pageScaleFactor { 0 }; // 0 indicates "unset".

    Vector<String> m_documentState;

    ShouldOpenExternalURLsPolicy m_shouldOpenExternalURLsPolicy { ShouldOpenExternalURLsPolicy::ShouldNotAllow };

    Vector<Ref<HistoryItem>> m_children;

225 bool m_lastVisitWasFailure;

226 bool m_isTargetItem;

228 bool m_lastVisitWasFailure { false };

229 bool m_isTargetItem { false };

227230 bool m_wasRestoredFromSession { false };

231 bool m_shouldRestoreScrollPosition { true };

    // If two HistoryItems have the same item sequence number, then they are

    // clones of one another.  Traversing history from one such HistoryItem to

Source/WebCore/loader/FrameLoader.cpp

@@void FrameLoader::loadInSameDocument(const URL& url, SerializedScriptValue* stat

    // We need to scroll to the fragment whether or not a hash change occurred, since

    // the user might have scrolled since the previous navigation.

1058 scrollToFragmentWithParentBoundary(url);

1058 scrollToFragmentWithParentBoundary(url, isNewNavigation);

    
    m_isComplete = false;

    checkCompleted();

@@bool FrameLoader::shouldPerformFragmentNavigation(bool isFormSubmission, const S

        && !m_frame.document()->isFrameSet();

}

2871 void FrameLoader::scrollToFragmentWithParentBoundary(const URL& url)

static bool itemAllowsScrollRestoration(HistoryItem *historyItem)

{

    return historyItem && historyItem->shouldRestoreScrollPosition();

}

static bool isSameDocumentReload(bool isNewNavigation, FrameLoadType loadType)

{

    return !isNewNavigation && !isBackForwardLoadType(loadType);

}

void FrameLoader::scrollToFragmentWithParentBoundary(const URL& url, bool isNewNavigation)

{

    FrameView* view = m_frame.view();

    if (!view)

@@void FrameLoader::scrollToFragmentWithParentBoundary(const URL& url)

    if (boundaryFrame)

        boundaryFrame->view()->setSafeToPropagateScrollToParent(false);

2883 view->scrollToFragment(url);

2893 if (isSameDocumentReload(isNewNavigation, m_loadType) || itemAllowsScrollRestoration(history().currentItem()))

2894 view->scrollToFragment(url);

    if (boundaryFrame)

        boundaryFrame->view()->setSafeToPropagateScrollToParent(true);

@@void FrameLoader::continueLoadAfterNavigationPolicy(const ResourceRequest& reque

        setPolicyDocumentLoader(nullptr);

        // If the navigation request came from the back/forward menu, and we punt on it, we have the

3085 // problem that we have optimistically moved the b/f cursor already, so move it back. For sanity,

3096 // problem that we have optimistically moved the b/f cursor already, so move it back. For sanity,

        // we only do this when punting a navigation for the target frame or top-level frame.  

        if ((isTargetItem || m_frame.isMainFrame()) && isBackForwardLoadType(policyChecker().loadType())) {

            if (Page* page = m_frame.page()) {

Source/WebCore/loader/FrameLoader.h

@@private:

    void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);

    bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const URL&);

337 void scrollToFragmentWithParentBoundary(const URL&);

337 void scrollToFragmentWithParentBoundary(const URL&, bool isNewNavigation = true);

    void checkLoadCompleteForThisFrame();

Source/WebCore/loader/HistoryController.cpp

@@void HistoryController::restoreScrollPositionAndViewState()

    // Don't restore scroll point on iOS as FrameLoaderClient::restoreViewState() does that.

    if (view && !view->wasScrolledByUser()) {

        Page* page = m_frame.page();

161 auto desiredScrollPosition = m_currentItem->scrollPosition();

161 auto desiredScrollPosition = m_currentItem->shouldRestoreScrollPosition() ? m_currentItem->scrollPosition() : view->scrollPosition();

        LOG(Scrolling, "HistoryController::restoreScrollPositionAndViewState scrolling to %d,%d", desiredScrollPosition.x(), desiredScrollPosition.y());

        if (page && m_frame.isMainFrame() && m_currentItem->pageScaleFactor())

            page->setPageScaleFactor(m_currentItem->pageScaleFactor() * page->viewScaleFactor(), desiredScrollPosition);

@@bool HistoryController::shouldStopLoadingForHistoryItem(HistoryItem& targetItem)

// This includes recursion to handle loading into framesets properly

void HistoryController::goToItem(HistoryItem& targetItem, FrameLoadType type)

{

294 LOG(History, "HistoryController %p goToItem %p type=%d", this, &targetItem, type);

295

    ASSERT(!m_frame.tree().parent());

    // shouldGoToHistoryItem is a private delegate method. This is needed to fix:

@@void HistoryController::pushState(RefPtr<SerializedScriptValue>&& stateObject, c

    Page* page = m_frame.page();

    ASSERT(page);

858 bool shouldRestoreScrollPosition = m_currentItem->shouldRestoreScrollPosition();

859

    // Get a HistoryItem tree for the current frame tree.

    Ref<HistoryItem> topItem = m_frame.mainFrame().loader().history().createItemTree(m_frame, false);

@@void HistoryController::pushState(RefPtr<SerializedScriptValue>&& stateObject, c

    m_currentItem->setTitle(title);

    m_currentItem->setStateObject(WTFMove(stateObject));

    m_currentItem->setURLString(urlString);

868 m_currentItem->setShouldRestoreScrollPosition(shouldRestoreScrollPosition);

864869

865 LOG(History, "HistoryController %p pushState: Adding top item %p, setting url of current item %p to %s", this, topItem.ptr(), m_currentItem.get(), urlString.ascii().data());

870 LOG(History, "HistoryController %p pushState: Adding top item %p, setting url of current item %p to %s, scrollRestoration is %s", this, topItem.ptr(), m_currentItem.get(), urlString.ascii().data(), topItem->shouldRestoreScrollPosition() ? "auto" : "manual");

    page->backForward().addItem(WTFMove(topItem));

@@void HistoryController::replaceState(RefPtr<SerializedScriptValue>&& stateObject

    if (!m_currentItem)

        return;

881 LOG(History, "HistoryController %p replaceState: Setting url of current item %p to %s", this, m_currentItem.get(), urlString.ascii().data());

886 LOG(History, "HistoryController %p replaceState: Setting url of current item %p to %s scrollRestoration %s", this, m_currentItem.get(), urlString.ascii().data(), m_currentItem->shouldRestoreScrollPosition() ? "auto" : "manual");

    if (!urlString.isEmpty())

        m_currentItem->setURLString(urlString);

Source/WebCore/page/History.cpp

@@unsigned History::length() const

    return page->backForward().count();

}

ExceptionOr<History::ScrollRestoration> History::scrollRestoration() const

{

    if (!m_frame)

        return Exception { SECURITY_ERR };

    auto* historyItem = m_frame->loader().history().currentItem();

    if (!historyItem)

        return ScrollRestoration::Auto;

    return historyItem->shouldRestoreScrollPosition() ? ScrollRestoration::Auto : ScrollRestoration::Manual;

}

ExceptionOr<void> History::setScrollRestoration(ScrollRestoration scrollRestoration)

{

    if (!m_frame)

        return Exception { SECURITY_ERR };

    auto* historyItem = m_frame->loader().history().currentItem();

    if (historyItem)

        historyItem->setShouldRestoreScrollPosition(scrollRestoration == ScrollRestoration::Auto);

    return { };

}

SerializedScriptValue* History::state()

{

    m_lastStateObjectRequested = stateInternal();

Source/WebCore/page/History.h

@@public:

    static Ref<History> create(Frame& frame) { return adoptRef(*new History(frame)); }

    unsigned length() const;

    
    enum class ScrollRestoration {

        Auto,

        Manual

    };

    ExceptionOr<ScrollRestoration> scrollRestoration() const;

    ExceptionOr<void> setScrollRestoration(ScrollRestoration);

    SerializedScriptValue* state();

    void back();

    void forward();

Source/WebCore/page/History.idl

    GenerateIsReachable=ImplFrame,

] interface History {

    readonly attribute unsigned long length;

30 [SetterMayThrowException, GetterMayThrowException] attribute ScrollRestoration scrollRestoration;

    [CachedAttribute, Custom] readonly attribute SerializedScriptValue state;

    [CallWith=Document, ForwardDeclareInHeader] void back();

    [Custom, MayThrowException] void pushState(any data, DOMString title, optional USVString? url = null);

    [Custom, MayThrowException] void replaceState(any data, DOMString title, optional USVString? url = null);

};

40

41enum ScrollRestoration { "auto", "manual" };

Source/WebKit2/Shared/SessionState.cpp

@@void FrameState::encode(IPC::Encoder& encoder) const

    encoder << itemSequenceNumber;

    encoder << scrollPosition;

117 encoder << shouldRestoreScrollPosition;

    encoder << pageScaleFactor;

    encoder << httpBody;

@@bool FrameState::decode(IPC::Decoder& decoder, FrameState& result)

    if (!decoder.decode(result.scrollPosition))

        return false;

156 if (!decoder.decode(result.shouldRestoreScrollPosition))

157 return false;

    if (!decoder.decode(result.pageScaleFactor))

        return false;

Source/WebKit2/Shared/SessionState.h

@@struct FrameState {

    int64_t itemSequenceNumber;

    WebCore::IntPoint scrollPosition;

99 bool shouldRestoreScrollPosition;

    float pageScaleFactor;

    std::optional<HTTPBody> httpBody;

Source/WebKit2/Shared/WebBackForwardListItem.h

@@public:

    uint64_t pageID() const { return m_pageID; }

    void setPageState(PageState pageState) { m_itemState.pageState = WTFMove(pageState); }

55 const PageState& pageState() const { return m_itemState.pageState; }

    const String& originalURL() const { return m_itemState.pageState.mainFrameState.originalURLString; }

    const String& url() const { return m_itemState.pageState.mainFrameState.urlString; }

Source/WebKit2/UIProcess/API/Cocoa/WKWebView.mm

@@@implementation WKWebView {

    std::optional<CGRect> _frozenVisibleContentRect;

    std::optional<CGRect> _frozenUnobscuredContentRect;

254 BOOL _needsToRestoreScrollPosition;

255254 BOOL _commitDidRestoreScrollPosition;

256 WebCore::FloatPoint _scrollOffsetToRestore;

255 std::optional<WebCore::FloatPoint> _scrollOffsetToRestore;

257256 WebCore::FloatSize _obscuredInsetWhenSaved;

258257

259 BOOL _needsToRestoreUnobscuredCenter;

260 WebCore::FloatPoint _unobscuredCenterToRestore;

258 std::optional<WebCore::FloatPoint> _unobscuredCenterToRestore;

    uint64_t _firstTransactionIDAfterPageRestore;

    double _scaleToRestore;

@@- (void)_processDidExit

    _needsResetViewStateAfterCommitLoadForMainFrame = NO;

    _dynamicViewportUpdateMode = DynamicViewportUpdateMode::NotResizing;

    [_contentView setHidden:NO];

1372 _n~~eeds~~ToRestore~~ScrollPosition~~ = NO;

1373 _~~needsToRestoreU~~nobscuredCenter = NO;

1370 _scrollOffsetToRestore = std::nullopt;

1371 _unobscuredCenterToRestore = std::nullopt;

    _scrollViewBackgroundColor = WebCore::Color();

    _delayUpdateVisibleContentRects = NO;

    _hadDelayedUpdateVisibleContentRects = NO;

@@- (void)_didCommitLayerTree:(const WebKit::RemoteLayerTreeTransaction&)layerTree

        needUpdateVisbleContentRects = YES;

    }

1493 bool isTransactionAfterPageRestore = layerTreeTransaction.transactionID() >= _firstTransactionIDAfterPageRestore;

    if (layerTreeTransaction.transactionID() >= _firstTransactionIDAfterPageRestore) {

        if (_scrollOffsetToRestore) {

            WebCore::FloatPoint scaledScrollOffset = _scrollOffsetToRestore.value();

            _scrollOffsetToRestore = std::nullopt;

14941495

1495 if (_needsToRestoreScrollPosition && isTransactionAfterPageRestore) {

1496 _needsToRestoreScrollPosition = NO;

            if (areEssentiallyEqualAsFloat(contentZoomScale(self), _scaleToRestore)) {

                scaledScrollOffset.scale(_scaleToRestore);

                WebCore::FloatPoint contentOffsetInScrollViewCoordinates = scaledScrollOffset - _obscuredInsetWhenSaved;

14971499

        if (areEssentiallyEqualAsFloat(contentZoomScale(self), _scaleToRestore)) {

            WebCore::FloatPoint scaledScrollOffset = _scrollOffsetToRestore;

            scaledScrollOffset.scale(_scaleToRestore);

            WebCore::FloatPoint contentOffsetInScrollViewCoordinates = scaledScrollOffset - _obscuredInsetWhenSaved;

            changeContentOffsetBoundedInValidRange(_scrollView.get(), contentOffsetInScrollViewCoordinates);

            _commitDidRestoreScrollPosition = YES;

            if (_gestureController)

                _gestureController->didRestoreScrollPosition();

                changeContentOffsetBoundedInValidRange(_scrollView.get(), contentOffsetInScrollViewCoordinates);

                _commitDidRestoreScrollPosition = YES;

            }

15081503 }

        
        needUpdateVisbleContentRects = YES;

    }

15121504

1513 if (_needsToRestoreUnobscuredCenter && isTransactionAfterPageRestore) {

1514 _needsToRestoreUnobscuredCenter = NO;

        if (_unobscuredCenterToRestore) {

            WebCore::FloatPoint unobscuredCenterToRestore = _unobscuredCenterToRestore.value();

            _unobscuredCenterToRestore = std::nullopt;

15151508

        if (areEssentiallyEqualAsFloat(contentZoomScale(self), _scaleToRestore)) {

            CGRect unobscuredRect = UIEdgeInsetsInsetRect(self.bounds, _obscuredInsets);

            WebCore::FloatSize unobscuredContentSizeAtNewScale(unobscuredRect.size.width / _scaleToRestore, unobscuredRect.size.height / _scaleToRestore);

            WebCore::FloatPoint topLeftInDocumentCoordinates(_unobscuredCenterToRestore.x() - unobscuredContentSizeAtNewScale.width() / 2, _unobscuredCenterToRestore.y() - unobscuredContentSizeAtNewScale.height() / 2);

            if (areEssentiallyEqualAsFloat(contentZoomScale(self), _scaleToRestore)) {

                CGRect unobscuredRect = UIEdgeInsetsInsetRect(self.bounds, _obscuredInsets);

                WebCore::FloatSize unobscuredContentSizeAtNewScale(unobscuredRect.size.width / _scaleToRestore, unobscuredRect.size.height / _scaleToRestore);

                WebCore::FloatPoint topLeftInDocumentCoordinates(unobscuredCenterToRestore.x() - unobscuredContentSizeAtNewScale.width() / 2, unobscuredCenterToRestore.y() - unobscuredContentSizeAtNewScale.height() / 2);

15201513

1521 topLeftInDocumentCoordinates.scale(_scaleToRestore);

1522 topLeftInDocumentCoordinates.moveBy(WebCore::FloatPoint(-_obscuredInsets.left, -_obscuredInsets.top));

1514 topLeftInDocumentCoordinates.scale(_scaleToRestore);

1515 topLeftInDocumentCoordinates.moveBy(WebCore::FloatPoint(-_obscuredInsets.left, -_obscuredInsets.top));

15231516

            changeContentOffsetBoundedInValidRange(_scrollView.get(), topLeftInDocumentCoordinates);

            if (_gestureController)

                _gestureController->didRestoreScrollPosition();

1517 changeContentOffsetBoundedInValidRange(_scrollView.get(), topLeftInDocumentCoordinates);

1518 }

        }

        needUpdateVisbleContentRects = YES;

        if (_gestureController)

            _gestureController->didRestoreScrollPosition();

    }

    if (needUpdateVisbleContentRects)

@@- (void)_couldNotRestorePageState

        _gestureController->didRestoreScrollPosition();

}

1571 - (void)_restorePageScrollPosition:(WebCore::FloatPoint)scrollPosition scrollOrigin:(WebCore::FloatPoint)scrollOrigin previousObscuredInset:(WebCore::FloatSize)obscuredInset scale:(double)scale

1566- (void)_restorePageScrollPosition:(std::optional<WebCore::FloatPoint>)scrollPosition scrollOrigin:(WebCore::FloatPoint)scrollOrigin previousObscuredInset:(WebCore::FloatSize)obscuredInset scale:(double)scale

{

    if (_dynamicViewportUpdateMode != DynamicViewportUpdateMode::NotResizing)

        return;

@@- (void)_restorePageScrollPosition:(WebCore::FloatPoint)scrollPosition scrollOri

    if (![self usesStandardContentView])

        return;

1579 _needsToRestoreUnobscuredCenter = NO;

1580 _needsToRestoreScrollPosition = YES;

15811574 _firstTransactionIDAfterPageRestore = downcast<WebKit::RemoteLayerTreeDrawingAreaProxy>(*_page->drawingArea()).nextLayerTreeTransactionID();

1582

1583 _scrollOffsetToRestore = WebCore::ScrollableArea::scrollOffsetFromPosition(WebCore::FloatPoint(scrollPosition), WebCore::toFloatSize(scrollOrigin));

    if (scrollPosition)

        _scrollOffsetToRestore = WebCore::ScrollableArea::scrollOffsetFromPosition(WebCore::FloatPoint(scrollPosition.value()), WebCore::toFloatSize(scrollOrigin));

    else

        _scrollOffsetToRestore = std::nullopt;

    _obscuredInsetWhenSaved = obscuredInset;

    _scaleToRestore = scale;

}

1588 - (void)_restorePageStateToUnobscuredCenter:(WebCore::FloatPoint)center scale:(double)scale

1584- (void)_restorePageStateToUnobscuredCenter:(std::optional<WebCore::FloatPoint>)center scale:(double)scale

{

    if (_dynamicViewportUpdateMode != DynamicViewportUpdateMode::NotResizing)

        return;

@@- (void)_restorePageStateToUnobscuredCenter:(WebCore::FloatPoint)center scale:(d

    if (![self usesStandardContentView])

        return;

1596 _needsToRestoreScrollPosition = NO;

1597 _needsToRestoreUnobscuredCenter = YES;

15981592 _firstTransactionIDAfterPageRestore = downcast<WebKit::RemoteLayerTreeDrawingAreaProxy>(*_page->drawingArea()).nextLayerTreeTransactionID();

1599 _unobscuredCenterToRestore = center;

1593 _unobscuredCenterToRestore = center.value();

1594

    _scaleToRestore = scale;

}

Source/WebKit2/UIProcess/API/Cocoa/WKWebViewInternal.h

@@struct PrintInfo;

- (void)_dynamicViewportUpdateChangedTargetToScale:(double)newScale position:(CGPoint)newScrollPosition nextValidLayerTreeTransactionID:(uint64_t)nextValidLayerTreeTransactionID;

- (void)_couldNotRestorePageState;

84 - (void)_restorePageScrollPosition:(WebCore::FloatPoint)scrollPosition scrollOrigin:(WebCore::FloatPoint)scrollOrigin previousObscuredInset:(WebCore::FloatSize)topInset scale:(double)scale;

85 - (void)_restorePageStateToUnobscuredCenter:(WebCore::FloatPoint)center scale:(double)scale; // FIXME: needs scroll origin?

84- (void)_restorePageScrollPosition:(std::optional<WebCore::FloatPoint>)scrollPosition scrollOrigin:(WebCore::FloatPoint)scrollOrigin previousObscuredInset:(WebCore::FloatSize)topInset scale:(double)scale;

85- (void)_restorePageStateToUnobscuredCenter:(std::optional<WebCore::FloatPoint>)center scale:(double)scale; // FIXME: needs scroll origin?

- (PassRefPtr<WebKit::ViewSnapshot>)_takeViewSnapshot;

Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp

@@void PageClientImpl::requestScroll(const WebCore::FloatPoint&, const WebCore::In

    notImplemented();

}

WebCore::FloatPoint PageClientImpl::viewScrollPosition()

{

    return { };

}

WebCore::IntSize PageClientImpl::viewSize()

{

    auto* drawingArea = static_cast<DrawingAreaProxyImpl*>(webkitWebViewBaseGetPage(WEBKIT_WEB_VIEW_BASE(m_viewWidget))->drawingArea());

Source/WebKit2/UIProcess/API/gtk/PageClientImpl.h

@@private:

    std::unique_ptr<DrawingAreaProxy> createDrawingAreaProxy() override;

    void setViewNeedsDisplay(const WebCore::Region&) override;

    void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin, bool isProgrammaticScroll) override;

60 WebCore::FloatPoint viewScrollPosition() override;

    WebCore::IntSize viewSize() override;

    bool isViewWindowActive() override;

    bool isViewFocused() override;

Source/WebKit2/UIProcess/PageClient.h

@@public:

    // Tell the view to scroll to the given position, and whether this was a programmatic scroll.

    virtual void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin, bool isProgrammaticScroll) = 0;

    // Return the current scroll position (not necessarily the same as the WebCore scroll position, because of scaling, insets etc.)

    virtual WebCore::FloatPoint viewScrollPosition() = 0;

    // Return the size of the view the page is associated with.

    virtual WebCore::IntSize viewSize() = 0;

@@public:

    virtual void dynamicViewportUpdateChangedTarget(double newScale, const WebCore::FloatPoint& newScrollPosition, uint64_t transactionID) = 0;

    virtual void couldNotRestorePageState() = 0;

296 virtual void restorePageState(c~~onst~~ WebCore::FloatPoint& scrollPosition, const WebCore::FloatPoint& scrollOrigin, const WebCore::FloatSize& obscuredInsetOnSave, double scale) = 0;

297 virtual void restorePageCenterAndScale(c~~onst~~ WebCore::FloatPoint& center, double scale) = 0;

299 virtual void restorePageState(std::optional<WebCore::FloatPoint> scrollPosition, const WebCore::FloatPoint& scrollOrigin, const WebCore::FloatSize& obscuredInsetOnSave, double scale) = 0;

300 virtual void restorePageCenterAndScale(std::optional<WebCore::FloatPoint> center, double scale) = 0;

    virtual void startAssistingNode(const AssistedNodeInformation&, bool userIsInteracting, bool blurPreviousNode, API::Object* userData) = 0;

    virtual void stopAssistingNode() = 0;

Source/WebKit2/UIProcess/WebPageProxy.cpp

@@void WebPageProxy::requestScroll(const FloatPoint& scrollPosition, const IntPoin

    m_pageClient.requestScroll(scrollPosition, scrollOrigin, isProgrammaticScroll);

}

WebCore::FloatPoint WebPageProxy::viewScrollPosition() const

{

    return m_pageClient.viewScrollPosition();

}

void WebPageProxy::setSuppressVisibilityUpdates(bool flag)

{

    if (m_suppressVisibilityUpdates == flag)

Source/WebKit2/UIProcess/WebPageProxy.h

@@public:

    void setViewNeedsDisplay(const WebCore::Region&);

    void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin, bool isProgrammaticScroll);

449 WebCore::FloatPoint viewScrollPosition() const;

450

    void setDelegatesScrolling(bool delegatesScrolling) { m_delegatesScrolling = delegatesScrolling; }

    bool delegatesScrolling() const { return m_delegatesScrolling; }

@@private:

    void dynamicViewportUpdateChangedTarget(double newTargetScale, const WebCore::FloatPoint& newScrollPosition, uint64_t dynamicViewportSizeUpdateID);

    void couldNotRestorePageState();

1514 void restorePageState(c~~onst~~ WebCore::FloatPoint& scrollPosition, const WebCore::FloatPoint& scrollOrigin, const WebCore::FloatSize& obscuredInsetOnSave, double scale);

1515 void restorePageCenterAndScale(c~~onst~~ WebCore::FloatPoint&, double scale);

1516 void restorePageState(std::optional<WebCore::FloatPoint> scrollPosition, const WebCore::FloatPoint& scrollOrigin, const WebCore::FloatSize& obscuredInsetOnSave, double scale);

1517 void restorePageCenterAndScale(std::optional<WebCore::FloatPoint>, double scale);

    void didGetTapHighlightGeometries(uint64_t requestID, const WebCore::Color& color, const Vector<WebCore::FloatQuad>& geometries, const WebCore::IntSize& topLeftRadius, const WebCore::IntSize& topRightRadius, const WebCore::IntSize& bottomLeftRadius, const WebCore::IntSize& bottomRightRadius);

Source/WebKit2/UIProcess/WebPageProxy.messages.in

@@messages -> WebPageProxy {

#if PLATFORM(IOS)

    DynamicViewportUpdateChangedTarget(double newTargetScale, WebCore::FloatPoint newScrollPosition, uint64_t dynamicViewportSizeUpdateID)

    CouldNotRestorePageState()

379 RestorePageState(WebCore::FloatPoint scrollPosition, WebCore::FloatPoint scrollOrigin, WebCore::FloatSize obscuredInsetOnSave, double scale)

380 RestorePageCenterAndScale(WebCore::FloatPoint unobscuredCenter, double scale)

379 RestorePageState(std::optional<WebCore::FloatPoint> scrollPosition, WebCore::FloatPoint scrollOrigin, WebCore::FloatSize obscuredInsetOnSave, double scale)

380 RestorePageCenterAndScale(std::optional<WebCore::FloatPoint> unobscuredCenter, double scale)

    DidGetTapHighlightGeometries(uint64_t requestID, WebCore::Color color, Vector<WebCore::FloatQuad> geometries, WebCore::IntSize topLeftRadius, WebCore::IntSize topRightRadius, WebCore::IntSize bottomLeftRadius, WebCore::IntSize bottomRightRadius)

    StartAssistingNode(struct WebKit::AssistedNodeInformation information, bool userIsInteracting, bool blurPreviousNode, WebKit::UserData userData)

Source/WebKit2/UIProcess/ios/PageClientImplIOS.h

@@private:

    std::unique_ptr<DrawingAreaProxy> createDrawingAreaProxy() override;

    void setViewNeedsDisplay(const WebCore::Region&) override;

    void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin, bool isProgrammaticScroll) override;

54 WebCore::FloatPoint viewScrollPosition() override;

    WebCore::IntSize viewSize() override;

    bool isViewWindowActive() override;

    bool isViewFocused() override;

@@private:

    void dynamicViewportUpdateChangedTarget(double newScale, const WebCore::FloatPoint& newScrollPosition, uint64_t transactionID) override;

    void couldNotRestorePageState() override;

124 void restorePageState(c~~onst~~ WebCore::FloatPoint&, const WebCore::FloatPoint&, const WebCore::FloatSize&, double) override;

125 void restorePageCenterAndScale(c~~onst~~ WebCore::FloatPoint&, double) override;

125 void restorePageState(std::optional<WebCore::FloatPoint>, const WebCore::FloatPoint&, const WebCore::FloatSize&, double) override;

126 void restorePageCenterAndScale(std::optional<WebCore::FloatPoint>, double) override;

    void startAssistingNode(const AssistedNodeInformation&, bool userIsInteracting, bool blurPreviousNode, API::Object* userData) override;

    void stopAssistingNode() override;

Source/WebKit2/UIProcess/ios/PageClientImplIOS.mm

@@void PageClientImpl::requestScroll(const FloatPoint& scrollPosition, const IntPo

    [m_webView _scrollToContentScrollPosition:scrollPosition scrollOrigin:scrollOrigin];

}

WebCore::FloatPoint PageClientImpl::viewScrollPosition()

{

    if (UIScrollView *scroller = [m_contentView _scroller])

        return scroller.contentOffset;

    return { };

}

IntSize PageClientImpl::viewSize()

{

    if (UIScrollView *scroller = [m_contentView _scroller])

@@void PageClientImpl::couldNotRestorePageState()

    [m_webView _couldNotRestorePageState];

}

524 void PageClientImpl::restorePageState(c~~onst~~ WebCore::FloatPoint& scrollPosition, const WebCore::FloatPoint& scrollOrigin, const WebCore::FloatSize& obscuredInsetOnSave, double scale)

532void PageClientImpl::restorePageState(std::optional<WebCore::FloatPoint> scrollPosition, const WebCore::FloatPoint& scrollOrigin, const WebCore::FloatSize& obscuredInsetOnSave, double scale)

{

    [m_webView _restorePageScrollPosition:scrollPosition scrollOrigin:scrollOrigin previousObscuredInset:obscuredInsetOnSave scale:scale];

}

529 void PageClientImpl::restorePageCenterAndScale(c~~onst~~ WebCore::FloatPoint& center, double scale)

537void PageClientImpl::restorePageCenterAndScale(std::optional<WebCore::FloatPoint> center, double scale)

{

    [m_webView _restorePageStateToUnobscuredCenter:center scale:scale];

}

Source/WebKit2/UIProcess/ios/ViewGestureControllerIOS.mm

@@void ViewGestureController::beginSwipeGesture(_UINavigationInteractiveTransition

        float deviceScaleFactor = m_webPageProxy.deviceScaleFactor();

        FloatSize swipeLayerSizeInDeviceCoordinates(liveSwipeViewFrame.size);

        swipeLayerSizeInDeviceCoordinates.scale(deviceScaleFactor);

197 if (snapshot->hasImage() && snapshot->size() == swipeLayerSizeInDeviceCoordinates && deviceScaleFactor == snapshot->deviceScaleFactor())

        
        BOOL shouldRestoreScrollPosition = targetItem->pageState().mainFrameState.shouldRestoreScrollPosition;

        IntPoint currentScrollPosition = roundedIntPoint(m_webPageProxy.viewScrollPosition());

        if (snapshot->hasImage() && snapshot->size() == swipeLayerSizeInDeviceCoordinates && deviceScaleFactor == snapshot->deviceScaleFactor() && (shouldRestoreScrollPosition || (currentScrollPosition == snapshot->viewScrollPosition())))

            [m_snapshotView layer].contents = snapshot->asLayerContents();

        Color coreColor = snapshot->backgroundColor();

        if (coreColor.isValid())

Source/WebKit2/UIProcess/ios/WebPageProxyIOS.mm

@@void WebPageProxy::couldNotRestorePageState()

    m_pageClient.couldNotRestorePageState();

}

909 void WebPageProxy::restorePageState(c~~onst~~ WebCore::FloatPoint& scrollPosition, const WebCore::FloatPoint& scrollOrigin, const WebCore::FloatSize& obscuredInsetOnSave, double scale)

909void WebPageProxy::restorePageState(std::optional<WebCore::FloatPoint> scrollPosition, const WebCore::FloatPoint& scrollOrigin, const WebCore::FloatSize& obscuredInsetOnSave, double scale)

{

    m_pageClient.restorePageState(scrollPosition, scrollOrigin, obscuredInsetOnSave, scale);

}

914 void WebPageProxy::restorePageCenterAndScale(c~~onst~~ WebCore::FloatPoint& center, double scale)

914void WebPageProxy::restorePageCenterAndScale(std::optional<WebCore::FloatPoint> center, double scale)

{

    m_pageClient.restorePageCenterAndScale(center, scale);

}

Source/WebKit2/UIProcess/mac/PageClientImpl.h

@@private:

    std::unique_ptr<DrawingAreaProxy> createDrawingAreaProxy() override;

    void setViewNeedsDisplay(const WebCore::Region&) override;

    void requestScroll(const WebCore::FloatPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin, bool isProgrammaticScroll) override;

67 WebCore::FloatPoint viewScrollPosition() override;

    WebCore::IntSize viewSize() override;

    bool isViewWindowActive() override;

Source/WebKit2/UIProcess/mac/PageClientImpl.mm

@@void PageClientImpl::requestScroll(const FloatPoint& scrollPosition, const IntPo

    ASSERT_NOT_REACHED();

}

WebCore::FloatPoint PageClientImpl::viewScrollPosition()

{

    return { };

}

IntSize PageClientImpl::viewSize()

{

    return IntSize([m_view bounds].size);

Source/WebKit2/UIProcess/mac/ViewSnapshotStore.h

#define ViewSnapshotStore_h

#include <WebCore/Color.h>

30#include <WebCore/IntPoint.h>

#include <WebCore/IntSize.h>

#include <WebCore/IOSurface.h>

#include <wtf/ListHashSet.h>

@@public:

    void setBackgroundColor(WebCore::Color color) { m_backgroundColor = color; }

    WebCore::Color backgroundColor() const { return m_backgroundColor; }

    
    void setViewScrollPosition(WebCore::IntPoint scrollPosition) { m_viewScrollPosition = scrollPosition; }

    WebCore::IntPoint viewScrollPosition() const { return m_viewScrollPosition; }

    void setDeviceScaleFactor(float deviceScaleFactor) { m_deviceScaleFactor = deviceScaleFactor; }

    float deviceScaleFactor() const { return m_deviceScaleFactor; }

@@private:

    uint64_t m_renderTreeSize;

    float m_deviceScaleFactor;

    WebCore::Color m_backgroundColor;

111 WebCore::IntPoint m_viewScrollPosition; // Scroll position at snapshot time. Integral to make comparison reliable.

};

class ViewSnapshotStore {

Source/WebKit2/UIProcess/mac/ViewSnapshotStore.mm

@@void ViewSnapshotStore::recordSnapshot(WebPageProxy& webPageProxy, WebBackForwar

    snapshot->setRenderTreeSize(webPageProxy.renderTreeSize());

    snapshot->setDeviceScaleFactor(webPageProxy.deviceScaleFactor());

    snapshot->setBackgroundColor(webPageProxy.pageExtendedBackgroundColor());

123 snapshot->setViewScrollPosition(WebCore::roundedIntPoint(webPageProxy.viewScrollPosition()));

    item.setSnapshot(WTFMove(snapshot));

}

Source/WebKit2/WebProcess/WebCoreSupport/SessionStateConversion.cpp

@@static FrameState toFrameState(const HistoryItem& historyItem)

    frameState.itemSequenceNumber = historyItem.itemSequenceNumber();

    frameState.scrollPosition = historyItem.scrollPosition();

88 frameState.shouldRestoreScrollPosition = historyItem.shouldRestoreScrollPosition();

    frameState.pageScaleFactor = historyItem.pageScaleFactor();

    if (FormData* formData = const_cast<HistoryItem&>(historyItem).formData()) {

@@static void applyFrameState(HistoryItem& historyItem, const FrameState& frameSta

    historyItem.setItemSequenceNumber(frameState.itemSequenceNumber);

    historyItem.setScrollPosition(frameState.scrollPosition);

165 historyItem.setShouldRestoreScrollPosition(frameState.shouldRestoreScrollPosition);

    historyItem.setPageScaleFactor(frameState.pageScaleFactor);

    if (frameState.httpBody) {

Source/WebKit2/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp

@@void WebFrameLoaderClient::restoreViewState()

    if (FrameView* view = frame.view()) {

        if (m_frame->isMainFrame())

            m_frame->page()->restorePageState(*currentItem);

1229 else if (!view->wasScrolledByUser())

1229 else if (!view->wasScrolledByUser()) {

1230 WTFLogAlways("WebFrameLoaderClient::restoreViewState restoring scroll position %d,%d", currentItem->scrollPosition().x(), currentItem->scrollPosition().y());

12301231 view->setScrollPosition(currentItem->scrollPosition());

1232 }

    }

#else

    // Inform the UI process of the scale factor.

Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm

@@void WebPage::restorePageState(const HistoryItem& historyItem)

        float boundedScale = std::min<float>(m_viewportConfiguration.maximumScale(), std::max<float>(m_viewportConfiguration.minimumScale(), historyItem.pageScaleFactor()));

        scalePage(boundedScale, IntPoint());

        m_drawingArea->setExposedContentRect(historyItem.exposedContentRect());

        send(Messages::WebPageProxy::RestorePageState(historyItem.scrollPosition(), frameView.scrollOrigin(), historyItem.obscuredInset(), boundedScale));

        std::optional<FloatPoint> scrollPosition;

        if (historyItem.shouldRestoreScrollPosition()) {

            m_drawingArea->setExposedContentRect(historyItem.exposedContentRect());

            scrollPosition = FloatPoint(historyItem.scrollPosition());

        }

        send(Messages::WebPageProxy::RestorePageState(scrollPosition, frameView.scrollOrigin(), historyItem.obscuredInset(), boundedScale));

    } else {

        IntSize oldContentSize = historyItem.contentSize();

        IntSize newContentSize = frameView.contentsSize();

@@void WebPage::restorePageState(const HistoryItem& historyItem)

        double newScale = scaleAfterViewportWidthChange(historyItem.pageScaleFactor(), !historyItem.scaleIsInitial(), m_viewportConfiguration, currentMinimumLayoutSizeInScrollViewCoordinates.width(), newContentSize, oldContentSize, visibleHorizontalFraction);

        FloatPoint newCenter;

        if (!oldContentSize.isEmpty() && !newContentSize.isEmpty() && newContentSize != oldContentSize)

            newCenter = relativeCenterAfterContentSizeChange(historyItem.unobscuredContentRect(), oldContentSize, newContentSize);

        else

            newCenter = FloatRect(historyItem.unobscuredContentRect()).center();

        FloatSize unobscuredRectAtNewScale = frameView.customSizeForResizeEvent();

        unobscuredRectAtNewScale.scale(1 / newScale);

        FloatRect oldExposedRect = frameView.exposedContentRect();

        FloatRect adjustedExposedRect = adjustExposedRectForNewScale(oldExposedRect, m_page->pageScaleFactor(), newScale);

        FloatPoint oldCenter = adjustedExposedRect.center();

        adjustedExposedRect.move(newCenter - oldCenter);

        std::optional<FloatPoint> newCenter;

        if (historyItem.shouldRestoreScrollPosition()) {

            if (!oldContentSize.isEmpty() && !newContentSize.isEmpty() && newContentSize != oldContentSize)

                newCenter = relativeCenterAfterContentSizeChange(historyItem.unobscuredContentRect(), oldContentSize, newContentSize);

            else

                newCenter = FloatRect(historyItem.unobscuredContentRect()).center();

        }

339335

340336 scalePage(newScale, IntPoint());

341

        send(Messages::WebPageProxy::RestorePageCenterAndScale(newCenter, newScale));

    }

}

LayoutTests/ChangeLog

2017-03-06  Simon Fraser  <simon.fraser@apple.com>

        Add support for history.scrollRestoration

        https://bugs.webkit.org/show_bug.cgi?id=147782

        rdar://problem/22614568

        Reviewed by NOBODY (OOPS!).

        Sadly history-scroll-restoration.html needs to be cloned for iOS and to use uiController.doAfterPresentationUpdate()

        there, since restoration involves a trip to the UI process, and this same test did not work for Mac WK1 (dispatch_async()

        doesn't seem to give the right timing in DRT).

        * TestExpectations:

        * fast/dom/Window/window-appendages-cleared-expected.txt:

        * fast/history/history-scroll-restoration-attribute-expected.txt: Added.

        * fast/history/history-scroll-restoration-attribute.html: Added.

        * fast/history/history-scroll-restoration-expected.txt: Added.

        * fast/history/history-scroll-restoration.html: Added.

        * platform/ios-simulator-wk2/TestExpectations:

        * platform/ios-simulator/TestExpectations:

2017-03-04  Myles C. Maxfield  <mmaxfield@apple.com>

        Update CSSFontSelector's matching algorithm to understand ranges

LayoutTests/imported/w3c/ChangeLog

2017-03-06  Simon Fraser  <simon.fraser@apple.com>

        Add support for history.scrollRestoration

        https://bugs.webkit.org/show_bug.cgi?id=147782

        rdar://problem/22614568

        Reviewed by NOBODY (OOPS!).

        New passing baselines.

        * web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-basic-expected.txt:

        * web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-fragment-scrolling-cross-origin-expected.txt:

        * web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-navigation-cross-origin-expected.txt:

        * web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-navigation-samedoc-expected.txt:

2017-03-04  Chris Dumez  <cdumez@apple.com>

        Rebaseline W3C test after r213412.

LayoutTests/TestExpectations

@@fast/viewport/ios [ Skip ]

fast/visual-viewport/ios/ [ Skip ]

fast/events/ios [ Skip ]

fast/events/touch/ios [ Skip ]

28fast/history/ios [ Skip ]

fast/scrolling/ios [ Skip ]

scrollingcoordinator/ios [ Skip ]

fast/content-observation [ Skip ]

@@webkit.org/b/168175 imported/w3c/web-platform-tests/html/semantics/embedded-cont

webkit.org/b/168175 imported/w3c/web-platform-tests/html/browsers/browsing-the-web/history-traversal/same-url.html [ Pass Failure ]

webkit.org/b/168175 imported/w3c/web-platform-tests/html/browsers/offline/browser-state/navigator_online_online.html [ Pass Failure ]

webkit.org/b/168175 imported/w3c/web-platform-tests/html/semantics/text-level-semantics/the-a-element/a-download-click.html [ Timeout Pass ]

1052webkit.org/b/169264 imported/w3c/web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-navigation-samedoc.html [ Failure ]

webkit.org/b/168066 performance-api/performance-now-api.html [ Pass Failure ]

webkit.org/b/168005 performance-api/performance-now-time-origin-in-worker.html [ Pass Failure ]

LayoutTests/fast/dom/Window/window-appendages-cleared-expected.txt

@@PASS history.go == "LEFTOVER" is false

PASS history.length == "LEFTOVER" is false

PASS history.pushState == "LEFTOVER" is false

PASS history.replaceState == "LEFTOVER" is false

7PASS history.scrollRestoration == "LEFTOVER" is false

PASS history.state == "LEFTOVER" is false

PASS location.ancestorOrigins == "LEFTOVER" is false

PASS location.assign == "LEFTOVER" is false

LayoutTests/fast/history/history-scroll-restoration-attribute-expected.txt

Tests the history.scrollRestoration attribute

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

PASS 'scrollRestoration' in history is true

PASS history.scrollRestoration is "auto"

PASS history.scrollRestoration is "manual"

PASS history.scrollRestoration is "manual"

PASS history.scrollRestoration is "auto"

PASS successfullyParsed is true

TEST COMPLETE

LayoutTests/fast/history/history-scroll-restoration-attribute.html

<html>

<head>

<script src="../../resources/js-test-pre.js"></script>

</head>

<body>

<script>

    description("Tests the history.scrollRestoration attribute");

    if (window.testRunner)

        testRunner.clearBackForwardList();

    shouldBeTrue("'scrollRestoration' in history");

    history.scrollRestoration = 'auto';

    shouldBeEqualToString('history.scrollRestoration', 'auto');

    history.scrollRestoration = 'manual';

    shouldBeEqualToString('history.scrollRestoration', 'manual');

    history.scrollRestoration = 'bananas';

    shouldBeEqualToString('history.scrollRestoration', 'manual');

    history.scrollRestoration = 'auto';

    shouldBeEqualToString('history.scrollRestoration', 'auto');

</script>

<script src="../../resources/js-test-post.js"></script>

</body>

</html>

LayoutTests/fast/history/history-scroll-restoration-expected.txt

Tests that history.scrollRestoration works for same-document navigations

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

PASS 'scrollRestoration' in history is true

PASS history.scrollRestoration is "auto"

PASS window.scrollX is 123

PASS window.scrollY is 456

PASS history.scrollRestoration is "manual"

PASS window.scrollX is 333

PASS window.scrollY is 555

PASS successfullyParsed is true

TEST COMPLETE

LayoutTests/fast/history/history-scroll-restoration.html

<html>

<head>

<script src="../../resources/js-test-pre.js"></script>

<style>

    body {

        height: 2000px;

        width: 2000px;

    }

</style>

</head>

<body>

<script>

    var jsTestIsAsync = true;

    description("Tests that history.scrollRestoration works for same-document navigations");

    if (window.testRunner)

        testRunner.clearBackForwardList();

    shouldBeTrue("'scrollRestoration' in history");

    // Can't create history entries inside the onload handler.

    window.setTimeout(testAutoScrollRestoration, 0);

    function testAutoScrollRestoration()

    {

        history.scrollRestoration = 'auto';

        shouldBeEqualToString('history.scrollRestoration', 'auto');

        window.scrollTo(123, 456);

        history.pushState(null, '', '#1');

        window.scrollTo(0, 0);

        history.back();

        window.setTimeout(function () {

            shouldBe('window.scrollX', '123');

            shouldBe('window.scrollY', '456');

            testManualScrollRestoration();

        }, 0);

    }

    function testManualScrollRestoration()

    {

        history.scrollRestoration = 'manual';

        shouldBeEqualToString('history.scrollRestoration', 'manual');

        window.scrollTo(234, 567);

        history.pushState(null, '', '#2');

        window.scrollTo(333, 555);

        history.back();

        window.setTimeout(function() {

            shouldBe('window.scrollX', '333');

            shouldBe('window.scrollY', '555');

            window.scrollTo(0, 0);

            finishJSTest();

        }, 0);

    }

</script>

<script src="../../resources/js-test-post.js"></script>

</body>

</html>

LayoutTests/fast/history/ios/history-scroll-restoration-expected.txt

Tests that history.scrollRestoration works for same-document navigations

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

PASS 'scrollRestoration' in history is true

PASS history.scrollRestoration is "auto"

PASS window.scrollX is 123

PASS window.scrollY is 456

PASS history.scrollRestoration is "manual"

PASS window.scrollX is 333

PASS window.scrollY is 555

PASS successfullyParsed is true

TEST COMPLETE

LayoutTests/fast/history/ios/history-scroll-restoration.html

<html>

<head>

<script src="../../../resources/js-test-pre.js"></script>

<style>

    body {

        height: 2000px;

        width: 2000px;

    }

</style>

</head>

<body>

<script>

    var jsTestIsAsync = true;

    description("Tests that history.scrollRestoration works for same-document navigations");

    if (window.testRunner)

        testRunner.clearBackForwardList();

    shouldBeTrue("'scrollRestoration' in history");

    // Can't create history entries inside the onload handler.

    window.setTimeout(testAutoScrollRestoration, 0);

    function waitForPresentationUpdateUIScript()

    {

        return `(function() {

            uiController.doAfterPresentationUpdate(function() {

                uiController.uiScriptComplete();

            });

        })()`;

    }

    function testAutoScrollRestoration()

    {

        history.scrollRestoration = 'auto';

        shouldBeEqualToString('history.scrollRestoration', 'auto');

        window.scrollTo(123, 456);

        history.pushState(null, '', '#1');

        window.scrollTo(0, 0);

        history.back();

        testRunner.runUIScript(waitForPresentationUpdateUIScript(), function () {

            shouldBe('window.scrollX', '123');

            shouldBe('window.scrollY', '456');

            testManualScrollRestoration();

        });

    }

    function testManualScrollRestoration()

    {

        history.scrollRestoration = 'manual';

        shouldBeEqualToString('history.scrollRestoration', 'manual');

        window.scrollTo(234, 567);

        history.pushState(null, '', '#2');

        window.scrollTo(333, 555);

        history.back();

        testRunner.runUIScript(waitForPresentationUpdateUIScript(), function () {

            shouldBe('window.scrollX', '333');

            shouldBe('window.scrollY', '555');

            window.scrollTo(0, 0);

            finishJSTest();

        });

    }

</script>

<script src="../../../resources/js-test-post.js"></script>

</body>

</html>

LayoutTests/imported/w3c/web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-basic-expected.txt

11

2 F~~AIL~~ Default value is "auto" ~~assert_equals: expected (string) "auto" but got (undefined) undefined~~

2PASS Default value is "auto"

33PASS It is writable

4 F~~AIL~~ Invalid values are ignored ~~assert_equals: setting to invalid value (3.1415) should be ignored expected (string) "auto" but got (number) 3.1415~~

4PASS Invalid values are ignored

55

LayoutTests/imported/w3c/web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-fragment-scrolling-cross-origin-expected.txt

11Blocked access to external URL http://www.localhost:8800/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/resources/blank1.html

2 CONSOLE MESSAGE: line 2451: Error: assert_equals: navigating back should retain scrollRestoration value expected (string) "manual" but got (undefined) undefined

32

43

Harness Error (TIMEOUT), message = null

TIMEOUT Manual scroll restoration should take precedent over scrolling to fragment in cross origin navigation Test timed out

4PASS Manual scroll restoration should take precedent over scrolling to fragment in cross origin navigation

85

LayoutTests/imported/w3c/web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-navigation-cross-origin-expected.txt

11

22

3 F~~AIL~~ Navigating to new page should reset to "auto" and navigating back should restore and respect scroll restoration mode ~~assert_equals: new page loads should set scrollRestoration to "auto" expected (string) "auto" but got (undefined) undefined~~

3PASS Navigating to new page should reset to "auto" and navigating back should restore and respect scroll restoration mode

44

LayoutTests/imported/w3c/web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-navigation-samedoc-expected.txt

11

2 F~~AIL~~ history.{push,replace}State retain scroll restoration mode and navigation in the same document respects it ~~assert_equals: scrollX is correct for #4 expected 555 but got 200~~

2PASS history.{push,replace}State retain scroll restoration mode and navigation in the same document respects it

33

LayoutTests/platform/ios-simulator-wk2/TestExpectations

# Platform-specific directories. Skipped globally, then re-enabled here.

#//////////////////////////////////////////////////////////////////////////////////////////

9fast/history/ios [ Pass ]

fast/scrolling/ios [ Pass ]

fast/viewport/ios [ Pass ]

fast/visual-viewport/ios/ [ Pass ]

@@fast/history/form-submit-in-frame.html

fast/history/gesture-before-onload-form-submit.html

fast/history/gesture-before-onload-location-href.html

fast/history/history_reload.html

787fast/history/history-scroll-restoration.html [ Skip ]

fast/history/timed-refresh-in-cached-frame.html

fast/history/window-open.html

fast/images/animate-list-item-image-assertion.html

LayoutTests/platform/ios-simulator/TestExpectations

@@webkit.org/b/152935 fast/scrolling/scroll-position-on-reload-rtl.html [ Failure

webkit.org/b/153371 imported/w3c/web-platform-tests/XMLHttpRequest/getresponseheader-chunked-trailer.htm [ Pass Failure ]

2442webkit.org/b/169210 imported/w3c/web-platform-tests/html/browsers/browsing-the-web/history-traversal/persisted-user-state-restoration/scroll-restoration-navigation-samedoc.html [ Failure ]

2443

webkit.org/b/153498 svg/dom/SVGScriptElement/script-change-externalResourcesRequired-while-loading.svg [ Pass Timeout ]

# displaylist tests are flaky on ios-simulator wk2