Move loadType() to DocumentLoader

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 165 matching lines @@
   request.setSkipServiceWorker(frameLoadType ==
                                        FrameLoadTypeReloadBypassingCache
                                    ? WebURLRequest::SkipServiceWorker::All
                                    : WebURLRequest::SkipServiceWorker::None);
   return request;
 }
 
 FrameLoader::FrameLoader(LocalFrame* frame)
     : m_frame(frame),
       m_progressTracker(ProgressTracker::create(frame)),
-      m_loadType(FrameLoadTypeStandard),
       m_inStopAllLoaders(false),
       m_checkTimer(TaskRunnerHelper::get(TaskType::Networking, frame),
                    this,
                    &FrameLoader::checkTimerFired),
       m_forcedSandboxFlags(SandboxNone),
       m_dispatchingDidClearWindowObjectInMainWorld(false),
       m_protectProvisionalLoader(false),
       m_isNavigationHandledByClient(false) {
   DCHECK(m_frame);
   TRACE_EVENT_OBJECT_CREATED_WITH_ID("loading", "FrameLoader", this);
@@ skipping 67 matching lines @@
     m_frame->navigationScheduler().startTimer();
     scheduleCheckCompleted();
   }
 }
 
 void FrameLoader::saveScrollState() {
   if (!m_currentItem || !m_frame->view())
     return;
 
   // Shouldn't clobber anything if we might still restore later.
-  if (needsHistoryItemRestore(m_loadType) && m_documentLoader &&
+  if (m_documentLoader &&
+      needsHistoryItemRestore(m_documentLoader->loadType()) &&
       !m_documentLoader->initialScrollState().wasScrolledByUser)
     return;
 
   if (ScrollableArea* layoutScrollableArea =
           m_frame->view()->layoutViewportScrollableArea())
     m_currentItem->setScrollOffset(layoutScrollableArea->getScrollOffset());
   m_currentItem->setVisualViewportScrollOffset(toScrollOffset(
       m_frame->host()->visualViewport().visibleRect().location()));
 
   if (m_frame->isMainFrame())
@@ skipping 18 matching lines @@
   // Calling document.open counts as committing the first real document load.
   if (!m_stateMachine.committedFirstRealDocumentLoad())
     m_stateMachine.advanceTo(FrameLoaderStateMachine::CommittedFirstRealLoad);
 
   // Only model a document.open() as part of a navigation if its parent is not
   // done or in the process of completing.
   if (Frame* parent = m_frame->tree().parent()) {
     if ((parent->isLocalFrame() &&
          toLocalFrame(parent)->document()->loadEventStillNeeded()) ||
         (parent->isRemoteFrame() && parent->isLoading())) {
-      m_progressTracker->progressStarted();
+      m_progressTracker->progressStarted(m_documentLoader->loadType());
     }
   }
 
   // Prevent window.open(url) -- eg window.open("about:blank") -- from blowing
   // away results from a subsequent window.document.open / window.document.write
   // call. Canceling redirection here works for all cases because document.open
   // implicitly precedes document.write.
   m_frame->navigationScheduler().cancel();
 }
 
@@ skipping 127 matching lines @@
     default:
       break;
   }
   return HistoryInertCommit;
 }
 
 void FrameLoader::receivedFirstData() {
   if (m_stateMachine.creatingInitialEmptyDocument())
     return;
 
-  HistoryCommitType historyCommitType = loadTypeToCommitType(m_loadType);
+  FrameLoadType loadType = m_documentLoader->loadType();
+  HistoryCommitType historyCommitType = loadTypeToCommitType(loadType);
   if (historyCommitType == StandardCommit &&
       (m_documentLoader->urlForHistory().isEmpty() ||
        (opener() && !m_currentItem &&
         m_documentLoader->originalRequest().url().isEmpty())))
     historyCommitType = HistoryInertCommit;
-  setHistoryItemStateForCommit(m_loadType, historyCommitType,
+  setHistoryItemStateForCommit(loadType, historyCommitType,
                                HistoryNavigationType::DifferentDocument);
 
   if (!m_stateMachine.committedMultipleRealLoads() &&
-      m_loadType == FrameLoadTypeStandard) {
+      loadType == FrameLoadTypeStandard) {
     m_stateMachine.advanceTo(
         FrameLoaderStateMachine::CommittedMultipleRealLoads);
   }
 
   client()->dispatchDidCommitLoad(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.
@@ skipping 27 matching lines @@
 
   m_frame->document()->setReadyState(Document::Loading);
 
   if (dispatchWindowObjectAvailable)
     dispatchDidClearDocumentOfWindowObject();
 
   m_frame->document()->initContentSecurityPolicy(
       m_documentLoader ? m_documentLoader->releaseContentSecurityPolicy()
                        : ContentSecurityPolicy::create());
 
-  if (m_provisionalItem && isBackForwardLoadType(m_loadType)) {
+  if (m_provisionalItem &&
+      isBackForwardLoadType(m_documentLoader->loadType())) {
     m_frame->document()->setStateForNewFormElements(
         m_provisionalItem->getDocumentState());
   }
 }
 
 void FrameLoader::didBeginDocument() {
   DCHECK(m_frame);
   DCHECK(m_frame->client());
   DCHECK(m_frame->document());
   DCHECK(m_frame->document()->fetcher());
@@ skipping 105 matching lines @@
   }
 
   checkCompleted();
 
   if (!m_frame->view())
     return;
 
   // Check if the scrollbars are really needed for the content. If not, remove
   // them, relayout, and repaint.
   m_frame->view()->restoreScrollbar();
-  processFragment(m_frame->document()->url(), NavigationToDifferentDocument);
+  processFragment(m_frame->document()->url(), m_documentLoader->loadType(),
+                  NavigationToDifferentDocument);
 }
 
 static bool allDescendantsAreComplete(Frame* frame) {
   for (Frame* child = frame->tree().firstChild(); child;
        child = child->tree().traverseNext(frame)) {
     if (child->isLoading())
       return false;
   }
   return true;
 }
@@ skipping 81 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();
-
-    m_loadType = FrameLoadTypeStandard;
+    if (m_documentLoader)

[yhirano, 2017/01/25 06:30:43]

Can you tell me when |m_documentLoader| is null?

[Nate Chapin, 2017/01/25 17:25:29]

m_documentLoader is null:
* In a narrow window during FrameLoader::init(), which shouldn't be reachable
here.
* During frame detach. Most (maybe all?) of the m_documentLoader null checks in
FrameLoader are for this case.

It's possible there's a better place to defend against a null m_documentLoader,
but there are definitely layout tests that crashed without this null check.

+      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 94 matching lines @@
     ClientRedirectPolicy clientRedirect,
     Document* initiatingDocument) {
   // If we have a state object, we cannot also be a new navigation.
   DCHECK(!stateObject || frameLoadType == FrameLoadTypeBackForward);
 
   // If we have a provisional request for a different document, a fragment
   // scroll should cancel it.
   detachDocumentLoader(m_provisionalDocumentLoader);
   if (!m_frame->host())
     return;
-  AutoReset<FrameLoadType> loadTypeChange(&m_loadType, frameLoadType);
   saveScrollState();
 
   KURL oldURL = m_frame->document()->url();
   bool hashChange = equalIgnoringFragmentIdentifier(url, oldURL) &&
                     url.fragmentIdentifier() != oldURL.fragmentIdentifier();
   if (hashChange) {
     // If we were in the autoscroll/middleClickAutoscroll mode we want to stop
     // it before following the link to the anchor
     m_frame->eventHandler().stopAutoscroll();
     m_frame->domWindow()->enqueueHashchangeEvent(oldURL, url);
   }
   m_documentLoader->setIsClientRedirect(clientRedirect ==
                                         ClientRedirectPolicy::ClientRedirect);
   updateForSameDocumentNavigation(url, SameDocumentNavigationDefault, nullptr,
                                   ScrollRestorationAuto, frameLoadType,
                                   initiatingDocument);
 
   m_documentLoader->initialScrollState().wasScrolledByUser = false;
 
   checkCompleted();
 
   m_frame->domWindow()->statePopped(stateObject
                                         ? std::move(stateObject)
                                         : SerializedScriptValue::nullValue());
 
   if (historyLoadType == HistorySameDocumentLoad)
-    restoreScrollPositionAndViewState();
+    restoreScrollPositionAndViewStateForLoadType(frameLoadType);
 
   // 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);
+  processFragment(url, frameLoadType, NavigationWithinSameDocument);
   takeObjectSnapshot();
 }
 
 // static
 void FrameLoader::setReferrerForFrameRequest(FrameLoadRequest& frameRequest) {
   ResourceRequest& request = frameRequest.resourceRequest();
   Document* originDocument = frameRequest.originDocument();
 
   if (!originDocument)
     return;
@@ skipping 18 matching lines @@
 FrameLoadType FrameLoader::determineFrameLoadType(
     const FrameLoadRequest& request) {
   if (m_frame->tree().parent() &&
       !m_stateMachine.committedFirstRealDocumentLoad())
     return FrameLoadTypeInitialInChildFrame;
   if (!m_frame->tree().parent() && !client()->backForwardLength())
     return FrameLoadTypeStandard;
   if (m_provisionalDocumentLoader &&
       request.substituteData().failingURL() ==
           m_provisionalDocumentLoader->url() &&
-      m_loadType == FrameLoadTypeBackForward)
+      m_provisionalDocumentLoader->loadType() == FrameLoadTypeBackForward)
     return FrameLoadTypeBackForward;
   if (request.resourceRequest().getCachePolicy() ==
       WebCachePolicy::ValidatingCacheData)
     return FrameLoadTypeReload;
   if (request.resourceRequest().getCachePolicy() ==
       WebCachePolicy::BypassingCache)
     return FrameLoadTypeReloadBypassingCache;
   // From the HTML5 spec for location.assign():
   // "If the browsing context's session history contains only one Document,
   // and that was the about:blank Document created when the browsing context
   // was created, then the navigation must be done with replacement enabled."
   if (request.replacesCurrentItem() ||
       (!m_stateMachine.committedMultipleRealLoads() &&
        equalIgnoringCase(m_frame->document()->url(), blankURL())))
     return FrameLoadTypeReplaceCurrentItem;
 
   if (request.resourceRequest().url() == m_documentLoader->urlForHistory()) {
     if (request.resourceRequest().httpMethod() == HTTPNames::POST)
       return FrameLoadTypeStandard;
     if (!request.originDocument())
       return FrameLoadTypeReloadMainResource;
     return FrameLoadTypeReplaceCurrentItem;
   }
 
   if (request.substituteData().failingURL() ==
           m_documentLoader->urlForHistory() &&
-      m_loadType == FrameLoadTypeReload)
+      m_documentLoader->loadType() == FrameLoadTypeReload)
     return FrameLoadTypeReload;
 
   if (m_frame->settings()->getHistoryEntryRequiresUserGesture() &&
       request.originDocument() &&
       !request.originDocument()->hasReceivedUserGesture())
     return FrameLoadTypeReplaceCurrentItem;
 
   return FrameLoadTypeStandard;
 }
 
