Reflow comments in core/loader

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

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 257 matching lines @@
   }
 
   if (loadType == FrameLoadTypeReload)
     return CachePolicyRevalidate;
 
   if (m_documentLoader &&
       m_documentLoader->request().getCachePolicy() ==
           WebCachePolicy::ReturnCacheDataElseLoad)
     return CachePolicyHistoryBuffer;
 
-  // Returns CachePolicyVerify for other cases, mainly FrameLoadTypeStandard
-  // and FrameLoadTypeReloadMainResource. See public/web/WebFrameLoadType.h
-  // to know how these load types work.
+  // Returns CachePolicyVerify for other cases, mainly FrameLoadTypeStandard and
+  // FrameLoadTypeReloadMainResource. See public/web/WebFrameLoadType.h to know
+  // how these load types work.
   return CachePolicyVerify;
 }
 
 static WebCachePolicy memoryCachePolicyToResourceRequestCachePolicy(
     const CachePolicy policy) {
   if (policy == CachePolicyVerify)
     return WebCachePolicy::UseProtocolCachePolicy;
   if (policy == CachePolicyRevalidate)
     return WebCachePolicy::ValidatingCacheData;
   if (policy == CachePolicyReload)
@@ skipping 21 matching lines @@
       if (!f->isLocalFrame())
         continue;
       FrameLoadType parentFrameLoadType = toLocalFrame(f)->loader().loadType();
       if (parentFrameLoadType == FrameLoadTypeBackForward)
         return WebCachePolicy::ReturnCacheDataElseLoad;
       if (parentFrameLoadType == FrameLoadTypeReloadBypassingCache)
         return WebCachePolicy::BypassingCache;
       if (parentFrameLoadType == FrameLoadTypeReload)
         return WebCachePolicy::ValidatingCacheData;
     }
-    // Returns UseProtocolCachePolicy for other cases, parent frames not
-    // having special kinds of FrameLoadType as they are checked inside
-    // the for loop above, or |frameLoadType| being FrameLoadTypeStandard.
-    // See public/web/WebFrameLoadType.h to know how these load types work.
+    // Returns UseProtocolCachePolicy for other cases, parent frames not having
+    // special kinds of FrameLoadType as they are checked inside the for loop
+    // above, or |frameLoadType| being FrameLoadTypeStandard. See
+    // public/web/WebFrameLoadType.h to know how these load types work.
     return WebCachePolicy::UseProtocolCachePolicy;
   }
 
   // For users on slow connections, we want to avoid blocking the parser in
   // the main frame on script loads inserted via document.write, since it can
   // add significant delays before page content is displayed on the screen.
   if (type == Resource::Script && isMainFrame() && m_document &&
       shouldDisallowFetchForMainFrameScript(request, defer, *m_document))
     return WebCachePolicy::ReturnCacheDataDontLoad;
 
   if (request.isConditional())
     return WebCachePolicy::ValidatingCacheData;
 
   if (m_documentLoader && m_document && !m_document->loadEventFinished()) {
-    // For POST requests, we mutate the main resource's cache policy to avoid form resubmission.
-    // This policy should not be inherited by subresources.
+    // For POST requests, we mutate the main resource's cache policy to avoid
+    // form resubmission. This policy should not be inherited by subresources.
     WebCachePolicy mainResourceCachePolicy =
         m_documentLoader->request().getCachePolicy();
     if (m_documentLoader->request().httpMethod() == "POST") {
       if (mainResourceCachePolicy == WebCachePolicy::ReturnCacheDataDontLoad)
         return WebCachePolicy::ReturnCacheDataElseLoad;
       return WebCachePolicy::UseProtocolCachePolicy;
     }
     return memoryCachePolicyToResourceRequestCachePolicy(getCachePolicy());
   }
   return WebCachePolicy::UseProtocolCachePolicy;
 }
 
