Loading: bulk style errors fix 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) 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 454 matching lines @@
   HistoryCommitType historyCommitType = loadTypeToCommitType(m_loadType);
   if (historyCommitType == StandardCommit &&
       (m_documentLoader->urlForHistory().isEmpty() ||
        (opener() && !m_currentItem &&
         m_documentLoader->originalRequest().url().isEmpty())))
     historyCommitType = HistoryInertCommit;
   setHistoryItemStateForCommit(m_loadType, historyCommitType,
                                HistoryNavigationType::DifferentDocument);
 
   if (!m_stateMachine.committedMultipleRealLoads() &&
-      m_loadType == FrameLoadTypeStandard)
+      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.
   m_frame->securityContext()->contentSecurityPolicy()->reportAccumulatedHeaders(
       client());
 
   // didObserveLoadingBehavior() must be called after dispatchDidCommitLoad() is
   // called for the metrics tracking logic to handle it properly.
-  if (client()->isControlledByServiceWorker(*m_documentLoader))
+  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.
   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();
 }
 
 void FrameLoader::didInstallNewDocument(bool dispatchWindowObjectAvailable) {
   DCHECK(m_frame);
   DCHECK(m_frame->document());
 
   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_loadType)) {
     m_frame->document()->setStateForNewFormElements(
         m_provisionalItem->documentState());
+  }
 }
 
 void FrameLoader::didBeginDocument() {
   DCHECK(m_frame);
   DCHECK(m_frame->document());
   DCHECK(m_frame->document()->fetcher());
 
   if (m_documentLoader) {
     String suboriginHeader =
         m_documentLoader->response().httpHeaderField(HTTPNames::Suborigin);
     if (!suboriginHeader.isNull()) {
       Vector<String> messages;
       Suborigin suborigin;
       if (parseSuboriginHeader(suboriginHeader, &suborigin, messages))
         m_frame->document()->enforceSuborigin(suborigin);
 
-      for (auto& message : messages)
+      for (auto& message : messages) {
         m_frame->document()->addConsoleMessage(
             ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel,
                                    "Error with Suborigin header: " + message));
+      }
     }
     m_frame->document()->clientHintsPreferences().updateFrom(
         m_documentLoader->clientHintsPreferences());
   }
 
   Settings* settings = m_frame->document()->settings();
   if (settings) {
     m_frame->document()->fetcher()->setImagesEnabled(settings->imagesEnabled());
     m_frame->document()->fetcher()->setAutoLoadImages(
         settings->loadsImagesAutomatically());
   }
 
   if (m_documentLoader) {
     const AtomicString& dnsPrefetchControl =
         m_documentLoader->response().httpHeaderField(
             HTTPNames::X_DNS_Prefetch_Control);
     if (!dnsPrefetchControl.isEmpty())
       m_frame->document()->parseDNSPrefetchControlHeader(dnsPrefetchControl);
 
     String headerContentLanguage = m_documentLoader->response().httpHeaderField(
         HTTPNames::Content_Language);
     if (!headerContentLanguage.isEmpty()) {
       size_t commaIndex = headerContentLanguage.find(',');
       headerContentLanguage.truncate(
           commaIndex);  // kNotFound == -1 == don't truncate
       headerContentLanguage =
           headerContentLanguage.stripWhiteSpace(isHTMLSpace<UChar>);
-      if (!headerContentLanguage.isEmpty())
+      if (!headerContentLanguage.isEmpty()) {
         m_frame->document()->setContentLanguage(
             AtomicString(headerContentLanguage));
+      }
     }
 
     OriginTrialContext::addTokensFromHeader(
         m_frame->document(),
         m_documentLoader->response().httpHeaderField(HTTPNames::Origin_Trial));
   }
 
   if (m_documentLoader) {
     String referrerPolicyHeader = m_documentLoader->response().httpHeaderField(
         HTTPNames::Referrer_Policy);
     if (!referrerPolicyHeader.isNull()) {
       m_frame->document()->parseAndSetReferrerPolicy(referrerPolicyHeader);
     }
   }
 
   client()->didCreateNewDocument();
 }
 
 void FrameLoader::finishedParsing() {
   if (m_stateMachine.creatingInitialEmptyDocument())
     return;
 
   m_progressTracker->finishedParsing();
 
   if (client()) {
     ScriptForbiddenScope forbidScripts;
     client()->dispatchDidFinishDocumentLoad();
   }
 
-  if (client())
+  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.
   m_frame->view()->restoreScrollbar();
   processFragment(m_frame->document()->url(), NavigationToDifferentDocument);
@@ skipping 351 matching lines @@
   // 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)
+  if (isFormSubmission) {
     return (isReload || isBackForward) ? NavigationTypeFormResubmitted
                                        : NavigationTypeFormSubmitted;
+  }
   if (haveEvent)
     return NavigationTypeLinkClicked;
   if (isReload)
     return NavigationTypeReload;
   if (isBackForward)
     return NavigationTypeBackForward;
   return NavigationTypeOther;
 }
 
 static WebURLRequest::RequestContext determineRequestContextFromNavigationType(
@@ skipping 191 matching lines @@
   m_frame->document()->cancelParsing();
   if (!m_protectProvisionalLoader)
     detachDocumentLoader(m_provisionalDocumentLoader);
 
   m_checkTimer.stop();
   m_frame->navigationScheduler().cancel();
 
   // It's possible that the above actions won't have stopped loading if load
   // completion had been blocked on parsing or if we were in the middle of
   // committing an empty document. In that case, emulate a failed navigation.
-  if (!m_provisionalDocumentLoader && m_documentLoader && m_frame->isLoading())
+  if (!m_provisionalDocumentLoader && m_documentLoader &&
+      m_frame->isLoading()) {
     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.
@@ skipping 251 matching lines @@
     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())
+  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.
   bool shouldScrollToFragment =
       (loadStartType == NavigationWithinSameDocument &&
        !isBackForwardLoadType(m_loadType)) ||
       (documentLoader() &&
        !documentLoader()->initialScrollState().didRestoreFromHistory);
 
   view->processUrlFragment(url, shouldScrollToFragment
@@ skipping 427 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