@@ skipping 394 matching lines @@
     DOMWindow* window = m_frame->domWindow();
     window->setStatus(String());
     window->setDefaultStatus(String());
   }
 }
 
 bool FrameLoader::isLoadingMainFrame() const {
   return m_frame->isMainFrame();
 }
 
-FrameLoadType FrameLoader::loadType() const {
-  return m_loadType;
+void FrameLoader::restoreScrollPositionAndViewState() {
+  if (!m_frame->page() || !documentLoader())
+    return;
+  restoreScrollPositionAndViewStateForLoadType(documentLoader()->loadType());
 }
 
-void FrameLoader::restoreScrollPositionAndViewState() {
+void FrameLoader::restoreScrollPositionAndViewStateForLoadType(
+    FrameLoadType loadType) {
   FrameView* view = m_frame->view();
-  if (!m_frame->page() || !view || !view->layoutViewportScrollableArea() ||
-      !m_currentItem || !m_stateMachine.committedFirstRealDocumentLoad() ||
-      !documentLoader()) {
+  if (!view || !view->layoutViewportScrollableArea() || !m_currentItem ||
+      !m_stateMachine.committedFirstRealDocumentLoad()) {
     return;
   }
-
-  if (!needsHistoryItemRestore(m_loadType))
+  if (!needsHistoryItemRestore(loadType))
     return;
 
   bool shouldRestoreScroll =
       m_currentItem->scrollRestorationType() != ScrollRestorationManual;
   bool shouldRestoreScale = m_currentItem->pageScaleFactor();
 
   // This tries to balance:
   // 1. restoring as soon as possible
   // 2. not overriding user scroll (TODO(majidvp): also respect user scale)
   // 3. detecting clamping to avoid repeatedly popping the scroll position down
@@ skipping 71 matching lines @@
 }
 
 void FrameLoader::loadFailed(DocumentLoader* loader,
                              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);
+  HistoryCommitType historyCommitType =
+      loadTypeToCommitType(loader->loadType());
   if (loader == m_provisionalDocumentLoader) {
     m_provisionalDocumentLoader->setSentDidFinishLoad();
     client()->dispatchDidFailProvisionalLoad(error, historyCommitType);
     if (loader != m_provisionalDocumentLoader)
       return;
     detachDocumentLoader(m_provisionalDocumentLoader);
   } else {
     DCHECK_EQ(loader, m_documentLoader);
     if (m_frame->document()->parser())
       m_frame->document()->parser()->stopParsing();
@@ skipping 15 matching lines @@
   return (!isFormSubmission || equalIgnoringCase(httpMethod, HTTPNames::GET)) &&
          !isReloadLoadType(loadType) && 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::processFragment(const KURL& url,
+                                  FrameLoadType frameLoadType,
                                   LoadStartType loadStartType) {
   FrameView* view = m_frame->view();
   if (!view)
     return;
 
   // Leaking scroll position to a cross-origin ancestor would permit the
   // so-called "framesniffing" attack.
   Frame* boundaryFrame =
       url.hasFragmentIdentifier()
           ? m_frame->findUnsafeParentScrollPropagationBoundary()
           : 0;
 
   // FIXME: Handle RemoteFrames
   if (boundaryFrame && boundaryFrame->isLocalFrame()) {
     toLocalFrame(boundaryFrame)
         ->view()
         ->setSafeToPropagateScrollToParent(false);
   }
 
   // If scroll position is restored from history fragment or scroll
   // restoration type is manual, then we should not override it unless this
   // is a same document reload.
   bool shouldScrollToFragment =
       (loadStartType == NavigationWithinSameDocument &&
-       !isBackForwardLoadType(m_loadType)) ||
+       !isBackForwardLoadType(frameLoadType)) ||
       (documentLoader() &&
        !documentLoader()->initialScrollState().didRestoreFromHistory &&
        !(m_currentItem &&
          m_currentItem->scrollRestorationType() == ScrollRestorationManual));
 
   view->processUrlFragment(url, shouldScrollToFragment
                                     ? FrameView::UrlFragmentScroll
                                     : FrameView::UrlFragmentDontScroll);
 
   if (boundaryFrame && boundaryFrame->isLocalFrame())
@@ skipping 38 matching lines @@
   return shouldClose;
 }
 
 bool FrameLoader::shouldContinueForNavigationPolicy(
     const ResourceRequest& request,
     const SubstituteData& substituteData,
     DocumentLoader* loader,
     ContentSecurityPolicyDisposition shouldCheckMainWorldContentSecurityPolicy,
     NavigationType type,
     NavigationPolicy policy,
-    bool replacesCurrentHistoryItem,
+    FrameLoadType frameLoadType,
     bool isClientRedirect,
     HTMLFormElement* form) {
   m_isNavigationHandledByClient = false;
 
   // 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
@@ skipping 16 matching lines @@
     }
   }
 
   bool isFormSubmission = type == NavigationTypeFormSubmitted ||
                           type == NavigationTypeFormResubmitted;
   if (isFormSubmission &&
       !m_frame->document()->contentSecurityPolicy()->allowFormAction(
           request.url()))
     return false;
 
+  bool replacesCurrentHistoryItem =
+      frameLoadType == FrameLoadTypeReplaceCurrentItem;
   policy = client()->decidePolicyForNavigation(request, loader, type, policy,
                                                replacesCurrentHistoryItem,
                                                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();
+    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;
   }
@@ skipping 23 matching lines @@
                                    ? WebURLRequest::FrameTypeTopLevel
                                    : WebURLRequest::FrameTypeNested);
 
   // Record the latest requiredCSP value that will be used when sending this
   // request.
   recordLatestRequiredCSP();
   modifyRequestForCSP(resourceRequest, nullptr);
   if (!shouldContinueForNavigationPolicy(
           resourceRequest, frameLoadRequest.substituteData(), nullptr,
           frameLoadRequest.shouldCheckMainWorldContentSecurityPolicy(),
-          navigationType, navigationPolicy,
-          type == FrameLoadTypeReplaceCurrentItem,
+          navigationType, navigationPolicy, type,
           frameLoadRequest.clientRedirect() ==
               ClientRedirectPolicy::ClientRedirect,
           frameLoadRequest.form()))
     return;
 
   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;
 
   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);
   m_frame->navigationScheduler().cancel();
   m_checkTimer.stop();
 
-  m_loadType = type;
-
   if (frameLoadRequest.form())
     client()->dispatchWillSubmitForm(frameLoadRequest.form());
 
-  m_progressTracker->progressStarted();
+  m_progressTracker->progressStarted(type);
   m_provisionalDocumentLoader->appendRedirect(
       m_provisionalDocumentLoader->getRequest().url());
   client()->dispatchDidStartProvisionalLoad();
   DCHECK(m_provisionalDocumentLoader);
   m_provisionalDocumentLoader->startLoadingMainResource();
 
   takeObjectSnapshot();
 }
 
 void FrameLoader::applyUserAgent(ResourceRequest& request) {
@@ skipping 173 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