Initialize the simple cache backend at runtime.

net/disk_cache/entry_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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/timer.h"
@@ skipping 111 matching lines @@
                             entry));
 
 
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, InternalSyncIO) {
-  SetDirectMode();
   InitCache();
   InternalSyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   InternalSyncIO();
 }
 
@@ skipping 141 matching lines @@
 
   EXPECT_FALSE(helper.callback_reused_error());
 
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, InternalAsyncIO) {
-  SetDirectMode();
   InitCache();
   InternalAsyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   InternalAsyncIO();
 }
 
@@ skipping 50 matching lines @@
                             base::Unretained(this),
                             entry));
 
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, ExternalSyncIO) {
-  SetDirectMode();
   InitCache();
   ExternalSyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, ExternalSyncIONoBuffer) {
-  SetDirectMode();
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   ExternalSyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   ExternalSyncIO();
 }
@@ skipping 103 matching lines @@
 
   EXPECT_FALSE(helper.callback_reused_error());
 
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, ExternalAsyncIO) {
-  SetDirectMode();
   InitCache();
   ExternalAsyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, ExternalAsyncIONoBuffer) {
-  SetDirectMode();
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   ExternalAsyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   ExternalAsyncIO();
 }
 
 // Tests that IOBuffers are not referenced after IO completes.
 void DiskCacheEntryTest::ReleaseBuffer() {
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
   ASSERT_TRUE(NULL != entry);
 
   const int kBufferSize = 1024;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
   CacheTestFillBuffer(buffer->data(), kBufferSize, false);
 
   net::ReleaseBufferCompletionCallback cb(buffer);
   int rv = entry->WriteData(0, 0, buffer, kBufferSize, cb.callback(), false);
   EXPECT_EQ(kBufferSize, cb.GetResult(rv));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ReleaseBuffer) {
-  SetDirectMode();
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   ReleaseBuffer();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyReleaseBuffer) {
   SetMemoryOnlyMode();
   InitCache();
   ReleaseBuffer();
 }
@@ skipping 213 matching lines @@
   EXPECT_EQ(45500, entry->GetDataSize(0));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, GrowData) {
   InitCache();
   GrowData();
 }
 
 TEST_F(DiskCacheEntryTest, GrowDataNoBuffer) {
-  SetDirectMode();
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   GrowData();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData) {
   SetMemoryOnlyMode();
   InitCache();
   GrowData();
 }
@@ skipping 57 matching lines @@
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, TruncateData) {
   InitCache();
   TruncateData();
 }
 
 TEST_F(DiskCacheEntryTest, TruncateDataNoBuffer) {
-  SetDirectMode();
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   TruncateData();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) {
   SetMemoryOnlyMode();
   InitCache();
   TruncateData();
 }
@@ skipping 35 matching lines @@
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ZeroLengthIO) {
   InitCache();
   ZeroLengthIO();
 }
 
 TEST_F(DiskCacheEntryTest, ZeroLengthIONoBuffer) {
-  SetDirectMode();
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   ZeroLengthIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) {
   SetMemoryOnlyMode();
   InitCache();
   ZeroLengthIO();
 }
