Refactor FrameLoader loading interface

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 86 matching lines @@
 
 using namespace HTMLNames;
 
 bool isBackForwardLoadType(FrameLoadType type)
 {
     return type == FrameLoadTypeBackForward || type == FrameLoadTypeInitialHistoryLoad;
 }
 
 static bool needsHistoryItemRestore(FrameLoadType type)
 {
-    return type == FrameLoadTypeBackForward || type == FrameLoadTypeReload || type == FrameLoadTypeReloadFromOrigin;
+    return type == FrameLoadTypeBackForward || type == FrameLoadTypeReload
+        || type == FrameLoadTypeReloadFromOrigin;
+}
+
+// static
+ResourceRequest FrameLoader::resourceRequestFromHistoryItem(HistoryItem* item,
+    ResourceRequestCachePolicy cachePolicy)
+{
+    RefPtr<FormData> formData = item->formData();
+    ResourceRequest request(item->url());
+    request.setHTTPReferrer(item->referrer());
+    request.setCachePolicy(cachePolicy);
+    if (formData) {
+        request.setHTTPMethod("POST");
+        request.setHTTPBody(formData);
+        request.setHTTPContentType(item->formContentType());
+        RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::createFromString(item->referrer().referrer);
+        request.addHTTPOriginIfNeeded(securityOrigin->toAtomicString());
+    }
+    return request;
+}
+
+ResourceRequest FrameLoader::resourceRequestForReload(FrameLoadType frameLoadType,
+    const KURL& overrideURL, ClientRedirectPolicy clientRedirectPolicy)
+{
+    ASSERT(frameLoadType == FrameLoadTypeReload || frameLoadType == FrameLoadTypeReloadFromOrigin);
+    ResourceRequestCachePolicy cachePolicy = frameLoadType == FrameLoadTypeReloadFromOrigin ?
+        ReloadBypassingCache : ReloadIgnoringCacheData;
+    if (!m_currentItem)
+        return ResourceRequest();
+    ResourceRequest request = resourceRequestFromHistoryItem(m_currentItem.get(), cachePolicy);
+
+    // ClientRedirectPolicy is an indication that this load was triggered by
+    // some direct interaction with the page. If this reload is not a client
+    // redirect, we should reuse the referrer from the original load of the
+    // current document. If this reload is a client redirect (e.g., location.reload()),
+    // it was initiated by something in the current document and should
+    // therefore show the current document's url as the referrer.
+    if (clientRedirectPolicy == ClientRedirect) {
+        request.setHTTPReferrer(Referrer(m_frame->document()->outgoingReferrer(),
+            m_frame->document()->referrerPolicy()));
+    }
+
+    if (!overrideURL.isEmpty()) {
+        request.setURL(overrideURL);
+        request.clearHTTPReferrer();
+    }
+    request.setSkipServiceWorker(frameLoadType == FrameLoadTypeReloadFromOrigin);
+    return request;
+}
+
+// static
+FrameLoadRequest FrameLoader::frameRequestForReload(const ResourceRequest& resourceRequest,
+    ClientRedirectPolicy clientRedirectPolicy)
+{
+    FrameLoadRequest request = FrameLoadRequest(nullptr, resourceRequest);
+    request.setClientRedirect(clientRedirectPolicy);
+    return request;
 }
 
 FrameLoader::FrameLoader(LocalFrame* frame)
     : m_frame(frame)
     , m_progressTracker(ProgressTracker::create(frame))
     , m_loadType(FrameLoadTypeStandard)
     , m_inStopAllLoaders(false)
     , m_checkTimer(this, &FrameLoader::checkTimerFired)
     , m_didAccessInitialDocument(false)
     , m_didAccessInitialDocumentTimer(this, &FrameLoader::didAccessInitialDocumentTimerFired)