-// The |m_documentLoader| is null in the FrameFetchContext of an imported document.
-// FIXME(http://crbug.com/274173): This means Inspector, which uses DocumentLoader
-// as a grouping entity, cannot see imported documents.
+// The |m_documentLoader| is null in the FrameFetchContext of an imported
+// document.
+// FIXME(http://crbug.com/274173): This means Inspector, which uses
+// DocumentLoader as a grouping entity, cannot see imported documents.
 inline DocumentLoader* FrameFetchContext::masterDocumentLoader() const {
   return m_documentLoader ? m_documentLoader.get()
                           : frame()->loader().documentLoader();
 }
 
 void FrameFetchContext::dispatchDidChangeResourcePriority(
     unsigned long identifier,
     ResourceLoadPriority loadPriority,
     int intraPriorityValue) {
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceChangePriority", TRACE_EVENT_SCOPE_THREAD,
       "data",
       InspectorChangeResourcePriorityEvent::data(identifier, loadPriority));
   InspectorInstrumentation::didChangeResourcePriority(frame(), identifier,
                                                       loadPriority);
 }
 
 void FrameFetchContext::prepareRequest(ResourceRequest& request) {
   frame()->loader().applyUserAgent(request);
   frame()->loader().client()->dispatchWillSendRequest(request);
 }
 
 void FrameFetchContext::dispatchWillSendRequest(
     unsigned long identifier,
     ResourceRequest& request,
     const ResourceResponse& redirectResponse,
     const FetchInitiatorInfo& initiatorInfo) {
   // For initial requests, prepareRequest() is called in
-  // willStartLoadingResource(), before revalidation policy is determined.
-  // That call doesn't exist for redirects, so call preareRequest() here.
+  // willStartLoadingResource(), before revalidation policy is determined. That
+  // call doesn't exist for redirects, so call preareRequest() here.
   if (!redirectResponse.isNull())
     prepareRequest(request);
   else
     frame()->loader().progress().willStartLoading(identifier,
                                                   request.priority());
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceSendRequest", TRACE_EVENT_SCOPE_THREAD,
       "data", InspectorSendRequestEvent::data(identifier, frame(), request));
   InspectorInstrumentation::willSendRequest(frame(), identifier,
                                             masterDocumentLoader(), request,
@@ skipping 52 matching lines @@
 }
 
 void FrameFetchContext::dispatchDidFail(unsigned long identifier,
                                         const ResourceError& error,
                                         bool isInternalRequest) {
   frame()->loader().progress().completeProgress(identifier);
   TRACE_EVENT_INSTANT1("devtools.timeline", "ResourceFinish",
                        TRACE_EVENT_SCOPE_THREAD, "data",
                        InspectorResourceFinishEvent::data(identifier, 0, true));
   InspectorInstrumentation::didFailLoading(frame(), identifier, error);
-  // Notification to FrameConsole should come AFTER InspectorInstrumentation call, DevTools front-end relies on this.
+  // Notification to FrameConsole should come AFTER InspectorInstrumentation
+  // call, DevTools front-end relies on this.
   if (!isInternalRequest)
     frame()->console().didFailLoading(identifier, error);
   if (frame()->frameScheduler())
     frame()->frameScheduler()->didStopLoading(identifier);
 }
 
 void FrameFetchContext::dispatchDidLoadResourceFromMemoryCache(
     unsigned long identifier,
     Resource* resource,
     WebURLRequest::FrameType frameType,
@@ skipping 182 matching lines @@
     case Resource::XSLStyleSheet:
       DCHECK(RuntimeEnabledFeatures::xsltEnabled());
     case Resource::SVGDocument:
       if (!securityOrigin->canRequest(url)) {
         printAccessDeniedMessage(url);
         return ResourceRequestBlockedReasonOrigin;
       }
       break;
   }
 
-  // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved.
+  // FIXME: Convert this to check the isolated world's Content Security Policy
+  // once webkit.org/b/104520 is solved.
   bool shouldBypassMainWorldCSP =
       frame()->script().shouldBypassMainWorldCSP() ||
       options.contentSecurityPolicyOption == DoNotCheckContentSecurityPolicy;
 
-  // Don't send CSP messages for preloads, we might never actually display those items.
+  // Don't send CSP messages for preloads, we might never actually display those
+  // items.
   ContentSecurityPolicy::ReportingStatus cspReporting =
       forPreload ? ContentSecurityPolicy::SuppressReport
                  : ContentSecurityPolicy::SendReport;
 
   if (m_document) {
     DCHECK(m_document->contentSecurityPolicy());
     if (!shouldBypassMainWorldCSP &&
         !m_document->contentSecurityPolicy()->allowRequest(
             resourceRequest.requestContext(), url,
             options.contentSecurityPolicyNonce, options.integrityMetadata,
             redirectStatus, cspReporting))
       return ResourceRequestBlockedReasonCSP;
   }
 
   if (type == Resource::Script || type == Resource::ImportResource) {
     DCHECK(frame());
     if (!frame()->loader().client()->allowScriptFromSource(
             !frame()->settings() || frame()->settings()->scriptEnabled(),
             url)) {
       frame()->loader().client()->didNotAllowScript();
-      // TODO(estark): Use a different ResourceRequestBlockedReason
-      // here, since this check has nothing to do with
-      // CSP. https://crbug.com/600795
+      // TODO(estark): Use a different ResourceRequestBlockedReason here, since
+      // this check has nothing to do with CSP. https://crbug.com/600795
       return ResourceRequestBlockedReasonCSP;
     }
   } else if (type == Resource::Media || type == Resource::TextTrack) {
     DCHECK(frame());
     if (!frame()->loader().client()->allowMedia(url))
       return ResourceRequestBlockedReasonOther;
   }
 
   // SVG Images have unique security rules that prevent all subresource requests
   // except for data urls.
   if (type != Resource::MainResource &&
       frame()->chromeClient().isSVGImageChromeClient() && !url.protocolIsData())
     return ResourceRequestBlockedReasonOrigin;
 
