Disk cache: Reference CL for the implementation of file format version 3.

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/port.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
@@ skipping 27 matching lines @@
 class DiskCacheBackendTest : public DiskCacheTestWithCache {
  protected:
   void BackendBasics();
   void BackendKeying();
   void BackendShutdownWithPendingFileIO(bool fast);
   void BackendShutdownWithPendingIO(bool fast);
   void BackendShutdownWithPendingCreate(bool fast);
   void BackendSetSize();
   void BackendLoad();
   void BackendChain();
+  void BucketUse();
+  void BackendNewEvictionTrim();
   void BackendValidEntry();
   void BackendInvalidEntry();
   void BackendInvalidEntryRead();
   void BackendInvalidEntryWithLoad();
   void BackendTrimInvalidEntry();
   void BackendTrimInvalidEntry2();
   void BackendEnumerations();
   void BackendEnumerations2();
   void BackendInvalidEntryEnumeration();
   void BackendFixEnumerators();
@@ skipping 18 matching lines @@
   void BackendInvalidEntry11(bool eviction);
   void BackendTrimInvalidEntry12();
   void BackendDoomAll();
   void BackendDoomAll2();
   void BackendInvalidRankings();
   void BackendInvalidRankings2();
   void BackendDisable();
   void BackendDisable2();
   void BackendDisable3();
   void BackendDisable4();
+  void BackendTotalBuffersSize1();
+  void BackendTotalBuffersSize2();
+  void BackendUpdateRankForExternalCacheHit();
   void TracingBackendBasics();
 };
 
 void DiskCacheBackendTest::BackendBasics() {
   InitCache();
   disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
   EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
   ASSERT_TRUE(NULL != entry1);
   entry1->Close();
   entry1 = NULL;
 
   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
   ASSERT_TRUE(NULL != entry1);
   entry1->Close();
   entry1 = NULL;
-
+  
   EXPECT_NE(net::OK, CreateEntry("the first key", &entry1));
   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
   EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
   ASSERT_EQ(net::OK, CreateEntry("some other key", &entry2));
   ASSERT_TRUE(NULL != entry1);
   ASSERT_TRUE(NULL != entry2);
   EXPECT_EQ(2, cache_->GetEntryCount());
 
   disk_cache::Entry* entry3 = NULL;
   ASSERT_EQ(net::OK, OpenEntry("some other key", &entry3));
@@ skipping 36 matching lines @@
 TEST_F(DiskCacheBackendTest, AppCacheBasics) {
   SetCacheType(net::APP_CACHE);
   BackendBasics();
 }
 
 TEST_F(DiskCacheBackendTest, ShaderCacheBasics) {
   SetCacheType(net::SHADER_CACHE);
   BackendBasics();
 }
 
+TEST_F(DiskCacheBackendTest, V3Basics) {
+  UseVersion3();
+  BackendBasics();
+}
+
 void DiskCacheBackendTest::BackendKeying() {
   InitCache();
   const char* kName1 = "the first key";
   const char* kName2 = "the first Key";
   disk_cache::Entry *entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(kName1, &entry1));
 
   ASSERT_EQ(net::OK, CreateEntry(kName2, &entry2));
   EXPECT_TRUE(entry1 != entry2) << "Case sensitive";
   entry2->Close();
@@ skipping 25 matching lines @@
   buffer2[19999] = '\0';
   ASSERT_EQ(net::OK, CreateEntry(buffer2, &entry2)) << "key on external file";
   entry2->Close();
   entry1->Close();
 }
 
 TEST_F(DiskCacheBackendTest, Keying) {
   BackendKeying();
 }
 
+TEST_F(DiskCacheBackendTest, V3Keying) {
+  UseVersion3();
+  BackendKeying();
+}
+
 TEST_F(DiskCacheBackendTest, NewEvictionKeying) {
   SetNewEviction();
   BackendKeying();
 }
 
+TEST_F(DiskCacheBackendTest, V3NewEvictionKeying) {
+  UseVersion3();
+  SetNewEviction();
+  BackendKeying();
+}
+
 TEST_F(DiskCacheBackendTest, MemoryOnlyKeying) {
   SetMemoryOnlyMode();
   BackendKeying();
 }
 
 TEST_F(DiskCacheBackendTest, AppCacheKeying) {
   SetCacheType(net::APP_CACHE);
   BackendKeying();
 }
 
