Reflow comments in core/fetch

third_party/WebKit/Source/core/fetch/MemoryCache.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) 2004, 2005, 2006, 2007, 2008 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.
@@ skipping 23 matching lines @@
 #include "wtf/text/CString.h"
 
 namespace blink {
 
 static Persistent<MemoryCache>* gMemoryCache;
 
 static const unsigned cDefaultCacheCapacity = 8192 * 1024;
 static const unsigned cDeferredPruneDeadCapacityFactor = 2;
 static const int cMinDelayBeforeLiveDecodedPrune = 1;  // Seconds.
 static const double cMaxPruneDeferralDelay = 0.5;      // Seconds.
-static const float cTargetPrunePercentage =
-    .95f;  // Percentage of capacity toward which we prune, to avoid immediately pruning again.
+
+// Percentage of capacity toward which we prune, to avoid immediately pruning
+// again.
+static const float cTargetPrunePercentage = .95f;
 
 MemoryCache* memoryCache() {
   DCHECK(WTF::isMainThread());
   if (!gMemoryCache)
     gMemoryCache = new Persistent<MemoryCache>(MemoryCache::create());
   return gMemoryCache->get();
 }
 
 MemoryCache* replaceMemoryCacheForTesting(MemoryCache* cache) {
   memoryCache();
@@ skipping 66 matching lines @@
   visitor->trace(m_allResources);
   visitor->trace(m_liveDecodedResources);
   visitor->trace(m_resourceMaps);
   MemoryCacheDumpClient::trace(visitor);
   MemoryCoordinatorClient::trace(visitor);
 }
 
 KURL MemoryCache::removeFragmentIdentifierIfNeeded(const KURL& originalURL) {
   if (!originalURL.hasFragmentIdentifier())
     return originalURL;
-  // Strip away fragment identifier from HTTP URLs.
-  // Data URLs must be unmodified. For file and custom URLs clients may expect resources
-  // to be unique even when they differ by the fragment identifier only.
+  // Strip away fragment identifier from HTTP URLs. Data URLs must be
+  // unmodified. For file and custom URLs clients may expect resources to be
+  // unique even when they differ by the fragment identifier only.
   if (!originalURL.protocolIsInHTTPFamily())
     return originalURL;
   KURL url = originalURL;
   url.removeFragmentIdentifier();
   return url;
 }
 
 String MemoryCache::defaultCacheIdentifier() {
   return emptyString();
 }
@@ skipping 16 matching lines @@
   CHECK(!contains(resource));
   resources->set(url, MemoryCacheEntry::create(resource));
   update(resource, 0, resource->size(), true);
 
   RESOURCE_LOADING_DVLOG(1) << "MemoryCache::add Added "
                             << resource->url().getString() << ", resource "
                             << resource;
 }
 
 void MemoryCache::remove(Resource* resource) {
-  // The resource may have already been removed by someone other than our caller,
-  // who needed a fresh copy for a reload.
+  // The resource may have already been removed by someone other than our
+  // caller, who needed a fresh copy for a reload.
   if (MemoryCacheEntry* entry = getEntryForResource(resource))
     evict(entry);
 }
 
 bool MemoryCache::contains(const Resource* resource) const {
   return getEntryForResource(resource);
 }
 
 Resource* MemoryCache::resourceForURL(const KURL& resourceURL) {
   return resourceForURL(resourceURL, defaultCacheIdentifier());
@@ skipping 24 matching lines @@
     if (MemoryCacheEntry* entry = resourceMapIter.value->get(url)) {
       Resource* resource = entry->resource();
       DCHECK(resource);
       results.append(resource);
     }
   }
   return results;
 }
 
 size_t MemoryCache::deadCapacity() const {
-  // Dead resource capacity is whatever space is not occupied by live resources, bounded by an independent minimum and maximum.
+  // Dead resource capacity is whatever space is not occupied by live resources,
+  // bounded by an independent minimum and maximum.
   size_t capacity =
       m_capacity -
       std::min(m_liveSize, m_capacity);  // Start with available capacity.
   capacity = std::max(capacity,
                       m_minDeadCapacity);  // Make sure it's above the minimum.
   capacity = std::min(capacity,
                       m_maxDeadCapacity);  // Make sure it's below the maximum.
   return capacity;
 }
 
 size_t MemoryCache::liveCapacity() const {
-  // Live resource capacity is whatever is left over after calculating dead resource capacity.
+  // Live resource capacity is whatever is left over after calculating dead
+  // resource capacity.
   return m_capacity - deadCapacity();
 }
 
 void MemoryCache::pruneLiveResources(PruneStrategy strategy) {
   DCHECK(!m_prunePending);
   size_t capacity = liveCapacity();
   if (strategy == MaximalPrune)
     capacity = 0;
   if (!m_liveSize || (capacity && m_liveSize <= capacity))
     return;
 
-  size_t targetSize = static_cast<size_t>(
-      capacity *
-      cTargetPrunePercentage);  // Cut by a percentage to avoid immediately pruning again.
+  // Cut by a percentage to avoid immediately pruning again.
+  size_t targetSize = static_cast<size_t>(capacity * cTargetPrunePercentage);
 
-  // Destroy any decoded data in live objects that we can.
-  // Start from the tail, since this is the lowest priority
-  // and least recently accessed of the objects.
+  // Destroy any decoded data in live objects that we can. Start from the tail,
+  // since this is the lowest priority and least recently accessed of the
+  // objects.
 
   // The list might not be sorted by the m_lastDecodedFrameTimeStamp. The impact
   // of this weaker invariant is minor as the below if statement to check the
   // elapsedTime will evaluate to false as the current time will be a lot
-  // greater than the current->m_lastDecodedFrameTimeStamp.
-  // For more details see: https://bugs.webkit.org/show_bug.cgi?id=30209
+  // greater than the current->m_lastDecodedFrameTimeStamp. For more details
+  // see: https://bugs.webkit.org/show_bug.cgi?id=30209
 
   MemoryCacheEntry* current = m_liveDecodedResources.m_tail;
   while (current) {
     Resource* resource = current->resource();
     MemoryCacheEntry* previous = current->m_previousInLiveResourcesList;
     DCHECK(resource->isAlive());
 
     if (resource->isLoaded() && resource->decodedSize()) {
       // Check to see if the remaining resources are too new to prune.
       double elapsedTime =
           m_pruneFrameTimeStamp - current->m_lastDecodedAccessTime;
       if (strategy == AutomaticPrune &&
           elapsedTime < m_delayBeforeLiveDecodedPrune)
         return;
 
-      // Destroy our decoded data if possible. This will remove us
-      // from m_liveDecodedResources, and possibly move us to a
-      // different LRU list in m_allResources.
+      // Destroy our decoded data if possible. This will remove us from
+      // m_liveDecodedResources, and possibly move us to a different LRU list in
+      // m_allResources.
       resource->prune();
 
       if (targetSize && m_liveSize <= targetSize)
         return;
     }
     current = previous;
   }
 }
 
 void MemoryCache::pruneDeadResources(PruneStrategy strategy) {
   size_t capacity = deadCapacity();
   if (strategy == MaximalPrune)
     capacity = 0;
   if (!m_deadSize || (capacity && m_deadSize <= capacity))
     return;
 
-  size_t targetSize = static_cast<size_t>(
-      capacity *
-      cTargetPrunePercentage);  // Cut by a percentage to avoid immediately pruning again.
+  // Cut by a percentage to avoid immediately pruning again.
+  size_t targetSize = static_cast<size_t>(capacity * cTargetPrunePercentage);
 
   int size = m_allResources.size();
   if (targetSize && m_deadSize <= targetSize)
     return;
 
   bool canShrinkLRULists = true;
   for (int i = size - 1; i >= 0; i--) {
-    // Remove from the tail, since this is the least frequently accessed of the objects.
+    // Remove from the tail, since this is the least frequently accessed of the
+    // objects.
     MemoryCacheEntry* current = m_allResources[i].m_tail;
 
     // First flush all the decoded data in this queue.
     while (current) {
       Resource* resource = current->resource();
       MemoryCacheEntry* previous = current->m_previousInAllResourcesList;
 
-      // Decoded data may reference other resources. Skip |current| if
-      // |current| somehow got kicked out of cache during
-      // destroyDecodedData().
+      // Decoded data may reference other resources. Skip |current| if |current|
+      // somehow got kicked out of cache during destroyDecodedData().
       if (!resource || !contains(resource)) {
         current = previous;
         continue;
       }
 
       if (!resource->isAlive() && !resource->isPreloaded() &&
           resource->isLoaded()) {
         // Destroy our decoded data. This will remove us from
-        // m_liveDecodedResources, and possibly move us to a different
-        // LRU list in m_allResources.
+        // m_liveDecodedResources, and possibly move us to a different LRU list
+        // in m_allResources.
         resource->prune();
 
         if (targetSize && m_deadSize <= targetSize)
           return;
       }
       current = previous;
     }
 
     // Now evict objects from this queue.
     current = m_allResources[i].m_tail;
     while (current) {
       Resource* resource = current->resource();
       MemoryCacheEntry* previous = current->m_previousInAllResourcesList;
       if (!resource || !contains(resource)) {
         current = previous;
         continue;
       }
       if (!resource->isAlive() && !resource->isPreloaded()) {
         evict(current);
         if (targetSize && m_deadSize <= targetSize)
           return;
       }
       current = previous;
     }
 
-    // Shrink the vector back down so we don't waste time inspecting
-    // empty LRU lists on future prunes.
+    // Shrink the vector back down so we don't waste time inspecting empty LRU
+    // lists on future prunes.
     if (m_allResources[i].m_head)
       canShrinkLRULists = false;
     else if (canShrinkLRULists)
       m_allResources.resize(i);
   }
 }
 
 void MemoryCache::setCapacities(size_t minDeadBytes,
                                 size_t maxDeadBytes,
                                 size_t totalBytes) {
   DCHECK_LE(minDeadBytes, maxDeadBytes);
   DCHECK_LE(maxDeadBytes, totalBytes);
   m_minDeadCapacity = minDeadBytes;
   m_maxDeadCapacity = maxDeadBytes;
   m_maxDeferredPruneDeadCapacity =
       cDeferredPruneDeadCapacityFactor * maxDeadBytes;
   m_capacity = totalBytes;
   prune();
 }
 
 void MemoryCache::evict(MemoryCacheEntry* entry) {
   DCHECK(WTF::isMainThread());
 
   Resource* resource = entry->resource();
   DCHECK(resource);
   RESOURCE_LOADING_DVLOG(1) << "Evicting resource " << resource << " for "
                             << resource->url().getString() << " from cache";
   TRACE_EVENT1("blink", "MemoryCache::evict", "resource",
                resource->url().getString().utf8());
-  // The resource may have already been removed by someone other than our caller,
-  // who needed a fresh copy for a reload. See <http://bugs.webkit.org/show_bug.cgi?id=12479#c6>.
+  // The resource may have already been removed by someone other than our
+  // caller, who needed a fresh copy for a reload. See
+  // <http://bugs.webkit.org/show_bug.cgi?id=12479#c6>.
   update(resource, resource->size(), 0, false);
   removeFromLiveDecodedResourcesList(entry);
 
   ResourceMap* resources = m_resourceMaps.get(resource->cacheIdentifier());
   DCHECK(resources);
   KURL url = removeFragmentIdentifierIfNeeded(resource->url());
   ResourceMap::iterator it = resources->find(url);
   DCHECK_NE(it, resources->end());
 
   MemoryCacheEntry* entryPtr = it->value;
@@ skipping 147 matching lines @@
 }
 
 void MemoryCache::update(Resource* resource,
                          size_t oldSize,
                          size_t newSize,
                          bool wasAccessed) {
   MemoryCacheEntry* entry = getEntryForResource(resource);
   if (!entry)
     return;
 
-  // The object must now be moved to a different queue, since either its size or its accessCount has been changed,
-  // and both of those are used to determine which LRU queue the resource should be in.
+  // The object must now be moved to a different queue, since either its size or
+  // its accessCount has been changed, and both of those are used to determine
+  // which LRU queue the resource should be in.
   if (oldSize)
     removeFromLRUList(entry, lruListFor(entry->m_accessCount, oldSize));
   if (wasAccessed)
     entry->m_accessCount++;
   if (newSize)
     insertInLRUList(entry, lruListFor(entry->m_accessCount, newSize));
 
   ptrdiff_t delta = newSize - oldSize;
   if (resource->isAlive()) {
     DCHECK(delta >= 0 || m_liveSize >= static_cast<size_t>(-delta));
@@ skipping 89 matching lines @@
 
 void MemoryCache::prune() {
   TRACE_EVENT0("renderer", "MemoryCache::prune()");
 
   if (m_inPruneResources)
     return;
   if (m_liveSize + m_deadSize <= m_capacity && m_maxDeadCapacity &&
       m_deadSize <= m_maxDeadCapacity)  // Fast path.
     return;
 
-  // To avoid burdening the current thread with repetitive pruning jobs,
-  // pruning is postponed until the end of the current task. If it has
-  // been more than m_maxPruneDeferralDelay since the last prune,
-  // then we prune immediately.
-  // If the current thread's run loop is not active, then pruning will happen
-  // immediately only if it has been over m_maxPruneDeferralDelay
-  // since the last prune.
+  // To avoid burdening the current thread with repetitive pruning jobs, pruning
+  // is postponed until the end of the current task. If it has been more than
+  // m_maxPruneDeferralDelay since the last prune, then we prune immediately. If
+  // the current thread's run loop is not active, then pruning will happen
+  // immediately only if it has been over m_maxPruneDeferralDelay since the last
+  // prune.
   double currentTime = WTF::currentTime();
   if (m_prunePending) {
     if (currentTime - m_pruneTimeStamp >= m_maxPruneDeferralDelay) {
       pruneNow(currentTime, AutomaticPrune);
     }
   } else {
     if (currentTime - m_pruneTimeStamp >= m_maxPruneDeferralDelay) {
       pruneNow(currentTime, AutomaticPrune);  // Delay exceeded, prune now.
     } else {
       // Defer.
@@ skipping 16 matching lines @@
   pruneNow(currentTime, MaximalPrune);
 }
 
 void MemoryCache::pruneNow(double currentTime, PruneStrategy strategy) {
   if (m_prunePending) {
     m_prunePending = false;
     Platform::current()->currentThread()->removeTaskObserver(this);
   }
 
   AutoReset<bool> reentrancyProtector(&m_inPruneResources, true);
-  pruneDeadResources(
-      strategy);  // Prune dead first, in case it was "borrowing" capacity from live.
+
+  // Prune dead first, in case it was "borrowing" capacity from live.
+  pruneDeadResources(strategy);
   pruneLiveResources(strategy);
   m_pruneFrameTimeStamp = m_lastFramePaintTimeStamp;
   m_pruneTimeStamp = currentTime;
 }
 
 void MemoryCache::updateFramePaintTimestamp() {
   m_lastFramePaintTimeStamp = currentTime();
 }
 
 bool MemoryCache::onMemoryDump(WebMemoryDumpLevelOfDetail levelOfDetail,
@@ skipping 43 matching lines @@
 bool MemoryCache::isInSameLRUListForTest(const Resource* x, const Resource* y) {
   MemoryCacheEntry* ex = getEntryForResource(x);
   MemoryCacheEntry* ey = getEntryForResource(y);
   DCHECK(ex);
   DCHECK(ey);
   return lruListFor(ex->m_accessCount, x->size()) ==
          lruListFor(ey->m_accessCount, y->size());
 }
 
 }  // namespace blink