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());
+    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() ||

[Charlie Harrison, 2016/10/03 21:48:21]

Optional nit: I think !(resourceIter->value->resource() &&
resourceIter->value->resource()->isUnusedPreload()) is clearer as an explicit
null check.

+          !resourceIter->value->resource()->isUnusedPreload()) {
+        evict(resourceIter->value.get());
+        resourceIter = resources->begin();

[Charlie Harrison, 2016/10/03 21:48:21]

Hm... If we have N unused preloads, and then M regular resources, wouldn't this
loop have N * M iterations? I wonder if we can do something smarter about
incrementing the iterator so it doesn't just go back to the beginning. 

 Can we increment the iterator before we evict the resource? I don't think
iterators to other elements in a map are invalidated on erasure for STL maps,
but I'm not sure about WTF.

+      } else {
+        ++resourceIter;
+      }
     }
-    m_resourceMaps.remove(resourceMapIter);
+    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