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 10 matching lines @@
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/histogram_macros.h"
 #include "net/disk_cache/mapped_file.h"
 #include "net/disk_cache/mem_backend_impl.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_util.h"
 #include "net/disk_cache/tracing_cache_backend.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(OS_WIN)
-#include "base/win/scoped_handle.h"
-#endif
+using base::Time;
 
-using base::Time;
+namespace {
+const int kDelayToNextTimestamp = 60;
+}
 
 // Tests that can run with different types of caches.
 class DiskCacheBackendTest : public DiskCacheTestWithCache {
  protected:
+  // Some utility methods:
+
+  // Perform IO operations on the cache until there is pending IO.
+  int GeneratePendingIO(net::TestCompletionCallback* cb);
+
+  // Adds 5 sparse entries. |doomed_start| and |doomed_end| if not NULL,
+  // will be filled with times, used by DoomEntriesSince and DoomEntriesBetween.
+  // There are 4 entries after doomed_start and 2 after doomed_end.
+  void InitSparseCache(base::Time* doomed_start, base::Time* doomed_end);
+
+  bool CreateSetOfRandomEntries(std::set<std::string>* key_pool);
+  bool EnumerateAndMatchKeys(int max_to_open,
+                             void** iter,
+                             std::set<std::string>* keys_to_match,
+                             size_t* count);
+
+  // 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();
   void BackendDoomRecent();
-
-  // Adds 5 sparse entries. |doomed_start| and |doomed_end| if not NULL,
-  // will be filled with times, used by DoomEntriesSince and DoomEntriesBetween.
-  // There are 4 entries after doomed_start and 2 after doomed_end.
-  void InitSparseCache(base::Time* doomed_start, base::Time* doomed_end);
-
   void BackendDoomBetween();
   void BackendTransaction(const std::string& name, int num_entries, bool load);
   void BackendRecoverInsert();
   void BackendRecoverRemove();
   void BackendRecoverWithEviction();
   void BackendInvalidEntry2();
   void BackendInvalidEntry3();
   void BackendInvalidEntry7();
   void BackendInvalidEntry8();
   void BackendInvalidEntry9(bool eviction);
   void BackendInvalidEntry10(bool eviction);
   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;
+  int rv = cache_->CreateEntry("some key", &entry, cb->callback());
+  if (cb->GetResult(rv) != net::OK)
+    return net::ERR_CACHE_CREATE_FAILURE;
+
+  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.
+    if (!simple_cache_mode_) {
+      rv = static_cast<disk_cache::EntryImpl*>(entry)->WriteDataImpl(
+          0, i, buffer.get(), kSize, cb->callback(), false);
+    } else {
+      rv = entry->WriteData(0, i, buffer.get(), kSize, cb->callback(), false);
+    }
+
+    if (rv == net::ERR_IO_PENDING)
+      break;
+    if (rv != kSize)
+      rv = net::ERR_FAILED;
+  }
+
+  // Don't call Close() to avoid going through the queue or we'll deadlock
+  // waiting for the operation to finish.
+  if (!simple_cache_mode_)
+    static_cast<disk_cache::EntryImpl*>(entry)->Release();
+  else
+    entry->Close();
+
+  return rv;
+}
+
+void DiskCacheBackendTest::InitSparseCache(base::Time* doomed_start,
+                                           base::Time* doomed_end) {
+  InitCache();
+
+  const int kSize = 50;
+  // This must be greater then MemEntryImpl::kMaxSparseEntrySize.
+  const int kOffset = 10 + 1024 * 1024;
+
+  disk_cache::Entry* entry0 = NULL;
+  disk_cache::Entry* entry1 = NULL;
+  disk_cache::Entry* entry2 = NULL;
+
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
+  CacheTestFillBuffer(buffer->data(), kSize, false);
+
+  ASSERT_EQ(net::OK, CreateEntry("zeroth", &entry0));
+  ASSERT_EQ(kSize, WriteSparseData(entry0, 0, buffer.get(), kSize));
+  ASSERT_EQ(kSize,
+            WriteSparseData(entry0, kOffset + kSize, buffer.get(), kSize));
+  entry0->Close();
+
+  FlushQueueForTest();
+  AddDelay();
+  if (doomed_start)
+    *doomed_start = base::Time::Now();
+
+  // Order in rankings list:
+  // first_part1, first_part2, second_part1, second_part2
+  ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
+  ASSERT_EQ(kSize, WriteSparseData(entry1, 0, buffer.get(), kSize));
+  ASSERT_EQ(kSize,
+            WriteSparseData(entry1, kOffset + kSize, buffer.get(), kSize));
+  entry1->Close();
+
+  ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
+  ASSERT_EQ(kSize, WriteSparseData(entry2, 0, buffer.get(), kSize));
+  ASSERT_EQ(kSize,
+            WriteSparseData(entry2, kOffset + kSize, buffer.get(), kSize));
+  entry2->Close();
+
+  FlushQueueForTest();
+  AddDelay();
+  if (doomed_end)
+    *doomed_end = base::Time::Now();
+
+  // Order in rankings list:
+  // third_part1, fourth_part1, third_part2, fourth_part2
+  disk_cache::Entry* entry3 = NULL;
+  disk_cache::Entry* entry4 = NULL;
+  ASSERT_EQ(net::OK, CreateEntry("third", &entry3));
+  ASSERT_EQ(kSize, WriteSparseData(entry3, 0, buffer.get(), kSize));
+  ASSERT_EQ(net::OK, CreateEntry("fourth", &entry4));
+  ASSERT_EQ(kSize, WriteSparseData(entry4, 0, buffer.get(), kSize));
+  ASSERT_EQ(kSize,
+            WriteSparseData(entry3, kOffset + kSize, buffer.get(), kSize));
+  ASSERT_EQ(kSize,
+            WriteSparseData(entry4, kOffset + kSize, buffer.get(), kSize));
+  entry3->Close();
+  entry4->Close();
+
+  FlushQueueForTest();
+  AddDelay();
+}
+
+// Creates entries based on random keys. Stores these keys in |key_pool|.
+bool DiskCacheBackendTest::CreateSetOfRandomEntries(
+    std::set<std::string>* key_pool) {
+  const int kNumEntries = 10;
+
+  for (int i = 0; i < kNumEntries; ++i) {
+    std::string key = GenerateKey(true);
+    disk_cache::Entry* entry;
+    if (CreateEntry(key, &entry) != net::OK)
+      return false;
+    key_pool->insert(key);
+    entry->Close();
+  }
+  return key_pool->size() == implicit_cast<size_t>(cache_->GetEntryCount());
+}
+
+// Performs iteration over the backend and checks that the keys of entries
+// opened are in |keys_to_match|, then erases them. Up to |max_to_open| entries
+// will be opened, if it is positive. Otherwise, iteration will continue until
+// OpenNextEntry stops returning net::OK.
+bool DiskCacheBackendTest::EnumerateAndMatchKeys(
+    int max_to_open,
+    void** iter,
+    std::set<std::string>* keys_to_match,
+    size_t* count) {
+  disk_cache::Entry* entry;
+
+  while (OpenNextEntry(iter, &entry) == net::OK) {
+    if (!entry)
+      return false;
+    EXPECT_EQ(1U, keys_to_match->erase(entry->GetKey()));
+    entry->Close();
+    ++(*count);
+    if (max_to_open >= 0 && implicit_cast<int>(*count) >= max_to_open)
+      break;
+  };
+
+  return true;
+}
+
 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));
