Avoid MemoryCache eviction of preloaded resources with devtools open

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 609 matching lines @@
           break;
         default:
           stats.other.addResource(resource);
           break;
       }
     }
   }
   return stats;
 }
 
-void MemoryCache::evictResources() {
-  while (true) {
-    ResourceMapIndex::iterator resourceMapIter = m_resourceMaps.begin();
-    if (resourceMapIter == m_resourceMaps.end())
-      break;
+void MemoryCache::evictResources(EvictResourcePolicy policy) {
+  for (auto resourceMapIter = m_resourceMaps.begin();
+       resourceMapIter != m_resourceMaps.end();) {
     ResourceMap* resources = resourceMapIter->value.get();
-    while (true) {
-      ResourceMap::iterator resourceIter = resources->begin();
-      if (resourceIter == resources->end())
-        break;
-      evict(resourceIter->value.get());
+    HeapVector<Member<MemoryCacheEntry>> unusedPreloads;
+    for (auto resourceIter = resources->begin();
+         resourceIter != resources->end();) {
+      DCHECK(resourceIter.get());
+      DCHECK(resourceIter->value.get());
+      DCHECK(resourceIter->value->resource());
+      if (policy == EvictAllResources ||
+          !(resourceIter->value->resource() &&
+            resourceIter->value->resource()->isUnusedPreload())) {
+        evict(resourceIter->value.get());
+      } else {
+        // Store unused preloads aside, so they could be added back later.
+        // That is in order to avoid the performance impact of iterating over
+        // the same resource multiple times.
+        unusedPreloads.append(resourceIter->value.get());
+        resources->remove(resourceIter);
+      }
+      resourceIter = resources->begin();

[Charlie Harrison, 2016/10/10 21:00:21]

Optional: Can this update step go into the for loop?

     }
-    m_resourceMaps.remove(resourceMapIter);
+    for (const auto& unusedPreload : unusedPreloads) {
+      KURL url =
+          removeFragmentIdentifierIfNeeded(unusedPreload->resource()->url());
+      resources->set(url, unusedPreload);
+    }
+    // We may iterate multiple times over resourceMaps with unused preloads.
+    // That's extremely unlikely to have any real-life performance impact.
+    if (!resources->size()) {
+      m_resourceMaps.remove(resourceMapIter);
+      resourceMapIter = m_resourceMaps.begin();
+    } else {
+      ++resourceMapIter;
+    }
   }
 }
 
 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.
@@ skipping 100 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