Replace history.options with history.scrollRestoration attribute

Source/core/loader/FrameLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008 Alp Toker <alp@atoker.com>
  * Copyright (C) Research In Motion Limited 2009. All rights reserved.
  * Copyright (C) 2011 Kris Jordan <krisjordan@gmail.com>
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ skipping 232 matching lines @@
     if (ScrollableArea* layoutScrollableArea = m_frame->view()->layoutViewportScrollableArea())
         m_currentItem->setScrollPoint(layoutScrollableArea->scrollPosition());
     m_currentItem->setPinchViewportScrollPoint(m_frame->host()->pinchViewport().visibleRect().location());
 
     if (m_frame->isMainFrame())
         m_currentItem->setPageScaleFactor(m_frame->page()->pageScaleFactor());
 
     client()->didUpdateCurrentHistoryItem();
 }
 
+void FrameLoader::setScrollRestorationType(HistoryScrollRestorationType scrollRestoration)

[Nate Chapin, 2015/07/27 23:46:55]

I don't think this method is sufficiently reusable to stand on its own. It
should be fine to just put it in History::setScrollRestoration inline.

[majidvp, 2015/07/28 12:19:06]

Acknowledged.

[majidvp, 2015/07/28 15:44:11]

Done.

+{
+    if (!m_currentItem)
+        return;
+
+    m_currentItem->setScrollRestorationType(scrollRestoration);
+    client()->didUpdateCurrentHistoryItem();

[Nate Chapin, 2015/07/27 23:46:55]

Is this actually necessary?

[majidvp, 2015/07/28 12:19:06]

It causes a navigation sync with browser to be 
scheduled for the entry. I think without it, the 
updated value does not get communicated to browser
an may not get persisted. This is also what we do 
when we update scroll position as well.

+}
+
 void FrameLoader::dispatchUnloadEvent()
 {
     saveScrollState();
 
     if (m_frame->document() && !SVGImage::isInSVGImage(m_frame->document()))
         m_frame->document()->dispatchUnloadEvents();
 
     if (Page* page = m_frame->page())
         page->undoStack().didUnloadFrame(*m_frame);
 }
@@ skipping 107 matching lines @@
     // Don't propagate state from the old item if this is a different-document navigation, unless the before
     // and after pages are logically related. This means they have the same url (ignoring fragment) and
     // the new item was loaded via reload or client redirect.
     if (navigationType == HistoryNavigationType::DifferentDocument && (historyCommitType != HistoryInertCommit || !equalIgnoringFragmentIdentifier(oldItem->url(), m_currentItem->url())))
         return;
     m_currentItem->setDocumentSequenceNumber(oldItem->documentSequenceNumber());
     m_currentItem->setScrollPoint(oldItem->scrollPoint());
     m_currentItem->setPinchViewportScrollPoint(oldItem->pinchViewportScrollPoint());
     m_currentItem->setPageScaleFactor(oldItem->pageScaleFactor());
     m_currentItem->setStateObject(oldItem->stateObject());
+    m_currentItem->setScrollRestorationType(oldItem->scrollRestorationType());
+
     // The item sequence number determines whether items are "the same", such back/forward navigation
     // between items with the same item sequence number is a no-op. Only treat this as identical if the
     // navigation did not create a back/forward entry and the url is identical or it was loaded via
     // history.replaceState().
     if (historyCommitType == HistoryInertCommit && (navigationType == HistoryNavigationType::HistoryApi || oldItem->url() == m_currentItem->url()))
         m_currentItem->setItemSequenceNumber(oldItem->itemSequenceNumber());
 }
 
 static HistoryCommitType loadTypeToCommitType(FrameLoadType type)
 {
@@ skipping 174 matching lines @@
     m_frame->navigationScheduler().startTimer();
 
     if (m_frame->view())
         m_frame->view()->handleLoadCompleted();
 
     if (shouldSendCompleteNotifications(m_frame)) {
         m_loadType = FrameLoadTypeStandard;
         m_progressTracker->progressCompleted();
         // Retry restoring scroll offset since finishing loading disables content
         // size clamping.
+        // TODO(majidvp): Remove this call as it appears to be a no-op because
+        // we set load type to |FrameLoadTypeStandard| just above.
         restoreScrollPositionAndViewState();
         m_frame->localDOMWindow()->finishedLoading();
 
         // Report mobile vs. desktop page statistics. This will only report on Android.
         if (m_frame->isMainFrame())
             m_frame->document()->viewportDescription().reportMobilePageStats(m_frame);
         client()->dispatchDidFinishLoad();
     }
 
     Frame* parent = m_frame->tree().parent();
@@ skipping 99 matching lines @@
     bool hashChange = equalIgnoringFragmentIdentifier(url, oldURL) && url.fragmentIdentifier() != oldURL.fragmentIdentifier();
     if (hashChange) {
         m_frame->eventHandler().stopAutoscroll();
         m_frame->localDOMWindow()->enqueueHashchangeEvent(oldURL, url);
     }
     m_documentLoader->setIsClientRedirect(clientRedirect == ClientRedirect);
     updateForSameDocumentNavigation(url, SameDocumentNavigationDefault, nullptr, ScrollRestorationAuto, type);
 
     m_frame->view()->setWasScrolledByUser(false);
 
-    // We need to scroll to the fragment whether or not a hash change occurred, since
-    // the user might have scrolled since the previous navigation.
-    processFragment(url, NavigationWithinSameDocument);
     checkCompleted();
 
     m_frame->localDOMWindow()->statePopped(stateObject ? stateObject : SerializedScriptValue::nullValue());
 }
 
 void FrameLoader::setReferrerForFrameRequest(ResourceRequest& request, ShouldSendReferrer shouldSendReferrer, Document* originDocument)
 {
     if (!originDocument)
         return;
     // FIXME: This should be an assertion, but there's some plugin code in the chromium repo
@@ skipping 201 matching lines @@
             m_documentLoader->setNavigationType(determineNavigationType(
                 newLoadType, false, request.triggeringEvent()));
             if (shouldTreatURLAsSameAsCurrent(url))
                 newLoadType = FrameLoadTypeReplaceCurrentItem;
         }
 
         loadInSameDocument(url, stateObject, newLoadType, request.clientRedirect());
 
         if (sameDocumentHistoryNavigation)
             restoreScrollPositionAndViewState();