@@ skipping 50 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 69 matching lines @@
   base::FilePath filename = cache_path_.AppendASCII("f_000001");
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kSize, false);
   ASSERT_EQ(kSize, file_util::WriteFile(filename, buffer1->data(), kSize));
 
   // Now let's create a file with the cache.
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
-  ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1, 0, false));
+  ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1.get(), 0, false));
   entry->Close();
 
   // 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());
+  if (fast)
+    AvoidTestFlag();
+
+  UseCurrentThread();
+  CreateBackend(NULL);
+  SetNoBuffering();
+
   net::TestCompletionCallback cb;
-  int rv;
+  int rv = GeneratePendingIO(&cb);
 
-  {
-    ASSERT_TRUE(CleanupCacheDir());
-    base::Thread cache_thread("CacheThread");
-    ASSERT_TRUE(cache_thread.StartWithOptions(
-                    base::Thread::Options(MessageLoop::TYPE_IO, 0)));
+  // The cache destructor will see one pending operation here.
+  delete cache_;
+  // Prevent the TearDown() to delete the backend again.
+  cache_ = NULL;
 
-    uint32 flags = disk_cache::kNoBuffering;
-    if (!fast)
-      flags |= disk_cache::kNoRandom;
-
-    UseCurrentThread();
-    CreateBackend(flags, NULL);
-
-    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);
-
-    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_;
-    // 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());
-    }
+  if (rv == net::ERR_IO_PENDING) {
+    if (fast)
+      EXPECT_FALSE(cb.have_result());
+    else
+      EXPECT_TRUE(cb.have_result());
   }
 
   MessageLoop::current()->RunUntilIdle();
 
