Reflow comments in core/loader

third_party/WebKit/Source/core/loader/appcache/ApplicationCacheHost.cpp

 /*
  * Copyright (C) 2009 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 58 matching lines @@
   DCHECK(m_documentLoader);
 }
 
 ApplicationCacheHost::~ApplicationCacheHost() {
   // Verify that detachFromDocumentLoader() has been performed already.
   DCHECK(!m_host);
 }
 
 void ApplicationCacheHost::willStartLoadingMainResource(
     ResourceRequest& request) {
-  // We defer creating the outer host object to avoid spurious creation/destruction
-  // around creating empty documents. At this point, we're initiating a main resource
-  // load for the document, so its for real.
+  // We defer creating the outer host object to avoid spurious
+  // creation/destruction around creating empty documents. At this point, we're
+  // initiating a main resource load for the document, so its for real.
 
   if (!isApplicationCacheEnabled())
     return;
 
   DCHECK(m_documentLoader->frame());
   LocalFrame& frame = *m_documentLoader->frame();
   m_host = frame.loader().client()->createApplicationCacheHost(this);
   if (!m_host)
     return;
 
   WrappedResourceRequest wrapped(request);
 
   const WebApplicationCacheHost* spawningHost = nullptr;
   Frame* spawningFrame = frame.tree().parent();
   if (!spawningFrame || !spawningFrame->isLocalFrame())
     spawningFrame = frame.loader().opener();
   if (!spawningFrame || !spawningFrame->isLocalFrame())
     spawningFrame = &frame;
   if (DocumentLoader* spawningDocLoader =
           toLocalFrame(spawningFrame)->loader().documentLoader())
     spawningHost = spawningDocLoader->applicationCacheHost()
                        ? spawningDocLoader->applicationCacheHost()->m_host.get()
                        : nullptr;
 
   m_host->willStartMainResourceRequest(wrapped, spawningHost);
 
-  // NOTE: The semantics of this method, and others in this interface, are subtly different
-  // than the method names would suggest. For example, in this method never returns an appcached
-  // response in the SubstituteData out argument, instead we return the appcached response thru
-  // the usual resource loading pipeline.
+  // NOTE: The semantics of this method, and others in this interface, are
+  // subtly different than the method names would suggest. For example, in this
+  // method never returns an appcached response in the SubstituteData out
+  // argument, instead we return the appcached response thru the usual resource
+  // loading pipeline.
 }
 
 void ApplicationCacheHost::selectCacheWithoutManifest() {
   if (m_host)
     m_host->selectCacheWithoutManifest();
 }
 
 void ApplicationCacheHost::selectCacheWithManifest(const KURL& manifestURL) {
   DCHECK(m_documentLoader);
 
   LocalFrame* frame = m_documentLoader->frame();
   Document* document = frame->document();
   if (document->isSecureContext()) {
     UseCounter::count(document,
                       UseCounter::ApplicationCacheManifestSelectSecureOrigin);
     UseCounter::countCrossOriginIframe(
         *document, UseCounter::ApplicationCacheManifestSelectSecureOrigin);
   } else {
     Deprecation::countDeprecation(
         document, UseCounter::ApplicationCacheManifestSelectInsecureOrigin);
     Deprecation::countDeprecationCrossOriginIframe(
         *document, UseCounter::ApplicationCacheManifestSelectInsecureOrigin);
     HostsUsingFeatures::countAnyWorld(
         *document, HostsUsingFeatures::Feature::
                        ApplicationCacheManifestSelectInsecureHost);
   }
   if (m_host && !m_host->selectCacheWithManifest(manifestURL)) {
-    // It's a foreign entry, restart the current navigation from the top
-    // of the navigation algorithm. The navigation will not result in the
-    // same resource being loaded, because "foreign" entries are never picked
-    // during navigation.
-    // see ApplicationCacheGroup::selectCache()
+    // It's a foreign entry, restart the current navigation from the top of the
+    // navigation algorithm. The navigation will not result in the same resource
+    // being loaded, because "foreign" entries are never picked during
+    // navigation. see ApplicationCacheGroup::selectCache()
     frame->navigate(*document, document->url(), true, UserGestureStatus::None);
   }
 }
 
 void ApplicationCacheHost::didReceiveResponseForMainResource(
     const ResourceResponse& response) {
   if (m_host) {
     WrappedResourceResponse wrapped(response);
     m_host->didReceiveResponseForMainResource(wrapped);
   }
@@ skipping 22 matching lines @@
   }
 }
 
 void ApplicationCacheHost::setApplicationCache(
     ApplicationCache* domApplicationCache) {
   DCHECK(!m_domApplicationCache || !domApplicationCache);
   m_domApplicationCache = domApplicationCache;
 }
 
 void ApplicationCacheHost::detachFromDocumentLoader() {
-  // Detach from the owning DocumentLoader and let go of WebApplicationCacheHost.
+  // Detach from the owning DocumentLoader and let go of
+  // WebApplicationCacheHost.
   setApplicationCache(nullptr);
   m_host.reset();
   m_documentLoader = nullptr;
 }
 
 void ApplicationCacheHost::notifyApplicationCache(
     EventID id,
     int progressTotal,
     int progressDone,
     WebApplicationCacheHost::ErrorReason errorReason,
@@ skipping 100 matching lines @@
 
 bool ApplicationCacheHost::isApplicationCacheEnabled() {
   DCHECK(m_documentLoader->frame());
   return m_documentLoader->frame()->settings() &&
          m_documentLoader->frame()
              ->settings()
              ->offlineWebApplicationCacheEnabled();
 }
 
 void ApplicationCacheHost::didChangeCacheAssociation() {
-  // FIXME: Prod the inspector to update its notion of what cache the page is using.
+  // FIXME: Prod the inspector to update its notion of what cache the page is
+  // using.
 }
 
 void ApplicationCacheHost::notifyEventListener(
     WebApplicationCacheHost::EventID eventID) {
   notifyApplicationCache(static_cast<ApplicationCacheHost::EventID>(eventID), 0,
                          0, WebApplicationCacheHost::UnknownError, String(), 0,
                          String());
 }
 
 void ApplicationCacheHost::notifyProgressEventListener(const WebURL&,
@@ skipping 12 matching lines @@
   notifyApplicationCache(kErrorEvent, 0, 0, reason, url.string(), status,
                          message);
 }
 
 DEFINE_TRACE(ApplicationCacheHost) {
   visitor->trace(m_domApplicationCache);
   visitor->trace(m_documentLoader);
 }
 
 }  // namespace blink