@@ skipping 89 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)));
 
-    uint32 flags = disk_cache::kNoBuffering;
-    if (!fast)
-      flags |= disk_cache::kNoRandom;
+    if (fast)
+      AvoidTestFlag();
 
     UseCurrentThread();
-    CreateBackend(flags, NULL);
+    CreateBackend(NULL);
+    SetNoBuffering();
 
     disk_cache::EntryImpl* entry;
     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);
@@ skipping 51 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)));
 
-    uint32 flags = disk_cache::kNoBuffering;
-    if (!fast)
-      flags |= disk_cache::kNoRandom;
+    if (fast)
+      AvoidTestFlag();
 
-    CreateBackend(flags, &cache_thread);
+    CreateBackend(&cache_thread);
+    SetNoBuffering();
 
     disk_cache::Entry* entry;
     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_;
     // Prevent the TearDown() to delete the backend again.
@@ skipping 18 matching lines @@
 // 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::BackendFlags flags =
-      fast ? disk_cache::kNone : disk_cache::kNoRandom;
-    CreateBackend(flags, &cache_thread);
+    if (fast)
+      AvoidTestFlag();
+    CreateBackend(&cache_thread);
 
     disk_cache::Entry* entry;
     int rv = cache_->CreateEntry("some key", &entry, cb.callback());
     ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
     delete cache_;
     // Prevent the TearDown() to delete the backend again.
     cache_ = NULL;
     EXPECT_FALSE(cb.have_result());
   }
@@ skipping 65 matching lines @@
 
   SetMaxSize(cache_size);
 
   // The cache is 95% full.
 
   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
   EXPECT_EQ(cache_size / 10, WriteData(entry, 0, 0, buffer, cache_size / 10,
                                        false));
 
   disk_cache::Entry* entry2;
-  ASSERT_EQ(net::OK, CreateEntry("an extra key", &entry2));
+  std::string extra_key("an extra key");
+  ASSERT_EQ(net::OK, CreateEntry(extra_key, &entry2));
   EXPECT_EQ(cache_size / 10, WriteData(entry2, 0, 0, buffer, cache_size / 10,
                                        false));
   entry2->Close();  // This will trigger the cache trim.
-
-  EXPECT_NE(net::OK, OpenEntry(first, &entry2));
+  WaitForEntryToClose(extra_key);
 
   FlushQueueForTest();  // Make sure that we are done trimming the cache.
   FlushQueueForTest();  // We may have posted two tasks to evict stuff.
 
   entry->Close();
+  WaitForEntryToClose(second);
+
+  EXPECT_NE(net::OK, OpenEntry(first, &entry2));
   ASSERT_EQ(net::OK, OpenEntry(second, &entry));
   EXPECT_EQ(cache_size / 10, entry->GetDataSize(0));
   entry->Close();
 }
 
 TEST_F(DiskCacheBackendTest, SetSize) {
   BackendSetSize();
 }
 
+TEST_F(DiskCacheBackendTest, V3SetSize) {
+  UseVersion3();
+  UseVersion3();
+  SetNewEviction();
+  BackendSetSize();
+}
+
 TEST_F(DiskCacheBackendTest, NewEvictionSetSize) {
   SetNewEviction();
   BackendSetSize();
 }
 