-#if defined(OS_WIN)
   // Wait for the actual operation to complete, or we'll keep a file handle that
-  // may cause issues later. Note that on Posix systems even though this test
-  // uses a single thread, the actual IO is posted to a worker thread and the
-  // cache destructor breaks the link to reach cb when the operation completes.
+  // may cause issues later.
   rv = cb.GetResult(rv);
-#endif
 }
 
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO) {
   BackendShutdownWithPendingFileIO(false);
 }
 
 // We'll be leaking from this test.
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO_Fast) {
   // The integrity test sets kNoRandom so there's a version mismatch if we don't
   // force new eviction.
   SetNewEviction();
   BackendShutdownWithPendingFileIO(true);
 }
 
 // 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 38 matching lines @@
   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, cache_size / 10,
-                                       false)) << "normal file";
+  EXPECT_EQ(cache_size / 10,
+            WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false)) <<
+                "normal file";
 
-  EXPECT_EQ(net::ERR_FAILED, WriteData(entry, 1, 0, buffer, cache_size / 5,
-                                       false)) << "file size above the limit";
+  EXPECT_EQ(net::ERR_FAILED,
+            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, cache_size / 5,
+  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,
+  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, cache_size / 10,
-                                       false));
+  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, 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));
   memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
   entry->Close();
   SimulateCrash();
 
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   memset(buffer2->data(), 0, kSize);
-  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2.get(), kSize));
   entry->Close();
   EXPECT_STREQ(buffer1->data(), buffer2->data());
 }
 
 TEST_F(DiskCacheBackendTest, ValidEntry) {
   BackendValidEntry();
 }
 
 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() {
   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);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
   SimulateCrash();
 
   EXPECT_NE(net::OK, OpenEntry(key, &entry));
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
-// This and the other intentionally leaky tests below are excluded from
-// valgrind runs by naming them in the files
-//   net/data/valgrind/net_unittests.gtest.txt
-// The scripts tools/valgrind/chrome_tests.sh
-// read those files and pass the appropriate --gtest_filter to net_unittests.
+#if !defined(LEAK_SANITIZER)
+// We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, InvalidEntry) {
   BackendInvalidEntry();
 }
 
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry) {
   SetNewEviction();
   BackendInvalidEntry();
 }
 
@@ skipping 15 matching lines @@
   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);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
-  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer, kSize));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize));
 
   SimulateCrash();
 
   if (type_ == net::APP_CACHE) {
     // Reading an entry and crashing should not make it dirty.
     ASSERT_EQ(net::OK, OpenEntry(key, &entry));
     EXPECT_EQ(1, cache_->GetEntryCount());
     entry->Close();
   } else {
     EXPECT_NE(net::OK, OpenEntry(key, &entry));
@@ skipping 102 matching lines @@
   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));
   memset(buffer->data(), 0, kSize);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 
   // Simulate a crash.
   SimulateCrash();
 
   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 
   EXPECT_EQ(2, cache_->GetEntryCount());
   SetMaxSize(kSize);
   entry->Close();  // Trim the cache.
   FlushQueueForTest();
 
   // If we evicted the entry in less than 20mS, we have one entry in the cache;
   // if it took more than that, we posted a task and we'll delete the second
   // entry too.
   MessageLoop::current()->RunUntilIdle();
