Reflow comments in core/loader

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

 /*
- * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * 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, 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
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 100 matching lines @@
   return type == FrameLoadTypeReload ||
          type == FrameLoadTypeReloadMainResource ||
          type == FrameLoadTypeReloadBypassingCache;
 }
 
 static bool needsHistoryItemRestore(FrameLoadType type) {
   if (!RuntimeEnabledFeatures::
           reloadwithoutSubResourceCacheRevalidationEnabled() &&
       type == FrameLoadTypeReloadMainResource)
     return false;
-  // TODO(toyoshim): Shall we return true for FrameLoadTypeInitialHistoryLoad too?
+  // TODO(toyoshim): Shall we return true for FrameLoadTypeInitialHistoryLoad
+  // too?
   return type == FrameLoadTypeBackForward || isReloadLoadType(type);
 }
 
 // static
 ResourceRequest FrameLoader::resourceRequestFromHistoryItem(
     HistoryItem* item,
     WebCachePolicy cachePolicy) {
   RefPtr<EncodedFormData> formData = item->formData();
   ResourceRequest request(item->url());
   request.setHTTPReferrer(item->referrer());
@@ skipping 16 matching lines @@
   DCHECK(isReloadLoadType(frameLoadType));
   WebCachePolicy cachePolicy =
       frameLoadType == FrameLoadTypeReloadBypassingCache
           ? WebCachePolicy::BypassingCache
           : WebCachePolicy::ValidatingCacheData;
   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.
+  // 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 == ClientRedirectPolicy::ClientRedirect) {
     request.setHTTPReferrer(Referrer(m_frame->document()->outgoingReferrer(),
                                      m_frame->document()->getReferrerPolicy()));
   }
 
   if (!overrideURL.isEmpty()) {
     request.setURL(overrideURL);
     request.clearHTTPReferrer();
   }
   request.setSkipServiceWorker(frameLoadType ==
@@ skipping 114 matching lines @@
 
   if (m_frame->document() && !SVGImage::isInSVGImage(m_frame->document()))
     m_frame->document()->dispatchUnloadEvents();
 }
 
 void FrameLoader::didExplicitOpen() {
   // 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.
+  // 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();
     }
   }
 
-  // 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
+  // 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();
 }
 
 void FrameLoader::clear() {
-  // clear() is called during (Local)Frame detachment or when
-  // reusing a FrameLoader by putting a new Document within it
+  // clear() is called during (Local)Frame detachment or when reusing a
+  // FrameLoader by putting a new Document within it
   // (DocumentLoader::ensureWriter().)
   if (m_stateMachine.creatingInitialEmptyDocument())
     return;
 
   m_frame->editor().clear();
   m_frame->document()->removeFocusedElementOfSubtree(m_frame->document());
   m_frame->eventHandler().clear();
   if (m_frame->view())
     m_frame->view()->clear();
 
   m_frame->script().enableEval();
 
   m_frame->navigationScheduler().cancel();
 
   m_checkTimer.stop();
 
   if (m_stateMachine.isDisplayingInitialEmptyDocument())
     m_stateMachine.advanceTo(FrameLoaderStateMachine::CommittedFirstRealLoad);
 
   takeObjectSnapshot();
 }
 
-// This is only called by ScriptController::executeScriptIfJavaScriptURL
-// and always contains the result of evaluating a javascript: url.
-// This is the <iframe src="javascript:'html'"> case.
+// This is only called by ScriptController::executeScriptIfJavaScriptURL and
+// always contains the result of evaluating a javascript: url. This is the
+// <iframe src="javascript:'html'"> case.
 void FrameLoader::replaceDocumentWhileExecutingJavaScriptURL(
     const String& source,
     Document* ownerDocument) {
   if (!m_frame->document()->loader() ||
       m_frame->document()->pageDismissalEventBeingDispatched() !=
           Document::NoDismissal)
     return;
 
-  // DocumentLoader::replaceDocumentWhileExecutingJavaScriptURL can cause the DocumentLoader to get deref'ed and possible destroyed,
-  // so protect it with a RefPtr.
+  // DocumentLoader::replaceDocumentWhileExecutingJavaScriptURL can cause the
+  // DocumentLoader to get deref'ed and possible destroyed, so protect it with a
+  // RefPtr.
   DocumentLoader* documentLoader(m_frame->document()->loader());
 
   UseCounter::count(*m_frame->document(),
                     UseCounter::ReplaceDocumentViaJavaScriptURL);
 
   // Prepare a DocumentInit before clearing the frame, because it may need to
   // inherit an aliased security context.
   DocumentInit init(ownerDocument, m_frame->document()->url(), m_frame);
   init.withNewRegistrationContext();
 
@@ skipping 33 matching lines @@
   else
     m_currentItem = HistoryItem::create();
   m_currentItem->setURL(m_documentLoader->urlForHistory());
   m_currentItem->setDocumentState(m_frame->document()->formElementsState());
   m_currentItem->setTarget(m_frame->tree().uniqueName());
   m_currentItem->setReferrer(SecurityPolicy::generateReferrer(
       m_documentLoader->request().getReferrerPolicy(), m_currentItem->url(),
       m_documentLoader->request().httpReferrer()));
   m_currentItem->setFormInfoFromRequest(m_documentLoader->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.
+  // 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.
+  // 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->setVisualViewportScrollPoint(
       oldItem->visualViewportScrollPoint());
   m_currentItem->setPageScaleFactor(oldItem->pageScaleFactor());
   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
+  // 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->setStateObject(oldItem->stateObject());
     m_currentItem->setItemSequenceNumber(oldItem->itemSequenceNumber());
   }
 }
 
 static HistoryCommitType loadTypeToCommitType(FrameLoadType type) {
@@ skipping 26 matching lines @@
 
   if (!m_stateMachine.committedMultipleRealLoads() &&
       m_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.
+  // 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.
+  // didObserveLoadingBehavior() must be called after dispatchDidCommitLoad() is
+  // called for the metrics tracking logic to handle it properly.
   if (client()->isControlledByServiceWorker(*m_documentLoader))
     client()->didObserveLoadingBehavior(
         WebLoadingBehaviorServiceWorkerControlled);
 
-  // Links with media values need more information (like viewport
-  // information). This happens after the first chunk is parsed in
-  // HTMLDocumentParser.
+  // Links with media values need more information (like viewport information).
+  // This happens after the first chunk is parsed in HTMLDocumentParser.
   m_documentLoader->dispatchLinkHeaderPreloads(nullptr,
                                                LinkLoader::OnlyLoadNonMedia);
 
   TRACE_EVENT1("devtools.timeline", "CommitLoad", "data",
                InspectorCommitLoadEvent::data(m_frame));
   InspectorInstrumentation::didCommitLoad(m_frame, m_documentLoader.get());
   m_frame->page()->didCommitLoad(m_frame);
   dispatchDidClearDocumentOfWindowObject();
 
   takeObjectSnapshot();
@@ skipping 97 matching lines @@
 
   if (client())
     client()->runScriptsAtDocumentReady(
         m_documentLoader ? m_documentLoader->isCommittedButEmpty() : true);
 
   checkCompleted();
 
   if (!m_frame->view())
     return;  // We are being destroyed by something checkCompleted called.
 
-  // Check if the scrollbars are really needed for the content.
-  // If not, remove them, relayout, and repaint.
+  // 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);
 }
 
 static bool allDescendantsAreComplete(Frame* frame) {
   for (Frame* child = frame->tree().firstChild(); child;
        child = child->tree().traverseNext(frame)) {
     if (child->isLoading())
       return false;
   }
@@ skipping 17 matching lines @@
   if (!document->haveImportsLoaded())
     return false;
   if (document->fetcher()->requestCount())
     return false;
   if (document->isDelayingLoadEvent())
     return false;
   return allDescendantsAreComplete(document->frame());
 }
 
 static bool shouldSendFinishNotification(LocalFrame* frame) {
-  // Don't send stop notifications for inital empty documents, since they don't generate start notifications.
+  // Don't send stop notifications for inital empty documents, since they don't
+  // generate start notifications.
   if (!frame->loader().stateMachine()->committedFirstRealDocumentLoad())
     return false;
 
   // Don't send didFinishLoad more than once per DocumentLoader.
   if (frame->loader().documentLoader()->sentDidFinishLoad())
     return false;
 
-  // We might have declined to run the load event due to an imminent content-initiated navigation.
+  // We might have declined to run the load event due to an imminent
+  // content-initiated navigation.
   if (!frame->document()->loadEventFinished())
     return false;
 
   // An event might have restarted a child frame.
   if (!allDescendantsAreComplete(frame))
     return false;
   return true;
 }
 
 static bool shouldSendCompleteNotification(LocalFrame* frame,
@@ skipping 20 matching lines @@
   m_frame->navigationScheduler().startTimer();
 
   if (m_frame->view())
     m_frame->view()->handleLoadCompleted();
 
   // The readystatechanged or load event may have disconnected this frame.
   if (!m_frame->client())
     return;
 
   if (shouldSendFinishNotification(m_frame)) {
-    // Report mobile vs. desktop page statistics. This will only report on Android.
+    // Report mobile vs. desktop page statistics. This will only report on
+    // Android.
     if (m_frame->isMainFrame())
       m_frame->document()->viewportDescription().reportMobilePageStats(m_frame);
     m_documentLoader->setSentDidFinishLoad();
     client()->dispatchDidFinishLoad();
     // Finishing the load can detach the frame when running layout tests.
     if (!m_frame->client())
       return;
   }
 
   if (shouldSendCompleteNotification(m_frame, m_isNavigationHandledByClient)) {
@@ skipping 28 matching lines @@
   return client() ? client()->opener() : 0;
 }
 
 void FrameLoader::setOpener(LocalFrame* opener) {
   // If the frame is already detached, the opener has already been cleared.
   if (client())
     client()->setOpener(opener);
 }
 
 bool FrameLoader::allowPlugins(ReasonForCallingAllowPlugins reason) {
-  // With Oilpan, a FrameLoader might be accessed after the
-  // FrameHost has been detached. FrameClient will not be
-  // accessible, so bail early.
+  // With Oilpan, a FrameLoader might be accessed after the FrameHost has been
+  // detached. FrameClient will not be accessible, so bail early.
   if (!client())
     return false;
   Settings* settings = m_frame->settings();
   bool allowed = client()->allowPlugins(settings && settings->pluginsEnabled());
   if (!allowed && reason == AboutToInstantiatePlugin)
     client()->didNotAllowPlugins();
   return allowed;
 }
 
 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
+  // 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
   if (m_frame->document()->loadEventFinished())
     client()->didStartLoading(NavigationWithinSameDocument);
 
   HistoryCommitType historyCommitType = loadTypeToCommitType(type);
   if (!m_currentItem)
     historyCommitType = HistoryInertCommit;
   if (m_frame->settings()->historyEntryRequiresUserGesture() &&
       !UserGestureIndicator::processedUserGestureSinceLoad() &&
       initiatingDocument)
     historyCommitType = HistoryInertCommit;
@@ skipping 26 matching lines @@
 void FrameLoader::loadInSameDocument(
     const KURL& url,
     PassRefPtr<SerializedScriptValue> stateObject,
     FrameLoadType frameLoadType,
     HistoryLoadType historyLoadType,
     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.
+  // 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
+    // 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->localDOMWindow()->enqueueHashchangeEvent(oldURL, url);
   }
   m_documentLoader->setIsClientRedirect(clientRedirect ==
                                         ClientRedirectPolicy::ClientRedirect);
   updateForSameDocumentNavigation(url, SameDocumentNavigationDefault, nullptr,
                                   ScrollRestorationAuto, frameLoadType,
                                   initiatingDocument);
 
   m_documentLoader->initialScrollState().wasScrolledByUser = false;
 
   checkCompleted();
 
   m_frame->localDOMWindow()->statePopped(
       stateObject ? std::move(stateObject)
                   : SerializedScriptValue::nullValue());
 
   if (historyLoadType == HistorySameDocumentLoad)
     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.
+  // 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);
   takeObjectSnapshot();
 }
 
 // static
 void FrameLoader::setReferrerForFrameRequest(FrameLoadRequest& frameRequest) {
   ResourceRequest& request = frameRequest.resourceRequest();
   Document* originDocument = frameRequest.originDocument();
 
   if (!originDocument)
     return;
-  // Anchor elements with the 'referrerpolicy' attribute will have
-  // already set the referrer on the request.
+  // Anchor elements with the 'referrerpolicy' attribute will have already set
+  // the referrer on the request.
   if (request.didSetHTTPReferrer())
     return;
   if (frameRequest.getShouldSendReferrer() == NeverSendReferrer)
     return;
 
-  // Always use the initiating document to generate the referrer.
-  // We need to generateReferrer(), because we haven't enforced ReferrerPolicy or https->http
-  // referrer suppression yet.
+  // Always use the initiating document to generate the referrer. We need to
+  // generateReferrer(), because we haven't enforced ReferrerPolicy or
+  // https->http referrer suppression yet.
   Referrer referrer = SecurityPolicy::generateReferrer(
       originDocument->getReferrerPolicy(), request.url(),
       originDocument->outgoingReferrer());
 
   request.setHTTPReferrer(referrer);
   RefPtr<SecurityOrigin> referrerOrigin =
       SecurityOrigin::createFromString(referrer.referrer);
   request.addHTTPOriginIfNeeded(referrerOrigin.get());
 }
 
 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)
     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 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.originDocument())
       return FrameLoadTypeReloadMainResource;
     return request.resourceRequest().httpMethod() == HTTPNames::POST
                ? FrameLoadTypeStandard
                : FrameLoadTypeReplaceCurrentItem;
   }
 
   if (request.substituteData().failingURL() ==
           m_documentLoader->urlForHistory() &&
       m_loadType == FrameLoadTypeReload)
     return FrameLoadTypeReload;
 
   if (m_frame->settings()->historyEntryRequiresUserGesture() &&
       !UserGestureIndicator::processedUserGestureSinceLoad() &&
       request.originDocument())
     return FrameLoadTypeReplaceCurrentItem;
 
   return FrameLoadTypeStandard;
 }
 
 bool FrameLoader::prepareRequestForThisFrame(FrameLoadRequest& request) {
-  // If no origin Document* was specified, skip remaining security checks and assume the caller has fully initialized the FrameLoadRequest.
+  // If no origin Document* was specified, skip remaining security checks and
+  // assume the caller has fully initialized the FrameLoadRequest.
   if (!request.originDocument())
     return true;
 
   KURL url = request.resourceRequest().url();
   if (m_frame->script().executeScriptIfJavaScriptURL(url))
     return false;
 
   if (!request.originDocument()->getSecurityOrigin()->canDisplay(url)) {
     reportLocalLoadFailed(m_frame, url.elidedString());
     return false;
   }
 
   if (!request.form() && request.frameName().isEmpty())
     request.setFrameName(m_frame->document()->baseTarget());
   return true;
 }
 
 static bool shouldOpenInNewWindow(Frame* targetFrame,
                                   const FrameLoadRequest& request,
                                   NavigationPolicy policy) {
   if (!targetFrame && !request.frameName().isEmpty())
     return true;
-  // FIXME: This case is a workaround for the fact that ctrl+clicking a form submission incorrectly
-  // sends as a GET rather than a POST if it creates a new window in a different process.
+  // FIXME: This case is a workaround for the fact that ctrl+clicking a form
+  // submission incorrectly sends as a GET rather than a POST if it creates a
+  // new window in a different process.
   return request.form() && policy != NavigationPolicyCurrentTab;
 }
 
 static NavigationType determineNavigationType(FrameLoadType frameLoadType,
                                               bool isFormSubmission,
                                               bool haveEvent) {
   bool isReload = isReloadLoadType(frameLoadType);
   bool isBackForward = isBackForwardLoadType(frameLoadType);
   if (isFormSubmission)
     return (isReload || isBackForward) ? NavigationTypeFormResubmitted
@@ skipping 174 matching lines @@
   frame->document()->addConsoleMessage(
       ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel,
                              "Not allowed to load local resource: " + url));
 }
 
 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 this method is called from within this method, infinite recursion can
+  // occur (3442218). Avoid this.
   if (m_inStopAllLoaders)
     return;
 
   m_inStopAllLoaders = true;
 
   m_isNavigationHandledByClient = false;
 
   for (Frame* child = m_frame->tree().firstChild(); child;
        child = child->tree().nextSibling()) {
     if (child->isLocalFrame())
@@ skipping 17 matching lines @@
     loadFailed(m_documentLoader.get(),
                ResourceError::cancelledError(m_documentLoader->url()));
 
   m_inStopAllLoaders = false;
   takeObjectSnapshot();
 }
 
 void FrameLoader::didAccessInitialDocument() {
   // We only need to notify the client for the main frame.
   if (isLoadingMainFrame()) {
-    // Forbid script execution to prevent re-entering V8, since this is
-    // called from a binding security check.
+    // Forbid script execution to prevent re-entering V8, since this is called
+    // from a binding security check.
     ScriptForbiddenScope forbidScripts;
     if (client())
       client()->didAccessInitialDocument();
   }
 }
 
 bool FrameLoader::prepareForCommit() {
   PluginScriptForbiddenScope forbidPluginDestructorScripting;
   DocumentLoader* pdl = m_provisionalDocumentLoader;
 
   if (m_frame->document()) {
     unsigned nodeCount = 0;
     for (Frame* frame = m_frame; frame; frame = frame->tree().traverseNext()) {
       if (frame->isLocalFrame()) {
         LocalFrame* localFrame = toLocalFrame(frame);
         nodeCount += localFrame->document()->nodeCount();
       }
     }
     unsigned totalNodeCount =
         InstanceCounters::counterValue(InstanceCounters::NodeCounter);
     float ratio = static_cast<float>(nodeCount) / totalNodeCount;
     ThreadState::current()->schedulePageNavigationGCIfNeeded(ratio);
   }
 
   // Don't allow any new child frames to load in this frame: attaching a new
-  // child frame during or after detaching children results in an attached
-  // frame on a detached DOM tree, which is bad.
+  // child frame during or after detaching children results in an attached frame
+  // on a detached DOM tree, which is bad.
   SubframeLoadingDisabler disabler(m_frame->document());
   if (m_documentLoader) {
     client()->dispatchWillCommitProvisionalLoad();
     dispatchUnloadEvent();
   }
   m_frame->detachChildren();
   // The previous calls to dispatchUnloadEvent() and detachChildren() can
   // execute arbitrary script via things like unload events. If the executed
-  // script intiates a new load or causes the current frame to be detached,
-  // we need to abandon the current load.
+  // script intiates a new load or causes the current frame to be detached, we
+  // need to abandon the current load.
   if (pdl != m_provisionalDocumentLoader)
     return false;
-  // detachFromFrame() will abort XHRs that haven't completed, which can
-  // trigger event listeners for 'abort'. These event listeners might call
+  // detachFromFrame() will abort XHRs that haven't completed, which can trigger
+  // event listeners for 'abort'. These event listeners might call
   // window.stop(), which will in turn detach the provisional document loader.
   // At this point, the provisional document loader should not detach, because
   // then the FrameLoader would not have any attached DocumentLoaders.
   if (m_documentLoader) {
     AutoReset<bool> inDetachDocumentLoader(&m_protectProvisionalLoader, true);
     detachDocumentLoader(m_documentLoader);
   }
   // 'abort' listeners can also detach the frame.
   if (!m_frame->client())
     return false;
   DCHECK_EQ(m_provisionalDocumentLoader, pdl);
   // No more events will be dispatched so detach the Document.
-  // TODO(yoav): Should we also be nullifying domWindow's document (or domWindow) since the doc is now detached?
+  // TODO(yoav): Should we also be nullifying domWindow's document (or
+  // domWindow) since the doc is now detached?
   if (m_frame->document())
     m_frame->document()->shutdown();
   m_documentLoader = m_provisionalDocumentLoader.release();
   takeObjectSnapshot();
 
   return true;
 }
 
 void FrameLoader::commitProvisionalLoad() {
   DCHECK(client()->hasWebView());
 
-  // Check if the destination page is allowed to access the previous page's timing information.
+  // Check if the destination page is allowed to access the previous page's
+  // timing information.
   if (m_frame->document()) {
     RefPtr<SecurityOrigin> securityOrigin =
         SecurityOrigin::create(m_provisionalDocumentLoader->request().url());
     m_provisionalDocumentLoader->timing().setHasSameOriginAsPreviousDocument(
         securityOrigin->canRequest(m_frame->document()->url()));
   }
 
   if (!prepareForCommit())
     return;
 
   if (isLoadingMainFrame()) {
     m_frame->page()->chromeClient().setEventListenerProperties(
         WebEventListenerClass::TouchStartOrMove,
         WebEventListenerProperties::Nothing);
     m_frame->page()->chromeClient().setEventListenerProperties(
         WebEventListenerClass::MouseWheel, WebEventListenerProperties::Nothing);
     m_frame->page()->chromeClient().setEventListenerProperties(
         WebEventListenerClass::TouchEndOrCancel,
         WebEventListenerProperties::Nothing);
   }
 
   client()->transitionToCommittedForNewPage();
   m_frame->navigationScheduler().cancel();
   m_frame->editor().clearLastEditCommand();
 
-  // If we are still in the process of initializing an empty document then
-  // its frame is not in a consistent state for rendering, so avoid setJSStatusBarText
-  // since it may cause clients to attempt to render the frame.
+  // If we are still in the process of initializing an empty document then its
+  // frame is not in a consistent state for rendering, so avoid
+  // setJSStatusBarText since it may cause clients to attempt to render the
+  // frame.
   if (!m_stateMachine.creatingInitialEmptyDocument()) {
     DOMWindow* window = m_frame->domWindow();
     window->setStatus(String());
     window->setDefaultStatus(String());
   }
 }
 
 bool FrameLoader::isLoadingMainFrame() const {
   return m_frame->isMainFrame();
 }
@@ skipping 11 matching lines @@
   }
 
   if (!needsHistoryItemRestore(m_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 as the page height increases
-  //   4. ignore clamp detection if we are not restoring scroll or after load
-  //      completes because that may be because the page will never reach its
-  //      previous height
+  // 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
+  //    as the page height increases
+  // 4. ignore clamp detection if we are not restoring scroll or after load
+  //    completes because that may be because the page will never reach its
+  //    previous height
   bool canRestoreWithoutClamping =
       view->layoutViewportScrollableArea()->clampScrollPosition(
           m_currentItem->scrollPoint()) == m_currentItem->scrollPoint();
   bool canRestoreWithoutAnnoyingUser =
       !documentLoader()->initialScrollState().wasScrolledByUser &&
       (canRestoreWithoutClamping || !m_frame->isLoading() ||
        !shouldRestoreScroll);
   if (!canRestoreWithoutAnnoyingUser)
     return;
 
   if (shouldRestoreScroll)
     view->layoutViewportScrollableArea()->setScrollPosition(
         m_currentItem->scrollPoint(), ProgrammaticScroll);
 
   // For main frame restore scale and visual viewport position
   if (m_frame->isMainFrame()) {
     FloatPoint visualViewportOffset(m_currentItem->visualViewportScrollPoint());
 
-    // If the visual viewport's offset is (-1, -1) it means the history item
-    // is an old version of HistoryItem so distribute the scroll between
-    // the main frame and the visual viewport as best as we can.
+    // If the visual viewport's offset is (-1, -1) it means the history item is
+    // an old version of HistoryItem so distribute the scroll between the main
+    // frame and the visual viewport as best as we can.
     if (visualViewportOffset.x() == -1 && visualViewportOffset.y() == -1)
       visualViewportOffset =
           FloatPoint(m_currentItem->scrollPoint() - view->scrollPosition());
 
     VisualViewport& visualViewport = m_frame->host()->visualViewport();
     if (shouldRestoreScale && shouldRestoreScroll)
       visualViewport.setScaleAndLocation(m_currentItem->pageScaleFactor(),
                                          visualViewportOffset);
     else if (shouldRestoreScale)
       visualViewport.setScale(m_currentItem->pageScaleFactor());
@@ skipping 54 matching lines @@
       m_progressTracker->progressCompleted();
     }
   }
   checkCompleted();
 }
 
 bool FrameLoader::shouldPerformFragmentNavigation(bool isFormSubmission,
                                                   const String& httpMethod,
                                                   FrameLoadType loadType,
                                                   const KURL& url) {
-  // 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.
+  // 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, 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.
+         // 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,
                                   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.
+  // 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 then we should not override it unless
-  // this is a same document reload.
+  // 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() &&
        !documentLoader()->initialScrollState().didRestoreFromHistory);
 
   view->processUrlFragment(url, shouldScrollToFragment
                                     ? FrameView::UrlFragmentScroll
                                     : FrameView::UrlFragmentDontScroll);
 
   if (boundaryFrame && boundaryFrame->isLocalFrame())
     toLocalFrame(boundaryFrame)->view()->setSafeToPropagateScrollToParent(true);
 }
 
 bool FrameLoader::shouldClose(bool isReload) {
   Page* page = m_frame->page();
   if (!page || !page->chromeClient().canOpenBeforeUnloadConfirmPanel())
     return true;
 
-  // Store all references to each subframe in advance since beforeunload's event handler may modify frame
+  // Store all references to each subframe in advance since beforeunload's event
+  // handler may modify frame
   HeapVector<Member<LocalFrame>> targetFrames;
   targetFrames.append(m_frame);
   for (Frame* child = m_frame->tree().firstChild(); child;
        child = child->tree().traverseNext(m_frame)) {
-    // FIXME: There is not yet any way to dispatch events to out-of-process frames.
+    // FIXME: There is not yet any way to dispatch events to out-of-process
+    // frames.
     if (child->isLocalFrame())
       targetFrames.append(toLocalFrame(child));
   }
 
   bool shouldClose = false;
   {
     NavigationDisablerForUnload navigationDisabler;
     size_t i;
 
     bool didAllowNavigation = false;
@@ skipping 21 matching lines @@
     NavigationPolicy policy,
     bool replacesCurrentHistoryItem,
     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 a subframe, 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 we're loading content into a subframe, 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 (shouldCheckMainWorldContentSecurityPolicy == CheckContentSecurityPolicy) {
     Frame* parentFrame = m_frame->tree().parent();
     if (parentFrame) {
       ContentSecurityPolicy* parentPolicy =
           parentFrame->securityContext()->contentSecurityPolicy();
       if (!parentPolicy->allowChildFrameFromSource(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.
@@ skipping 63 matching lines @@
           navigationType, navigationPolicy,
           type == FrameLoadTypeReplaceCurrentItem,
           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.
+  // 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, request, frameLoadRequest.substituteData().isValid()
                             ? frameLoadRequest.substituteData()
                             : defaultSubstituteDataForURL(request.url()));
   m_provisionalDocumentLoader->setNavigationType(navigationType);
   m_provisionalDocumentLoader->setReplacesCurrentHistoryItem(
       type == FrameLoadTypeReplaceCurrentItem);
@@ skipping 178 matching lines @@
   // out-of-process frames. For now, we'll always use default behavior.
   if (!parentFrame->isLocalFrame())
     return nullptr;
 
   DCHECK(toLocalFrame(parentFrame)->document());
   return toLocalFrame(parentFrame)->document()->insecureNavigationsToUpgrade();
 }
 
 void FrameLoader::upgradeInsecureRequest(ResourceRequest& resourceRequest,
                                          Document* document) const {
-  // Tack an 'Upgrade-Insecure-Requests' header to outgoing navigational requests, as described in
+  // Tack an 'Upgrade-Insecure-Requests' header to outgoing navigational
+  // requests, as described in
   // https://w3c.github.io/webappsec/specs/upgrade/#feature-detect
   if (resourceRequest.frameType() != WebURLRequest::FrameTypeNone) {
     // Early return if the request has already been upgraded.
     if (resourceRequest.httpHeaderField("Upgrade-Insecure-Requests") ==
         AtomicString("1"))
       return;
 
     resourceRequest.addHTTPHeaderField("Upgrade-Insecure-Requests", "1");
   }
 
   KURL url = resourceRequest.url();
 
-  // If we don't yet have an |m_document| (because we're loading an iframe, for instance), check the FrameLoader's policy.
+  // If we don't yet have an |m_document| (because we're loading an iframe, for
+  // instance), check the FrameLoader's policy.
   WebInsecureRequestPolicy relevantPolicy =
       document ? document->getInsecureRequestPolicy()
                : getInsecureRequestPolicy();
   SecurityContext::InsecureNavigationsSet* relevantNavigationSet =
       document ? document->insecureNavigationsToUpgrade()
                : insecureNavigationsToUpgrade();
 
   if (url.protocolIs("http") && relevantPolicy & kUpgradeInsecureRequests) {
     // We always upgrade requests that meet any of the following criteria:
     //
@@ skipping 34 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