Introduce parent and child entries for MemEntryImpl...

net/disk_cache/mem_backend_impl.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/disk_cache/mem_backend_impl.h"
 
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/mem_entry_impl.h"
 
@@ skipping 109 matching lines @@
   Entry* entry;
   if (!OpenEntry(key, &entry))
     return false;
 
   entry->Doom();
   entry->Close();
   return true;
 }
 
 void MemBackendImpl::InternalDoomEntry(MemEntryImpl* entry) {
+  // Only parent entries can be passed into this method.
+  DCHECK(entry->type() == MemEntryImpl::kParentEntry);
+
   rankings_.Remove(entry);
   EntryMap::iterator it = entries_.find(entry->GetKey());
   if (it != entries_.end())
     entries_.erase(it);
   else
     NOTREACHED();
 
   entry->InternalDoom();
 }
 
@@ skipping 14 matching lines @@
   // rankings_ is ordered by last used, this will descend through the cache
   // and start dooming items before the end_time, and will stop once it reaches
   // an item used before the initial time.
   while (next) {
     MemEntryImpl* node = next;
     next = rankings_.GetNext(next);
 
     if (node->GetLastUsed() < initial_time)
       break;
 
-    if (node->GetLastUsed() < end_time) {
+    if (node->GetLastUsed() < end_time)
       node->Doom();
-    }
   }
 
   return true;
 }
 
-// We use OpenNextEntry to retrieve elements from the cache, until we get
-// entries that are too old.
 bool MemBackendImpl::DoomEntriesSince(const Time initial_time) {
   for (;;) {
-    Entry* entry;
-    void* iter = NULL;
-    if (!OpenNextEntry(&iter, &entry))
+    // Get the entry in the front.
+    Entry* entry = rankings_.GetNext(NULL);
+
+    // Break the loop when there are no more entries or the entry is too old.
+    if (!entry || entry->GetLastUsed() < initial_time)
       return true;
-
-    if (initial_time > entry->GetLastUsed()) {
-      entry->Close();
-      EndEnumeration(&iter);
-      return true;
-    }
-
     entry->Doom();
-    entry->Close();
-    EndEnumeration(&iter);  // Dooming the entry invalidates the iterator.
   }
 }
 
 bool MemBackendImpl::OpenNextEntry(void** iter, Entry** next_entry) {
   MemEntryImpl* current = reinterpret_cast<MemEntryImpl*>(*iter);
   MemEntryImpl* node = rankings_.GetNext(current);
+  // We should never return a child entry so iterate until we hit a parent
+  // entry.
+  while (node && node->type() != MemEntryImpl::kParentEntry) {
+    node = rankings_.GetNext(node);
+  }
   *next_entry = node;
   *iter = node;
 
   if (node)
     node->Open();
 
   return NULL != node;
 }
 
 void MemBackendImpl::EndEnumeration(void** iter) {
@@ skipping 38 matching lines @@
 }
 
 void MemBackendImpl::UpdateRank(MemEntryImpl* node) {
   rankings_.UpdateRank(node);
 }
 
 int MemBackendImpl::MaxFileSize() const {
   return max_size_ / 8;
 }
 
+void MemBackendImpl::InsertIntoRankingList(MemEntryImpl* entry) {
+  rankings_.Insert(entry);
+}
+
+void MemBackendImpl::RemoveFromRankingList(MemEntryImpl* entry) {
+  rankings_.Remove(entry);
+}
+
 }  // namespace disk_cache