+TEST_F(DiskCacheBackendTest, V3NewEvictionSetSize) {
+  UseVersion3();
+  SetNewEviction();
+  BackendSetSize();
+}
+
 TEST_F(DiskCacheBackendTest, MemoryOnlySetSize) {
   SetMemoryOnlyMode();
   BackendSetSize();
 }
 
 void DiskCacheBackendTest::BackendLoad() {
   InitCache();
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
@@ skipping 86 matching lines @@
 TEST_F(DiskCacheBackendTest, AppCacheChain) {
   SetCacheType(net::APP_CACHE);
   BackendChain();
 }
 
 TEST_F(DiskCacheBackendTest, ShaderCacheChain) {
   SetCacheType(net::SHADER_CACHE);
   BackendChain();
 }
 
-TEST_F(DiskCacheBackendTest, NewEvictionTrim) {
+// Tests the proper use of cell buckets while the index grow.
+void DiskCacheBackendTest::BucketUse() {
+  UseVersion3();
+  InitCache();
+  const int kNumEntries = 20;
+  disk_cache::Entry* entries[kNumEntries];
+  std::string key("The first key");
+
+  // This generates kNumEntries collisions so the extra table has to be used.
+  // There are only 2 extra buckets on the test setup, so the index has to grow.
+  for (int i = 0; i < kNumEntries; i++) {
+    ASSERT_EQ(net::OK, CreateEntry(key, &entries[i]));
+    entries[i]->Doom();
+    FlushQueueForTest();
+  }
+
+  for (int i = 0; i < kNumEntries / 2; i++)
+    entries[i]->Close();
+
+  for (int i = 0; i < kNumEntries / 2; i++) {
+    ASSERT_EQ(net::OK, CreateEntry(key, &entries[i]));
+    entries[i]->Doom();
+  }
+
+  for (int i = 0; i < kNumEntries; i++)
+    entries[i]->Close();
+}
+
+TEST_F(DiskCacheBackendTest, V3BucketUse) {
+  BucketUse();
+}
+
+TEST_F(DiskCacheBackendTest, V3DoubleIndexBucketUse) {
+  PresetTestMode();  // Doubles the index instead of a slow growth.
+  BucketUse();
+}
+
+TEST_F(DiskCacheBackendTest, V3DoubleIndex) {
+  UseVersion3();
+  PresetTestMode();
+  InitCache();
+
+  disk_cache::Entry* entry;
+  const int kNumEntries = 200;
+  for (int i = 0; i < kNumEntries; i++) {
+    std::string name(base::StringPrintf("Key %d", i));
+    ASSERT_EQ(net::OK, CreateEntry(name, &entry));
+    entry->Close();
+    FlushQueueForTest();
+  }
+  
+  // Generate enough collisions to force growing the extra table (and with it,
+  // the index).
+  const int kNumSavedEntries = 5;
+  disk_cache::Entry* entries[kNumSavedEntries];
+  std::string key("The first key");
+  for (int i = 0; i < kNumSavedEntries; i++) {
+    ASSERT_EQ(net::OK, CreateEntry(key, &entries[i]));
+    entries[i]->Doom();
+    FlushQueueForTest();
+  }
+
+  for (int i = 0; i < kNumSavedEntries; i++)
+    entries[i]->Close();
+
+  // Verify that all entries are there.
+  for (int i = 0; i < kNumEntries; i++) {
+    std::string name(base::StringPrintf("Key %d", i));
+    ASSERT_EQ(net::OK, OpenEntry(name, &entry));
+    entry->Close();
+  }
+}
+
+void DiskCacheBackendTest::BackendNewEvictionTrim() {
   SetNewEviction();
   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));
       entry->Close();
     }
+    if (!(i % 10))
+      FlushQueueForTest();
+
+    if (i == 0 || i == 90) {
+      WaitForEntryToClose(name);
+      AddDelayForTest(70);
+    }
   }
 
   // The first eviction must come from list 1 (10% limit), the second must come
   // from list 0.
   TrimForTest(false);
   EXPECT_NE(net::OK, OpenEntry("Key 0", &entry));
   TrimForTest(false);
   EXPECT_NE(net::OK, OpenEntry("Key 90", &entry));
 
   // 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();
 }
 
+TEST_F(DiskCacheBackendTest, NewEvictionTrim) {
+  BackendNewEvictionTrim();
+}
+
+TEST_F(DiskCacheBackendTest, V3NewEvictionTrim) {
+  UseVersion3();
+  BackendNewEvictionTrim();
+}
+
 // Before looking for invalid entries, let's check a valid entry.
 void DiskCacheBackendTest::BackendValidEntry() {
   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));
