Initialize the simple cache backend at runtime.

net/disk_cache/backend_unittest.cc

 // Copyright (c) 2012 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/string_util.h"
 #include "base/stringprintf.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
@@ skipping 199 matching lines @@
 
 TEST_F(DiskCacheTest, CreateBackend) {
   net::TestCompletionCallback cb;
 
   {
     ASSERT_TRUE(CleanupCacheDir());
     base::Thread cache_thread("CacheThread");
     ASSERT_TRUE(cache_thread.StartWithOptions(
                     base::Thread::Options(MessageLoop::TYPE_IO, 0)));
 
-    // Test the private factory methods.
+    // Test the private factory method(s).
     disk_cache::Backend* cache = NULL;
-    int rv = disk_cache::BackendImpl::CreateBackend(
-        cache_path_, false, 0, net::DISK_CACHE, disk_cache::kNoRandom,
-        cache_thread.message_loop_proxy(), NULL, &cache, cb.callback());
-    ASSERT_EQ(net::OK, cb.GetResult(rv));
-    ASSERT_TRUE(cache);
-    delete cache;
-
     cache = disk_cache::MemBackendImpl::CreateBackend(0, NULL);
     ASSERT_TRUE(cache);
     delete cache;
     cache = NULL;
 
     // Now test the public API.
-    rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, cache_path_, 0, false,
-                                        cache_thread.message_loop_proxy(),
-                                        NULL, &cache, cb.callback());
+    int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, cache_path_, 0,
+                                            false,
+                                            cache_thread.message_loop_proxy(),
+                                            NULL, &cache, cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     ASSERT_TRUE(cache);
     delete cache;
     cache = NULL;
 
     rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE, base::FilePath(), 0,
                                         false, NULL, NULL, &cache,
                                         cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     ASSERT_TRUE(cache);
     delete cache;
   }
 
   MessageLoop::current()->RunUntilIdle();
 }
 
 // Testst that re-creating the cache performs the expected cleanup.
 TEST_F(DiskCacheBackendTest, CreateBackend_MissingFile) {
   ASSERT_TRUE(CopyTestCache("bad_entry"));
   base::FilePath filename = cache_path_.AppendASCII("data_1");
   file_util::Delete(filename, false);
   DisableFirstCleanup();
   SetForceCreation();
 
   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
-  InitCache();
+  InitDefaultCacheViaCreator();
   base::ThreadRestrictions::SetIOAllowed(prev);
 }
 
 TEST_F(DiskCacheBackendTest, ExternalFiles) {
   InitCache();
   // First, let's create a file on the folder.
   base::FilePath filename = cache_path_.AppendASCII("f_000001");
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
@@ skipping 16 matching lines @@
 void DiskCacheBackendTest::BackendShutdownWithPendingFileIO(bool fast) {
   net::TestCompletionCallback cb;
   int rv;
 
   {
     ASSERT_TRUE(CleanupCacheDir());
     base::Thread cache_thread("CacheThread");
     ASSERT_TRUE(cache_thread.StartWithOptions(
                     base::Thread::Options(MessageLoop::TYPE_IO, 0)));
 
-    disk_cache::Backend* cache;
     uint32 flags = disk_cache::kNoBuffering;
     if (!fast)
       flags |= disk_cache::kNoRandom;
-    rv = disk_cache::BackendImpl::CreateBackend(
-             cache_path_, false, 0, net::DISK_CACHE, flags,
-             base::MessageLoopProxy::current(), NULL,
-             &cache, cb.callback());
-    ASSERT_EQ(net::OK, cb.GetResult(rv));
+
+    UseCurrentThread();
+    CreateBackend(flags, NULL);
 
     disk_cache::EntryImpl* entry;
-    rv = cache->CreateEntry(
+    rv = cache_->CreateEntry(
         "some key", reinterpret_cast<disk_cache::Entry**>(&entry),
         cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
 
     const int kSize = 25000;
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
     CacheTestFillBuffer(buffer->data(), kSize, false);
 
     for (int i = 0; i < 10 * 1024 * 1024; i += 64 * 1024) {
       // We are using the current thread as the cache thread because we want to
       // be able to call directly this method to make sure that the OS (instead
       // of us switching thread) is returning IO pending.
       rv = entry->WriteDataImpl(0, i, buffer, kSize, cb.callback(), false);
       if (rv == net::ERR_IO_PENDING)
         break;
       EXPECT_EQ(kSize, rv);
     }
 
     // Don't call Close() to avoid going through the queue or we'll deadlock
     // waiting for the operation to finish.
     entry->Release();
 
     // The cache destructor will see one pending operation here.
-    delete cache;
+    delete cache_;
+    // Prevent the TearDown() to delete the backend again.
+    cache_ = NULL;
 
     if (rv == net::ERR_IO_PENDING) {
       if (fast)
         EXPECT_FALSE(cb.have_result());
       else
         EXPECT_TRUE(cb.have_result());
     }
   }
 
   MessageLoop::current()->RunUntilIdle();
@@ skipping 22 matching lines @@
 // Tests that we deal with background-thread pending operations.
 void DiskCacheBackendTest::BackendShutdownWithPendingIO(bool fast) {
   net::TestCompletionCallback cb;
 
   {
     ASSERT_TRUE(CleanupCacheDir());
     base::Thread cache_thread("CacheThread");
     ASSERT_TRUE(cache_thread.StartWithOptions(
                     base::Thread::Options(MessageLoop::TYPE_IO, 0)));
 
-    disk_cache::Backend* cache;
     uint32 flags = disk_cache::kNoBuffering;
     if (!fast)
       flags |= disk_cache::kNoRandom;
-    int rv = disk_cache::BackendImpl::CreateBackend(
-        cache_path_, false, 0, net::DISK_CACHE, flags,
-        cache_thread.message_loop_proxy(), NULL, &cache, cb.callback());
-    ASSERT_EQ(net::OK, cb.GetResult(rv));
+
+    CreateBackend(flags, &cache_thread);
 
     disk_cache::Entry* entry;
-    rv = cache->CreateEntry("some key", &entry, cb.callback());
+    int rv = cache_->CreateEntry("some key", &entry, cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
 
     entry->Close();
 
     // The cache destructor will see one pending operation here.
-    delete cache;
+    delete cache_;
+    // Prevent the TearDown() to delete the backend again.
+    cache_ = NULL;
   }
 
   MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingIO) {
   BackendShutdownWithPendingIO(false);
 }
 
 // We'll be leaking from this test.
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingIO_Fast) {
   // The integrity test sets kNoRandom so there's a version mismatch if we don't
   // force new eviction.
   SetNewEviction();
   BackendShutdownWithPendingIO(true);
 }
 
 // Tests that we deal with create-type pending operations.
 void DiskCacheBackendTest::BackendShutdownWithPendingCreate(bool fast) {
   net::TestCompletionCallback cb;
 
   {
     ASSERT_TRUE(CleanupCacheDir());
     base::Thread cache_thread("CacheThread");
     ASSERT_TRUE(cache_thread.StartWithOptions(
                     base::Thread::Options(MessageLoop::TYPE_IO, 0)));
 
-    disk_cache::Backend* cache;
     disk_cache::BackendFlags flags =
       fast ? disk_cache::kNone : disk_cache::kNoRandom;
-    int rv = disk_cache::BackendImpl::CreateBackend(
-        cache_path_, false, 0, net::DISK_CACHE, flags,
-        cache_thread.message_loop_proxy(), NULL, &cache, cb.callback());
-    ASSERT_EQ(net::OK, cb.GetResult(rv));
+    CreateBackend(flags, &cache_thread);
 
     disk_cache::Entry* entry;
-    rv = cache->CreateEntry("some key", &entry, cb.callback());
+    int rv = cache_->CreateEntry("some key", &entry, cb.callback());
     ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
-    delete cache;
+    delete cache_;
+    // Prevent the TearDown() to delete the backend again.
+    cache_ = NULL;
     EXPECT_FALSE(cb.have_result());
   }
 
   MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate) {
   BackendShutdownWithPendingCreate(false);
 }
 
 // We'll be leaking an entry from this test.
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate_Fast) {
   // The integrity test sets kNoRandom so there's a version mismatch if we don't
   // force new eviction.
   SetNewEviction();
   BackendShutdownWithPendingCreate(true);
 }
 
 TEST_F(DiskCacheTest, TruncatedIndex) {
   ASSERT_TRUE(CleanupCacheDir());
   base::FilePath index = cache_path_.AppendASCII("index");
   ASSERT_EQ(5, file_util::WriteFile(index, "hello", 5));
 
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
                   base::Thread::Options(MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
   disk_cache::Backend* backend = NULL;
-  int rv = disk_cache::BackendImpl::CreateBackend(
-      cache_path_, false, 0, net::DISK_CACHE, disk_cache::kNone,
+  int rv = disk_cache::CreateCacheBackend(
+      net::DISK_CACHE, cache_path_, 0, false,
       cache_thread.message_loop_proxy(), NULL, &backend, cb.callback());
   ASSERT_NE(net::OK, cb.GetResult(rv));
 
   ASSERT_TRUE(backend == NULL);
   delete backend;
 }
 
 void DiskCacheBackendTest::BackendSetSize() {
-  SetDirectMode();
   const int cache_size = 0x10000;  // 64 kB
   SetMaxSize(cache_size);
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(cache_size));
@@ skipping 152 matching lines @@
   BackendChain();
 }
 
 TEST_F(DiskCacheBackendTest, ShaderCacheChain) {
   SetCacheType(net::SHADER_CACHE);
   BackendChain();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionTrim) {
   SetNewEviction();
-  SetDirectMode();
   InitCache();
 
   disk_cache::Entry* entry;
   for (int i = 0; i < 100; i++) {
     std::string name(base::StringPrintf("Key %d", i));
     ASSERT_EQ(net::OK, CreateEntry(name, &entry));
     entry->Close();
     if (i < 90) {
       // Entries 0 to 89 are in list 1; 90 to 99 are in list 0.
       ASSERT_EQ(net::OK, OpenEntry(name, &entry));
@@ skipping 10 matching lines @@
 
   // Double check that we still have the list tails.
   ASSERT_EQ(net::OK, OpenEntry("Key 1", &entry));
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry("Key 91", &entry));
   entry->Close();
 }
 
 // Before looking for invalid entries, let's check a valid entry.
 void DiskCacheBackendTest::BackendValidEntry() {
-  SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
@@ skipping 16 matching lines @@
 
 TEST_F(DiskCacheBackendTest, NewEvictionValidEntry) {
   SetNewEviction();
   BackendValidEntry();
 }
 
 // The same logic of the previous test (ValidEntry), but this time force the
 // entry to be invalid, simulating a crash in the middle.
 // We'll be leaking memory from this test.
 void DiskCacheBackendTest::BackendInvalidEntry() {
-  // Use the implementation directly... we need to simulate a crash.
-  SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   memset(buffer->data(), 0, kSize);
   base::strlcpy(buffer->data(), "And the data to save", kSize);
@@ skipping 27 matching lines @@
 
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntry) {
   SetCacheType(net::SHADER_CACHE);
   BackendInvalidEntry();
 }
 
 // Almost the same test, but this time crash the cache after reading an entry.
 // We'll be leaking memory from this test.
 void DiskCacheBackendTest::BackendInvalidEntryRead() {
-  // Use the implementation directly... we need to simulate a crash.
-  SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   memset(buffer->data(), 0, kSize);
   base::strlcpy(buffer->data(), "And the data to save", kSize);
@@ skipping 105 matching lines @@
 }
 
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntryWithLoad) {
   SetCacheType(net::SHADER_CACHE);
   BackendInvalidEntryWithLoad();
 }
 
 // We'll be leaking memory from this test.
 void DiskCacheBackendTest::BackendTrimInvalidEntry() {
-  // Use the implementation directly... we need to simulate a crash.
-  SetDirectMode();
-
   const int kSize = 0x3000;  // 12 kB
   SetMaxSize(kSize * 10);
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
@@ skipping 32 matching lines @@
 }
 
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry) {
   SetNewEviction();
   BackendTrimInvalidEntry();
 }
 
 // We'll be leaking memory from this test.
 void DiskCacheBackendTest::BackendTrimInvalidEntry2() {
-  // Use the implementation directly... we need to simulate a crash.
-  SetDirectMode();
   SetMask(0xf);  // 16-entry table.
 
   const int kSize = 0x3000;  // 12 kB
   SetMaxSize(kSize * 40);
   InitCache();
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   memset(buffer->data(), 0, kSize);
   disk_cache::Entry* entry;
 
@@ skipping 221 matching lines @@
   void* iter = NULL;
   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
   EXPECT_EQ(entry2->GetKey(), second);
   entry2->Close();
   cache_->EndEnumeration(&iter);
 }
 
 // Verify handling of invalid entries while doing enumerations.
 // We'll be leaking memory from this test.
 void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
-  // Use the implementation directly... we need to simulate a crash.
-  SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry *entry, *entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
@@ skipping 338 matching lines @@
 
 TEST_F(DiskCacheBackendTest, RecoverWithEviction) {
   BackendRecoverWithEviction();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionRecoverWithEviction) {
   SetNewEviction();
   BackendRecoverWithEviction();
 }
 
-// Tests dealing with cache files that cannot be recovered.
-TEST_F(DiskCacheTest, DeleteOld) {
+// Tests that the |BackendImpl| fails to start with the wrong cache version.
+TEST_F(DiskCacheTest, WrongVersion) {
   ASSERT_TRUE(CopyTestCache("wrong_version"));
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
                   base::Thread::Options(MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
-  disk_cache::Backend* cache;
-  int rv = disk_cache::BackendImpl::CreateBackend(
-               cache_path_, true, 0, net::DISK_CACHE, disk_cache::kNoRandom,
-               cache_thread.message_loop_proxy(), NULL, &cache, cb.callback());
-  ASSERT_EQ(net::OK, cb.GetResult(rv));
-
-  MessageLoopHelper helper;
-
-  ASSERT_TRUE(NULL != cache);
-  ASSERT_EQ(0, cache->GetEntryCount());
+  disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
+      cache_path_, cache_thread.message_loop_proxy(), NULL);
+  int rv = cache->Init(cb.callback());
+  ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
 
   delete cache;
 }
 
+// Tests that the cache is properly restarted on recovery error.
+TEST_F(DiskCacheBackendTest, DeleteOld) {
+  ASSERT_TRUE(CopyTestCache("wrong_version"));
+  InitDefaultCacheViaCreator();
+}
+
 // We want to be able to deal with messed up entries on disk.
 void DiskCacheBackendTest::BackendInvalidEntry2() {
   ASSERT_TRUE(CopyTestCache("bad_entry"));
   DisableFirstCleanup();
   InitCache();
 
   disk_cache::Entry *entry1, *entry2;
   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
   EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
   entry1->Close();
@@ skipping 131 matching lines @@
   FlushQueueForTest();
   entry->Close();
 
   ASSERT_EQ(net::OK, OpenEntry("some other key", &entry));
   entry->Close();
 }
 
 // Tests handling of corrupt entries by keeping the rankings node around, with
 // a fatal failure.
 void DiskCacheBackendTest::BackendInvalidEntry7() {
-  SetDirectMode();
   const int kSize = 0x3000;  // 12 kB.
   SetMaxSize(kSize * 10);
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
   entry->Close();
   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
@@ skipping 24 matching lines @@
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry7) {
   SetNewEviction();
   BackendInvalidEntry7();
 }
 
 // Tests handling of corrupt entries by keeping the rankings node around, with
 // a non fatal failure.
 void DiskCacheBackendTest::BackendInvalidEntry8() {
-  SetDirectMode();
   const int kSize = 0x3000;  // 12 kB
   SetMaxSize(kSize * 10);
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
   entry->Close();
   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
@@ skipping 27 matching lines @@
 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry8) {
   SetNewEviction();
   BackendInvalidEntry8();
 }
 
 // Tests handling of corrupt entries detected by enumerations. Note that these
 // tests (xx9 to xx11) are basically just going though slightly different
 // codepaths so they are tighlty coupled with the code, but that is better than
 // not testing error handling code.
 void DiskCacheBackendTest::BackendInvalidEntry9(bool eviction) {
-  SetDirectMode();
   const int kSize = 0x3000;  // 12 kB.
   SetMaxSize(kSize * 10);
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
   entry->Close();
   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
@@ skipping 44 matching lines @@
   BackendInvalidEntry9(true);
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry9) {
   SetNewEviction();
   BackendInvalidEntry9(true);
 }
 
 // Tests handling of corrupt entries detected by enumerations.
 void DiskCacheBackendTest::BackendInvalidEntry10(bool eviction) {
-  SetDirectMode();
   const int kSize = 0x3000;  // 12 kB.
   SetMaxSize(kSize * 10);
   SetNewEviction();
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
   entry->Close();
@@ skipping 43 matching lines @@
 TEST_F(DiskCacheBackendTest, InvalidEntry10) {
   BackendInvalidEntry10(false);
 }
 
 TEST_F(DiskCacheBackendTest, TrimInvalidEntry10) {
   BackendInvalidEntry10(true);
 }
 
 // Tests handling of corrupt entries detected by enumerations.
 void DiskCacheBackendTest::BackendInvalidEntry11(bool eviction) {
-  SetDirectMode();
   const int kSize = 0x3000;  // 12 kB.
   SetMaxSize(kSize * 10);
   SetNewEviction();
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
   entry->Close();
@@ skipping 51 matching lines @@
 TEST_F(DiskCacheBackendTest, InvalidEntry11) {
   BackendInvalidEntry11(false);
 }
 
 TEST_F(DiskCacheBackendTest, TrimInvalidEntry11) {
   BackendInvalidEntry11(true);
 }
 
 // Tests handling of corrupt entries in the middle of a long eviction run.
 void DiskCacheBackendTest::BackendTrimInvalidEntry12() {
-  SetDirectMode();
   const int kSize = 0x3000;  // 12 kB
   SetMaxSize(kSize * 10);
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
   entry->Close();
   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
@@ skipping 56 matching lines @@
   EXPECT_EQ(2, cache_->GetEntryCount());
 
   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
   FlushQueueForTest();  // Allow the restart to finish.
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheBackendTest, InvalidRankingsSuccess) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   InitCache();
   BackendInvalidRankings();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankingsSuccess) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   SetNewEviction();
   InitCache();
   BackendInvalidRankings();
 }
 
 TEST_F(DiskCacheBackendTest, InvalidRankingsFailure) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   InitCache();
   SetTestMode();  // Fail cache reinitialization.
   BackendInvalidRankings();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankingsFailure) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   SetNewEviction();
   InitCache();
   SetTestMode();  // Fail cache reinitialization.
   BackendInvalidRankings();
 }
 
 // If the LRU is corrupt and we have open entries, we disable the cache.
 void DiskCacheBackendTest::BackendDisable() {
   disk_cache::Entry *entry1, *entry2;
   void* iter = NULL;
   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
 
   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry2));
   EXPECT_EQ(0, cache_->GetEntryCount());
   EXPECT_NE(net::OK, CreateEntry("Something new", &entry2));
 
   entry1->Close();
   FlushQueueForTest();  // Flushing the Close posts a task to restart the cache.
   FlushQueueForTest();  // This one actually allows that task to complete.
 
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheBackendTest, DisableSuccess) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   InitCache();
   BackendDisable();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   SetNewEviction();
   InitCache();
   BackendDisable();
 }
 
 TEST_F(DiskCacheBackendTest, DisableFailure) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   InitCache();
   SetTestMode();  // Fail cache reinitialization.
   BackendDisable();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionDisableFailure) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   SetNewEviction();
   InitCache();
   SetTestMode();  // Fail cache reinitialization.
   BackendDisable();
 }
 
 // This is another type of corruption on the LRU; disable the cache.
 void DiskCacheBackendTest::BackendDisable2() {
   EXPECT_EQ(8, cache_->GetEntryCount());
 
   disk_cache::Entry* entry;
   void* iter = NULL;
   int count = 0;
   while (OpenNextEntry(&iter, &entry) == net::OK) {
     ASSERT_TRUE(NULL != entry);
     entry->Close();
     count++;
     ASSERT_LT(count, 9);
   };
 
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheBackendTest, DisableSuccess2) {
   ASSERT_TRUE(CopyTestCache("list_loop"));
   DisableFirstCleanup();
-  SetDirectMode();
   InitCache();
   BackendDisable2();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess2) {
   ASSERT_TRUE(CopyTestCache("list_loop"));
   DisableFirstCleanup();
   SetNewEviction();
-  SetDirectMode();
   InitCache();
   BackendDisable2();
 }
 
 TEST_F(DiskCacheBackendTest, DisableFailure2) {
   ASSERT_TRUE(CopyTestCache("list_loop"));
   DisableFirstCleanup();
-  SetDirectMode();
   InitCache();
   SetTestMode();  // Fail cache reinitialization.
   BackendDisable2();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionDisableFailure2) {
   ASSERT_TRUE(CopyTestCache("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;
@@ skipping 72 matching lines @@
   entry3->Close();
   FlushQueueForTest();  // Flushing the Close posts a task to restart the cache.
   FlushQueueForTest();  // This one actually allows that task to complete.
 
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheBackendTest, DisableSuccess4) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   InitCache();
   BackendDisable4();
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess4) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
-  SetDirectMode();
   SetNewEviction();
   InitCache();
   BackendDisable4();
 }
 
 TEST_F(DiskCacheTest, Backend_UsageStats) {
   MessageLoopHelper helper;
 
   ASSERT_TRUE(CleanupCacheDir());
   scoped_ptr<disk_cache::BackendImpl> cache;
@@ skipping 115 matching lines @@
   ASSERT_TRUE(store2.CreateUniqueTempDir());
 
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
   const int kNumberOfCaches = 2;
   disk_cache::Backend* cache[kNumberOfCaches];
 
-  int rv = disk_cache::BackendImpl::CreateBackend(
-      store1.path(), false, 0, net::DISK_CACHE, disk_cache::kNone,
+  int rv = disk_cache::CreateCacheBackend(
+      net::DISK_CACHE, store1.path(), 0, false,
       cache_thread.message_loop_proxy(), NULL, &cache[0], cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
-  rv = disk_cache::BackendImpl::CreateBackend(
-      store2.path(), false, 0, net::MEDIA_CACHE, disk_cache::kNone,
+  rv = disk_cache::CreateCacheBackend(
+      net::MEDIA_CACHE, store2.path(), 0, false,
       cache_thread.message_loop_proxy(), NULL, &cache[1], cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
 
   ASSERT_TRUE(cache[0] != NULL && cache[1] != NULL);
 
   std::string key("the first key");
   disk_cache::Entry* entry;
   for (int i = 0; i < kNumberOfCaches; i++) {
     rv = cache[i]->CreateEntry(key, &entry, cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
@@ skipping 48 matching lines @@
   // Region 6: expected = kint32max
   EXPECT_EQ(kint32max,
             disk_cache::PreferedCacheSize(largest_size * 100));
   EXPECT_EQ(kint32max,
             disk_cache::PreferedCacheSize(largest_size * 10000));
 }
 
 // Tests that we can "migrate" a running instance from one experiment group to
 // another.
 TEST_F(DiskCacheBackendTest, Histograms) {
-  SetDirectMode();
   InitCache();
   disk_cache::BackendImpl* backend_ = cache_impl_;  // Needed be the macro.
 
   for (int i = 1; i < 3; i++) {
     CACHE_UMA(HOURS, "FillupTime", i, 28);
   }
 }
 
 // Make sure that we keep the total memory used by the internal buffers under
 // control.
 TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
-  SetDirectMode();
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 200;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, true);
 
   for (int i = 0; i < 10; i++) {
@@ skipping 12 matching lines @@
     entry->Close();
     ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   }
 
   entry->Close();
   EXPECT_EQ(0, cache_impl_->GetTotalBuffersSize());
 }
 
 // This test assumes at least 150MB of system memory.
 TEST_F(DiskCacheBackendTest, TotalBuffersSize2) {
-  SetDirectMode();
   InitCache();
 
   const int kOneMB = 1024 * 1024;
   EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
   EXPECT_EQ(kOneMB, cache_impl_->GetTotalBuffersSize());
 
   EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
   EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
 
   EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
   EXPECT_EQ(kOneMB * 3, cache_impl_->GetTotalBuffersSize());
 
   cache_impl_->BufferDeleted(kOneMB);
   EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
 
   // Check the upper limit.
   EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, 30 * kOneMB));
 
   for (int i = 0; i < 30; i++)
     cache_impl_->IsAllocAllowed(0, kOneMB);  // Ignore the result.
 
   EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, kOneMB));
 }
 
 // Tests that sharing of external files works and we are able to delete the
 // files when we need to.
 TEST_F(DiskCacheBackendTest, FileSharing) {
-  SetDirectMode();
   InitCache();
 
   disk_cache::Addr address(0x80000001);
   ASSERT_TRUE(cache_impl_->CreateExternalFile(&address));
   base::FilePath name = cache_impl_->GetFileName(address);
 
   scoped_refptr<disk_cache::File> file(new disk_cache::File(false));
   file->Init(name);
 
 #if defined(OS_WIN)
@@ skipping 18 matching lines @@
   memset(buffer1, 't', kSize);
   memset(buffer2, 0, kSize);
   EXPECT_TRUE(file->Write(buffer1, kSize, 0));
   EXPECT_TRUE(file->Read(buffer2, kSize, 0));
   EXPECT_EQ(0, memcmp(buffer1, buffer2, kSize));
 
   EXPECT_TRUE(disk_cache::DeleteCacheFile(name));
 }
 
 TEST_F(DiskCacheBackendTest, UpdateRankForExternalCacheHit) {
-  SetDirectMode();
   InitCache();
 
   disk_cache::Entry* entry;
 
   for (int i = 0; i < 2; ++i) {
     std::string key = base::StringPrintf("key%d", i);
     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
     entry->Close();
   }
 
   // Ping the oldest entry.
   cache_->OnExternalCacheHit("key0");
 
   TrimForTest(false);
 
   // Make sure the older key remains.
   EXPECT_EQ(1, cache_->GetEntryCount());
   ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
   entry->Close();
 }
 
 TEST_F(DiskCacheBackendTest, ShaderCacheUpdateRankForExternalCacheHit) {
   SetCacheType(net::SHADER_CACHE);
-  SetDirectMode();
   InitCache();
 
   disk_cache::Entry* entry;
 
   for (int i = 0; i < 2; ++i) {
     std::string key = base::StringPrintf("key%d", i);
     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
     entry->Close();
   }
 
   // Ping the oldest entry.
   cache_->OnExternalCacheHit("key0");
 
   TrimForTest(false);
 
   // Make sure the older key remains.
   EXPECT_EQ(1, cache_->GetEntryCount());
   ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
   entry->Close();
 }