@@ skipping 74 matching lines @@
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, Buffering) {
   InitCache();
   Buffering();
 }
 
 TEST_F(DiskCacheEntryTest, BufferingNoBuffer) {
-  SetDirectMode();
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   Buffering();
 }
 
 // Some extra tests to make sure that buffering works properly when changing
 // the entry size.
 void DiskCacheEntryTest::SizeChanges() {
   std::string key("the first key");
   disk_cache::Entry* entry;
@@ skipping 66 matching lines @@
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SizeChanges) {
   InitCache();
   SizeChanges();
 }
 
 TEST_F(DiskCacheEntryTest, SizeChangesNoBuffer) {
-  SetDirectMode();
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   SizeChanges();
 }
 
 // Write more than the total cache capacity but to a single entry. |size| is the
 // amount of bytes to write each time.
 void DiskCacheEntryTest::ReuseEntry(int size) {
   std::string key1("the first key");
   disk_cache::Entry* entry;
@@ skipping 12 matching lines @@
     entry->Close();
     ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
   }
 
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry";
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ReuseExternalEntry) {
-  SetDirectMode();
   SetMaxSize(200 * 1024);
   InitCache();
   ReuseEntry(20 * 1024);
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyReuseExternalEntry) {
-  SetDirectMode();
   SetMemoryOnlyMode();
   SetMaxSize(200 * 1024);
   InitCache();
   ReuseEntry(20 * 1024);
 }
 
 TEST_F(DiskCacheEntryTest, ReuseInternalEntry) {
-  SetDirectMode();
   SetMaxSize(100 * 1024);
   InitCache();
   ReuseEntry(10 * 1024);
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyReuseInternalEntry) {
-  SetDirectMode();
   SetMemoryOnlyMode();
   SetMaxSize(100 * 1024);
   InitCache();
   ReuseEntry(10 * 1024);
 }
 
 // Reading somewhere that was not written should return zeros.
 void DiskCacheEntryTest::InvalidData() {
   std::string key("the first key");
   disk_cache::Entry* entry;
@@ skipping 57 matching lines @@
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, InvalidData) {
   InitCache();
   InvalidData();
 }
 
 TEST_F(DiskCacheEntryTest, InvalidDataNoBuffer) {
-  SetDirectMode();
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   InvalidData();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) {
   SetMemoryOnlyMode();
   InitCache();
   InvalidData();
 }
@@ skipping 46 matching lines @@
   EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer, kSize, false));
   EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer, kSize, false));
   entry->Doom();
   entry->Close();
 
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, DoomEntry) {
-  SetDirectMode();
   InitCache();
   DoomNormalEntry();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomNormalEntry();
 }
 
@@ skipping 61 matching lines @@
   EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1));
   EXPECT_EQ(key, entry->GetKey());
   EXPECT_TRUE(initial < entry->GetLastModified());
   EXPECT_TRUE(initial < entry->GetLastUsed());
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, DoomedEntry) {
-  SetDirectMode();
   InitCache();
   DoomedEntry();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomedEntry();
 }
 
 // Tests that we discard entries if the data is missing.
 TEST_F(DiskCacheEntryTest, MissingData) {
-  SetDirectMode();
   InitCache();
 
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   // Write to an external file.
   const int kSize = 20000;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
@@ skipping 385 matching lines @@
   entry1->Close();
   entry2->Close();
   FlushQueueForTest();
   if (memory_only_)
     EXPECT_EQ(2, cache_->GetEntryCount());
   else
     EXPECT_EQ(3, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, UpdateSparseEntry) {
-  SetDirectMode();
   SetCacheType(net::MEDIA_CACHE);
   InitCache();
   UpdateSparseEntry();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) {
   SetMemoryOnlyMode();
   SetCacheType(net::MEDIA_CACHE);
   InitCache();
   UpdateSparseEntry();
@@ skipping 50 matching lines @@
       // (it's always async on Posix so it is easy to miss). Unfortunately we
       // don't have any signal to watch for so we can only wait.
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
       MessageLoop::current()->RunUntilIdle();
     }
     EXPECT_EQ(0, cache_->GetEntryCount());
   }
 }
 
 TEST_F(DiskCacheEntryTest, DoomSparseEntry) {
-  SetDirectMode();
   UseCurrentThread();
   InitCache();
   DoomSparseEntry();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomSparseEntry();
 }
@@ skipping 14 matching lines @@
     TestCompletionCallback::SetResult(result);
   }
 
   disk_cache::Backend* cache_;
   DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback);
 };
 
 // Tests that we don't crash when the backend is deleted while we are working
 // deleting the sub-entries of a sparse entry.
 TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
-  SetDirectMode();
   UseCurrentThread();
   InitCache();
   std::string key("the key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 4 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
@@ skipping 235 matching lines @@
   store->key_len = 800;
   memset(store->key + key.size(), 'k', sizeof(store->key) - key.size());
   entry_impl->entry()->set_modified();
   entry->Close();
 
   // We have a corrupt entry. Now reload it. We should NOT read beyond the
   // allocated buffer here.
   ASSERT_NE(net::OK, OpenEntry(key, &entry));
   DisableIntegrityCheck();
 }