-  // Measure the number of legacy URL schemes ('ftp://') and the number of embedded-credential
-  // ('http://user:password@...') resources embedded as subresources. in the hopes that we can
-  // block them at some point in the future.
+  // Measure the number of legacy URL schemes ('ftp://') and the number of
+  // embedded-credential ('http://user:password@...') resources embedded as
+  // subresources. in the hopes that we can block them at some point in the
+  // future.
   if (resourceRequest.frameType() != WebURLRequest::FrameTypeTopLevel) {
     DCHECK(frame()->document());
     if (SchemeRegistry::shouldTreatURLSchemeAsLegacy(url.protocol()) &&
         !SchemeRegistry::shouldTreatURLSchemeAsLegacy(
             frame()->document()->getSecurityOrigin()->protocol()))
       UseCounter::count(frame()->document(),
                         UseCounter::LegacyProtocolEmbeddedAsSubresource);
     if (!url.user().isEmpty() || !url.pass().isEmpty())
       UseCounter::count(
           frame()->document(),
           UseCounter::RequestedSubresourceWithEmbeddedCredentials);
   }
 
   // Check for mixed content. We do this second-to-last so that when folks block
   // mixed content with a CSP policy, they don't get a warning. They'll still
   // get a warning in the console about CSP blocking the load.
   MixedContentChecker::ReportingStatus mixedContentReporting =
       forPreload ? MixedContentChecker::SuppressReport
                  : MixedContentChecker::SendReport;
   if (MixedContentChecker::shouldBlockFetch(frame(), resourceRequest, url,
                                             mixedContentReporting))
     return ResourceRequestBlockedReasonMixedContent;
 