@@ skipping 43 matching lines @@
         m_policyDocumentLoader->setDefersLoading(defers);
 
     if (Document* document = m_frame->document()) {
         if (defers)
             document->suspendScheduledTasks();
         else
             document->resumeScheduledTasks();
     }
 
     if (!defers) {
-        if (m_deferredHistoryLoad.isValid()) {
-            loadHistoryItem(m_deferredHistoryLoad.m_item.get(), FrameLoadTypeBackForward,
-                m_deferredHistoryLoad.m_type, m_deferredHistoryLoad.m_cachePolicy);
-            m_deferredHistoryLoad = DeferredHistoryLoad();
+        if (m_deferredHistoryLoad.get()) {
+            load(FrameLoadRequest(nullptr, m_deferredHistoryLoad->m_request),
+                m_deferredHistoryLoad->m_loadType, m_deferredHistoryLoad->m_item.get(),
+                m_deferredHistoryLoad->m_historyLoadType);
+            m_deferredHistoryLoad.clear();
         }
         m_frame->navigationScheduler().startTimer();
         scheduleCheckCompleted();
     }
 }
 
 void FrameLoader::saveScrollState()
 {
     if (!m_currentItem || !m_frame->view())
         return;
@@ skipping 202 matching lines @@
         String headerContentLanguage = m_documentLoader->response().httpHeaderField("Content-Language");
         if (!headerContentLanguage.isEmpty()) {
             size_t commaIndex = headerContentLanguage.find(',');
             headerContentLanguage.truncate(commaIndex); // kNotFound == -1 == don't truncate
             headerContentLanguage = headerContentLanguage.stripWhiteSpace(isHTMLSpace<UChar>);
             if (!headerContentLanguage.isEmpty())
                 m_frame->document()->setContentLanguage(AtomicString(headerContentLanguage));
         }
     }
 
-    if (m_provisionalItem && (m_loadType == FrameLoadTypeBackForward || m_loadType == FrameLoadTypeInitialHistoryLoad))
+    if (m_provisionalItem && isBackForwardLoadType(m_loadType))
         m_frame->document()->setStateForNewFormElements(m_provisionalItem->documentState());
 
     client()->didCreateNewDocument();
 }
 
 void FrameLoader::finishedParsing()
 {
     if (m_stateMachine.creatingInitialEmptyDocument())
         return;
 
@@ skipping 341 matching lines @@
         KeyboardEvent* keyEvent = toKeyboardEvent(event);
         navigationPolicyFromMouseEvent(0, keyEvent->ctrlKey(), keyEvent->shiftKey(), keyEvent->altKey(), keyEvent->metaKey(), &policy);
     } else if (event->isGestureEvent()) {
         // The click is simulated when triggering the gesture-tap event
         GestureEvent* gestureEvent = toGestureEvent(event);
         navigationPolicyFromMouseEvent(0, gestureEvent->ctrlKey(), gestureEvent->shiftKey(), gestureEvent->altKey(), gestureEvent->metaKey(), &policy);
     }
     return policy;
 }
 
