Reflow comments in core/fetch

third_party/WebKit/Source/core/fetch/MemoryCache.h

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@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.
 
     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.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 
-    This class provides all functionality needed for loading images, style sheets and html
+    This class provides all functionality needed for loading images, style
+   sheets and html
     pages from the web. It has a memory cache for these objects.
 */
 
 #ifndef MemoryCache_h
 #define MemoryCache_h
 
 #include "core/CoreExport.h"
 #include "core/fetch/Resource.h"
 #include "platform/MemoryCacheDumpProvider.h"
 #include "platform/MemoryCoordinator.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Allocator.h"
 #include "wtf/HashMap.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class Resource;
 class KURL;
 class ExecutionContext;
 
-// This cache holds subresources used by Web pages: images, scripts, stylesheets, etc.
+// This cache holds subresources used by Web pages: images, scripts,
+// stylesheets, etc.
 
-// The cache keeps a flexible but bounded window of dead resources that grows/shrinks
-// depending on the live resource load. Here's an example of cache growth over time,
-// with a min dead resource capacity of 25% and a max dead resource capacity of 50%:
-
-//        |-----|                              Dead: -
-//        |----------|                         Live: +
-//      --|----------|                         Cache boundary: | (objects outside this mark have been evicted)
+// The cache keeps a flexible but bounded window of dead resources that
+// grows/shrinks depending on the live resource load. Here's an example of cache
+// growth over time, with a min dead resource capacity of 25% and a max dead
+// resource capacity of 50%:
+//
+// Dead: -
+// Live: +
+// Cache boundary: | (objects outside this mark have been evicted)
+//
+//        |-----|
+//        |----------|
+//      --|----------|
 //      --|----------++++++++++|
 // -------|-----+++++++++++++++|
 // -------|-----+++++++++++++++|+++++
 
 enum UpdateReason { UpdateForAccess, UpdateForPropertyChange };
 
 // MemoryCacheEntry class is used only in MemoryCache class, but we don't make
 // MemoryCacheEntry class an inner class of MemoryCache because of dependency
 // from MemoryCacheLRUList.
 class MemoryCacheEntry final : public GarbageCollected<MemoryCacheEntry> {
@@ skipping 102 matching lines @@
   HeapVector<Member<Resource>> resourcesForURL(const KURL&);
 
   void add(Resource*);
   void remove(Resource*);
   bool contains(const Resource*) const;
 
   static KURL removeFragmentIdentifierIfNeeded(const KURL& originalURL);
 
   static String defaultCacheIdentifier();
 
-  // Sets the cache's memory capacities, in bytes. These will hold only approximately,
-  // since the decoded cost of resources like scripts and stylesheets is not known.
-  //  - minDeadBytes: The maximum number of bytes that dead resources should consume when the cache is under pressure.
-  //  - maxDeadBytes: The maximum number of bytes that dead resources should consume when the cache is not under pressure.
-  //  - totalBytes: The maximum number of bytes that the cache should consume overall.
+  // Sets the cache's memory capacities, in bytes. These will hold only
+  // approximately, since the decoded cost of resources like scripts and
+  // stylesheets is not known.
+  //  - minDeadBytes: The maximum number of bytes that dead resources should
+  //  consume when the cache is under pressure.

[Yoav Weiss, 2016/10/03 08:52:20]

Indentation?

[Charlie Harrison, 2016/10/03 12:36:54]

Done.

+  //  - maxDeadBytes: The maximum number of bytes that dead resources should
+  //  consume when the cache is not under pressure.
+  //  - totalBytes: The maximum number of bytes that the cache should consume
+  //  overall.
   void setCapacities(size_t minDeadBytes,
                      size_t maxDeadBytes,
                      size_t totalBytes);
   void setDelayBeforeLiveDecodedPrune(double seconds) {
     m_delayBeforeLiveDecodedPrune = seconds;
   }
   void setMaxPruneDeferralDelay(double seconds) {
     m_maxPruneDeferralDelay = seconds;
   }
 
@@ skipping 57 matching lines @@
   bool containedInLRUList(MemoryCacheEntry*, MemoryCacheLRUList*);
 
   // Track decoded resources that are in the cache and referenced by a Web page.
   void insertInLiveDecodedResourcesList(MemoryCacheEntry*);
   void removeFromLiveDecodedResourcesList(MemoryCacheEntry*);
   bool containedInLiveDecodedResourcesList(MemoryCacheEntry*);
 
   size_t liveCapacity() const;
   size_t deadCapacity() const;
 
-  // pruneDeadResources() - Flush decoded and encoded data from resources not referenced by Web pages.
-  // pruneLiveResources() - Flush decoded data from resources still referenced by Web pages.
+  // pruneDeadResources() - Flush decoded and encoded data from resources not
+  // referenced by Web pages.
+  // pruneLiveResources() - Flush decoded data from resources still referenced
+  // by Web pages.
   void pruneDeadResources(PruneStrategy);
   void pruneLiveResources(PruneStrategy);
   void pruneNow(double currentTime, PruneStrategy);
 
   void evict(MemoryCacheEntry*);
 
   MemoryCacheEntry* getEntryForResource(const Resource*) const;
 
   static void removeURLFromCacheInternal(ExecutionContext*, const KURL&);
 
   bool m_inPruneResources;
   bool m_prunePending;
   double m_maxPruneDeferralDelay;
   double m_pruneTimeStamp;
   double m_pruneFrameTimeStamp;
-  double
-      m_lastFramePaintTimeStamp;  // used for detecting decoded resource thrash in the cache
+  double m_lastFramePaintTimeStamp;  // used for detecting decoded resource
+                                     // thrash in the cache
 
   size_t m_capacity;
   size_t m_minDeadCapacity;
   size_t m_maxDeadCapacity;
   size_t m_maxDeferredPruneDeadCapacity;
   double m_delayBeforeLiveDecodedPrune;
 
-  size_t
-      m_liveSize;  // The number of bytes currently consumed by "live" resources in the cache.
-  size_t
-      m_deadSize;  // The number of bytes currently consumed by "dead" resources in the cache.
+  // The number of bytes currently consumed by "live" resources in the cache.
+  size_t m_liveSize;
+  // The number of bytes currently consumed by "dead" resources in the cache.
+  size_t m_deadSize;
 
-  // Size-adjusted and popularity-aware LRU list collection for cache objects. This collection can hold
-  // more resources than the cached resource map, since it can also hold "stale" multiple versions of objects that are
-  // waiting to die when the clients referencing them go away.
+  // Size-adjusted and popularity-aware LRU list collection for cache objects.
+  // This collection can hold more resources than the cached resource map, since
+  // it can also hold "stale" multiple versions of objects that are waiting to
+  // die when the clients referencing them go away.
   HeapVector<MemoryCacheLRUList, 32> m_allResources;
 
-  // Lists just for live resources with decoded data. Access to this list is based off of painting the resource.
+  // Lists just for live resources with decoded data. Access to this list is
+  // based off of painting the resource.
   MemoryCacheLRUList m_liveDecodedResources;
 
-  // A URL-based map of all resources that are in the cache (including the freshest version of objects that are currently being
-  // referenced by a Web page).
-  // removeFragmentIdentifierIfNeeded() should be called for the url before using it as a key for the map.
+  // A URL-based map of all resources that are in the cache (including the
+  // freshest version of objects that are currently being referenced by a Web
+  // page). removeFragmentIdentifierIfNeeded() should be called for the url
+  // before using it as a key for the map.
   using ResourceMap = HeapHashMap<String, Member<MemoryCacheEntry>>;
   using ResourceMapIndex = HeapHashMap<String, Member<ResourceMap>>;
   ResourceMap* ensureResourceMap(const String& cacheIdentifier);
   ResourceMapIndex m_resourceMaps;
 
   friend class MemoryCacheTest;
 };
 
 // Returns the global cache.
 CORE_EXPORT MemoryCache* memoryCache();
 
 // Sets the global cache, used to swap in a test instance. Returns the old
 // MemoryCache object.
 CORE_EXPORT MemoryCache* replaceMemoryCacheForTesting(MemoryCache*);
 
 }  // namespace blink
 
 #endif