+
+        // We need to scroll to the fragment whether or not a hash change occurred, since
+        // the user might have scrolled since the previous navigation.
+        processFragment(url, NavigationWithinSameDocument);
         return;
     }
 
     // Perform navigation to a different document.
     bool sameURL = url == m_documentLoader->urlForHistory();
     startLoad(request, newLoadType, policy);
 
     // Example of this case are sites that reload the same URL with a different cookie
     // driving the generated content, or a master frame with links that drive a target
     // frame, where the user has clicked on the same link repeatedly.
@@ skipping 174 matching lines @@
 
 void FrameLoader::restoreScrollPositionAndViewState()
 {
     FrameView* view = m_frame->view();
     if (!m_frame->page() || !view || !m_currentItem || !m_stateMachine.committedFirstRealDocumentLoad())
         return;
 
     if (!needsHistoryItemRestore(m_loadType))
         return;
 
-    if (m_currentItem->scrollRestorationType() == ScrollRestorationManual)
+    if (m_currentItem->scrollRestorationType() == ScrollRestorationManual) {
+        documentLoader()->initialScrollState().didRestoreFromHistory = true;
         return;
+    }
 
     // This tries to balance 1. restoring as soon as possible, 2. detecting
     // clamping to avoid repeatedly popping the scroll position down as the
     // page height increases, 3. ignore clamp detection after load completes
     // because that may be because the page will never reach its previous
     // height.
     bool canRestoreWithoutClamping = view->clampOffsetAtScale(m_currentItem->scrollPoint(), 1) == m_currentItem->scrollPoint();
     bool canRestoreWithoutAnnoyingUser = !view->wasScrolledByUser() && (canRestoreWithoutClamping || m_frame->isLoading());
     if (!canRestoreWithoutAnnoyingUser)
         return;
@@ skipping 106 matching lines @@
     if (!view)
         return;
 
     // Leaking scroll position to a cross-origin ancestor would permit the so-called "framesniffing" attack.
     RefPtrWillBeRawPtr<Frame> boundaryFrame = url.hasFragmentIdentifier() ? m_frame->findUnsafeParentScrollPropagationBoundary() : 0;
 
     // FIXME: Handle RemoteFrames
     if (boundaryFrame && boundaryFrame->isLocalFrame())
         toLocalFrame(boundaryFrame.get())->view()->setSafeToPropagateScrollToParent(false);
 
-    view->processUrlFragment(url,
-        loadStartType == NavigationToDifferentDocument && documentLoader()->initialScrollState().didRestoreFromHistory ?
-            FrameView::UrlFragmentDontScroll : FrameView::UrlFragmentScroll);
+    // If scroll position is restored from history fragment then we should not override it unless
+    // this is a same document reload.
+    bool shouldScrollToFragment = (loadStartType == NavigationWithinSameDocument && !isBackForwardLoadType(m_loadType))
+        || !documentLoader()->initialScrollState().didRestoreFromHistory;
+
+    view->processUrlFragment(url, shouldScrollToFragment ?
+        FrameView::UrlFragmentScroll : FrameView::UrlFragmentDontScroll);
 
     if (boundaryFrame && boundaryFrame->isLocalFrame())
         toLocalFrame(boundaryFrame.get())->view()->setSafeToPropagateScrollToParent(true);
 }
 
 bool FrameLoader::shouldClose()
 {
     Page* page = m_frame->page();
     if (!page || !page->chromeClient().canOpenBeforeUnloadConfirmPanel())
         return true;
@@ skipping 242 matching lines @@
     // FIXME: We need a way to propagate insecure requests policy flags to
     // out-of-process frames. For now, we'll always use default behavior.
     if (!parentFrame->isLocalFrame())
         return nullptr;
 
     ASSERT(toLocalFrame(parentFrame)->document());
     return toLocalFrame(parentFrame)->document()->insecureNavigationsToUpgrade();
 }
 
 } // namespace blink