@@ skipping 314 matching lines @@
   Time initial = Time::Now();
   int seed = static_cast<int>(initial.ToInternalValue());
   srand(seed);
 
   const int kNumEntries = 100;
   for (int i = 0; i < kNumEntries; i++) {
     std::string key = GenerateKey(true);
     disk_cache::Entry* entry;
     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
     entry->Close();
+    if (!(i % 10))
+      FlushQueueForTest();
   }
   EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
   Time final = Time::Now();
 
   disk_cache::Entry* entry;
   void* iter = NULL;
   int count = 0;
   Time last_modified[kNumEntries];
   Time last_used[kNumEntries];
   while (OpenNextEntry(&iter, &entry) == net::OK) {
@@ skipping 22 matching lines @@
     entry->Close();
     count++;
   };
   EXPECT_EQ(kNumEntries, count);
 }
 
 TEST_F(DiskCacheBackendTest, Enumerations) {
   BackendEnumerations();
 }
 
+TEST_F(DiskCacheBackendTest, V3Enumerations) {
+  UseVersion3();
+  BackendEnumerations();
+}
+
 TEST_F(DiskCacheBackendTest, NewEvictionEnumerations) {
   SetNewEviction();
   BackendEnumerations();
 }
 
+TEST_F(DiskCacheBackendTest, V3NewEvictionEnumerations) {
+  UseVersion3();
+  SetNewEviction();
+  BackendEnumerations();
+}
+
 TEST_F(DiskCacheBackendTest, MemoryOnlyEnumerations) {
   SetMemoryOnlyMode();
   BackendEnumerations();
 }
 
 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerations) {
   SetCacheType(net::SHADER_CACHE);
   BackendEnumerations();
 }
 
 TEST_F(DiskCacheBackendTest, AppCacheEnumerations) {
   SetCacheType(net::APP_CACHE);
   BackendEnumerations();
 }
 
 // Verifies enumerations while entries are open.
 void DiskCacheBackendTest::BackendEnumerations2() {
   InitCache();
   const std::string first("first");
   const std::string second("second");
   disk_cache::Entry *entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
   entry1->Close();
   ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
   entry2->Close();
   FlushQueueForTest();
 
   // Make sure that the timestamp is not the same.
-  AddDelay();
+  AddDelayForTest(70);
   ASSERT_EQ(net::OK, OpenEntry(second, &entry1));
   void* iter = NULL;
   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
   EXPECT_EQ(entry2->GetKey(), second);
 
   // Two entries and the iterator pointing at "first".
   entry1->Close();
   entry2->Close();
 
   // The iterator should still be valid, so we should not crash.
@@ skipping 15 matching lines @@
 
   entry1->Close();
   entry2->Close();
   cache_->EndEnumeration(&iter);
 }
 
 TEST_F(DiskCacheBackendTest, Enumerations2) {
   BackendEnumerations2();
 }
 
+TEST_F(DiskCacheBackendTest, V3Enumerations2) {
+  UseVersion3();
+  BackendEnumerations2();
+}
+
 TEST_F(DiskCacheBackendTest, NewEvictionEnumerations2) {
   SetNewEviction();
   BackendEnumerations2();
 }
 
+TEST_F(DiskCacheBackendTest, V3NewEvictionEnumerations2) {
+  UseVersion3();
+  SetNewEviction();
+  BackendEnumerations2();
+}
+
 TEST_F(DiskCacheBackendTest, MemoryOnlyEnumerations2) {
   SetMemoryOnlyMode();
   BackendEnumerations2();
 }
 
 TEST_F(DiskCacheBackendTest, AppCacheEnumerations2) {
   SetCacheType(net::APP_CACHE);
   BackendEnumerations2();
 }
 
@@ skipping 153 matching lines @@
 void DiskCacheBackendTest::BackendDoomRecent() {
   InitCache();
 
   disk_cache::Entry *entry;
   ASSERT_EQ(net::OK, CreateEntry("first", &entry));
   entry->Close();
   ASSERT_EQ(net::OK, CreateEntry("second", &entry));
   entry->Close();
   FlushQueueForTest();
 
-  AddDelay();
-  Time middle = Time::Now();
+  AddDelayForTest(70);
+  Time middle = GetCurrentTime();
 
   ASSERT_EQ(net::OK, CreateEntry("third", &entry));
   entry->Close();
   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
   entry->Close();
   FlushQueueForTest();
 
-  AddDelay();
-  Time final = Time::Now();
+  AddDelayForTest(70);
+  Time final = GetCurrentTime();
 
   ASSERT_EQ(4, cache_->GetEntryCount());
   EXPECT_EQ(net::OK, DoomEntriesSince(final));
   ASSERT_EQ(4, cache_->GetEntryCount());
 
   EXPECT_EQ(net::OK, DoomEntriesSince(middle));
   ASSERT_EQ(2, cache_->GetEntryCount());
 
   ASSERT_EQ(net::OK, OpenEntry("second", &entry));
   entry->Close();
 }
 
 TEST_F(DiskCacheBackendTest, DoomRecent) {
   BackendDoomRecent();
 }
 
