Reflow comments in core/loader

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

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * 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
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 67 matching lines @@
 
 namespace blink {
 
 static bool isArchiveMIMEType(const String& mimeType) {
   return equalIgnoringCase("multipart/related", mimeType);
 }
 
 static bool shouldInheritSecurityOriginFromOwner(const KURL& url) {
   // https://html.spec.whatwg.org/multipage/browsers.html#origin
   //
-  // If a Document is the initial "about:blank" document
-  //     The origin and effective script origin of the Document are those it
-  //     was assigned when its browsing context was created.
+  // If a Document is the initial "about:blank" document The origin and
+  // effective script origin of the Document are those it was assigned when its
+  // browsing context was created.
   //
   // Note: We generalize this to all "blank" URLs and invalid URLs because we
   // treat all of these URLs as about:blank.
   return url.isEmpty() || url.protocolIsAbout();
 }
 
 DocumentLoader::DocumentLoader(LocalFrame* frame,
                                const ResourceRequest& req,
                                const SubstituteData& substituteData)
     : m_frame(frame),
@@ skipping 91 matching lines @@
 
   if (resource)
     fetcher()->preloadStarted(resource);
   return resource;
 }
 
 void DocumentLoader::didRedirect(const KURL& oldURL, const KURL& newURL) {
   timing().addRedirect(oldURL, newURL);
 
   // If a redirection happens during a back/forward navigation, don't restore
-  // any state from the old HistoryItem.
-  // There is a provisional history item for back/forward navigation only.
-  // In the other case, clearing it is a no-op.
+  // any state from the old HistoryItem. There is a provisional history item for
+  // back/forward navigation only. In the other case, clearing it is a no-op.
   DCHECK(frameLoader());
   frameLoader()->clearProvisionalHistoryItem();
 }
 
 void DocumentLoader::dispatchLinkHeaderPreloads(
     ViewportDescriptionWrapper* viewport,
     LinkLoader::MediaPreloadPolicy mediaPolicy) {
   LinkLoader::loadLinksFromHeader(
       response().httpHeaderField(HTTPNames::Link), response().url(),
       m_frame->document(), NetworkHintsInterfaceImpl(),
@@ skipping 67 matching lines @@
     responseEndTime = m_timeOfLastDataReceived;
   if (!responseEndTime)
     responseEndTime = monotonicallyIncreasingTime();
   timing().setResponseEnd(responseEndTime);
 
   commitIfReady();
   if (!frameLoader())
     return;
 
   if (!maybeCreateArchive()) {
-    // If this is an empty document, it will not have actually been created yet. Commit dummy data so that
-    // DocumentWriter::begin() gets called and creates the Document.
+    // If this is an empty document, it will not have actually been created yet.
+    // Commit dummy data so that DocumentWriter::begin() gets called and creates
+    // the Document.
     if (!m_writer)
       commitData(0, 0);
   }
 
   if (!m_frame)
     return;
 
   m_applicationCacheHost->finishedLoadingMainResource();
   endWriting(m_writer.get());
   if (m_state < MainResourceDone)
     m_state = MainResourceDone;
   clearMainResourceHandle();
 }
 
 void DocumentLoader::redirectReceived(
     Resource* resource,
     ResourceRequest& request,
     const ResourceResponse& redirectResponse) {
   DCHECK_EQ(resource, m_mainResource);
   DCHECK(!redirectResponse.isNull());
   m_request = request;
 
-  // If the redirecting url is not allowed to display content from the target origin,
-  // then block the redirect.
+  // If the redirecting url is not allowed to display content from the target
+  // origin, then block the redirect.
   const KURL& requestURL = m_request.url();
   RefPtr<SecurityOrigin> redirectingOrigin =
       SecurityOrigin::create(redirectResponse.url());
   if (!redirectingOrigin->canDisplay(requestURL)) {
     FrameLoader::reportLocalLoadFailed(m_frame, requestURL.getString());
     m_fetcher->stopFetching();
     return;
   }
   if (!frameLoader()->shouldContinueForNavigationPolicy(
           m_request, SubstituteData(), this, CheckContentSecurityPolicy,
@@ skipping 41 matching lines @@
   return true;
 }
 
 void DocumentLoader::cancelLoadAfterXFrameOptionsOrCSPDenied(
     const ResourceResponse& response) {
   InspectorInstrumentation::continueAfterXFrameOptionsDenied(
       m_frame, this, mainResourceIdentifier(), response, m_mainResource.get());
 
   setWasBlockedAfterXFrameOptionsOrCSP();
 
-  // Pretend that this was an empty HTTP 200 response.  Don't reuse the
-  // original URL for the empty page (https://crbug.com/622385).
+  // Pretend that this was an empty HTTP 200 response.  Don't reuse the original
+  // URL for the empty page (https://crbug.com/622385).
   //
   // TODO(mkwst):  Remove this once XFO moves to the browser.
   // https://crbug.com/555418.
   clearMainResourceHandle();
   KURL blockedURL = SecurityOrigin::urlWithUniqueSecurityOrigin();
   m_originalRequest.setURL(blockedURL);
   m_request.setURL(blockedURL);
   m_redirectChain.removeLast();
   appendRedirect(blockedURL);
   m_response = ResourceResponse(blockedURL, "text/html", 0, nullAtom, String());
   finishedLoading(monotonicallyIncreasingTime());
 
   return;
 }
 
 void DocumentLoader::responseReceived(
     Resource* resource,
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK_EQ(m_mainResource, resource);
   DCHECK(!handle);
   DCHECK(frame());
 
   m_applicationCacheHost->didReceiveResponseForMainResource(response);
 
-  // The memory cache doesn't understand the application cache or its caching rules. So if a main resource is served
-  // from the application cache, ensure we don't save the result for future use. All responses loaded
-  // from appcache will have a non-zero appCacheID().
+  // The memory cache doesn't understand the application cache or its caching
+  // rules. So if a main resource is served from the application cache, ensure
+  // we don't save the result for future use. All responses loaded from appcache
+  // will have a non-zero appCacheID().
   if (response.appCacheID())
     memoryCache()->remove(m_mainResource.get());
 
   m_contentSecurityPolicy = ContentSecurityPolicy::create();
   m_contentSecurityPolicy->setOverrideURLForSelf(response.url());
   m_contentSecurityPolicy->didReceiveHeaders(
       ContentSecurityPolicyResponseHeaders(response));
   if (!m_contentSecurityPolicy->allowAncestors(m_frame, response.url())) {
     cancelLoadAfterXFrameOptionsOrCSPDenied(response);
     return;
   }
 
-  // 'frame-ancestors' obviates 'x-frame-options': https://w3c.github.io/webappsec/specs/content-security-policy/#frame-ancestors-and-frame-options
+  // 'frame-ancestors' obviates 'x-frame-options':
+  // https://w3c.github.io/webappsec/specs/content-security-policy/#frame-ancestors-and-frame-options
   if (!m_contentSecurityPolicy->isFrameAncestorsEnforced()) {
     HTTPHeaderMap::const_iterator it =
         response.httpHeaderFields().find(HTTPNames::X_Frame_Options);
     if (it != response.httpHeaderFields().end()) {
       String content = it->value;
       if (frameLoader()->shouldInterruptLoadForXFrameOptions(
               content, response.url(), mainResourceIdentifier())) {
         String message = "Refused to display '" +
                          response.url().elidedString() +
                          "' in a frame because it set 'X-Frame-Options' to '" +
@@ skipping 87 matching lines @@
 void DocumentLoader::dataReceived(Resource* resource,
                                   const char* data,
                                   size_t length) {
   DCHECK(data);
   DCHECK(length);
   DCHECK_EQ(resource, m_mainResource);
   DCHECK(!m_response.isNull());
   DCHECK(!m_frame->page()->defersLoading());
 
   if (m_inDataReceived) {
-    // If this function is reentered, defer processing of the additional
-    // data to the top-level invocation. Reentrant calls can occur because
-    // of web platform (mis-)features that require running a nested message
-    // loop:
+    // If this function is reentered, defer processing of the additional data to
+    // the top-level invocation. Reentrant calls can occur because of web
+    // platform (mis-)features that require running a nested message loop:
     // - alert(), confirm(), prompt()
     // - Detach of plugin elements.
     // - Synchronous XMLHTTPRequest
     m_dataBuffer->append(data, length);
     return;
   }
 
   AutoReset<bool> reentrancyProtector(&m_inDataReceived, true);
   processData(data, length);
 
-  // Process data received in reentrant invocations. Note that the
-  // invocations of processData() may queue more data in reentrant
-  // invocations, so iterate until it's empty.
+  // Process data received in reentrant invocations. Note that the invocations
+  // of processData() may queue more data in reentrant invocations, so iterate
+  // until it's empty.
   const char* segment;
   size_t pos = 0;
   while (size_t length = m_dataBuffer->getSomeData(segment, pos)) {
     processData(segment, length);
     pos += length;
   }
   // All data has been consumed, so flush the buffer.
   m_dataBuffer->clear();
 }
 
 void DocumentLoader::processData(const char* data, size_t length) {
   m_applicationCacheHost->mainResourceDataReceived(data, length);
   m_timeOfLastDataReceived = monotonicallyIncreasingTime();
 
   if (isArchiveMIMEType(response().mimeType()))
     return;
   commitIfReady();
   if (!frameLoader())
     return;
   commitData(data, length);
 
-  // If we are sending data to MediaDocument, we should stop here
-  // and cancel the request.
+  // If we are sending data to MediaDocument, we should stop here and cancel the
+  // request.
   if (m_frame && m_frame->document()->isMediaDocument())
     m_fetcher->stopFetching();
 }
 
 void DocumentLoader::clearRedirectChain() {
   m_redirectChain.clear();
 }
 
 void DocumentLoader::appendRedirect(const KURL& url) {
   m_redirectChain.append(url);
@@ skipping 20 matching lines @@
 }
 
 void DocumentLoader::clearMainResourceHandle() {
   if (!m_mainResource)
     return;
   m_mainResource->removeClient(this);
   m_mainResource = nullptr;
 }
 
 bool DocumentLoader::maybeCreateArchive() {
-  // Give the archive machinery a crack at this document. If the MIME type is not an archive type, it will return 0.
+  // Give the archive machinery a crack at this document. If the MIME type is
+  // not an archive type, it will return 0.
   if (!isArchiveMIMEType(m_response.mimeType()))
     return false;
 
   DCHECK(m_mainResource);
   ArchiveResource* mainResource =
       m_fetcher->createArchive(m_mainResource.get());
   if (!mainResource)
     return false;
-  // The origin is the MHTML file, we need to set the base URL to the document encoded in the MHTML so
-  // relative URLs are resolved properly.
+  // The origin is the MHTML file, we need to set the base URL to the document
+  // encoded in the MHTML so relative URLs are resolved properly.
   ensureWriter(mainResource->mimeType(), mainResource->url());
 
   // The Document has now been created.
   m_frame->document()->enforceSandboxFlags(SandboxAll);
 
   commitData(mainResource->data()->data(), mainResource->data()->size());
   return true;
 }
 
 const AtomicString& DocumentLoader::responseMIMEType() const {
@@ skipping 45 matching lines @@
        CheckContentSecurityPolicy, DocumentContext));
   FetchRequest fetchRequest(m_request, FetchInitiatorTypeNames::document,
                             mainResourceLoadOptions);
   m_mainResource =
       RawResource::fetchMainResource(fetchRequest, fetcher(), m_substituteData);
   if (!m_mainResource) {
     m_request = ResourceRequest(blankURL());
     maybeLoadEmpty();
     return;
   }
-  // A bunch of headers are set when the underlying resource load begins, and m_request needs to include those.
-  // Even when using a cached resource, we may make some modification to the request, e.g. adding the referer header.
+  // A bunch of headers are set when the underlying resource load begins, and
+  // m_request needs to include those. Even when using a cached resource, we may
+  // make some modification to the request, e.g. adding the referer header.
   m_request = m_mainResource->isLoading() ? m_mainResource->resourceRequest()
                                           : fetchRequest.resourceRequest();
   m_mainResource->addClient(this);
 }
 
 void DocumentLoader::endWriting(DocumentWriter* writer) {
   DCHECK_EQ(m_writer, writer);
   m_writer->end();
   m_writer.clear();
 }
@@ skipping 31 matching lines @@
 
   return DocumentWriter::create(document, parsingPolicy, mimeType, encoding);
 }
 
 const AtomicString& DocumentLoader::mimeType() const {
   if (m_writer)
     return m_writer->mimeType();
   return m_response.mimeType();
 }
 
-// This is only called by FrameLoader::replaceDocumentWhileExecutingJavaScriptURL()
+// This is only called by
+// FrameLoader::replaceDocumentWhileExecutingJavaScriptURL()
 void DocumentLoader::replaceDocumentWhileExecutingJavaScriptURL(
     const DocumentInit& init,
     const String& source) {
   m_writer = createWriterFor(init, mimeType(),
                              m_writer ? m_writer->encoding() : emptyAtom, true,
                              ForceSynchronousParsing);
   if (!source.isNull())
     m_writer->appendReplacingData(source);
   endWriting(m_writer.get());
 }
 
 DEFINE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 }  // namespace blink