Drop replacesCurrentHistoryItem, NavigationType

third_party/WebKit/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.
@@ skipping 456 matching lines @@
     historyCommitType = HistoryInertCommit;
   setHistoryItemStateForCommit(loadType, historyCommitType,
                                HistoryNavigationType::DifferentDocument);
 
   if (!m_stateMachine.committedMultipleRealLoads() &&
       loadType == FrameLoadTypeStandard) {
     m_stateMachine.advanceTo(
         FrameLoaderStateMachine::CommittedMultipleRealLoads);
   }
 
-  client()->dispatchDidCommitLoad(m_currentItem.get(), historyCommitType);
+  client()->didCommitProvisionalLoad(m_documentLoader, loadType,
+                                     m_currentItem.get(), historyCommitType);
 
   // 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(
       client());
 
   // didObserveLoadingBehavior() must be called after dispatchDidCommitLoad() is
   // called for the metrics tracking logic to handle it properly.
@@ skipping 252 matching lines @@
     // Finishing the load can detach the frame when running layout tests.
     if (!m_frame->client())
       return;
   }
 
   if (shouldSendCompleteNotification(m_frame, m_isNavigationHandledByClient)) {
     m_progressTracker->progressCompleted();
     // Retry restoring scroll offset since finishing loading disables content
     // size clamping.
     restoreScrollPositionAndViewState();
-    if (m_documentLoader)
-      m_documentLoader->setLoadType(FrameLoadTypeStandard);
     m_frame->domWindow()->finishedLoading();
   }
 
   Frame* parent = m_frame->tree().parent();
   if (parent && parent->isLocalFrame())
     toLocalFrame(parent)->loader().checkCompleted();
 }
 
 void FrameLoader::checkTimerFired(TimerBase*) {
   if (Page* page = m_frame->page()) {
@@ skipping 33 matching lines @@
 
 void FrameLoader::updateForSameDocumentNavigation(
     const KURL& newURL,
     SameDocumentNavigationSource sameDocumentNavigationSource,
     PassRefPtr<SerializedScriptValue> data,
     HistoryScrollRestorationType scrollRestorationType,
     FrameLoadType type,
     Document* initiatingDocument) {
   // Update the data source's request with the new URL to fake the URL change
   m_frame->document()->setURL(newURL);
-  documentLoader()->setReplacesCurrentHistoryItem(type !=
-                                                  FrameLoadTypeStandard);
   documentLoader()->updateForSameDocumentNavigation(
       newURL, sameDocumentNavigationSource);
 
   // Generate start and stop notifications only when loader is completed so that
   // we don't fire them for fragment redirection that happens in window.onload
   // handler. See https://bugs.webkit.org/show_bug.cgi?id=31838
   // Do not fire the notifications if the frame is concurrently navigating away
   // from the document, since a new document is already loading.
   if (m_frame->document()->loadEventFinished() && !m_provisionalDocumentLoader)
     client()->didStartLoading(NavigationWithinSameDocument);
 
   HistoryCommitType historyCommitType = loadTypeToCommitType(type);
   if (!m_currentItem)
     historyCommitType = HistoryInertCommit;
   if (m_frame->settings()->getHistoryEntryRequiresUserGesture() &&
       initiatingDocument &&
       !initiatingDocument->frame()->hasReceivedUserGesture()) {
     historyCommitType = HistoryInertCommit;
   }
 
   setHistoryItemStateForCommit(
       type, historyCommitType,
       sameDocumentNavigationSource == SameDocumentNavigationHistoryApi
           ? HistoryNavigationType::HistoryApi
           : HistoryNavigationType::Fragment);
   if (sameDocumentNavigationSource == SameDocumentNavigationHistoryApi) {
     m_currentItem->setStateObject(std::move(data));
     m_currentItem->setScrollRestorationType(scrollRestorationType);
   }
-  client()->dispatchDidNavigateWithinPage(
-      m_currentItem.get(), historyCommitType, !!initiatingDocument);
+  client()->didNavigateWithinPage(m_documentLoader, type, m_currentItem.get(),
+                                  historyCommitType, !!initiatingDocument);
   client()->dispatchDidReceiveTitle(m_frame->document()->title());
   if (m_frame->document()->loadEventFinished() && !m_provisionalDocumentLoader)
     client()->didStopLoading();
 }
 
 void FrameLoader::detachDocumentLoader(Member<DocumentLoader>& loader) {
   if (!loader)
     return;
 
   FrameNavigationDisabler navigationDisabler(*m_frame);
@@ skipping 167 matching lines @@
       // client()->decidePolicyForNavigation(...).
       NOTREACHED();
       return true;
 
     default:
       NOTREACHED() << policy;
       return true;
   }
 }
 
-static NavigationType determineNavigationType(FrameLoadType frameLoadType,
-                                              bool isFormSubmission,
-                                              bool haveEvent) {
-  bool isReload = isReloadLoadType(frameLoadType);
-  bool isBackForward = isBackForwardLoadType(frameLoadType);
-  if (isFormSubmission) {
-    return (isReload || isBackForward) ? NavigationTypeFormResubmitted
-                                       : NavigationTypeFormSubmitted;
-  }
+static WebURLRequest::RequestContext determineRequestContext(
+    FrameLoadType type,
+    bool isFormSubmission,
+    bool haveEvent) {
+  if (isFormSubmission)
+    return WebURLRequest::RequestContextForm;
   if (haveEvent)
-    return NavigationTypeLinkClicked;
-  if (isReload)
-    return NavigationTypeReload;
-  if (isBackForward)
-    return NavigationTypeBackForward;
-  return NavigationTypeOther;
-}
-
-static WebURLRequest::RequestContext determineRequestContextFromNavigationType(
-    const NavigationType navigationType) {
-  switch (navigationType) {
-    case NavigationTypeLinkClicked:
-      return WebURLRequest::RequestContextHyperlink;
-
-    case NavigationTypeOther:
-      return WebURLRequest::RequestContextLocation;
-
-    case NavigationTypeFormResubmitted:
-    case NavigationTypeFormSubmitted:
-      return WebURLRequest::RequestContextForm;
-
-    case NavigationTypeBackForward:
-    case NavigationTypeReload:
-      return WebURLRequest::RequestContextInternal;
-  }
-  NOTREACHED();
-  return WebURLRequest::RequestContextHyperlink;
+    return WebURLRequest::RequestContextHyperlink;
+  if (isReloadLoadType(type) || isBackForwardLoadType(type))
+    return WebURLRequest::RequestContextInternal;
+  return WebURLRequest::RequestContextLocation;
 }
 
 static NavigationPolicy navigationPolicyForRequest(
     const FrameLoadRequest& request) {
   NavigationPolicy policy = NavigationPolicyCurrentTab;
   Event* event = request.triggeringEvent();
   if (!event)
     return policy;
 
   if (request.form() && event->underlyingEvent())
@@ skipping 39 matching lines @@
     return;
   }
 
   FrameLoadRequest request(passedRequest);
   request.resourceRequest().setHasUserGesture(
       UserGestureIndicator::processingUserGesture());
 
   if (!prepareRequestForThisFrame(request))
     return;
 
-  if (isBackForwardLoadType(frameLoadType)) {
-    DCHECK(historyItem);
+  if (isBackForwardLoadType(frameLoadType))
     m_provisionalItem = historyItem;
-  }
 
   // Form submissions appear to need their special-case of finding the target at
   // schedule rather than at fire.
   Frame* targetFrame = request.form()
                            ? nullptr
                            : m_frame->findFrameForNavigation(
                                  AtomicString(request.frameName()), *m_frame);
 
   NavigationPolicy policy = navigationPolicyForRequest(request);
   if (targetFrame && targetFrame != m_frame &&
@@ skipping 11 matching lines @@
     if (!wasInSamePage && page)
       page->chromeClient().focus();
     return;
   }
 
   setReferrerForFrameRequest(request);
 
   if (!targetFrame && !request.frameName().isEmpty()) {
     if (policy == NavigationPolicyDownload) {
       client()->loadURLExternally(request.resourceRequest(),
-                                  NavigationPolicyDownload, String(), false);
+                                  NavigationPolicyDownload, String(),
+                                  FrameLoadTypeStandard);
     } else {
       request.resourceRequest().setFrameType(WebURLRequest::FrameTypeAuxiliary);
       createWindowForRequest(request, *m_frame, policy);
     }
     return;
   }
 
   if (!m_frame->isNavigationAllowed())
     return;
 
   const KURL& url = request.resourceRequest().url();
   FrameLoadType newLoadType = (frameLoadType == FrameLoadTypeStandard)
                                   ? determineFrameLoadType(request)
                                   : frameLoadType;
   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) {
     DCHECK(historyItem || !sameDocumentHistoryNavigation);
     RefPtr<SerializedScriptValue> stateObject =
         sameDocumentHistoryNavigation ? historyItem->stateObject() : nullptr;
 
-    if (!sameDocumentHistoryNavigation) {
-      m_documentLoader->setNavigationType(determineNavigationType(
-          newLoadType, false, request.triggeringEvent()));
-      if (shouldTreatURLAsSameAsCurrent(url))
-        newLoadType = FrameLoadTypeReplaceCurrentItem;
-    }
+    if (!sameDocumentHistoryNavigation && shouldTreatURLAsSameAsCurrent(url))
+      newLoadType = FrameLoadTypeReplaceCurrentItem;
 
     loadInSameDocument(url, stateObject, newLoadType, historyLoadType,
                        request.clientRedirect(), request.originDocument());
     return;
   }
 
   startLoad(request, newLoadType, policy);
 }
 
 SubstituteData FrameLoader::defaultSubstituteDataForURL(const KURL& url) {
@@ skipping 401 matching lines @@
   }
 
   return shouldClose;
 }
 
 bool FrameLoader::shouldContinueForNavigationPolicy(
     const ResourceRequest& request,
     const SubstituteData& substituteData,
     DocumentLoader* loader,
     ContentSecurityPolicyDisposition shouldCheckMainWorldContentSecurityPolicy,
-    NavigationType type,
     NavigationPolicy policy,
     FrameLoadType frameLoadType,
     bool isClientRedirect,
     HTMLFormElement* form) {
   // Don't ask if we are loading an empty URL.
   if (request.url().isEmpty() || substituteData.isValid())
     return true;
 
   // If we're loading content into |m_frame| (NavigationPolicyCurrentTab), check
   // against the parent's Content Security Policy and kill the load if that
   // check fails, unless we should bypass the main world's CSP.
   if (policy == NavigationPolicyCurrentTab &&
       shouldCheckMainWorldContentSecurityPolicy == CheckContentSecurityPolicy) {
     Frame* parentFrame = m_frame->tree().parent();
     if (parentFrame) {
       ContentSecurityPolicy* parentPolicy =
           parentFrame->securityContext()->contentSecurityPolicy();
       if (!parentPolicy->allowFrameFromSource(request.url(),
                                               request.redirectStatus())) {
         // Fire a load event, as timing attacks would otherwise reveal that the
         // frame was blocked. This way, it looks like every other cross-origin
         // page load.
         m_frame->document()->enforceSandboxFlags(SandboxOrigin);
         m_frame->owner()->dispatchLoad();
         return false;
       }
     }
   }
 
-  bool isFormSubmission = type == NavigationTypeFormSubmitted ||
-                          type == NavigationTypeFormResubmitted;
-  if (isFormSubmission &&
+  if (request.requestContext() == WebURLRequest::RequestContextForm &&
       !m_frame->document()->contentSecurityPolicy()->allowFormAction(
           request.url()))
     return false;
 
-  bool replacesCurrentHistoryItem =
-      frameLoadType == FrameLoadTypeReplaceCurrentItem;
-  policy = client()->decidePolicyForNavigation(request, loader, type, policy,
-                                               replacesCurrentHistoryItem,
-                                               isClientRedirect, form);
+  policy = client()->decidePolicyForNavigation(
+      request, loader, policy, frameLoadType, isClientRedirect, form);
   if (policy == NavigationPolicyCurrentTab)
     return true;
   if (policy == NavigationPolicyIgnore)
     return false;
   if (policy == NavigationPolicyHandledByClient) {
     m_isNavigationHandledByClient = true;
     // Mark the frame as loading since the embedder is handling the navigation.
     m_progressTracker->progressStarted(frameLoadType);
 
     m_frame->navigationScheduler().cancel();
 
     // If this is a form submit, dispatch that a form is being submitted
     // since the embedder is handling the navigation.
     if (form)
       client()->dispatchWillSubmitForm(form);
 
     return false;
   }
   if (!LocalDOMWindow::allowPopUp(*m_frame) &&
       !UserGestureIndicator::utilizeUserGesture())
     return false;
-  client()->loadURLExternally(request, policy, String(),
-                              replacesCurrentHistoryItem);
+  client()->loadURLExternally(request, policy, String(), frameLoadType);
   return false;
 }
 
 bool FrameLoader::checkLoadCanStart(FrameLoadRequest& frameLoadRequest,
                                     FrameLoadType type,
-                                    NavigationPolicy navigationPolicy,
-                                    NavigationType navigationType) {
+                                    NavigationPolicy navigationPolicy) {
   if (m_frame->document()->pageDismissalEventBeingDispatched() !=
       Document::NoDismissal) {
     return false;
   }
-
   // Record the latest requiredCSP value that will be used when sending this
   // request.
   ResourceRequest& resourceRequest = frameLoadRequest.resourceRequest();
   recordLatestRequiredCSP();
   modifyRequestForCSP(resourceRequest, nullptr);
 
   if (!shouldContinueForNavigationPolicy(
           resourceRequest, frameLoadRequest.substituteData(), nullptr,
           frameLoadRequest.shouldCheckMainWorldContentSecurityPolicy(),
-          navigationType, navigationPolicy, type,
-          frameLoadRequest.clientRedirect() ==
-              ClientRedirectPolicy::ClientRedirect,
+          navigationPolicy, type, frameLoadRequest.clientRedirect() ==
+                                      ClientRedirectPolicy::ClientRedirect,
           frameLoadRequest.form())) {
     return false;
   }
 
   m_frame->document()->cancelParsing();
   detachDocumentLoader(m_provisionalDocumentLoader);
 
   // beforeunload fired above, and detaching a DocumentLoader can fire events,
   // which can detach this frame.
   if (!m_frame->host())
     return false;
 
   return true;
 }
 
 void FrameLoader::startLoad(FrameLoadRequest& frameLoadRequest,
                             FrameLoadType type,
                             NavigationPolicy navigationPolicy) {
   DCHECK(client()->hasWebView());
   ResourceRequest& resourceRequest = frameLoadRequest.resourceRequest();
-  NavigationType navigationType = determineNavigationType(
+  resourceRequest.setRequestContext(determineRequestContext(
       type, resourceRequest.httpBody() || frameLoadRequest.form(),
-      frameLoadRequest.triggeringEvent());
-  resourceRequest.setRequestContext(
-      determineRequestContextFromNavigationType(navigationType));
+      frameLoadRequest.triggeringEvent()));
   resourceRequest.setFrameType(m_frame->isMainFrame()
                                    ? WebURLRequest::FrameTypeTopLevel
                                    : WebURLRequest::FrameTypeNested);
 
-  if (!checkLoadCanStart(frameLoadRequest, type, navigationPolicy,
-                         navigationType)) {
+  if (!checkLoadCanStart(frameLoadRequest, type, navigationPolicy)) {
     // PlzNavigate: if the navigation is a commit of a client-handled
     // navigation, record that there is no longer a navigation handled by the
     // client.
     if (m_isNavigationHandledByClient &&
         !frameLoadRequest.resourceRequest().checkForBrowserSideNavigation()) {
       m_isNavigationHandledByClient = false;
     }
     return;
   }
 
   m_provisionalDocumentLoader = client()->createDocumentLoader(
       m_frame, resourceRequest,
       frameLoadRequest.substituteData().isValid()
           ? frameLoadRequest.substituteData()
           : defaultSubstituteDataForURL(resourceRequest.url()),
       frameLoadRequest.clientRedirect());
   m_provisionalDocumentLoader->setLoadType(type);
-  m_provisionalDocumentLoader->setNavigationType(navigationType);
-  m_provisionalDocumentLoader->setReplacesCurrentHistoryItem(
-      type == FrameLoadTypeReplaceCurrentItem);
 
   // PlzNavigate: We need to ensure that script initiated navigations are
   // honored.
   if (!m_isNavigationHandledByClient) {
     m_frame->navigationScheduler().cancel();
     m_checkTimer.stop();
   }
 
   if (frameLoadRequest.form())
     client()->dispatchWillSubmitForm(frameLoadRequest.form());
 
   // If the loader wasn't waiting for the client to handle a navigation, update
   // the progress tracker. Otherwise don't, as it was already notified before
   // sending the navigation to teh client.
   if (!m_isNavigationHandledByClient)
     m_progressTracker->progressStarted(type);
   else
     m_isNavigationHandledByClient = false;
 
   m_provisionalDocumentLoader->appendRedirect(
       m_provisionalDocumentLoader->getRequest().url());
-  client()->dispatchDidStartProvisionalLoad();
+  client()->didStartProvisionalLoad(m_provisionalDocumentLoader, type);
   DCHECK(m_provisionalDocumentLoader);
   m_provisionalDocumentLoader->startLoadingMainResource();
 
   takeObjectSnapshot();
 }
 
 void FrameLoader::applyUserAgent(ResourceRequest& request) {
   String userAgent = this->userAgent();
   DCHECK(!userAgent.isNull());
   request.setHTTPUserAgent(AtomicString(userAgent));
@@ skipping 170 matching lines @@
                          m_documentLoader ? m_documentLoader->url() : String());
   return tracedValue;
 }
 
 inline void FrameLoader::takeObjectSnapshot() const {
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID("loading", "FrameLoader", this,
                                       toTracedValue());
 }
 
 }  // namespace blink