+TEST_F(DiskCacheBackendTest, V3DoomRecent) {
+  UseVersion3();
+  BackendDoomRecent();
+}
+
 TEST_F(DiskCacheBackendTest, NewEvictionDoomRecent) {
   SetNewEviction();
   BackendDoomRecent();
 }
 
+TEST_F(DiskCacheBackendTest, V3NewEvictionDoomRecent) {
+  UseVersion3();
+  SetNewEviction();
+  BackendDoomRecent();
+}
+
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomRecent) {
   SetMemoryOnlyMode();
   BackendDoomRecent();
 }
 
 void DiskCacheBackendTest::InitSparseCache(base::Time* doomed_start,
                                            base::Time* doomed_end) {
   InitCache();
 
   const int kSize = 50;
@@ skipping 67 matching lines @@
 TEST_F(DiskCacheBackendTest, DoomEntriesSinceSparse) {
   base::Time start;
   InitSparseCache(&start, NULL);
   DoomEntriesSince(start);
   // NOTE: BackendImpl counts child entries in its GetEntryCount(), while
   // MemBackendImpl does not. Thats why expected value differs here from
   // MemoryOnlyDoomEntriesSinceSparse.
   EXPECT_EQ(3, cache_->GetEntryCount());
 }
 
+TEST_F(DiskCacheBackendTest, V3DoomEntriesSinceSparse) {
+  base::Time start;
+  UseVersion3();
+  InitSparseCache(&start, NULL);
+  DoomEntriesSince(start);
+  // NOTE: BackendImpl counts child entries in its GetEntryCount(), while
+  // MemBackendImpl does not. Thats why expected value differs here from
+  // MemoryOnlyDoomEntriesSinceSparse.
+  EXPECT_EQ(3, cache_->GetEntryCount());
+}
+
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAllSparse) {
   SetMemoryOnlyMode();
   InitSparseCache(NULL, NULL);
   EXPECT_EQ(net::OK, DoomAllEntries());
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheBackendTest, DoomAllSparse) {
   InitSparseCache(NULL, NULL);
   EXPECT_EQ(net::OK, DoomAllEntries());
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
+TEST_F(DiskCacheBackendTest, V3DoomAllSparse) {
+  UseVersion3();
+  InitSparseCache(NULL, NULL);
+  EXPECT_EQ(net::OK, DoomAllEntries());
+  EXPECT_EQ(0, cache_->GetEntryCount());
+}
+
 void DiskCacheBackendTest::BackendDoomBetween() {
   InitCache();
 
   disk_cache::Entry *entry;
   ASSERT_EQ(net::OK, CreateEntry("first", &entry));
   entry->Close();
   FlushQueueForTest();
 
   AddDelay();
   Time middle_start = Time::Now();
@@ skipping 27 matching lines @@
   ASSERT_EQ(1, cache_->GetEntryCount());
 
   ASSERT_EQ(net::OK, OpenEntry("first", &entry));
   entry->Close();
 }
 
 TEST_F(DiskCacheBackendTest, DoomBetween) {
   BackendDoomBetween();
 }
 
+TEST_F(DiskCacheBackendTest, V3DoomBetween) {
+  UseVersion3();
+  BackendDoomBetween();
+}
+
 TEST_F(DiskCacheBackendTest, NewEvictionDoomBetween) {
   SetNewEviction();
   BackendDoomBetween();
 }
 
+TEST_F(DiskCacheBackendTest, V3NewEvictionDoomBetween) {
+  UseVersion3();
+  SetNewEviction();
+  BackendDoomBetween();
+}
+
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomBetween) {
   SetMemoryOnlyMode();
   BackendDoomBetween();
 }
 
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomEntriesBetweenSparse) {
   SetMemoryOnlyMode();
   base::Time start, end;
   InitSparseCache(&start, &end);
   DoomEntriesBetween(start, end);
@@ skipping 10 matching lines @@
   InitSparseCache(&start, &end);
   DoomEntriesBetween(start, end);
   EXPECT_EQ(9, cache_->GetEntryCount());
 
   start = end;
   end = base::Time::Now();
   DoomEntriesBetween(start, end);
   EXPECT_EQ(3, cache_->GetEntryCount());
 }
 
+TEST_F(DiskCacheBackendTest, V3DoomEntriesBetweenSparse) {
+  base::Time start, end;
+  UseVersion3();
+  InitSparseCache(&start, &end);
+  DoomEntriesBetween(start, end);
+  EXPECT_EQ(9, cache_->GetEntryCount());
+
+  start = end;
+  end = base::Time::Now();
+  DoomEntriesBetween(start, end);
+  EXPECT_EQ(3, cache_->GetEntryCount());
+}
+
 void DiskCacheBackendTest::BackendTransaction(const std::string& name,
                                               int num_entries, bool load) {
   success_ = false;
   ASSERT_TRUE(CopyTestCache(name));
   DisableFirstCleanup();
 
   uint32 mask;
   if (load) {
     mask = 0xf;
     SetMaxSize(0x100000);
@@ skipping 973 matching lines @@
   EXPECT_EQ(net::OK, DoomAllEntries());
   ASSERT_EQ(0, cache_->GetEntryCount());
 
   EXPECT_EQ(net::OK, DoomAllEntries());
 }
 
 TEST_F(DiskCacheBackendTest, DoomAll) {
   BackendDoomAll();
 }
 
+TEST_F(DiskCacheBackendTest, V3DoomAll) {
+  UseVersion3();
+  BackendDoomAll();
+}
+
 TEST_F(DiskCacheBackendTest, NewEvictionDoomAll) {
   SetNewEviction();
   BackendDoomAll();
 }
 
+TEST_F(DiskCacheBackendTest, V3NewEvictionDoomAll) {
+  UseVersion3();
+  SetNewEviction();
+  BackendDoomAll();
+}
+
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAll) {
   SetMemoryOnlyMode();
   BackendDoomAll();
 }
 
 TEST_F(DiskCacheBackendTest, AppCacheOnlyDoomAll) {
   SetCacheType(net::APP_CACHE);
   BackendDoomAll();
 }
 
@@ skipping 123 matching lines @@
   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) {
+void DiskCacheBackendTest::BackendTotalBuffersSize1() {
   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++) {
     SCOPED_TRACE(i);
     // Allocate 2MB for this entry.
     EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, true));
     EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer, kSize, true));
     EXPECT_EQ(kSize, WriteData(entry, 0, 1024 * 1024, buffer, kSize, false));
     EXPECT_EQ(kSize, WriteData(entry, 1, 1024 * 1024, buffer, kSize, false));
 
     // Delete one of the buffers and truncate the other.
     EXPECT_EQ(0, WriteData(entry, 0, 0, buffer, 0, true));
     EXPECT_EQ(0, WriteData(entry, 1, 10, buffer, 0, true));
 
     // Delete the second buffer, writing 10 bytes to disk.
     entry->Close();
     ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   }
 
   entry->Close();
-  EXPECT_EQ(0, cache_impl_->GetTotalBuffersSize());
+  EXPECT_EQ(0, GetTotalBuffersSize());
+}
+
+TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
+  BackendTotalBuffersSize1();
+}
+
+TEST_F(DiskCacheBackendTest, V3TotalBuffersSize1) {
+  UseVersion3();
+  BackendTotalBuffersSize1();
 }
 
 // This test assumes at least 150MB of system memory.
