Disk cache v3 ref2

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/metrics/field_trial.h"
 #include "base/port.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 21 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
 using base::Time;
 
 namespace {
 
+const int kDelayToNextTimestamp = 60;
 const char kExistingEntryKey[] = "existing entry key";
 
 scoped_ptr<disk_cache::BackendImpl> CreateExistingEntryCache(
     const base::Thread& cache_thread,
     base::FilePath& cache_path) {
   net::TestCompletionCallback cb;
 
   scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
       cache_path, cache_thread.message_loop_proxy(), NULL));
   int rv = cache->Init(cb.callback());
@@ skipping 32 matching lines @@
 
   // Actual tests:
   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 12 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();
 };
 
 int DiskCacheBackendTest::GeneratePendingIO(net::TestCompletionCallback* cb) {
   if (!use_current_thread_) {
     ADD_FAILURE();
     return net::ERR_FAILED;
   }
 
   disk_cache::Entry* entry;
@@ skipping 199 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();
 }
 
 TEST_F(DiskCacheBackendTest, ShaderCacheKeying) {
   SetCacheType(net::SHADER_CACHE);
   BackendKeying();
 }
 
 TEST_F(DiskCacheTest, CreateBackend) {
   net::TestCompletionCallback cb;
 
   {
     ASSERT_TRUE(CleanupCacheDir());
     base::Thread cache_thread("CacheThread");
     ASSERT_TRUE(cache_thread.StartWithOptions(
-        base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
+                    base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
     // Test the private factory method(s).
     scoped_ptr<disk_cache::Backend> cache;
     cache = disk_cache::MemBackendImpl::CreateBackend(0, NULL);
     ASSERT_TRUE(cache.get());
     cache.reset();
 
     // Now test the public API.
-    int rv =
-        disk_cache::CreateCacheBackend(net::DISK_CACHE,
-                                       net::CACHE_BACKEND_DEFAULT,
-                                       cache_path_,
-                                       0,
-                                       false,
-                                       cache_thread.message_loop_proxy().get(),
-                                       NULL,
-                                       &cache,
-                                       cb.callback());
+    int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
+                                            net::CACHE_BACKEND_DEFAULT,
+                                            cache_path_, 0, false,
+                                            cache_thread.message_loop_proxy(),
+                                            NULL, &cache, cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     ASSERT_TRUE(cache.get());
     cache.reset();
 
     rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE,
                                         net::CACHE_BACKEND_DEFAULT,
                                         base::FilePath(), 0,
                                         false, NULL, NULL, &cache,
                                         cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     ASSERT_TRUE(cache.get());
     cache.reset();
   }
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // Tests that |BackendImpl| fails to initialize with a missing file.
 TEST_F(DiskCacheBackendTest, CreateBackend_MissingFile) {
   ASSERT_TRUE(CopyTestCache("bad_entry"));
   base::FilePath filename = cache_path_.AppendASCII("data_1");
   base::DeleteFile(filename, false);
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
-      base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
+                  base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
   scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
       cache_path_, cache_thread.message_loop_proxy().get(), NULL));
   int rv = cache->Init(cb.callback());
   EXPECT_EQ(net::ERR_FAILED, cb.GetResult(rv));
   base::ThreadRestrictions::SetIOAllowed(prev);
 
   cache.reset();
@@ skipping 18 matching lines @@
 
   // And verify that the first file is still there.
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   ASSERT_EQ(kSize, file_util::ReadFile(filename, buffer2->data(), kSize));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize));
 }
 
 // Tests that we deal with file-level pending operations at destruction time.
 void DiskCacheBackendTest::BackendShutdownWithPendingFileIO(bool fast) {
   ASSERT_TRUE(CleanupCacheDir());
-  uint32 flags = disk_cache::kNoBuffering;
-  if (!fast)
-    flags |= disk_cache::kNoRandom;
+  if (fast)
+    AvoidTestFlag();
 
   UseCurrentThread();
-  CreateBackend(flags, NULL);
+  CreateBackend(NULL);
+  SetNoBuffering();
 
   net::TestCompletionCallback cb;
   int rv = GeneratePendingIO(&cb);
 
   // The cache destructor will see one pending operation here.
   cache_.reset();
 
   if (rv == net::ERR_IO_PENDING) {
     if (fast || simple_cache_mode_)
       EXPECT_FALSE(cb.have_result());
@@ skipping 39 matching lines @@
                net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, store.path(), 0,
                false, base::MessageLoopProxy::current().get(), NULL,
                &extra_cache, cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
   ASSERT_TRUE(extra_cache.get() != NULL);
 
   ASSERT_TRUE(CleanupCacheDir());
   SetNewEviction();  // Match the expected behavior for integrity verification.
   UseCurrentThread();
 
-  CreateBackend(disk_cache::kNoBuffering, NULL);
+  CreateBackend(NULL);
+  SetNoBuffering();
   rv = GeneratePendingIO(&cb);
 
   // cache_ has a pending operation, and extra_cache will go away.
   extra_cache.reset();
 
   if (rv == net::ERR_IO_PENDING)
     EXPECT_FALSE(cb.have_result());
 
   base::MessageLoop::current()->RunUntilIdle();
 
   // Wait for the actual operation to complete, or we'll keep a file handle that
   // may cause issues later.
   rv = cb.GetResult(rv);
 }
 
 // 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(base::MessageLoop::TYPE_IO, 0)));
+                    base::Thread::Options(base::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.
     cache_.reset();
   }
@@ skipping 16 matching lines @@
 #endif
 
 // 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(base::MessageLoop::TYPE_IO, 0)));
+                    base::Thread::Options(base::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);
 
     cache_.reset();
     EXPECT_FALSE(cb.have_result());
   }
 
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 13 matching lines @@
 }
 #endif
 
 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(base::MessageLoop::TYPE_IO, 0)));
+                  base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
   scoped_ptr<disk_cache::Backend> backend;
-  int rv =
-      disk_cache::CreateCacheBackend(net::DISK_CACHE,
-                                     net::CACHE_BACKEND_BLOCKFILE,
-                                     cache_path_,
-                                     0,
-                                     false,
-                                     cache_thread.message_loop_proxy().get(),
-                                     NULL,
-                                     &backend,
-                                     cb.callback());
+  int rv = disk_cache::CreateCacheBackend(
+      net::DISK_CACHE, net::CACHE_BACKEND_BLOCKFILE, cache_path_, 0, false,
+      cache_thread.message_loop_proxy(), NULL, &backend, cb.callback());
   ASSERT_NE(net::OK, cb.GetResult(rv));
 
   ASSERT_FALSE(backend);
 }
 
 void DiskCacheBackendTest::BackendSetSize() {
   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));
   memset(buffer->data(), 0, cache_size);
   EXPECT_EQ(cache_size / 10,
-            WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false))
-      << "normal file";
+            WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false)) <<
+                "normal file";
 
   EXPECT_EQ(net::ERR_FAILED,
-            WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false))
-      << "file size above the limit";
+            WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false)) <<
+                "file size above the limit";
 
   // By doubling the total size, we make this file cacheable.
   SetMaxSize(cache_size * 2);
-  EXPECT_EQ(cache_size / 5,
-            WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false));
+  EXPECT_EQ(cache_size / 5, WriteData(entry, 1, 0, buffer.get(), cache_size / 5,
+                                      false));
 
   // Let's fill up the cache!.
   SetMaxSize(cache_size * 10);
-  EXPECT_EQ(cache_size * 3 / 4,
-            WriteData(entry, 0, 0, buffer.get(), cache_size * 3 / 4, false));
+  EXPECT_EQ(cache_size * 3 / 4, WriteData(entry, 0, 0, buffer.get(),
+                                          cache_size * 3 / 4, false));
   entry->Close();
   FlushQueueForTest();
 
   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.get(), cache_size / 10, false));
 
   disk_cache::Entry* entry2;
-  ASSERT_EQ(net::OK, CreateEntry("an extra key", &entry2));
-  EXPECT_EQ(cache_size / 10,
-            WriteData(entry2, 0, 0, buffer.get(), cache_size / 10, false));
+  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.get(),
+                                       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();
+  }
+}
+
+// This test leaks memory because it simulates a crash.
+TEST_F(DiskCacheBackendTest, DISABLED_V3Backup) {
+  UseVersion3();
+  PresetTestMode();
+  InitCache();
+
+  disk_cache::Entry* entry;
+  std::string name1("First entry");
+  ASSERT_EQ(net::OK, CreateEntry(name1, &entry));
+  entry->Close();
+  WaitForEntryToClose(name1);
+
+  std::string name2("Another entry");
+  ASSERT_EQ(net::OK, CreateEntry(name2, &entry));
+
+  SimulateCrash();
+  EXPECT_EQ(net::OK, OpenEntry(name1, &entry));
+  entry->Close();
+  EXPECT_NE(net::OK, OpenEntry(name2, &entry));
+}
+
+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();
+    AddDelayForTest(kDelayToNextTimestamp);
+
     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);
   }
 
   // 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 310 matching lines @@
 void DiskCacheBackendTest::BackendEnumerations() {
   InitCache();
   Time initial = Time::Now();
 
   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(kDelayToNextTimestamp);
   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 155 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(kDelayToNextTimestamp);
+  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(kDelayToNextTimestamp);
+  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();
 }
 
 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomEntriesSinceSparse) {
   SetMemoryOnlyMode();
   base::Time start;
   InitSparseCache(&start, NULL);
   DoomEntriesSince(start);
   EXPECT_EQ(1, cache_->GetEntryCount());
 }
 
 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 28 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 128 matching lines @@
 TEST_F(DiskCacheBackendTest, NewEvictionRecoverWithEviction) {
   SetNewEviction();
   BackendRecoverWithEviction();
 }
 
 // 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(base::MessageLoop::TYPE_IO, 0)));
+                  base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
   scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
       cache_path_, cache_thread.message_loop_proxy().get(), NULL));
   int rv = cache->Init(cb.callback());
   ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
 }
 
 class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
  public:
@@ skipping 113 matching lines @@
     entry->Close();
   }
 }
 
 // Tests that the cache is properly restarted on recovery error.
 TEST_F(DiskCacheBackendTest, DeleteOld) {
   ASSERT_TRUE(CopyTestCache("wrong_version"));
   SetNewEviction();
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
-      base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
+                  base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   net::TestCompletionCallback cb;
   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
   base::FilePath path(cache_path_);
-  int rv =
-      disk_cache::CreateCacheBackend(net::DISK_CACHE,
-                                     net::CACHE_BACKEND_BLOCKFILE,
-                                     path,
-                                     0,
-                                     true,
-                                     cache_thread.message_loop_proxy().get(),
-                                     NULL,
-                                     &cache_,
-                                     cb.callback());
+  int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
+                                          net::CACHE_BACKEND_BLOCKFILE, path,
+                                          0, true,
+                                          cache_thread.message_loop_proxy(),
+                                          NULL, &cache_, cb.callback());
   path.clear();  // Make sure path was captured by the previous call.
   ASSERT_EQ(net::OK, cb.GetResult(rv));
   base::ThreadRestrictions::SetIOAllowed(prev);
   cache_.reset();
   EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
 }
 
 // We want to be able to deal with messed up entries on disk.
 void DiskCacheBackendTest::BackendInvalidEntry2() {
   ASSERT_TRUE(CopyTestCache("bad_entry"));
@@ skipping 735 matching lines @@
   InitCache();
   BackendDisable4();
 }
 
 TEST_F(DiskCacheTest, Backend_UsageStatsTimer) {
   MessageLoopHelper helper;
 
   ASSERT_TRUE(CleanupCacheDir());
   scoped_ptr<disk_cache::BackendImpl> cache;
   cache.reset(new disk_cache::BackendImpl(
-      cache_path_, base::MessageLoopProxy::current().get(), NULL));
+                  cache_path_, base::MessageLoopProxy::current(),
+                  NULL));
   ASSERT_TRUE(NULL != cache.get());
   cache->SetUnitTestMode();
   ASSERT_EQ(net::OK, cache->SyncInit());
 
   // Wait for a callback that never comes... about 2 secs :). The message loop
   // has to run to allow invocation of the usage timer.
   helper.WaitUntilCacheIoFinished(1);
 }
 
 TEST_F(DiskCacheBackendTest, Backend_UsageStats) {
@@ skipping 67 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 39 matching lines @@
   ASSERT_TRUE(store2.CreateUniqueTempDir());
 
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
   const int kNumberOfCaches = 2;
   scoped_ptr<disk_cache::Backend> cache[kNumberOfCaches];
 
-  int rv =
-      disk_cache::CreateCacheBackend(net::DISK_CACHE,
-                                     net::CACHE_BACKEND_DEFAULT,
-                                     store1.path(),
-                                     0,
-                                     false,
-                                     cache_thread.message_loop_proxy().get(),
-                                     NULL,
-                                     &cache[0],
-                                     cb.callback());
+  int rv = disk_cache::CreateCacheBackend(
+      net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, store1.path(), 0, false,
+      cache_thread.message_loop_proxy(), NULL, &cache[0], cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
-  rv = disk_cache::CreateCacheBackend(net::MEDIA_CACHE,
-                                      net::CACHE_BACKEND_DEFAULT,
-                                      store2.path(),
-                                      0,
-                                      false,
-                                      cache_thread.message_loop_proxy().get(),
-                                      NULL,
-                                      &cache[1],
-                                      cb.callback());
+  rv = disk_cache::CreateCacheBackend(
+      net::MEDIA_CACHE, net::CACHE_BACKEND_DEFAULT, 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].get() != NULL && cache[1].get() != 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));
     entry->Close();
@@ skipping 55 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.get(), kSize, true));
     EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer.get(), kSize, true));
     EXPECT_EQ(kSize,
               WriteData(entry, 0, 1024 * 1024, buffer.get(), kSize, false));
     EXPECT_EQ(kSize,
               WriteData(entry, 1, 1024 * 1024, buffer.get(), kSize, false));
 
     // Delete one of the buffers and truncate the other.
     EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true));
     EXPECT_EQ(0, WriteData(entry, 1, 10, buffer.get(), 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(kDelayToNextTimestamp);
   }
+  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_.reset(new disk_cache::TracingCacheBackend(cache_.Pass()));
   cache_impl_ = NULL;
   EXPECT_EQ(net::DISK_CACHE, cache_->GetCacheType());
   if (!simple_cache_mode_) {
     EXPECT_EQ(0, cache_->GetEntryCount());
   }
@@ skipping 351 matching lines @@
   void* iter = NULL;
   size_t count = 0;
   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
   cache_->EndEnumeration(&iter);
 
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
 }
 
 #endif  // defined(OS_POSIX)