Disk cache: Reset mask_ when the disk cache is being restarted....

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 41 matching lines @@
   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 BackendDoomAll();
+  void BackendDoomAll2();
   void BackendInvalidRankings();
   void BackendInvalidRankings2();
   void BackendDisable();
   void BackendDisable2();
+  void BackendDisable3();
 };
 
 void DiskCacheBackendTest::BackendBasics() {
   InitCache();
   disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
   EXPECT_FALSE(cache_->OpenEntry("the first key", &entry1));
   ASSERT_TRUE(cache_->CreateEntry("the first key", &entry1));
   ASSERT_TRUE(NULL != entry1);
   entry1->Close();
   entry1 = NULL;
@@ skipping 1086 matching lines @@
 TEST_F(DiskCacheBackendTest, NewEvictionDisableFailure2) {
   ASSERT_TRUE(CopyTestCache(L"list_loop"));
   DisableFirstCleanup();
   SetDirectMode();
   SetNewEviction();
   InitCache();
   SetTestMode();  // Fail cache reinitialization.
   BackendDisable2();
 }
 
+// If the index size changes when we disable the cache, we should not crash.
+void DiskCacheBackendTest::BackendDisable3() {
+  disk_cache::Entry *entry1, *entry2;
+  void* iter = NULL;
+  EXPECT_EQ(2, cache_->GetEntryCount());
+  ASSERT_TRUE(cache_->OpenNextEntry(&iter, &entry1));
+  entry1->Close();
+
+  EXPECT_FALSE(cache_->OpenNextEntry(&iter, &entry2));
+  ASSERT_TRUE(cache_->CreateEntry("Something new", &entry2));
+  entry2->Close();
+
+  EXPECT_EQ(1, cache_->GetEntryCount());
+}
+
+TEST_F(DiskCacheBackendTest, DisableSuccess3) {
+  ASSERT_TRUE(CopyTestCache(L"bad_rankings2"));
+  DisableFirstCleanup();
+  SetMaxSize(20 * 1024 * 1024);
+  InitCache();
+  BackendDisable3();
+}
+
+TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess3) {
+  ASSERT_TRUE(CopyTestCache(L"bad_rankings2"));
+  DisableFirstCleanup();
+  SetMaxSize(20 * 1024 * 1024);
+  SetNewEviction();
+  InitCache();
+  BackendDisable3();
+}
+
 TEST_F(DiskCacheTest, Backend_UsageStats) {
   MessageLoopHelper helper;
 
   std::wstring path = GetCachePath();
   ASSERT_TRUE(DeleteCache(path.c_str()));
   scoped_ptr<disk_cache::BackendImpl> cache;
   cache.reset(new disk_cache::BackendImpl(path));
   ASSERT_TRUE(NULL != cache.get());
   cache->SetUnitTestMode();
   ASSERT_TRUE(cache->Init());
@@ skipping 51 matching lines @@
 TEST_F(DiskCacheBackendTest, NewEvictionDoomAll) {
   SetNewEviction();
   BackendDoomAll();
 }
 
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAll) {
   SetMemoryOnlyMode();
   BackendDoomAll();
 }
 
+// If the index size changes when we doom the cache, we should not crash.
+void DiskCacheBackendTest::BackendDoomAll2() {
+  EXPECT_EQ(2, cache_->GetEntryCount());
+  EXPECT_TRUE(cache_->DoomAllEntries());
+
+  disk_cache::Entry* entry;
+  ASSERT_TRUE(cache_->CreateEntry("Something new", &entry));
+  entry->Close();
+
+  EXPECT_EQ(1, cache_->GetEntryCount());
+}
+
+TEST_F(DiskCacheBackendTest, DoomAll2) {
+  ASSERT_TRUE(CopyTestCache(L"bad_rankings2"));
+  DisableFirstCleanup();
+  SetMaxSize(20 * 1024 * 1024);
+  InitCache();
+  BackendDoomAll2();
+}
+
+TEST_F(DiskCacheBackendTest, NewEvictionDoomAll2) {
+  ASSERT_TRUE(CopyTestCache(L"bad_rankings2"));
+  DisableFirstCleanup();
+  SetMaxSize(20 * 1024 * 1024);
+  SetNewEviction();
+  InitCache();
+  BackendDoomAll2();
+}
+
 // We should be able to create the same entry on multiple simultaneous instances
 // of the cache.
 TEST_F(DiskCacheTest, MultipleInstances) {
   ScopedTestCache store1;
   ScopedTestCache store2(L"cache_test2");
   ScopedTestCache store3(L"cache_test3");
 
   const int kNumberOfCaches = 3;
   scoped_ptr<disk_cache::Backend> cache[kNumberOfCaches];
 
@@ skipping 37 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));
 }