-TEST_F(DiskCacheBackendTest, TotalBuffersSize2) {
+void DiskCacheBackendTest::BackendTotalBuffersSize2() {
   InitCache();
 
   const int kOneMB = 1024 * 1024;
-  EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
-  EXPECT_EQ(kOneMB, cache_impl_->GetTotalBuffersSize());
+  EXPECT_TRUE(IsAllocAllowed(0, kOneMB));
+  EXPECT_EQ(kOneMB, GetTotalBuffersSize());
 
-  EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
-  EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
+  EXPECT_TRUE(IsAllocAllowed(0, kOneMB));
+  EXPECT_EQ(kOneMB * 2, GetTotalBuffersSize());
 
-  EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
-  EXPECT_EQ(kOneMB * 3, cache_impl_->GetTotalBuffersSize());
+  EXPECT_TRUE(IsAllocAllowed(0, kOneMB));
+  EXPECT_EQ(kOneMB * 3, GetTotalBuffersSize());
 
-  cache_impl_->BufferDeleted(kOneMB);
-  EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
+  BufferDeleted(kOneMB);
+  EXPECT_EQ(kOneMB * 2, GetTotalBuffersSize());
 
   // Check the upper limit.
-  EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, 30 * kOneMB));
+  EXPECT_FALSE(IsAllocAllowed(0, 30 * kOneMB));
 
   for (int i = 0; i < 30; i++)
-    cache_impl_->IsAllocAllowed(0, kOneMB);  // Ignore the result.
+    IsAllocAllowed(0, kOneMB);  // Ignore the result.
 
-  EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, kOneMB));
+  EXPECT_FALSE(IsAllocAllowed(0, kOneMB));
+}
+
+TEST_F(DiskCacheBackendTest, TotalBuffersSize2) {
+  BackendTotalBuffersSize2();
+}
+
+TEST_F(DiskCacheBackendTest, V3TotalBuffersSize2) {
+  UseVersion3();
+  BackendTotalBuffersSize2();
 }
 
 // Tests that sharing of external files works and we are able to delete the
 // files when we need to.
 TEST_F(DiskCacheBackendTest, FileSharing) {
   InitCache();
 
   disk_cache::Addr address(0x80000001);
   ASSERT_TRUE(cache_impl_->CreateExternalFile(&address));
   base::FilePath name = cache_impl_->GetFileName(address);
@@ skipping 22 matching lines @@
   char buffer2[kSize];
   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) {
+void DiskCacheBackendTest::BackendUpdateRankForExternalCacheHit() {
   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();
+    AddDelayForTest(70);
   }
+  FlushQueueForTest();
 
   // Ping the oldest entry.
+  SetTestMode();
   cache_->OnExternalCacheHit("key0");
+  FlushQueueForTest();
 
   TrimForTest(false);
 
   // Make sure the older key remains.
-  EXPECT_EQ(1, cache_->GetEntryCount());
+  EXPECT_NE(net::OK, OpenEntry("key1", &entry));
   ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
   entry->Close();
 }
 
+TEST_F(DiskCacheBackendTest, UpdateRankForExternalCacheHit) {
+  BackendUpdateRankForExternalCacheHit();
+}
+
+TEST_F(DiskCacheBackendTest, V3UpdateRankForExternalCacheHit) {
+  UseVersion3();
+  BackendUpdateRankForExternalCacheHit();
+}
+
 TEST_F(DiskCacheBackendTest, ShaderCacheUpdateRankForExternalCacheHit) {
   SetCacheType(net::SHADER_CACHE);
-  InitCache();
+  BackendUpdateRankForExternalCacheHit();
+}
 
-  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, V3ShaderCacheUpdateRankForExternalCacheHit) {
+  UseVersion3();
+  SetCacheType(net::SHADER_CACHE);
+  BackendUpdateRankForExternalCacheHit();
 }
 
 void DiskCacheBackendTest::TracingBackendBasics() {
   InitCache();
   cache_ = new disk_cache::TracingCacheBackend(cache_);
   cache_impl_ = NULL;
   EXPECT_EQ(net::DISK_CACHE, cache_->GetCacheType());
   if (!simple_cache_mode_) {
     EXPECT_EQ(0, cache_->GetEntryCount());
   }
@@ skipping 205 matching lines @@
                                   NULL);
   cache->SetUnitTestMode();
   net::TestCompletionCallback cb;
   int rv = cache->Init(cb.callback());
   EXPECT_NE(net::OK, cb.GetResult(rv));
   delete cache;
   DisableIntegrityCheck();
 }
 
 #endif  // !defined(OS_WIN)