-  // Let the client have the final say into whether or not the load should proceed.
+  // Let the client have the final say into whether or not the load should
+  // proceed.
   DocumentLoader* documentLoader = masterDocumentLoader();
   if (documentLoader && documentLoader->subresourceFilter() &&
       type != Resource::MainResource && type != Resource::ImportResource &&
       !documentLoader->subresourceFilter()->allowLoad(
           url, resourceRequest.requestContext()))
     return ResourceRequestBlockedReasonSubresourceFilter;
 
   return ResourceRequestBlockedReasonNone;
 }
 
 bool FrameFetchContext::isControlledByServiceWorker() const {
   DCHECK(m_documentLoader || frame()->loader().documentLoader());
 
   // Service workers are bypassed by suborigins (see
   // https://w3c.github.io/webappsec-suborigins/). Since service worker
   // controllers are assigned based on physical origin, without knowledge of
-  // whether the context is in a suborigin, it is necessary to explicitly
-  // bypass service workers on a per-request basis. Additionally, it is
-  // necessary to explicitly return |false| here so that it is clear that the
-  // SW will be bypassed. In particular, this is important for
-  // ResourceFetcher::getCacheIdentifier(), which will return the SW's cache
-  // if the context's isControlledByServiceWorker() returns |true|, and thus
-  // will returned cached resources from the service worker. That would have
-  // the effect of not bypassing the SW.
+  // whether the context is in a suborigin, it is necessary to explicitly bypass
+  // service workers on a per-request basis. Additionally, it is necessary to
+  // explicitly return |false| here so that it is clear that the SW will be
+  // bypassed. In particular, this is important for
+  // ResourceFetcher::getCacheIdentifier(), which will return the SW's cache if
+  // the context's isControlledByServiceWorker() returns |true|, and thus will
+  // returned cached resources from the service worker. That would have the
+  // effect of not bypassing the SW.
   if (getSecurityOrigin() && getSecurityOrigin()->hasSuborigin())
     return false;
 
   if (m_documentLoader)
     return frame()->loader().client()->isControlledByServiceWorker(
         *m_documentLoader);
-  // m_documentLoader is null while loading resources from an HTML import.
-  // In such cases whether the request is controlled by ServiceWorker or not
-  // is determined by the document loader of the frame.
+  // m_documentLoader is null while loading resources from an HTML import. In
+  // such cases whether the request is controlled by ServiceWorker or not is
+  // determined by the document loader of the frame.
   return frame()->loader().client()->isControlledByServiceWorker(
       *frame()->loader().documentLoader());
 }
 
 int64_t FrameFetchContext::serviceWorkerID() const {
   DCHECK(m_documentLoader || frame()->loader().documentLoader());
   if (m_documentLoader)
     return frame()->loader().client()->serviceWorkerID(*m_documentLoader);
   // m_documentLoader is null while loading resources from an HTML import.
   // In such cases a service worker ID could be retrieved from the document
@@ skipping 15 matching lines @@
 }
 
 bool FrameFetchContext::pageDismissalEventBeingDispatched() const {
   return m_document &&
          m_document->pageDismissalEventBeingDispatched() !=
              Document::NoDismissal;
 }
 
 bool FrameFetchContext::updateTimingInfoForIFrameNavigation(
     ResourceTimingInfo* info) {
-  // <iframe>s should report the initial navigation requested by the parent document, but not subsequent navigations.
+  // <iframe>s should report the initial navigation requested by the parent
+  // document, but not subsequent navigations.
   // FIXME: Resource timing is broken when the parent is a remote frame.
   if (!frame()->deprecatedLocalOwner() ||
       frame()->deprecatedLocalOwner()->loadedNonEmptyDocument())
     return false;
   frame()->deprecatedLocalOwner()->didLoadNonEmptyDocument();
   // Do not report iframe navigation that restored from history, since its
   // location may have been changed after initial navigation.
   if (frame()->loader().loadType() == FrameLoadTypeInitialHistoryLoad)
     return false;
   info->setInitiatorType(frame()->deprecatedLocalOwner()->localName());
@@ skipping 68 matching lines @@
 void FrameFetchContext::populateRequestData(ResourceRequest& request) {
   if (!m_document)
     return;
 
   if (request.firstPartyForCookies().isNull()) {
     request.setFirstPartyForCookies(
         m_document ? m_document->firstPartyForCookies()
                    : SecurityOrigin::urlWithUniqueSecurityOrigin());
   }
 
-  // Subresource requests inherit their requestor origin from |m_document| directly.
-  // Top-level and nested frame types are taken care of in 'FrameLoadRequest()'.
-  // Auxiliary frame types in 'createWindow()' and 'FrameLoader::load'.
-  //
+  // Subresource requests inherit their requestor origin from |m_document|
+  // directly. Top-level and nested frame types are taken care of in
+  // 'FrameLoadRequest()'. Auxiliary frame types in 'createWindow()' and
+  // 'FrameLoader::load'.
   // TODO(mkwst): It would be cleaner to adjust blink::ResourceRequest to
   // initialize itself with a `nullptr` initiator so that this can be a simple
   // `isNull()` check. https://crbug.com/625969
   if (request.frameType() == WebURLRequest::FrameTypeNone &&
       request.requestorOrigin()->isUnique()) {
     request.setRequestorOrigin(m_document->isSandboxed(SandboxOrigin)
                                    ? SecurityOrigin::create(m_document->url())
                                    : m_document->getSecurityOrigin());
   }
 }
 
 MHTMLArchive* FrameFetchContext::archive() const {
   DCHECK(!isMainFrame());
   // TODO(nasko): How should this work with OOPIF?
-  // The MHTMLArchive is parsed as a whole, but can be constructed from
-  // frames in mutliple processes. In that case, which process should parse
-  // it and how should the output be spread back across multiple processes?
+  // The MHTMLArchive is parsed as a whole, but can be constructed from frames
+  // in mutliple processes. In that case, which process should parse it and how
+  // should the output be spread back across multiple processes?
   if (!frame()->tree().parent()->isLocalFrame())
     return nullptr;
   return toLocalFrame(frame()->tree().parent())
       ->loader()
       .documentLoader()
       ->fetcher()
       ->archive();
 }
 
 void FrameFetchContext::countClientHintsDPR() {
@@ skipping 35 matching lines @@
   MixedContentChecker::checkMixedPrivatePublic(frame(),
                                                response.remoteIPAddress());
   if (m_documentLoader &&
       m_documentLoader == frame()->loader().provisionalDocumentLoader()) {
     ResourceFetcher* fetcher = nullptr;
     if (frame()->document())
       fetcher = frame()->document()->fetcher();
     m_documentLoader->clientHintsPreferences()
         .updateFromAcceptClientHintsHeader(
             response.httpHeaderField(HTTPNames::Accept_CH), fetcher);
-    // When response is received with a provisional docloader, the resource haven't committed yet, and we cannot load resources, only preconnect.
+    // When response is received with a provisional docloader, the resource
+    // haven't committed yet, and we cannot load resources, only preconnect.
     resourceLoadingPolicy = LinkLoader::DoNotLoadResources;
   }
   LinkLoader::loadLinksFromHeader(
       response.httpHeaderField(HTTPNames::Link), response.url(),
       frame()->document(), NetworkHintsInterfaceImpl(), resourceLoadingPolicy,
       LinkLoader::LoadAll, nullptr);
 
   if (response.hasMajorCertificateErrors())
     MixedContentChecker::handleCertificateError(frame(), response, frameType,
                                                 requestContext);
@@ skipping 12 matching lines @@
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink