Move HistoryItem handling to DocumentLoader

third_party/WebKit/Source/core/loader/DocumentLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 13 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/loader/DocumentLoader.h"
 
 #include <memory>
 #include "core/dom/Document.h"
+#include "core/dom/DocumentParser.h"
 #include "core/dom/WeakIdentifierMap.h"
 #include "core/events/Event.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameClient.h"
 #include "core/frame/Settings.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
@@ skipping 106 matching lines @@
   DCHECK(!m_frame);
   DCHECK(!m_mainResource);
   DCHECK(!m_applicationCacheHost);
   DCHECK_EQ(m_state, SentDidFinishLoad);
 }
 
 DEFINE_TRACE(DocumentLoader) {
   visitor->trace(m_frame);
   visitor->trace(m_fetcher);
   visitor->trace(m_mainResource);
+  visitor->trace(m_historyItem);
   visitor->trace(m_writer);
   visitor->trace(m_subresourceFilter);
   visitor->trace(m_documentLoadTiming);
   visitor->trace(m_applicationCacheHost);
   visitor->trace(m_contentSecurityPolicy);
   RawResourceClient::trace(visitor);
 }
 
 unsigned long DocumentLoader::mainResourceIdentifier() const {
   return m_mainResource ? m_mainResource->identifier() : 0;
@@ skipping 95 matching lines @@
 }
 
 void DocumentLoader::didObserveLoadingBehavior(
     WebLoadingBehaviorFlag behavior) {
   if (m_frame) {
     DCHECK_GE(m_state, Committed);
     localFrameClient().didObserveLoadingBehavior(behavior);
   }
 }
 
+static HistoryCommitType loadTypeToCommitType(FrameLoadType type) {
+  switch (type) {
+    case FrameLoadTypeStandard:
+      return StandardCommit;
+    case FrameLoadTypeInitialInChildFrame:
+    case FrameLoadTypeInitialHistoryLoad:
+      return InitialCommitInChildFrame;
+    case FrameLoadTypeBackForward:
+      return BackForwardCommit;
+    default:
+      break;
+  }
+  return HistoryInertCommit;
+}
+
 void DocumentLoader::updateForSameDocumentNavigation(
     const KURL& newURL,
-    SameDocumentNavigationSource sameDocumentNavigationSource) {
+    SameDocumentNavigationSource sameDocumentNavigationSource,
+    PassRefPtr<SerializedScriptValue> data,
+    HistoryScrollRestorationType scrollRestorationType,
+    FrameLoadType type,
+    Document* initiatingDocument) {
+  if (m_frame->settings()->getHistoryEntryRequiresUserGesture() &&
+      initiatingDocument &&
+      !initiatingDocument->frame()->hasReceivedUserGesture()) {
+    type = FrameLoadTypeReplaceCurrentItem;
+  }
+
   KURL oldURL = m_request.url();
   m_originalRequest.setURL(newURL);
   m_request.setURL(newURL);
+  setReplacesCurrentHistoryItem(type != FrameLoadTypeStandard);
   if (sameDocumentNavigationSource == SameDocumentNavigationHistoryApi) {
     m_request.setHTTPMethod(HTTPNames::GET);
     m_request.setHTTPBody(nullptr);
   }
   clearRedirectChain();
   if (m_isClientRedirect)
     appendRedirect(oldURL);
   appendRedirect(newURL);
+
+  setHistoryItemStateForCommit(
+      m_historyItem.get(), type,
+      sameDocumentNavigationSource == SameDocumentNavigationHistoryApi
+          ? HistoryNavigationType::HistoryApi
+          : HistoryNavigationType::Fragment);
+  m_historyItem->setDocumentState(m_frame->document()->formElementsState());
+  if (sameDocumentNavigationSource == SameDocumentNavigationHistoryApi) {
+    m_historyItem->setStateObject(std::move(data));
+    m_historyItem->setScrollRestorationType(scrollRestorationType);
+  }
+  localFrameClient().dispatchDidNavigateWithinPage(
+      m_historyItem.get(), loadTypeToCommitType(type), initiatingDocument);
 }
 
 const KURL& DocumentLoader::urlForHistory() const {
   return unreachableURL().isEmpty() ? url() : unreachableURL();
 }
 
-void DocumentLoader::commitIfReady() {
-  if (m_state < Committed) {
-    m_state = Committed;
-    frameLoader().commitProvisionalLoad();
+void DocumentLoader::setHistoryItemStateForCommit(
+    HistoryItem* oldItem,
+    FrameLoadType loadType,
+    HistoryNavigationType navigationType) {
+  if (!m_historyItem || !isBackForwardLoadType(loadType))
+    m_historyItem = HistoryItem::create();
+
+  m_historyItem->setURL(urlForHistory());
+  m_historyItem->setReferrer(SecurityPolicy::generateReferrer(
+      m_request.getReferrerPolicy(), m_historyItem->url(),
+      m_request.httpReferrer()));
+  m_historyItem->setFormInfoFromRequest(m_request);
+
+  // Don't propagate state from the old item to the new item if there isn't an
+  // old item (obviously), or if this is a back/forward navigation, since we
+  // explicitly want to restore the state we just committed.
+  if (!oldItem || isBackForwardLoadType(loadType))
+    return;
+  // 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.
+  HistoryCommitType historyCommitType = loadTypeToCommitType(loadType);
+  if (navigationType == HistoryNavigationType::DifferentDocument &&
+      (historyCommitType != HistoryInertCommit ||
+       !equalIgnoringFragmentIdentifier(oldItem->url(), m_historyItem->url())))
+    return;
+  m_historyItem->setDocumentSequenceNumber(oldItem->documentSequenceNumber());
+  m_historyItem->setScrollOffset(oldItem->getScrollOffset());
+  m_historyItem->setDidSaveScrollOrScaleState(
+      oldItem->didSaveScrollOrScaleState());
+  m_historyItem->setVisualViewportScrollOffset(
+      oldItem->visualViewportScrollOffset());
+  m_historyItem->setPageScaleFactor(oldItem->pageScaleFactor());
+  m_historyItem->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_historyItem->url())) {
+    m_historyItem->setStateObject(oldItem->stateObject());
+    m_historyItem->setItemSequenceNumber(oldItem->itemSequenceNumber());
   }
 }
 
 void DocumentLoader::notifyFinished(Resource* resource) {
   DCHECK_EQ(m_mainResource, resource);
   DCHECK(m_mainResource);
 
   if (!m_mainResource->errorOccurred() && !m_mainResource->wasCanceled()) {
     finishedLoading(m_mainResource->loadFinishTime());
     return;
   }
 
   if (m_applicationCacheHost)
     m_applicationCacheHost->failedLoadingMainResource();
 
   if (m_mainResource->resourceError().wasBlockedByResponse()) {
     probe::canceledAfterReceivedResourceResponse(
         m_frame, this, mainResourceIdentifier(), resource->response(),
         m_mainResource.get());
   }
 
-  frameLoader().loadFailed(this, m_mainResource->resourceError());
+  loadFailed(m_mainResource->resourceError());
   clearMainResourceHandle();
 }
 
+void DocumentLoader::loadFailed(const ResourceError& error) {
+  if (!error.isCancellation() && m_frame->owner()) {
+    // FIXME: For now, fallback content doesn't work cross process.
+    if (m_frame->owner()->isLocal())
+      m_frame->deprecatedLocalOwner()->renderFallbackContent();
+  }
+
+  HistoryCommitType historyCommitType = loadTypeToCommitType(m_loadType);
+  FrameLoader& loader = frameLoader();
+  if (m_state < Committed) {
+    if (m_state == NotStarted)
+      probe::frameClearedScheduledClientNavigation(m_frame);
+    m_state = SentDidFinishLoad;
+    localFrameClient().dispatchDidFailProvisionalLoad(error, historyCommitType);
+    if (!m_frame)
+      return;
+    loader.detachProvisionalDocumentLoader(this);
+  } else if (m_state == Committed) {
+    if (m_frame->document()->parser())
+      m_frame->document()->parser()->stopParsing();
+    m_state = SentDidFinishLoad;
+    localFrameClient().dispatchDidFailLoad(error, historyCommitType);
+  }
+  loader.checkCompleted();
+}
+
 void DocumentLoader::finishedLoading(double finishTime) {
   DCHECK(m_frame->loader().stateMachine()->creatingInitialEmptyDocument() ||
          !m_frame->page()->suspended() ||
          MainThreadDebugger::instance()->isPaused());
 
   double responseEndTime = finishTime;
   if (!responseEndTime)
     responseEndTime = m_timeOfLastDataReceived;
   if (!responseEndTime)
     responseEndTime = monotonicallyIncreasingTime();
   timing().setResponseEnd(responseEndTime);
-
-  commitIfReady();
-  if (!m_frame)
-    return;
-
   if (!maybeCreateArchive()) {
     // If this is an empty document, it will not have actually been created yet.
     // Commit dummy data so that DocumentWriter::begin() gets called and creates
     // the Document.
     if (!m_writer)
       commitData(0, 0);
   }
 
   if (!m_frame)
     return;
@@ skipping 43 matching lines @@
     return false;
   }
 
   DCHECK(timing().fetchStart());
   appendRedirect(requestURL);
   timing().addRedirect(redirectResponse.url(), requestURL);
 
   // If a redirection happens during a back/forward navigation, don't restore
   // any state from the old HistoryItem. There is a provisional history item for
   // back/forward navigation only. In the other case, clearing it is a no-op.
-  frameLoader().clearProvisionalHistoryItem();
+  m_historyItem.clear();
 
   localFrameClient().dispatchDidReceiveServerRedirectForProvisionalLoad();
 
   return true;
 }
 
 static bool canShowMIMEType(const String& mimeType, LocalFrame* frame) {
   if (MIMETypeRegistry::isSupportedMIMEType(mimeType))
     return true;
   PluginData* pluginData = frame->pluginData();
@@ skipping 125 matching lines @@
   if (m_frame->owner() && m_response.isHTTP() &&
       !FetchUtils::isOkStatus(m_response.httpStatusCode()))
     m_frame->owner()->renderFallbackContent();
 }
 
 void DocumentLoader::ensureWriter(const AtomicString& mimeType,
                                   const KURL& overridingURL) {
   if (m_writer)
     return;
 
+  // Set history state before commitProvisionalLoad() so that we still have
+  // access to the previous committed DocumentLoader's HistoryItem, in case we
+  // need to copy state from it.
+  if (!frameLoader().stateMachine()->creatingInitialEmptyDocument()) {
+    setHistoryItemStateForCommit(frameLoader().documentLoader()->historyItem(),
+                                 m_loadType,
+                                 HistoryNavigationType::DifferentDocument);
+  }
+
+  DCHECK_EQ(m_state, Provisional);
+  frameLoader().commitProvisionalLoad();
+  if (!m_frame)
+    return;
+
   const AtomicString& encoding = response().textEncodingName();
 
   // Prepare a DocumentInit before clearing the frame, because it may need to
   // inherit an aliased security context.
   Document* owner = nullptr;
   // TODO(dcheng): This differs from the behavior of both IE and Firefox: the
   // origin is inherited from the document that loaded the URL.
   if (shouldInheritSecurityOriginFromOwner(url())) {
     Frame* ownerFrame = m_frame->tree().parent();
     if (!ownerFrame)
@@ skipping 14 matching lines @@
   installNewDocument(init, mimeType, encoding,
                      InstallNewDocumentReason::kNavigation, parsingPolicy,
                      overridingURL);
   m_writer->setDocumentWasLoadedAsPartOfNavigation();
   m_frame->document()->maybeHandleHttpRefresh(
       m_response.httpHeaderField(HTTPNames::Refresh),
       Document::HttpRefreshFromHeader);
 }
 
 void DocumentLoader::commitData(const char* bytes, size_t length) {
-  DCHECK_EQ(m_state, Committed);
   ensureWriter(m_response.mimeType());
+  DCHECK_GE(m_state, Committed);
 
   // This can happen if document.close() is called by an event handler while
   // there's still pending incoming data.
-  if (m_frame && !m_frame->document()->parsing())
+  if (!m_frame || !m_frame->document()->parsing())
     return;
 
   if (length)
     m_dataReceived = true;
 
   m_writer->addData(bytes, length);
 }
 
 void DocumentLoader::dataReceived(Resource* resource,
                                   const char* data,
@@ skipping 30 matching lines @@
   // All data has been consumed, so flush the buffer.
   m_dataBuffer->clear();
 }
 
 void DocumentLoader::processData(const char* data, size_t length) {
   m_applicationCacheHost->mainResourceDataReceived(data, length);
   m_timeOfLastDataReceived = monotonicallyIncreasingTime();
 
   if (isArchiveMIMEType(response().mimeType()))
     return;
-  commitIfReady();
-  if (!m_frame)
-    return;
   commitData(data, length);
 
   // If we are sending data to MediaDocument, we should stop here and cancel the
   // request.
   if (m_frame && m_frame->document()->isMediaDocument())
     m_fetcher->stopFetching();
 }
 
 void DocumentLoader::clearRedirectChain() {
   m_redirectChain.clear();
 }
 
 void DocumentLoader::appendRedirect(const KURL& url) {
   m_redirectChain.push_back(url);
 }
 
 void DocumentLoader::detachFromFrame() {
   DCHECK(m_frame);
 
   // It never makes sense to have a document loader that is detached from its
   // frame have any loads active, so go ahead and kill all the loads.
   m_fetcher->stopFetching();
 
   if (m_frame && !sentDidFinishLoad())
-    frameLoader().loadFailed(this, ResourceError::cancelledError(url()));
+    loadFailed(ResourceError::cancelledError(url()));
 
   // If that load cancellation triggered another detach, leave.
   // (fast/frames/detach-frame-nested-no-crash.html is an example of this.)
   if (!m_frame)
     return;
 
   m_fetcher->clearContext();
   m_applicationCacheHost->detachFromDocumentLoader();
   m_applicationCacheHost.clear();
   m_serviceWorkerNetworkProvider = nullptr;
@@ skipping 16 matching lines @@
     return false;
 
   DCHECK(m_mainResource);
   ArchiveResource* mainResource =
       m_fetcher->createArchive(m_mainResource.get());
   if (!mainResource)
     return false;
   // The origin is the MHTML file, we need to set the base URL to the document
   // encoded in the MHTML so relative URLs are resolved properly.
   ensureWriter(mainResource->mimeType(), mainResource->url());
+  if (!m_frame)
+    return false;
 
   // The Document has now been created.
   m_frame->document()->enforceSandboxFlags(SandboxAll);
 
   commitData(mainResource->data()->data(), mainResource->data()->size());
   return true;
 }
 
 const AtomicString& DocumentLoader::responseMIMEType() const {
   return m_response.mimeType();
@@ skipping 67 matching lines @@
 
 void DocumentLoader::endWriting() {
   m_writer->end();
   m_writer.clear();
 }
 
 void DocumentLoader::didInstallNewDocument(Document* document) {
   document->setReadyState(Document::Loading);
   document->initContentSecurityPolicy(m_contentSecurityPolicy.release());
 
-  frameLoader().didInstallNewDocument();
+  if (m_historyItem && isBackForwardLoadType(m_loadType))
+    document->setStateForNewFormElements(m_historyItem->getDocumentState());
 
   String suboriginHeader = m_response.httpHeaderField(HTTPNames::Suborigin);
   if (!suboriginHeader.isNull()) {
     Vector<String> messages;
     Suborigin suborigin;
     if (parseSuboriginHeader(suboriginHeader, &suborigin, messages))
       document->enforceSuborigin(suborigin);
 
     for (auto& message : messages) {
       document->addConsoleMessage(
@@ skipping 34 matching lines @@
     UseCounter::count(*document, UseCounter::ReferrerPolicyHeader);
     document->parseAndSetReferrerPolicy(referrerPolicyHeader);
   }
 
   localFrameClient().didCreateNewDocument();
 }
 
 void DocumentLoader::didCommitNavigation() {
   if (frameLoader().stateMachine()->creatingInitialEmptyDocument())
     return;
-  frameLoader().receivedFirstData();
+
+  if (!m_frame->loader().stateMachine()->committedMultipleRealLoads() &&
+      m_loadType == FrameLoadTypeStandard) {
+    m_frame->loader().stateMachine()->advanceTo(
+        FrameLoaderStateMachine::CommittedMultipleRealLoads);
+  }
+
+  localFrameClient().dispatchDidCommitLoad(m_historyItem.get(),
+                                           loadTypeToCommitType(m_loadType));
+
+  // When the embedder gets notified (above) that the new navigation has
+  // committed, the embedder will drop the old Content Security Policy and
+  // therefore now is a good time to report to the embedder the Content
+  // Security Policies that have accumulated so far for the new navigation.
+  m_frame->securityContext()->contentSecurityPolicy()->reportAccumulatedHeaders(
+      &localFrameClient());
 
   // didObserveLoadingBehavior() must be called after dispatchDidCommitLoad() is
   // called for the metrics tracking logic to handle it properly.
   if (m_serviceWorkerNetworkProvider &&
       m_serviceWorkerNetworkProvider->isControlledByServiceWorker()) {
     localFrameClient().didObserveLoadingBehavior(
         WebLoadingBehaviorServiceWorkerControlled);
   }
 
   // Links with media values need more information (like viewport information).
@@ skipping 88 matching lines @@
                      InstallNewDocumentReason::kJavascriptURL,
                      ForceSynchronousParsing, KURL());
   if (!source.isNull())
     m_writer->appendReplacingData(source);
   endWriting();
 }
 
 DEFINE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 }  // namespace blink