Reflow comments in core/fetch

third_party/WebKit/Source/core/fetch/Resource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
-    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
+    rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
@@ skipping 110 matching lines @@
 DEFINE_TRACE(Resource::CachedMetadataHandlerImpl) {
   visitor->trace(m_resource);
   CachedMetadataHandler::trace(visitor);
 }
 
 void Resource::CachedMetadataHandlerImpl::setCachedMetadata(
     uint32_t dataTypeID,
     const char* data,
     size_t size,
     CachedMetadataHandler::CacheType cacheType) {
-  // Currently, only one type of cached metadata per resource is supported.
-  // If the need arises for multiple types of metadata per resource this could
-  // be enhanced to store types of metadata in a map.
+  // Currently, only one type of cached metadata per resource is supported. If
+  // the need arises for multiple types of metadata per resource this could be
+  // enhanced to store types of metadata in a map.
   DCHECK(!m_cachedMetadata);
   m_cachedMetadata = CachedMetadata::create(dataTypeID, data, size);
   if (cacheType == CachedMetadataHandler::SendToPlatform)
     sendToPlatform();
 }
 
 void Resource::CachedMetadataHandlerImpl::clearCachedMetadata(
     CachedMetadataHandler::CacheType cacheType) {
   m_cachedMetadata.clear();
   if (cacheType == CachedMetadataHandler::SendToPlatform)
     sendToPlatform();
 }
 
 PassRefPtr<CachedMetadata> Resource::CachedMetadataHandlerImpl::cachedMetadata(
     uint32_t dataTypeID) const {
   if (!m_cachedMetadata || m_cachedMetadata->dataTypeID() != dataTypeID)
     return nullptr;
   return m_cachedMetadata.get();
 }
 
 String Resource::CachedMetadataHandlerImpl::encoding() const {
   return m_resource->encoding();
 }
 
 void Resource::CachedMetadataHandlerImpl::setSerializedCachedMetadata(
     const char* data,
     size_t size) {
-  // We only expect to receive cached metadata from the platform once.
-  // If this triggers, it indicates an efficiency problem which is most
-  // likely unexpected in code designed to improve performance.
+  // We only expect to receive cached metadata from the platform once. If this
+  // triggers, it indicates an efficiency problem which is most likely
+  // unexpected in code designed to improve performance.
   DCHECK(!m_cachedMetadata);
   m_cachedMetadata = CachedMetadata::createFromSerializedData(data, size);
 }
 
 void Resource::CachedMetadataHandlerImpl::sendToPlatform() {
   if (m_cachedMetadata) {
     const Vector<char>& serializedData = m_cachedMetadata->serializedData();
     Platform::current()->cacheMetadata(
         response().url(), response().responseTime(), serializedData.data(),
         serializedData.size());
@@ skipping 28 matching lines @@
 Resource::ServiceWorkerResponseCachedMetadataHandler::
     ServiceWorkerResponseCachedMetadataHandler(Resource* resource,
                                                SecurityOrigin* securityOrigin)
     : CachedMetadataHandlerImpl(resource), m_securityOrigin(securityOrigin) {}
 
 DEFINE_TRACE(Resource::ServiceWorkerResponseCachedMetadataHandler) {
   CachedMetadataHandlerImpl::trace(visitor);
 }
 
 void Resource::ServiceWorkerResponseCachedMetadataHandler::sendToPlatform() {
-  // We don't support sending the metadata to the platform when the response
-  // was directly fetched via a ServiceWorker
-  // (eg: FetchEvent.respondWith(fetch(FetchEvent.request))) to prevent an
-  // attacker's Service Worker from poisoning the metadata cache of HTTPCache.
+  // We don't support sending the metadata to the platform when the response was
+  // directly fetched via a ServiceWorker (eg:
+  // FetchEvent.respondWith(fetch(FetchEvent.request))) to prevent an attacker's
+  // Service Worker from poisoning the metadata cache of HTTPCache.
   if (response().cacheStorageCacheName().isNull())
     return;
 
   if (m_cachedMetadata) {
     const Vector<char>& serializedData = m_cachedMetadata->serializedData();
     Platform::current()->cacheMetadataInCacheStorage(
         response().url(), response().responseTime(), serializedData.data(),
         serializedData.size(), WebSecurityOrigin(m_securityOrigin),
         response().cacheStorageCacheName());
   } else {
@@ skipping 77 matching lines @@
       m_type(type),
       m_status(NotStarted),
       m_needsSynchronousCacheHit(false),
       m_linkPreload(false),
       m_isRevalidating(false),
       m_isAlive(false),
       m_options(options),
       m_responseTimestamp(currentTime()),
       m_cancelTimer(this, &Resource::cancelTimerFired),
       m_resourceRequest(request) {
-  DCHECK_EQ(
-      m_type,
-      unsigned(
-          type));  // m_type is a bitfield, so this tests careless updates of the enum.
+  // m_type is a bitfield, so this tests careless updates of the enum.
+  DCHECK_EQ(m_type, unsigned(type));
   InstanceCounters::incrementCounter(InstanceCounters::ResourceCounter);
 
   // Currently we support the metadata caching only for HTTP family.
   if (m_resourceRequest.url().protocolIsInHTTPFamily())
     m_cacheHandler = CachedMetadataHandlerImpl::create(this);
   MemoryCoordinator::instance().registerClient(this);
 }
 
 Resource::~Resource() {
   InstanceCounters::decrementCounter(InstanceCounters::ResourceCounter);
@@ skipping 154 matching lines @@
     return maxAgeValue;
   double expiresValue = response.expires();
   double dateValue = response.date();
   double creationTime =
       std::isfinite(dateValue) ? dateValue : responseTimestamp;
   if (std::isfinite(expiresValue))
     return expiresValue - creationTime;
   double lastModifiedValue = response.lastModified();
   if (std::isfinite(lastModifiedValue))
     return (creationTime - lastModifiedValue) * 0.1;
-  // If no cache headers are present, the specification leaves the decision to the UA. Other browsers seem to opt for 0.
+  // If no cache headers are present, the specification leaves the decision to
+  // the UA. Other browsers seem to opt for 0.
   return 0;
 }
 
 double Resource::freshnessLifetime() {
   return blink::freshnessLifetime(m_response, m_responseTimestamp);
 }
 
 double Resource::stalenessLifetime() {
   return m_response.cacheControlStaleWhileRevalidate();
 }
 
 static bool canUseResponse(ResourceResponse& response,
                            double responseTimestamp) {
   if (response.isNull())
     return false;
 
-  // FIXME: Why isn't must-revalidate considered a reason we can't use the response?
+  // FIXME: Why isn't must-revalidate considered a reason we can't use the
+  // response?
   if (response.cacheControlContainsNoCache() ||
       response.cacheControlContainsNoStore())
     return false;
 
   if (response.httpStatusCode() == 303) {
     // Must not be cached.
     return false;
   }
 
   if (response.httpStatusCode() == 302 || response.httpStatusCode() == 307) {
@@ skipping 112 matching lines @@
   if (isLoaded()) {
     c->notifyFinished(this);
     if (m_clients.contains(c)) {
       m_finishedClients.add(c);
       m_clients.remove(c);
     }
   }
 }
 
 static bool shouldSendCachedDataSynchronouslyForType(Resource::Type type) {
-  // Some resources types default to return data synchronously.
-  // For most of these, it's because there are layout tests that
-  // expect data to return synchronously in case of cache hit. In
-  // the case of fonts, there was a performance regression.
+  // Some resources types default to return data synchronously. For most of
+  // these, it's because there are layout tests that expect data to return
+  // synchronously in case of cache hit. In the case of fonts, there was a
+  // performance regression.
   // FIXME: Get to the point where we don't need to special-case sync/async
   // behavior for different resource types.
   if (type == Resource::Image)
     return true;
   if (type == Resource::CSSStyleSheet)
     return true;
   if (type == Resource::Script)
     return true;
   if (type == Resource::Font)
     return true;
@@ skipping 25 matching lines @@
 
 void Resource::addClient(ResourceClient* client,
                          PreloadReferencePolicy policy) {
   willAddClientOrObserver(policy);
 
   if (m_isRevalidating) {
     m_clients.add(client);
     return;
   }
 
-  // If we have existing data to send to the new client and the resource type supprts it, send it asynchronously.
+  // If we have existing data to send to the new client and the resource type
+  // supprts it, send it asynchronously.
   if (!m_response.isNull() &&
       !shouldSendCachedDataSynchronouslyForType(getType()) &&
       !m_needsSynchronousCacheHit) {
     m_clientsAwaitingCallback.add(client);
     ResourceCallback::callbackHandler().schedule(this);
     return;
   }
 
   m_clients.add(client);
   didAddClient(client);
@@ skipping 17 matching lines @@
   didRemoveClientOrObserver();
 }
 
 void Resource::didRemoveClientOrObserver() {
   if (!hasClientsOrObservers() && m_isAlive) {
     m_isAlive = false;
     memoryCache()->makeDead(this);
     allClientsAndObserversRemoved();
 
     // RFC2616 14.9.2:
-    // "no-store: ... MUST make a best-effort attempt to remove the information from volatile storage as promptly as possible"
-    // "... History buffers MAY store such responses as part of their normal operation."
-    // We allow non-secure content to be reused in history, but we do not allow secure content to be reused.
+    // "no-store: ... MUST make a best-effort attempt to remove the information
+    // from volatile storage as promptly as possible"
+    // "... History buffers MAY store such responses as part of their normal
+    // operation."
+    // We allow non-secure content to be reused in history, but we do not allow
+    // secure content to be reused.
     if (hasCacheControlNoStoreHeader() && url().protocolIs("https"))
       memoryCache()->remove(this);
   }
 }
 
 void Resource::allClientsAndObserversRemoved() {
   if (!m_loader)
     return;
   if (m_type == Raw)
     cancelTimerFired(&m_cancelTimer);
@@ skipping 23 matching lines @@
   m_encodedSize = encodedSize;
   memoryCache()->update(this, oldSize, size());
 }
 
 void Resource::didAccessDecodedData() {
   memoryCache()->updateDecodedResource(this, UpdateForAccess);
   memoryCache()->prune();
 }
 
 void Resource::finishPendingClients() {
-  // We're going to notify clients one by one. It is simple if the client does nothing.
-  // However there are a couple other things that can happen.
+  // We're going to notify clients one by one. It is simple if the client does
+  // nothing. However there are a couple other things that can happen.
   //
   // 1. Clients can be added during the loop. Make sure they are not processed.
-  // 2. Clients can be removed during the loop. Make sure they are always available to be
-  //    removed. Also don't call removed clients or add them back.
-
-  // Handle case (1) by saving a list of clients to notify. A separate list also ensure
-  // a client is either in m_clients or m_clientsAwaitingCallback.
+  // 2. Clients can be removed during the loop. Make sure they are always
+  //    available to be removed. Also don't call removed clients or add them
+  //    back.
+  //
+  // Handle case (1) by saving a list of clients to notify. A separate list also
+  // ensure a client is either in m_clients or m_clientsAwaitingCallback.
   HeapVector<Member<ResourceClient>> clientsToNotify;
   copyToVector(m_clientsAwaitingCallback, clientsToNotify);
 
   for (const auto& client : clientsToNotify) {
     // Handle case (2) to skip removed clients.
     if (!m_clientsAwaitingCallback.remove(client))
       continue;
     m_clients.add(client);
 
     // When revalidation starts after waiting clients are scheduled and
     // before they are added here. In such cases, we just add the clients
     // to |m_clients| without didAddClient(), as in Resource::addClient().
     if (!m_isRevalidating)
       didAddClient(client);
   }
 
-  // It is still possible for the above loop to finish a new client synchronously.
-  // If there's no client waiting we should deschedule.
+  // It is still possible for the above loop to finish a new client
+  // synchronously. If there's no client waiting we should deschedule.
   bool scheduled = ResourceCallback::callbackHandler().isScheduled(this);
   if (scheduled && m_clientsAwaitingCallback.isEmpty())
     ResourceCallback::callbackHandler().cancel(this);
 
   // Prevent the case when there are clients waiting but no callback scheduled.
   DCHECK(m_clientsAwaitingCallback.isEmpty() || scheduled);
 }
 
 void Resource::prune() {
   destroyDecodedDataIfPossible();
@@ skipping 90 matching lines @@
   SECURITY_CHECK(m_redirectChain.isEmpty());
   SECURITY_CHECK(equalIgnoringFragmentIdentifier(validatingResponse.url(),
                                                  m_response.url()));
   m_response.setResourceLoadTiming(validatingResponse.resourceLoadTiming());
 
   // RFC2616 10.3.5
   // Update cached headers from the 304 response
   const HTTPHeaderMap& newHeaders = validatingResponse.httpHeaderFields();
   for (const auto& header : newHeaders) {
     // Entity headers should not be sent by servers when generating a 304
-    // response; misconfigured servers send them anyway. We shouldn't allow
-    // such headers to update the original request. We'll base this on the
-    // list defined by RFC2616 7.1, with a few additions for extension headers
-    // we care about.
+    // response; misconfigured servers send them anyway. We shouldn't allow such
+    // headers to update the original request. We'll base this on the list
+    // defined by RFC2616 7.1, with a few additions for extension headers we
+    // care about.
     if (!shouldUpdateHeaderAfterRevalidation(header.key))
       continue;
     m_response.setHTTPHeaderField(header.key, header.value);
   }
 
   m_isRevalidating = false;
 }
 
 void Resource::revalidationFailed() {
   SECURITY_CHECK(m_redirectChain.isEmpty());
@@ skipping 137 matching lines @@
     case Resource::TextTrack:
     case Resource::Media:
     case Resource::Manifest:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace blink