-void FrameLoader::load(const FrameLoadRequest& passedRequest)
+void FrameLoader::load(const FrameLoadRequest& passedRequest, FrameLoadType frameLoadType,
+    HistoryItem* historyItem, HistoryLoadType historyLoadType)
 {
     ASSERT(m_frame->document());
 
     RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
 
     if (m_inStopAllLoaders)
         return;
 
+    if (m_frame->page()->defersLoading() && isBackForwardLoadType(frameLoadType)) {
+        m_deferredHistoryLoad = adoptPtr(new DeferredHistoryLoad(
+            passedRequest.resourceRequest(), historyItem, frameLoadType, historyLoadType));
+        return;
+    }
+
     FrameLoadRequest request(passedRequest);
     request.resourceRequest().setHasUserGesture(UserGestureIndicator::processingUserGesture());
 
     if (!prepareRequestForThisFrame(request))
         return;
 
+    if (isBackForwardLoadType(frameLoadType)) {
+        ASSERT(historyItem);
+        m_provisionalItem = historyItem;
+    }
+
     RefPtrWillBeRawPtr<LocalFrame> targetFrame = toLocalFrame(request.form() ? nullptr : m_frame->findFrameForNavigation(AtomicString(request.frameName()), *m_frame));
     if (targetFrame && targetFrame.get() != m_frame) {
         bool wasInSamePage = targetFrame->page() == m_frame->page();
 
         request.setFrameName("_self");
         targetFrame->loader().load(request);
         Page* page = targetFrame->page();
         if (!wasInSamePage && page)
             page->chromeClient().focus();
         return;
     }
 
     setReferrerForFrameRequest(request.resourceRequest(), request.shouldSendReferrer(), request.originDocument());
 
-    FrameLoadType newLoadType = determineFrameLoadType(request);
+    FrameLoadType newLoadType = (frameLoadType == FrameLoadTypeStandard) ?
+        determineFrameLoadType(request) : frameLoadType;
     NavigationPolicy policy = navigationPolicyForRequest(request);
     if (shouldOpenInNewWindow(targetFrame.get(), request, policy)) {
         if (policy == NavigationPolicyDownload) {
             client()->loadURLExternally(request.resourceRequest(), NavigationPolicyDownload);
         } else {
             request.resourceRequest().setFrameType(WebURLRequest::FrameTypeAuxiliary);
             createWindowForRequest(request, *m_frame, policy, request.shouldSendReferrer());
         }
         return;
     }
 
     const KURL& url = request.resourceRequest().url();
-    if (policy == NavigationPolicyCurrentTab && shouldPerformFragmentNavigation(request.form(), request.resourceRequest().httpMethod(), newLoadType, url)) {
-        m_documentLoader->setNavigationType(determineNavigationType(newLoadType, false, request.triggeringEvent()));
-        if (shouldTreatURLAsSameAsCurrent(url))
-            newLoadType = FrameLoadTypeRedirectWithLockedBackForwardList;
-        loadInSameDocument(url, nullptr, newLoadType, request.clientRedirect());
+    bool sameDocumentHistoryNavigation =
+        isBackForwardLoadType(newLoadType) && historyLoadType == HistorySameDocumentLoad;
+    bool sameDocumentNavigation = policy == NavigationPolicyCurrentTab
+        && shouldPerformFragmentNavigation(
+            request.form(), request.resourceRequest().httpMethod(), newLoadType, url);
+
+    // Perform same document navigation.
+    if (sameDocumentHistoryNavigation || sameDocumentNavigation) {
+        ASSERT(historyItem || !sameDocumentHistoryNavigation);
+        RefPtr<SerializedScriptValue> stateObject = sameDocumentHistoryNavigation ?
+            historyItem->stateObject() : nullptr;
+        ClientRedirectPolicy clientRedirect = sameDocumentHistoryNavigation ?

[Nate Chapin, 2015/06/04 23:23:09]

I think (though I'm not absolutely sure) that a history navigation will never be
flagged as a ClientRedirect, in which case this conditional is unnecessary.

[clamy, 2015/06/05 14:11:48]

Done (if the tests appear to fail I will bring it back).

+            NotClientRedirect : request.clientRedirect();
+
+        if (!sameDocumentHistoryNavigation) {
+            m_documentLoader->setNavigationType(determineNavigationType(
+                newLoadType, false, request.triggeringEvent()));
+            if (shouldTreatURLAsSameAsCurrent(url))
+                newLoadType = FrameLoadTypeRedirectWithLockedBackForwardList;
+        }
+
+        loadInSameDocument(url, stateObject, newLoadType, clientRedirect);
+
+        if (sameDocumentNavigation)
+            restoreScrollPositionAndViewState();
         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.
-    if (sameURL && newLoadType != FrameLoadTypeReload && newLoadType != FrameLoadTypeReloadFromOrigin && request.resourceRequest().httpMethod() != "POST")
+    if (sameURL
+        && !isBackForwardLoadType(frameLoadType)
+        && newLoadType != FrameLoadTypeReload
+        && newLoadType != FrameLoadTypeReloadFromOrigin
+        && request.resourceRequest().httpMethod() != "POST") {
         m_loadType = FrameLoadTypeSame;
+    }
 }
 
 SubstituteData FrameLoader::defaultSubstituteDataForURL(const KURL& url)
 {
     if (!shouldTreatURLAsSrcdocDocument(url))
         return SubstituteData();
     String srcdoc = m_frame->deprecatedLocalOwner()->fastGetAttribute(srcdocAttr);
     ASSERT(!srcdoc.isNull());
     CString encodedSrcdoc = srcdoc.utf8();
     return SubstituteData(SharedBuffer::create(encodedSrcdoc.data(), encodedSrcdoc.length()), "text/html", "UTF-8", KURL());
 }
 
 void FrameLoader::reportLocalLoadFailed(LocalFrame* frame, const String& url)
 {
     ASSERT(!url.isEmpty());
     if (!frame)
         return;
 
     frame->document()->addConsoleMessage(ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, "Not allowed to load local resource: " + url));
 }
 
-// static
-ResourceRequest FrameLoader::requestFromHistoryItem(HistoryItem* item, ResourceRequestCachePolicy cachePolicy)
-{
-    RefPtr<FormData> formData = item->formData();
-    ResourceRequest request(item->url());
-    request.setHTTPReferrer(item->referrer());
-    request.setCachePolicy(cachePolicy);
-    if (formData) {
-        request.setHTTPMethod("POST");
-        request.setHTTPBody(formData);
-        request.setHTTPContentType(item->formContentType());
-        RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::createFromString(item->referrer().referrer);
-        request.addHTTPOriginIfNeeded(securityOrigin->toAtomicString());
-    }
-    return request;
-}
-
-void FrameLoader::reload(ReloadPolicy reloadPolicy, const KURL& overrideURL, ClientRedirectPolicy clientRedirectPolicy)
-{
-    if (!m_currentItem)
-        return;
-
-    ResourceRequestCachePolicy cachePolicy = reloadPolicy == EndToEndReload ? ReloadBypassingCache : ReloadIgnoringCacheData;
-    ResourceRequest request = requestFromHistoryItem(m_currentItem.get(), cachePolicy);
-
-    // ClientRedirectPolicy is an indication that this load was triggered by
-    // some direct interaction with the page. If this reload is not a client
-    // redirect, we should reuse the referrer from the original load of the
-    // current document. If this reload is a client redirect (e.g., location.reload()),
-    // it was initiated by something in the current document and should
-    // therefore show the current document's url as the referrer.
-    if (clientRedirectPolicy == ClientRedirect)
-        request.setHTTPReferrer(Referrer(m_frame->document()->outgoingReferrer(), m_frame->document()->referrerPolicy()));
-
-    if (!overrideURL.isEmpty()) {
-        request.setURL(overrideURL);
-        request.clearHTTPReferrer();
-    }
-    request.setSkipServiceWorker(reloadPolicy == EndToEndReload);
-    FrameLoadRequest frameLoadRequest(nullptr, request);
-    frameLoadRequest.setClientRedirect(clientRedirectPolicy);
-    startLoad(frameLoadRequest, reloadPolicy == EndToEndReload ? FrameLoadTypeReloadFromOrigin : FrameLoadTypeReload, NavigationPolicyCurrentTab);
-}
-
 void FrameLoader::stopAllLoaders()
 {
     if (m_frame->document()->pageDismissalEventBeingDispatched() != Document::NoDismissal)
         return;
 
     // If this method is called from within this method, infinite recursion can occur (3442218). Avoid this.
     if (m_inStopAllLoaders)
         return;
 
     // Calling stopLoading() on the provisional document loader can blow away
@@ skipping 228 matching lines @@
         if (!m_provisionalDocumentLoader && m_frame->isLoading()) {
             client()->dispatchDidFailLoad(error, historyCommitType);
             m_progressTracker->progressCompleted();
         }
     }
     checkCompleted();
 }
 
 bool FrameLoader::shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType loadType, const KURL& url)
 {
-    ASSERT(loadType != FrameLoadTypeReloadFromOrigin);
     // We don't do this if we are submitting a form with method other than "GET", explicitly reloading,
     // currently displaying a frameset, or if the URL does not have a fragment.
     return (!isFormSubmission || equalIgnoringCase(httpMethod, "GET"))
         && loadType != FrameLoadTypeReload
+        && loadType != FrameLoadTypeReloadFromOrigin
         && loadType != FrameLoadTypeSame
         && loadType != FrameLoadTypeBackForward
         && url.hasFragmentIdentifier()
         && equalIgnoringFragmentIdentifier(m_frame->document()->url(), url)
         // We don't want to just scroll if a link from within a
         // frameset is trying to reload the frameset into _top.
         && !m_frame->document()->isFrameSet();
 }
 
 void FrameLoader::scrollToFragmentWithParentBoundary(const KURL& url)
@@ skipping 185 matching lines @@
 bool FrameLoader::shouldTreatURLAsSrcdocDocument(const KURL& url) const
 {
     if (!equalIgnoringCase(url.string(), "about:srcdoc"))
         return false;
     HTMLFrameOwnerElement* ownerElement = m_frame->deprecatedLocalOwner();
     if (!isHTMLIFrameElement(ownerElement))
         return false;
     return ownerElement->fastHasAttribute(srcdocAttr);
 }
 
-void FrameLoader::loadHistoryItem(HistoryItem* item, FrameLoadType frameLoadType, HistoryLoadType historyLoadType, ResourceRequestCachePolicy cachePolicy)
-{
-    RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
-    if (m_frame->page()->defersLoading()) {
-        m_deferredHistoryLoad = DeferredHistoryLoad(item, historyLoadType, cachePolicy);
-        return;
-    }
-
-    m_provisionalItem = item;
-    if (historyLoadType == HistorySameDocumentLoad) {
-        loadInSameDocument(item->url(), item->stateObject(), frameLoadType, NotClientRedirect);
-        restoreScrollPositionAndViewState();
-        return;
-    }
-    FrameLoadRequest request(nullptr, requestFromHistoryItem(item, cachePolicy));
-    startLoad(request, frameLoadType, NavigationPolicyCurrentTab);
-}
-
 void FrameLoader::dispatchDocumentElementAvailable()
 {
     client()->documentElementAvailable();
 }
 
 void FrameLoader::dispatchDidClearDocumentOfWindowObject()
 {
     if (!m_frame->script().canExecuteScripts(NotAboutToExecuteScript))
         return;
 
@@ skipping 67 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