Disk cache: First pass to make it possible to have...

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 25 matching lines @@
 
 // Verifies that we can recover a transaction (insert or remove on the rankings
 // list) that is interrupted.
 int TestTransaction(const std::wstring& name, int num_entries, bool load) {
   if (!CopyTestCache(name))
     return 1;
   std::wstring path = GetCachePath();
   scoped_ptr<disk_cache::Backend> cache;
 
   if (!load) {
-    cache.reset(disk_cache::CreateCacheBackend(path, false, 0));
+    cache.reset(disk_cache::CreateCacheBackend(path, false, 0,
+                                               net::DISK_CACHE));
   } else {
     disk_cache::BackendImpl* cache2 = new disk_cache::BackendImpl(path, 0xf);
     if (!cache2 || !cache2->SetMaxSize(0x100000) || !cache2->Init())
       return 2;
     cache.reset(cache2);
   }
   if (!cache.get())
     return 2;
 
   if (num_entries + 1 != cache->GetEntryCount())
@@ skipping 723 matching lines @@
   EXPECT_EQ(0, TestTransaction(L"remove_one4", 0, false));
   EXPECT_EQ(0, TestTransaction(L"remove_head4", 1, false));
 #endif
 }
 
 // Tests dealing with cache files that cannot be recovered.
 TEST_F(DiskCacheTest, Backend_DeleteOld) {
   ASSERT_TRUE(CopyTestCache(L"wrong_version"));
   std::wstring path = GetCachePath();
   scoped_ptr<disk_cache::Backend> cache;
-  cache.reset(disk_cache::CreateCacheBackend(path, true, 0));
+  cache.reset(disk_cache::CreateCacheBackend(path, true, 0, net::DISK_CACHE));
 
   MessageLoopHelper helper;
 
   ASSERT_TRUE(NULL != cache.get());
   ASSERT_EQ(0, cache->GetEntryCount());
 
   // Wait for a callback that never comes... about 2 secs :). The message loop
   // has to run to allow destruction of the cleaner thread.
   helper.WaitUntilCacheIoFinished(1);
 }
 
 // We want to be able to deal with messed up entries on disk.
 TEST_F(DiskCacheTest, Backend_InvalidEntry) {
   ASSERT_TRUE(CopyTestCache(L"bad_entry"));
   std::wstring path = GetCachePath();
-  disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path, false, 0);
+  disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path, false, 0,
+                                                              net::DISK_CACHE);
   ASSERT_TRUE(NULL != cache);
 
   disk_cache::Entry *entry1, *entry2;
   ASSERT_TRUE(cache->OpenEntry("the first key", &entry1));
   EXPECT_FALSE(cache->OpenEntry("some other key", &entry2));
   entry1->Close();
 
   // CheckCacheIntegrity will fail at this point.
   delete cache;
 }
 
 // We want to be able to deal with messed up entries on disk.
 TEST_F(DiskCacheTest, Backend_InvalidRankings) {
   ASSERT_TRUE(CopyTestCache(L"bad_rankings"));
   std::wstring path = GetCachePath();
-  disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path, false, 0);
+  disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path, false, 0,
+                                                              net::DISK_CACHE);
   ASSERT_TRUE(NULL != cache);
 
   disk_cache::Entry *entry1, *entry2;
   EXPECT_FALSE(cache->OpenEntry("the first key", &entry1));
   ASSERT_TRUE(cache->OpenEntry("some other key", &entry2));
   entry2->Close();
 
   // CheckCacheIntegrity will fail at this point.
   delete cache;
 }
@@ skipping 152 matching lines @@
 TEST_F(DiskCacheBackendTest, DoomAll) {
   InitCache();
   BackendDoomAll();
 }
 
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAll) {
   SetMemoryOnlyMode();
   InitCache();
   BackendDoomAll();
 }