Disk Cache: Don't depend on the backend being enabled to...

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 49 matching lines @@
   void BackendRecoverRemove();
   void BackendInvalidEntry2();
   void BackendNotMarkedButDirty(const std::wstring& name);
   void BackendDoomAll();
   void BackendDoomAll2();
   void BackendInvalidRankings();
   void BackendInvalidRankings2();
   void BackendDisable();
   void BackendDisable2();
   void BackendDisable3();
+  void BackendDisable4();
 };
 
 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 1237 matching lines @@
 
 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess3) {
   ASSERT_TRUE(CopyTestCache(L"bad_rankings2"));
   DisableFirstCleanup();
   SetMaxSize(20 * 1024 * 1024);
   SetNewEviction();
   InitCache();
   BackendDisable3();
 }
 
+// If we disable the cache, already open entries should work as far as possible.
+void DiskCacheBackendTest::BackendDisable4() {
+  disk_cache::Entry *entry1, *entry2, *entry3, *entry4;
+  void* iter = NULL;
+  ASSERT_TRUE(cache_->OpenNextEntry(&iter, &entry1));
+
+  char key2[2000];
+  char key3[20000];
+  CacheTestFillBuffer(key2, sizeof(key2), true);
+  CacheTestFillBuffer(key3, sizeof(key3), true);
+  key2[sizeof(key2) - 1] = '\0';
+  key3[sizeof(key3) - 1] = '\0';
+  ASSERT_TRUE(cache_->CreateEntry(key2, &entry2));
+  ASSERT_TRUE(cache_->CreateEntry(key3, &entry3));
+
+  const int kBufSize = 20000;
+  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kBufSize);
+  memset(buf->data(), 0, kBufSize);
+  EXPECT_EQ(100, entry2->WriteData(0, 0, buf, 100, NULL, false));
+  EXPECT_EQ(kBufSize, entry3->WriteData(0, 0, buf, kBufSize, NULL, false));
+
+  // This line should disable the cache but not delete it.
+  EXPECT_FALSE(cache_->OpenNextEntry(&iter, &entry4));
+  EXPECT_EQ(4, cache_->GetEntryCount());
+
+  EXPECT_FALSE(cache_->CreateEntry("cache is disabled", &entry4));
+
+  EXPECT_EQ(100, entry2->ReadData(0, 0, buf, 100, NULL));
+  EXPECT_EQ(100, entry2->WriteData(0, 0, buf, 100, NULL, false));
+  EXPECT_EQ(100, entry2->WriteData(1, 0, buf, 100, NULL, false));
+
+  EXPECT_EQ(kBufSize, entry3->ReadData(0, 0, buf, kBufSize, NULL));
+  EXPECT_EQ(kBufSize, entry3->WriteData(0, 0, buf, kBufSize, NULL, false));
+  EXPECT_EQ(kBufSize, entry3->WriteData(1, 0, buf, kBufSize, NULL, false));
+
+  std::string key = entry2->GetKey();
+  EXPECT_EQ(sizeof(key2) - 1, key.size());
+  key = entry3->GetKey();
+  EXPECT_EQ(sizeof(key3) - 1, key.size());
+
+  entry1->Close();
+  entry2->Close();
+  entry3->Close();
+  MessageLoop::current()->RunAllPending();
+
+  EXPECT_EQ(0, cache_->GetEntryCount());
+}
+
+TEST_F(DiskCacheBackendTest, DisableSuccess4) {
+  ASSERT_TRUE(CopyTestCache(L"bad_rankings"));
+  DisableFirstCleanup();
+  SetDirectMode();
+  InitCache();
+  BackendDisable4();
+}
+
+TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess4) {
+  ASSERT_TRUE(CopyTestCache(L"bad_rankings"));
+  DisableFirstCleanup();
+  SetDirectMode();
+  SetNewEviction();
+  InitCache();
+  BackendDisable4();
+}
+
 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 134 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));
 }