@@ skipping 28 matching lines @@
   InitCache();
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   memset(buffer->data(), 0, kSize);
   disk_cache::Entry* entry;
 
   // Writing 32 entries to this cache chains most of them.
   for (int i = 0; i < 32; i++) {
     std::string key(base::StringPrintf("some key %d", i));
     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
-    EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+    EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
     entry->Close();
     ASSERT_EQ(net::OK, OpenEntry(key, &entry));
     // Note that we are not closing the entries.
   }
 
   // Simulate a crash.
   SimulateCrash();
 
   ASSERT_EQ(net::OK, CreateEntry("Something else", &entry));
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 
   FlushQueueForTest();
   EXPECT_EQ(33, cache_->GetEntryCount());
   SetMaxSize(kSize);
 
   // For the new eviction code, all corrupt entries are on the second list so
   // they are not going away that easy.
   if (new_eviction_) {
     EXPECT_EQ(net::OK, DoomAllEntries());
   }
@@ skipping 14 matching lines @@
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, TrimInvalidEntry2) {
   BackendTrimInvalidEntry2();
 }
 
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry2) {
   SetNewEviction();
   BackendTrimInvalidEntry2();
 }
+#endif  // !defined(LEAK_SANITIZER)
 
 void DiskCacheBackendTest::BackendEnumerations() {
   InitCache();
   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(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();
 }
 
 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerations2) {
   SetCacheType(net::SHADER_CACHE);
   BackendEnumerations2();
 }
 
 // Verify that ReadData calls do not update the LRU cache
 // when using the SHADER_CACHE type.
 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerationReadData) {
   SetCacheType(net::SHADER_CACHE);
   InitCache();
   const std::string first("first");
   const std::string second("second");
   disk_cache::Entry *entry1, *entry2;
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
 
   ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
   memset(buffer1->data(), 0, kSize);
   base::strlcpy(buffer1->data(), "And the data to save", kSize);
-  EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
 
   ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
   entry2->Close();
 
   FlushQueueForTest();
 
   // Make sure that the timestamp is not the same.
   AddDelay();
 
   // Read from the last item in the LRU.
-  EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1, kSize));
+  EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
   entry1->Close();
 
   void* iter = NULL;
   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
   EXPECT_EQ(entry2->GetKey(), second);
   entry2->Close();
   cache_->EndEnumeration(&iter);
 }
 
+#if !defined(LEAK_SANITIZER)
 // Verify handling of invalid entries while doing enumerations.
 // We'll be leaking memory from this test.
 void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
   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);
-  EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
   entry1->Close();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
-  EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1, kSize));
+  EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
 
   std::string key2("Another key");
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
   entry2->Close();
   ASSERT_EQ(2, cache_->GetEntryCount());
 
   SimulateCrash();
 
   void* iter = NULL;
   int count = 0;
@@ skipping 10 matching lines @@
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, InvalidEntryEnumeration) {
   BackendInvalidEntryEnumeration();
 }
 
 // We'll be leaking memory from this test.
 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryEnumeration) {
   SetNewEviction();
   BackendInvalidEntryEnumeration();
 }
+#endif  // !defined(LEAK_SANITIZER)
 
 // Tests that if for some reason entries are modified close to existing cache
 // iterators, we don't generate fatal errors or reset the cache.
 void DiskCacheBackendTest::BackendFixEnumerators() {
   InitCache();
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
   const int kNumEntries = 10;
@@ skipping 56 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 = GetTime();
 
   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 = GetTime();
 
   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;
-  // This must be greater then MemEntryImpl::kMaxSparseEntrySize.
-  const int kOffset = 10 + 1024 * 1024;
-
-  disk_cache::Entry* entry0 = NULL;
-  disk_cache::Entry* entry1 = NULL;
-  disk_cache::Entry* entry2 = NULL;
-
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
-  CacheTestFillBuffer(buffer->data(), kSize, false);
-
-  ASSERT_EQ(net::OK, CreateEntry("zeroth", &entry0));
-  ASSERT_EQ(kSize, WriteSparseData(entry0, 0, buffer.get(), kSize));
-  ASSERT_EQ(kSize,
-            WriteSparseData(entry0, kOffset + kSize, buffer.get(), kSize));
-  entry0->Close();
-
-  FlushQueueForTest();
-  AddDelay();
-  if (doomed_start)
-    *doomed_start = base::Time::Now();
-
-  // Order in rankings list:
-  // first_part1, first_part2, second_part1, second_part2
-  ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
-  ASSERT_EQ(kSize, WriteSparseData(entry1, 0, buffer.get(), kSize));
-  ASSERT_EQ(kSize,
-            WriteSparseData(entry1, kOffset + kSize, buffer.get(), kSize));
-  entry1->Close();
-
-  ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
-  ASSERT_EQ(kSize, WriteSparseData(entry2, 0, buffer.get(), kSize));
-  ASSERT_EQ(kSize,
-            WriteSparseData(entry2, kOffset + kSize, buffer.get(), kSize));
-  entry2->Close();
-
-  FlushQueueForTest();
-  AddDelay();
-  if (doomed_end)
-    *doomed_end = base::Time::Now();
-
-  // Order in rankings list:
-  // third_part1, fourth_part1, third_part2, fourth_part2
-  disk_cache::Entry* entry3 = NULL;
-  disk_cache::Entry* entry4 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry("third", &entry3));
-  ASSERT_EQ(kSize, WriteSparseData(entry3, 0, buffer.get(), kSize));
-  ASSERT_EQ(net::OK, CreateEntry("fourth", &entry4));
-  ASSERT_EQ(kSize, WriteSparseData(entry4, 0, buffer.get(), kSize));
-  ASSERT_EQ(kSize,
-            WriteSparseData(entry3, kOffset + kSize, buffer.get(), kSize));
-  ASSERT_EQ(kSize,
-            WriteSparseData(entry4, kOffset + kSize, buffer.get(), kSize));
-  entry3->Close();
-  entry4->Close();
-
-  FlushQueueForTest();
-  AddDelay();
-}
-
 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 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 860 matching lines @@
   CacheTestFillBuffer(key2, sizeof(key2), true);
   CacheTestFillBuffer(key3, sizeof(key3), true);
   key2[sizeof(key2) - 1] = '\0';
   key3[sizeof(key3) - 1] = '\0';
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
   ASSERT_EQ(net::OK, CreateEntry(key3, &entry3));
 
   const int kBufSize = 20000;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kBufSize));
   memset(buf->data(), 0, kBufSize);
-  EXPECT_EQ(100, WriteData(entry2, 0, 0, buf, 100, false));
-  EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf, kBufSize, false));
+  EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
+  EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
 
   // This line should disable the cache but not delete it.
   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry4));
   EXPECT_EQ(0, cache_->GetEntryCount());
 
   EXPECT_NE(net::OK, CreateEntry("cache is disabled", &entry4));
 
-  EXPECT_EQ(100, ReadData(entry2, 0, 0, buf, 100));
-  EXPECT_EQ(100, WriteData(entry2, 0, 0, buf, 100, false));
-  EXPECT_EQ(100, WriteData(entry2, 1, 0, buf, 100, false));
+  EXPECT_EQ(100, ReadData(entry2, 0, 0, buf.get(), 100));
+  EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
+  EXPECT_EQ(100, WriteData(entry2, 1, 0, buf.get(), 100, false));
 
