Disk cache: Keep a map of all open entries....

net/disk_cache/backend_unittest.cc

 // Copyright (c) 2006-2008 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 "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
@@ skipping 39 matching lines @@
   void BackendTrimInvalidEntry();
   void BackendEnumerations();
   void BackendInvalidEntryEnumeration();
   void BackendFixEnumerators();
   void BackendDoomRecent();
   void BackendDoomBetween();
   void BackendTransaction(const std::wstring& name, int num_entries, bool load);
   void BackendRecoverInsert();
   void BackendRecoverRemove();
   void BackendInvalidEntry2();
-  void BackendNotMarkedButDirty();
+  void BackendNotMarkedButDirty(const std::wstring& name);
   void BackendDoomAll();
   void BackendDoomAll2();
   void BackendInvalidRankings();
   void BackendInvalidRankings2();
   void BackendDisable();
   void BackendDisable2();
   void BackendDisable3();
 };
 
 void DiskCacheBackendTest::BackendBasics() {
@@ skipping 896 matching lines @@
 TEST_F(DiskCacheBackendTest, InvalidEntry2) {
   BackendInvalidEntry2();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry2) {
   SetNewEviction();
   BackendInvalidEntry2();
 }
 
 // We want to be able to deal with abnormal dirty entries.
-void DiskCacheBackendTest::BackendNotMarkedButDirty() {
-  ASSERT_TRUE(CopyTestCache(L"dirty_entry"));
+void DiskCacheBackendTest::BackendNotMarkedButDirty(const std::wstring& name) {
+  ASSERT_TRUE(CopyTestCache(name));
   DisableFirstCleanup();
   InitCache();
 
   disk_cache::Entry *entry1, *entry2;
   ASSERT_TRUE(cache_->OpenEntry("the first key", &entry1));
   EXPECT_FALSE(cache_->OpenEntry("some other key", &entry2));
   entry1->Close();
 }
 
 TEST_F(DiskCacheBackendTest, NotMarkedButDirty) {
-  BackendNotMarkedButDirty();
+  BackendNotMarkedButDirty(L"dirty_entry");
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionNotMarkedButDirty) {
   SetNewEviction();
-  BackendNotMarkedButDirty();
+  BackendNotMarkedButDirty(L"dirty_entry");
+}
+
+TEST_F(DiskCacheBackendTest, NotMarkedButDirty2) {
+  BackendNotMarkedButDirty(L"dirty_entry2");
+}
+
+TEST_F(DiskCacheBackendTest, NewEvictionNotMarkedButDirty2) {
+  SetNewEviction();
+  BackendNotMarkedButDirty(L"dirty_entry2");
 }
 
 // We want to be able to deal with messed up entries on disk.
 void DiskCacheBackendTest::BackendInvalidRankings2() {
   ASSERT_TRUE(CopyTestCache(L"bad_rankings"));
   std::wstring path = GetCachePath();
   DisableFirstCleanup();
   InitCache();
 
   disk_cache::Entry *entry1, *entry2;
@@ skipping 345 matching lines @@
   EXPECT_EQ(kDefaultSize * 5 / 2,
             disk_cache::PreferedCacheSize(large_size * 100 / 2));
   EXPECT_EQ(kDefaultSize * 5 / 2,
             disk_cache::PreferedCacheSize(large_size * 500 / 2));
 
   EXPECT_EQ(kDefaultSize * 6 / 2,
             disk_cache::PreferedCacheSize(large_size * 600 / 2));
   EXPECT_EQ(kDefaultSize * 7 / 2,
             disk_cache::PreferedCacheSize(large_size * 700 / 2));
 }