-  EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf, kBufSize));
-  EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf, kBufSize, false));
-  EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf, kBufSize, false));
+  EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf.get(), kBufSize));
+  EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
+  EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf.get(), kBufSize, false));
 
   std::string key = entry2->GetKey();
   EXPECT_EQ(sizeof(key2) - 1, key.size());
   key = entry3->GetKey();
   EXPECT_EQ(sizeof(key3) - 1, key.size());
 
   entry1->Close();
   entry2->Close();
   entry3->Close();
   FlushQueueForTest();  // Flushing the Close posts a task to restart the cache.
@@ skipping 10 matching lines @@
 }
 
 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess4) {
   ASSERT_TRUE(CopyTestCache("bad_rankings"));
   DisableFirstCleanup();
   SetNewEviction();
   InitCache();
   BackendDisable4();
 }
 
-TEST_F(DiskCacheTest, Backend_UsageStats) {
+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(),
                   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) {
+  InitCache();
+  disk_cache::Entry* entry;
+  ASSERT_EQ(net::OK, CreateEntry("key", &entry));
+  entry->Close();
+  FlushQueueForTest();
+
+  disk_cache::StatsItems stats;
+  cache_->GetStats(&stats);
+  EXPECT_FALSE(stats.empty());
+
+  disk_cache::StatsItems::value_type hits("Create hit", "0x1");
+  EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
+
+  delete cache_;
+  cache_ = NULL;
+
+  // Now open the cache and verify that the stats are still there.
+  DisableFirstCleanup();
+  InitCache();
+  EXPECT_EQ(1, cache_->GetEntryCount());
+
+  stats.clear();
+  cache_->GetStats(&stats);
+  EXPECT_FALSE(stats.empty());
+
+  EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
+}
+
 void DiskCacheBackendTest::BackendDoomAll() {
   InitCache();
 
   disk_cache::Entry *entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
   ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
   entry1->Close();
   entry2->Close();
 
   ASSERT_EQ(net::OK, CreateEntry("third", &entry1));
@@ skipping 30 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));
+    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, 0, true));
-    EXPECT_EQ(0, WriteData(entry, 1, 10, buffer, 0, true));
+    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_ = 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 152 matching lines @@
 // Tests that the Simple Cache Backend fails to initialize with non-matching
 // file structure on disk.
 TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
   // Create a cache structure with the |BackendImpl|.
   InitCache();
   disk_cache::Entry* entry;
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
-  ASSERT_EQ(0, WriteData(entry, 0, 0, buffer, 0, false));
+  ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
   entry->Close();
   delete cache_;
   cache_ = NULL;
 
   // Check that the |SimpleBackendImpl| does not favor this structure.
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
                   base::Thread::Options(MessageLoop::TYPE_IO, 0)));
   disk_cache::SimpleBackendImpl* simple_cache =
-      new disk_cache::SimpleBackendImpl(cache_path_, 0, net::DISK_CACHE,
-                                        cache_thread.message_loop_proxy(),
+      new disk_cache::SimpleBackendImpl(cache_path_,
+                                        0,
+                                        net::DISK_CACHE,
+                                        cache_thread.message_loop_proxy().get(),
                                         NULL);
   net::TestCompletionCallback cb;
   int rv = simple_cache->Init(cb.callback());
   EXPECT_NE(net::OK, cb.GetResult(rv));
   delete simple_cache;
   DisableIntegrityCheck();
 }
 
 // Tests that the |BackendImpl| refuses to initialize on top of the files
 // generated by the Simple Cache Backend.
 TEST_F(DiskCacheBackendTest, BlockfileCacheOverSimpleCache) {
   // Create a cache structure with the |SimpleBackendImpl|.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* entry;
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
-  ASSERT_EQ(0, WriteData(entry, 0, 0, buffer, 0, false));
+  ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
   entry->Close();
   delete cache_;
   cache_ = NULL;
 
   // Check that the |BackendImpl| does not favor this structure.
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
                   base::Thread::Options(MessageLoop::TYPE_IO, 0)));
   disk_cache::BackendImpl* cache =
       new disk_cache::BackendImpl(cache_path_,
                                   base::MessageLoopProxy::current(),
                                   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)