Disk cache v3 ref2

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 20 matching lines @@
 
 // Tests that can run with different types of caches.
 class DiskCacheEntryTest : public DiskCacheTestWithCache {
  public:
   void InternalSyncIOBackground(disk_cache::Entry* entry);
   void ExternalSyncIOBackground(disk_cache::Entry* entry);
 
  protected:
   void InternalSyncIO();
   void InternalAsyncIO();
+  void InternalConcurrentIO();
   void ExternalSyncIO();
   void ExternalAsyncIO();
   void ReleaseBuffer();
   void StreamAccess();
   void GetKey();
   void GetTimes();
   void GrowData();
   void TruncateData();
   void ZeroLengthIO();
   void Buffering();
   void SizeAtCreate();
   void SizeChanges();
   void ReuseEntry(int size);
   void InvalidData();
   void ReadWriteDestroyBuffer();
   void DoomNormalEntry();
   void DoomEntryNextToOpenEntry();
   void DoomedEntry();
+  void MissingData();
   void BasicSparseIO();
   void HugeSparseIO();
-  void GetAvailableRange();
+  void SparseGetAvailableRange();
   void CouldBeSparse();
   void UpdateSparseEntry();
   void DoomSparseEntry();
+  void DoomSparseEntry2();
   void PartialSparseEntry();
+  void CleanupSparseEntry();
+  void CancelSparseIO();
+  void ReadyForSparseIONoCancel();
   bool SimpleCacheMakeBadChecksumEntry(const std::string& key, int* data_size);
   bool SimpleCacheThirdStreamFileExists(const char* key);
   void SyncDoomEntry(const char* key);
 };
 
 // This part of the test runs on the background thread.
 void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) {
   const int kSize1 = 10;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
-  EXPECT_EQ(
-      0,
-      entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
+  EXPECT_EQ(0, entry->ReadData(0, 0, buffer1.get(), kSize1,
+                               net::CompletionCallback()));
   base::strlcpy(buffer1->data(), "the data", kSize1);
-  EXPECT_EQ(10,
-            entry->WriteData(
-                0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
+  EXPECT_EQ(10, entry->WriteData(0, 0, buffer1.get(), kSize1,
+                                 net::CompletionCallback(), false));
   memset(buffer1->data(), 0, kSize1);
-  EXPECT_EQ(
-      10,
-      entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
+  EXPECT_EQ(10, entry->ReadData(0, 0, buffer1.get(), kSize1,
+                                net::CompletionCallback()));
   EXPECT_STREQ("the data", buffer1->data());
 
   const int kSize2 = 5000;
   const int kSize3 = 10000;
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
   scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
   memset(buffer3->data(), 0, kSize3);
   CacheTestFillBuffer(buffer2->data(), kSize2, false);
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
-  EXPECT_EQ(
-      5000,
-      entry->WriteData(
-          1, 1500, buffer2.get(), kSize2, net::CompletionCallback(), false));
+  EXPECT_EQ(5000, entry->WriteData(1, 1500, buffer2.get(), kSize2,
+                                   net::CompletionCallback(), false));
   memset(buffer2->data(), 0, kSize2);
-  EXPECT_EQ(4989,
-            entry->ReadData(
-                1, 1511, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(4989, entry->ReadData(1, 1511, buffer2.get(), kSize2,
+                                  net::CompletionCallback()));
   EXPECT_STREQ("big data goes here", buffer2->data());
-  EXPECT_EQ(
-      5000,
-      entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(5000, entry->ReadData(1, 0, buffer2.get(), kSize2,
+                                  net::CompletionCallback()));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
-  EXPECT_EQ(1500,
-            entry->ReadData(
-                1, 5000, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(1500, entry->ReadData(1, 5000, buffer2.get(), kSize2,
+                                  net::CompletionCallback()));
 
-  EXPECT_EQ(0,
-            entry->ReadData(
-                1, 6500, buffer2.get(), kSize2, net::CompletionCallback()));
-  EXPECT_EQ(
-      6500,
-      entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
-  EXPECT_EQ(8192,
-            entry->WriteData(
-                1, 0, buffer3.get(), 8192, net::CompletionCallback(), false));
-  EXPECT_EQ(
-      8192,
-      entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
+  EXPECT_EQ(0, entry->ReadData(1, 6500, buffer2.get(), kSize2,
+                               net::CompletionCallback()));
+  EXPECT_EQ(6500, entry->ReadData(1, 0, buffer3.get(), kSize3,
+                                  net::CompletionCallback()));
+  EXPECT_EQ(8192, entry->WriteData(1, 0, buffer3.get(), 8192,
+                                   net::CompletionCallback(), false));
+  EXPECT_EQ(8192, entry->ReadData(1, 0, buffer3.get(), kSize3,
+                                   net::CompletionCallback()));
   EXPECT_EQ(8192, entry->GetDataSize(1));
 
   // We need to delete the memory buffer on this thread.
-  EXPECT_EQ(0, entry->WriteData(
-      0, 0, NULL, 0, net::CompletionCallback(), true));
-  EXPECT_EQ(0, entry->WriteData(
-      1, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0,
+            entry->WriteData(0, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0,
+            entry->WriteData(1, 0, NULL, 0, net::CompletionCallback(), true));
 }
 
 // We need to support synchronous IO even though it is not a supported operation
 // from the point of view of the disk cache's public interface, because we use
 // it internally, not just by a few tests, but as part of the implementation
 // (see sparse_control.cc, for example).
 void DiskCacheEntryTest::InternalSyncIO() {
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
   ASSERT_TRUE(NULL != entry);
@@ skipping 31 matching lines @@
   // that, IO operations will be really hitting the disk. We don't care about
   // the content, so just extending the entry is enough (all extensions zero-
   // fill any holes).
   EXPECT_EQ(0, WriteData(entry, 0, 15 * 1024, NULL, 0, false));
   EXPECT_EQ(0, WriteData(entry, 1, 15 * 1024, NULL, 0, false));
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
 
   MessageLoopHelper helper;
   // Let's verify that each IO goes to the right callback object.
-  CallbackTest callback1(&helper, false);
-  CallbackTest callback2(&helper, false);
-  CallbackTest callback3(&helper, false);
-  CallbackTest callback4(&helper, false);
-  CallbackTest callback5(&helper, false);
-  CallbackTest callback6(&helper, false);
-  CallbackTest callback7(&helper, false);
-  CallbackTest callback8(&helper, false);
-  CallbackTest callback9(&helper, false);
-  CallbackTest callback10(&helper, false);
-  CallbackTest callback11(&helper, false);
-  CallbackTest callback12(&helper, false);
-  CallbackTest callback13(&helper, false);
+  CallbackTest cb1(&helper, false);
+  CallbackTest cb2(&helper, false);
+  CallbackTest cb3(&helper, false);
+  CallbackTest cb4(&helper, false);
+  CallbackTest cb5(&helper, false);
+  CallbackTest cb6(&helper, false);
+  CallbackTest cb7(&helper, false);
+  CallbackTest cb8(&helper, false);
 
   const int kSize1 = 10;
   const int kSize2 = 5000;
   const int kSize3 = 10000;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
   scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   CacheTestFillBuffer(buffer2->data(), kSize2, false);
   CacheTestFillBuffer(buffer3->data(), kSize3, false);
 
-  EXPECT_EQ(0,
-            entry->ReadData(
-                0,
-                15 * 1024,
-                buffer1.get(),
-                kSize1,
-                base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
+  int ret = entry->ReadData(0, 15 * 1024, buffer1.get(), kSize1,
+                            cb1.callback());
+  int expected = 0;
+  EXPECT_TRUE(0 == ret || net::ERR_IO_PENDING == ret);
+  if (net::ERR_IO_PENDING == ret)
+    expected++;
+
   base::strlcpy(buffer1->data(), "the data", kSize1);
-  int expected = 0;
-  int ret = entry->WriteData(
-      0,
-      0,
-      buffer1.get(),
-      kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback2)),
-      false);
+  ret = entry->WriteData(0, 0, buffer1.get(), kSize1, cb2.callback(), false);
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+
   memset(buffer2->data(), 0, kSize2);
-  ret = entry->ReadData(
-      0,
-      0,
-      buffer2.get(),
-      kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback3)));
-  EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
-  if (net::ERR_IO_PENDING == ret)
-    expected++;
-
-  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+  EXPECT_EQ(10, ReadData(entry, 0, 0, buffer2.get(), kSize1));
   EXPECT_STREQ("the data", buffer2->data());
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
-  ret = entry->WriteData(
-      1,
-      1500,
-      buffer2.get(),
-      kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback4)),
-      true);
-  EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
-  if (net::ERR_IO_PENDING == ret)
-    expected++;
-
-  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
-  memset(buffer3->data(), 0, kSize3);
-  ret = entry->ReadData(
-      1,
-      1511,
-      buffer3.get(),
-      kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
-  EXPECT_TRUE(4989 == ret || net::ERR_IO_PENDING == ret);
-  if (net::ERR_IO_PENDING == ret)
-    expected++;
-
-  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
-  EXPECT_STREQ("big data goes here", buffer3->data());
-  ret = entry->ReadData(
-      1,
-      0,
-      buffer2.get(),
-      kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
-  EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
-  if (net::ERR_IO_PENDING == ret)
-    expected++;
+  EXPECT_EQ(5000, WriteData(entry, 1, 1500, buffer2.get(), kSize2, true));
 
   memset(buffer3->data(), 0, kSize3);
+  EXPECT_EQ(4989, ReadData(entry, 1, 1511, buffer3.get(), kSize2));
+  EXPECT_STREQ("big data goes here", buffer3->data());
 
-  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+  ret = ReadData(entry, 1, 0, buffer2.get(), kSize2);
+  EXPECT_TRUE(ret == 1500 || ret == 5000);
+  memset(buffer3->data(), 0, kSize3);
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
-  ret = entry->ReadData(
-      1,
-      5000,
-      buffer2.get(),
-      kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback7)));
+
+  ret = entry->ReadData(1, 5000, buffer2.get(), kSize2, cb3.callback());
   EXPECT_TRUE(1500 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  ret = entry->ReadData(
-      1,
-      0,
-      buffer3.get(),
-      kSize3,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback9)));
+  ret = entry->ReadData(1, 0, buffer3.get(), kSize3, cb4.callback());
   EXPECT_TRUE(6500 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  ret = entry->WriteData(
-      1,
-      0,
-      buffer3.get(),
-      8192,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback10)),
-      true);
+  ret = entry->WriteData(1, 0, buffer3.get(), 8192, cb5.callback(), true);
   EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
-  ret = entry->ReadData(
-      1,
-      0,
-      buffer3.get(),
-      kSize3,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback11)));
+  ret = entry->ReadData(1, 0, buffer3.get(), kSize3, cb6.callback());
   EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_EQ(8192, entry->GetDataSize(1));
 
-  ret = entry->ReadData(
-      0,
-      0,
-      buffer1.get(),
-      kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback12)));
+  ret = entry->ReadData(0, 0, buffer1.get(), kSize1, cb7.callback());
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  ret = entry->ReadData(
-      1,
-      0,
-      buffer2.get(),
-      kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback13)));
+  ret = entry->ReadData(1, 0, buffer2.get(), kSize2, cb8.callback());
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
 
   EXPECT_FALSE(helper.callback_reused_error());
 
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, InternalAsyncIO) {
   InitCache();
   InternalAsyncIO();
 }
 
+TEST_F(DiskCacheEntryTest, V3InternalAsyncIO) {
+  UseVersion3();
+  InitCache();
+  InternalAsyncIO();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   InternalAsyncIO();
 }
 
 // This part of the test runs on the background thread.
 void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry) {
   const int kSize1 = 17000;
   const int kSize2 = 25000;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   CacheTestFillBuffer(buffer2->data(), kSize2, false);
   base::strlcpy(buffer1->data(), "the data", kSize1);
-  EXPECT_EQ(17000,
-            entry->WriteData(
-                0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
+  EXPECT_EQ(17000, entry->WriteData(0, 0, buffer1.get(), kSize1,
+                                    net::CompletionCallback(), false));
   memset(buffer1->data(), 0, kSize1);
-  EXPECT_EQ(
-      17000,
-      entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
+  EXPECT_EQ(17000, entry->ReadData(0, 0, buffer1.get(), kSize1,
+                                   net::CompletionCallback()));
   EXPECT_STREQ("the data", buffer1->data());
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
-  EXPECT_EQ(
-      25000,
-      entry->WriteData(
-          1, 10000, buffer2.get(), kSize2, net::CompletionCallback(), false));
+  EXPECT_EQ(25000, entry->WriteData(1, 10000, buffer2.get(), kSize2,
+                                    net::CompletionCallback(), false));
   memset(buffer2->data(), 0, kSize2);
-  EXPECT_EQ(24989,
-            entry->ReadData(
-                1, 10011, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(24989, entry->ReadData(1, 10011, buffer2.get(), kSize2,
+                                   net::CompletionCallback()));
   EXPECT_STREQ("big data goes here", buffer2->data());
-  EXPECT_EQ(
-      25000,
-      entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
-  EXPECT_EQ(5000,
-            entry->ReadData(
-                1, 30000, buffer2.get(), kSize2, net::CompletionCallback()));
+  EXPECT_EQ(25000, entry->ReadData(1, 0, buffer2.get(), kSize2,
+                                   net::CompletionCallback()));
+  EXPECT_EQ(5000, entry->ReadData(1, 30000, buffer2.get(), kSize2,
+                                  net::CompletionCallback()));
 
-  EXPECT_EQ(0,
-            entry->ReadData(
-                1, 35000, buffer2.get(), kSize2, net::CompletionCallback()));
-  EXPECT_EQ(
-      17000,
-      entry->ReadData(1, 0, buffer1.get(), kSize1, net::CompletionCallback()));
-  EXPECT_EQ(
-      17000,
-      entry->WriteData(
-          1, 20000, buffer1.get(), kSize1, net::CompletionCallback(), false));
+  EXPECT_EQ(0, entry->ReadData(1, 35000, buffer2.get(), kSize2,
+                               net::CompletionCallback()));
+  EXPECT_EQ(17000, entry->ReadData(1, 0, buffer1.get(), kSize1,
+                                   net::CompletionCallback()));
+  EXPECT_EQ(17000, entry->WriteData(1, 20000, buffer1.get(), kSize1,
+                                    net::CompletionCallback(), false));
   EXPECT_EQ(37000, entry->GetDataSize(1));
 
   // We need to delete the memory buffer on this thread.
-  EXPECT_EQ(0, entry->WriteData(
-      0, 0, NULL, 0, net::CompletionCallback(), true));
-  EXPECT_EQ(0, entry->WriteData(
-      1, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0,
+            entry->WriteData(0, 0, NULL, 0, net::CompletionCallback(), true));
+  EXPECT_EQ(0,
+            entry->WriteData(1, 0, NULL, 0, net::CompletionCallback(), true));
 }
 
 void DiskCacheEntryTest::ExternalSyncIO() {
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
 
   // The bulk of the test runs from within the callback, on the cache thread.
   RunTaskForTest(base::Bind(&DiskCacheEntryTest::ExternalSyncIOBackground,
                             base::Unretained(this),
                             entry));
 
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, ExternalSyncIO) {
   InitCache();
   ExternalSyncIO();
 }
 
+TEST_F(DiskCacheEntryTest, V3ExternalSyncIO) {
+  UseVersion3();
+  InitCache();
+  ExternalSyncIO();
+}
+
 TEST_F(DiskCacheEntryTest, ExternalSyncIONoBuffer) {
   InitCache();
-  cache_impl_->SetFlags(disk_cache::kNoBuffering);
+  SetNoBuffering();
   ExternalSyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   ExternalSyncIO();
 }
 
 void DiskCacheEntryTest::ExternalAsyncIO() {
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
 
   int expected = 0;
 
   MessageLoopHelper helper;
   // Let's verify that each IO goes to the right callback object.
-  CallbackTest callback1(&helper, false);
-  CallbackTest callback2(&helper, false);
-  CallbackTest callback3(&helper, false);
-  CallbackTest callback4(&helper, false);
-  CallbackTest callback5(&helper, false);
-  CallbackTest callback6(&helper, false);
-  CallbackTest callback7(&helper, false);
-  CallbackTest callback8(&helper, false);
-  CallbackTest callback9(&helper, false);
+  CallbackTest cb1(&helper, false);
+  CallbackTest cb2(&helper, false);
+  CallbackTest cb3(&helper, false);
+  CallbackTest cb4(&helper, false);
 
   const int kSize1 = 17000;
   const int kSize2 = 25000;
   const int kSize3 = 25000;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
   scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   CacheTestFillBuffer(buffer2->data(), kSize2, false);
   CacheTestFillBuffer(buffer3->data(), kSize3, false);
+
   base::strlcpy(buffer1->data(), "the data", kSize1);
-  int ret = entry->WriteData(
-      0,
-      0,
-      buffer1.get(),
-      kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback1)),
-      false);
-  EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
-  if (net::ERR_IO_PENDING == ret)
-    expected++;
-
-  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+  EXPECT_EQ(17000, WriteData(entry, 0, 0, buffer1.get(), kSize1, false));
 
   memset(buffer2->data(), 0, kSize1);
-  ret = entry->ReadData(
-      0,
-      0,
-      buffer2.get(),
-      kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback2)));
-  EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
-  if (net::ERR_IO_PENDING == ret)
-    expected++;
-
-  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+  EXPECT_EQ(17000, ReadData(entry, 0, 0, buffer2.get(), kSize1));
   EXPECT_STREQ("the data", buffer2->data());
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
-  ret = entry->WriteData(
-      1,
-      10000,
-      buffer2.get(),
-      kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback3)),
-      false);
-  EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
-  if (net::ERR_IO_PENDING == ret)
-    expected++;
-
-  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+  EXPECT_EQ(25000, WriteData(entry, 1, 10000, buffer2.get(), kSize2, false));
 
   memset(buffer3->data(), 0, kSize3);
-  ret = entry->ReadData(
-      1,
-      10011,
-      buffer3.get(),
-      kSize3,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback4)));
-  EXPECT_TRUE(24989 == ret || net::ERR_IO_PENDING == ret);
-  if (net::ERR_IO_PENDING == ret)
-    expected++;
+  EXPECT_EQ(24989, ReadData(entry, 1, 10011, buffer3.get(), kSize3));
+  EXPECT_STREQ("big data goes here", buffer3->data());
 
-  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
-  EXPECT_STREQ("big data goes here", buffer3->data());
-  ret = entry->ReadData(
-      1,
-      0,
-      buffer2.get(),
-      kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
-  EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
-  if (net::ERR_IO_PENDING == ret)
-    expected++;
-
-  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+  EXPECT_EQ(25000, ReadData(entry, 1, 0, buffer2.get(), kSize2));
   memset(buffer3->data(), 0, kSize3);
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 10000));
-  ret = entry->ReadData(
-      1,
-      30000,
-      buffer2.get(),
-      kSize2,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
+
+  int ret = entry->ReadData(1, 30000, buffer2.get(), kSize2, cb1.callback());
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_EQ(0,
-            entry->ReadData(
-                1,
-                35000,
-                buffer2.get(),
-                kSize2,
-                base::Bind(&CallbackTest::Run, base::Unretained(&callback7))));
-  ret = entry->ReadData(
-      1,
-      0,
-      buffer1.get(),
-      kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback8)));
+            entry->ReadData(1, 35000, buffer2.get(), kSize2, cb2.callback()));
+  ret = entry->ReadData(1, 0, buffer1.get(), kSize1, cb3.callback());
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
-  ret = entry->WriteData(
-      1,
-      20000,
-      buffer3.get(),
-      kSize1,
-      base::Bind(&CallbackTest::Run, base::Unretained(&callback9)),
-      false);
+
+  ret = entry->WriteData(1, 20000, buffer3.get(), kSize1, cb4.callback(),
+                         false);
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_EQ(37000, entry->GetDataSize(1));
 
   EXPECT_FALSE(helper.callback_reused_error());
 
   entry->Doom();
   entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, ExternalAsyncIO) {
   InitCache();
   ExternalAsyncIO();
 }
 
+TEST_F(DiskCacheEntryTest, V3ExternalAsyncIO) {
+  UseVersion3();
+  InitCache();
+  ExternalAsyncIO();
+}
+
 TEST_F(DiskCacheEntryTest, ExternalAsyncIONoBuffer) {
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   ExternalAsyncIO();
 }
 
+TEST_F(DiskCacheEntryTest, V3ExternalAsyncIONoBuffer) {
+  UseVersion3();
+  InitCache();
+  SetNoBuffering();
+  ExternalAsyncIO();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   ExternalAsyncIO();
 }
 
 // Tests that IOBuffers are not referenced after IO completes.
 void DiskCacheEntryTest::ReleaseBuffer() {
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
   ASSERT_TRUE(NULL != entry);
 
   const int kBufferSize = 1024;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
   CacheTestFillBuffer(buffer->data(), kBufferSize, false);
 
-  net::ReleaseBufferCompletionCallback cb(buffer.get());
-  int rv =
-      entry->WriteData(0, 0, buffer.get(), kBufferSize, cb.callback(), false);
+  net::ReleaseBufferCompletionCallback cb(buffer);
+  int rv = entry->WriteData(0, 0, buffer.get(), kBufferSize, cb.callback(),
+                            false);
   EXPECT_EQ(kBufferSize, cb.GetResult(rv));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ReleaseBuffer) {
   InitCache();
-  cache_impl_->SetFlags(disk_cache::kNoBuffering);
+  SetNoBuffering();
+  ReleaseBuffer();
+}
+
+TEST_F(DiskCacheEntryTest, V3ReleaseBuffer) {
+  UseVersion3();
+  InitCache();
+  SetNoBuffering();
   ReleaseBuffer();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyReleaseBuffer) {
   SetMemoryOnlyMode();
   InitCache();
   ReleaseBuffer();
 }
 
 void DiskCacheEntryTest::StreamAccess() {
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
   ASSERT_TRUE(NULL != entry);
 
   const int kBufferSize = 1024;
   const int kNumStreams = 3;
   scoped_refptr<net::IOBuffer> reference_buffers[kNumStreams];
   for (int i = 0; i < kNumStreams; i++) {
     reference_buffers[i] = new net::IOBuffer(kBufferSize);
     CacheTestFillBuffer(reference_buffers[i]->data(), kBufferSize, false);
   }
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kBufferSize));
   for (int i = 0; i < kNumStreams; i++) {
-    EXPECT_EQ(
-        kBufferSize,
-        WriteData(entry, i, 0, reference_buffers[i].get(), kBufferSize, false));
+    EXPECT_EQ(kBufferSize, WriteData(entry, i, 0, reference_buffers[i].get(),
+                                     kBufferSize, false));
     memset(buffer1->data(), 0, kBufferSize);
     EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1.get(), kBufferSize));
-    EXPECT_EQ(
-        0, memcmp(reference_buffers[i]->data(), buffer1->data(), kBufferSize));
+    EXPECT_EQ(0, memcmp(reference_buffers[i]->data(), buffer1->data(),
+                        kBufferSize));
   }
   EXPECT_EQ(net::ERR_INVALID_ARGUMENT,
             ReadData(entry, kNumStreams, 0, buffer1.get(), kBufferSize));
   entry->Close();
 
   // Open the entry and read it in chunks, including a read past the end.
   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
   ASSERT_TRUE(NULL != entry);
   const int kReadBufferSize = 600;
   const int kFinalReadSize = kBufferSize - kReadBufferSize;
   COMPILE_ASSERT(kFinalReadSize < kReadBufferSize, should_be_exactly_two_reads);
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kReadBufferSize));
   for (int i = 0; i < kNumStreams; i++) {
     memset(buffer2->data(), 0, kReadBufferSize);
     EXPECT_EQ(kReadBufferSize,
               ReadData(entry, i, 0, buffer2.get(), kReadBufferSize));
-    EXPECT_EQ(
-        0,
-        memcmp(reference_buffers[i]->data(), buffer2->data(), kReadBufferSize));
+    EXPECT_EQ(0, memcmp(reference_buffers[i]->data(), buffer2->data(),
+                        kReadBufferSize));
 
     memset(buffer2->data(), 0, kReadBufferSize);
-    EXPECT_EQ(
-        kFinalReadSize,
-        ReadData(entry, i, kReadBufferSize, buffer2.get(), kReadBufferSize));
-    EXPECT_EQ(0,
-              memcmp(reference_buffers[i]->data() + kReadBufferSize,
-                     buffer2->data(),
-                     kFinalReadSize));
+    EXPECT_EQ(kFinalReadSize, ReadData(entry, i, kReadBufferSize,
+                                       buffer2.get(), kReadBufferSize));
+    EXPECT_EQ(0, memcmp(reference_buffers[i]->data() + kReadBufferSize,
+                        buffer2->data(), kFinalReadSize));
   }
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, StreamAccess) {
   InitCache();
   StreamAccess();
 }
 
+TEST_F(DiskCacheEntryTest, V3StreamAccess) {
+  UseVersion3();
+  InitCache();
+  StreamAccess();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) {
   SetMemoryOnlyMode();
   InitCache();
   StreamAccess();
 }
 
 void DiskCacheEntryTest::GetKey() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_EQ(key, entry->GetKey()) << "short key";
   entry->Close();
+  WaitForEntryToClose(key);
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
   char key_buffer[20000];
 
   CacheTestFillBuffer(key_buffer, 3000, true);
   key_buffer[1000] = '\0';
 
   key = key_buffer;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_TRUE(key == entry->GetKey()) << "1000 bytes key";
   entry->Close();
+  WaitForEntryToClose(key);
 
   key_buffer[1000] = 'p';
   key_buffer[3000] = '\0';
   key = key_buffer;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_TRUE(key == entry->GetKey()) << "medium size key";
   entry->Close();
+  WaitForEntryToClose(key);
 
   CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true);
   key_buffer[19999] = '\0';
 
   key = key_buffer;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_TRUE(key == entry->GetKey()) << "long key";
   entry->Close();
+  WaitForEntryToClose(key);
 
   CacheTestFillBuffer(key_buffer, 0x4000, true);
   key_buffer[0x4000] = '\0';
 
   key = key_buffer;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_TRUE(key == entry->GetKey()) << "16KB key";
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, GetKey) {
   InitCache();
   GetKey();
 }
 
+TEST_F(DiskCacheEntryTest, V3GetKey) {
+  UseVersion3();
+  InitCache();
+  GetKey();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) {
   SetMemoryOnlyMode();
   InitCache();
   GetKey();
 }
 
 void DiskCacheEntryTest::GetTimes() {
   std::string key("the first key");
   disk_cache::Entry* entry;
 
@@ skipping 30 matching lines @@
     EXPECT_TRUE(entry->GetLastModified() < t3);
   }
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, GetTimes) {
   InitCache();
   GetTimes();
 }
 
+TEST_F(DiskCacheEntryTest, V3GetTimes) {
+  UseVersion3();
+  InitCache();
+  GetTimes();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyGetTimes) {
   SetMemoryOnlyMode();
   InitCache();
   GetTimes();
 }
 
 TEST_F(DiskCacheEntryTest, AppCacheGetTimes) {
   SetCacheType(net::APP_CACHE);
   InitCache();
   GetTimes();
@@ skipping 32 matching lines @@
   EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
   entry->Close();
 
   memset(buffer2->data(), 0, kSize);
   std::string key2("Second key");
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
   EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1.get(), 10, false));
   EXPECT_EQ(10, entry->GetDataSize(0));
   entry->Close();
+  WaitForEntryToClose(key2);
 
   // Go from an internal address to a bigger block size.
   ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
   EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false));
   EXPECT_EQ(2000, entry->GetDataSize(0));
   EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
   entry->Close();
+  WaitForEntryToClose(key2);
   memset(buffer2->data(), 0, kSize);
 
   // Go from an internal address to an external one.
   ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
   EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
   EXPECT_EQ(20000, entry->GetDataSize(0));
   EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
   entry->Close();
+  WaitForEntryToClose(key2);
 
   // Double check the size from disk.
   ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
   EXPECT_EQ(20000, entry->GetDataSize(0));
 
   // Now extend the entry without actual data.
   EXPECT_EQ(0, WriteData(entry, 0, 45500, buffer1.get(), 0, false));
   entry->Close();
+  WaitForEntryToClose(key2);
 
   // And check again from disk.
   ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
   EXPECT_EQ(45500, entry->GetDataSize(0));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, GrowData) {
   InitCache();
   GrowData();
 }
 
+TEST_F(DiskCacheEntryTest, V3GrowData) {
+  UseVersion3();
+  InitCache();
+  GrowData();
+}
+
 TEST_F(DiskCacheEntryTest, GrowDataNoBuffer) {
   InitCache();
   cache_impl_->SetFlags(disk_cache::kNoBuffering);
   GrowData();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData) {
   SetMemoryOnlyMode();
   InitCache();
   GrowData();
@@ skipping 17 matching lines @@
   EXPECT_EQ(200, entry->GetDataSize(0));
   EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1.get(), 100, false));
   EXPECT_EQ(200, entry->GetDataSize(0));
   EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1.get(), 100, true));
   EXPECT_EQ(100, entry->GetDataSize(0));
   EXPECT_EQ(0, WriteData(entry, 0, 50, buffer1.get(), 0, true));
   EXPECT_EQ(50, entry->GetDataSize(0));
   EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1.get(), 0, true));
   EXPECT_EQ(0, entry->GetDataSize(0));
   entry->Close();
+  WaitForEntryToClose(key);
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // Go to an external file.
   EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), 20000, true));
   EXPECT_EQ(20000, entry->GetDataSize(0));
   EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), 20000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000));
   memset(buffer2->data(), 0, kSize2);
 
   // External file truncation
   EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1.get(), 18000, false));
   EXPECT_EQ(20000, entry->GetDataSize(0));
   EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1.get(), 18000, true));
   EXPECT_EQ(18000, entry->GetDataSize(0));
   EXPECT_EQ(0, WriteData(entry, 0, 17500, buffer1.get(), 0, true));
   EXPECT_EQ(17500, entry->GetDataSize(0));
 
   // And back to an internal block.
   EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1.get(), 600, true));
   EXPECT_EQ(1600, entry->GetDataSize(0));
   EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer2.get(), 600));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 600));
   EXPECT_EQ(1000, ReadData(entry, 0, 0, buffer2.get(), 1000));
-  EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000))
-      << "Preserves previous data";
+  EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000)) <<
+      "Preserves previous data";
 
   // Go from external file to zero length.
   EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), 20000, true));
   EXPECT_EQ(20000, entry->GetDataSize(0));
   EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1.get(), 0, true));
   EXPECT_EQ(0, entry->GetDataSize(0));
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, TruncateData) {
   InitCache();
   TruncateData();
 }
 
+TEST_F(DiskCacheEntryTest, V3TruncateData) {
+  UseVersion3();
+  InitCache();
+  TruncateData();
+}
+
 TEST_F(DiskCacheEntryTest, TruncateDataNoBuffer) {
   InitCache();
-  cache_impl_->SetFlags(disk_cache::kNoBuffering);
+  SetNoBuffering();
+  TruncateData();
+}
+
+TEST_F(DiskCacheEntryTest, V3TruncateDataNoBuffer) {
+  UseVersion3();
+  InitCache();
+  SetNoBuffering();
   TruncateData();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) {
   SetMemoryOnlyMode();
   InitCache();
   TruncateData();
 }
 
 void DiskCacheEntryTest::ZeroLengthIO() {
@@ skipping 32 matching lines @@
   EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ZeroLengthIO) {
   InitCache();
   ZeroLengthIO();
 }
 
+TEST_F(DiskCacheEntryTest, V3ZeroLengthIO) {
+  UseVersion3();
+  InitCache();
+  ZeroLengthIO();
+}
+
 TEST_F(DiskCacheEntryTest, ZeroLengthIONoBuffer) {
   InitCache();
-  cache_impl_->SetFlags(disk_cache::kNoBuffering);
+  SetNoBuffering();
+  ZeroLengthIO();
+}
+
+TEST_F(DiskCacheEntryTest, V3ZeroLengthIONoBuffer) {
+  UseVersion3();
+  InitCache();
+  SetNoBuffering();
   ZeroLengthIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) {
   SetMemoryOnlyMode();
   InitCache();
   ZeroLengthIO();
 }
 
 // Tests that we handle the content correctly when buffering, a feature of the
 // standard cache that permits fast responses to certain reads.
 void DiskCacheEntryTest::Buffering() {
   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> buffer1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kSize, true);
   CacheTestFillBuffer(buffer2->data(), kSize, true);
 
   EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
   entry->Close();
+  WaitForEntryToClose(key);
 
   // Write a little more and read what we wrote before.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1.get(), kSize, false));
   EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
 
   // Now go to an external file.
   EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1.get(), kSize, false));
   entry->Close();
+  WaitForEntryToClose(key);
 
   // Write something else and verify old data.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1.get(), kSize, false));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
   EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
   EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
   EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
 
   // Extend the file some more.
   EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, false));
   entry->Close();
+  WaitForEntryToClose(key);
 
   // And now make sure that we can deal with data in both places (ram/disk).
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, false));
 
   // We should not overwrite the data at 18000 with this.
   EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false));
   CacheTestFillBuffer(buffer2->data(), kSize, true);
   EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
@@ skipping 21 matching lines @@
   EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, Buffering) {
   InitCache();
   Buffering();
 }
 
+TEST_F(DiskCacheEntryTest, V3Buffering) {
+  UseVersion3();
+  InitCache();
+  Buffering();
+}
+
 TEST_F(DiskCacheEntryTest, BufferingNoBuffer) {
   InitCache();
-  cache_impl_->SetFlags(disk_cache::kNoBuffering);
+  SetNoBuffering();
+  Buffering();
+}
+
+TEST_F(DiskCacheEntryTest, V3BufferingNoBuffer) {
+  UseVersion3();
+  InitCache();
+  SetNoBuffering();
   Buffering();
 }
 
 // Checks that entries are zero length when created.
 void DiskCacheEntryTest::SizeAtCreate() {
   const char key[]  = "the first key";
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kNumStreams = 3;
   for (int i = 0; i < kNumStreams; ++i)
     EXPECT_EQ(0, entry->GetDataSize(i));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SizeAtCreate) {
   InitCache();
   SizeAtCreate();
 }
 
+TEST_F(DiskCacheEntryTest, V3SizeAtCreate) {
+  UseVersion3();
+  InitCache();
+  SizeAtCreate();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlySizeAtCreate) {
   SetMemoryOnlyMode();
   InitCache();
   SizeAtCreate();
 }
 
 // Some extra tests to make sure that buffering works properly when changing
 // the entry size.
 void DiskCacheEntryTest::SizeChanges() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 200;
   const char zeros[kSize] = {};
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kSize, true);
   CacheTestFillBuffer(buffer2->data(), kSize, true);
 
   EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, true));
   EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, true));
   EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, true));
   entry->Close();
+  WaitForEntryToClose(key);
 
   // Extend the file and read between the old size and the new write.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_EQ(23000 + kSize, entry->GetDataSize(1));
   EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, true));
   EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
   EXPECT_EQ(kSize, ReadData(entry, 1, 24000, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, kSize));
 
   // Read at the end of the old file size.
@@ skipping 26 matching lines @@
   EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
   EXPECT_EQ(kSize, WriteData(entry, 1, 24500, buffer1.get(), kSize, true));
   EXPECT_EQ(24500 + kSize, entry->GetDataSize(1));
   EXPECT_EQ(kSize, ReadData(entry, 1, 23900, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
   EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
 
   // And now reduce the size below the old size.
   EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, true));
   EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
-  EXPECT_EQ(kSize, ReadData(entry, 1, 18900, buffer2.get(), kSize));
+
+  // Repeat the last write to make results consistent across backends.
+  EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false));
+
+  EXPECT_EQ(100, ReadData(entry, 1, 18900, buffer2.get(), kSize));
   EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
-  EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
 
   // Verify that the actual file is truncated.
   entry->Close();
+  WaitForEntryToClose(key);
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
 
   // Extend the newly opened file with a zero length write, expect zero fill.
   EXPECT_EQ(0, WriteData(entry, 1, 20000 + kSize, buffer1.get(), 0, false));
   EXPECT_EQ(kSize, ReadData(entry, 1, 19000 + kSize, buffer1.get(), kSize));
   EXPECT_EQ(0, memcmp(buffer1->data(), zeros, kSize));
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SizeChanges) {
   InitCache();
   SizeChanges();
 }
 
+TEST_F(DiskCacheEntryTest, V3SizeChanges) {
+  UseVersion3();
+  InitCache();
+  SizeChanges();
+}
+
 TEST_F(DiskCacheEntryTest, SizeChangesNoBuffer) {
   InitCache();
-  cache_impl_->SetFlags(disk_cache::kNoBuffering);
+  SetNoBuffering();
+  SizeChanges();
+}
+
+TEST_F(DiskCacheEntryTest, V3SizeChangesNoBuffer) {
+  UseVersion3();
+  InitCache();
+  SetNoBuffering();
   SizeChanges();
 }
 
 // Write more than the total cache capacity but to a single entry. |size| is the
 // amount of bytes to write each time.
 void DiskCacheEntryTest::ReuseEntry(int size) {
   std::string key1("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
 
   entry->Close();
   std::string key2("the second key");
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
   CacheTestFillBuffer(buffer->data(), size, false);
 
   for (int i = 0; i < 15; i++) {
     EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true));
     EXPECT_EQ(size, WriteData(entry, 0, 0, buffer.get(), size, false));
     entry->Close();
+    WaitForEntryToClose(key2);
     ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
   }
 
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry";
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ReuseExternalEntry) {
   SetMaxSize(200 * 1024);
   InitCache();
   ReuseEntry(20 * 1024);
 }
 
+TEST_F(DiskCacheEntryTest, V3ReuseExternalEntry) {
+  UseVersion3();
+  SetMaxSize(200 * 1024);
+  InitCache();
+  ReuseEntry(20 * 1024);
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyReuseExternalEntry) {
   SetMemoryOnlyMode();
   SetMaxSize(200 * 1024);
   InitCache();
   ReuseEntry(20 * 1024);
 }
 
 TEST_F(DiskCacheEntryTest, ReuseInternalEntry) {
   SetMaxSize(100 * 1024);
   InitCache();
   ReuseEntry(10 * 1024);
 }
 
+TEST_F(DiskCacheEntryTest, V3ReuseInternalEntry) {
+  UseVersion3();
+  SetMaxSize(100 * 1024);
+  InitCache();
+  ReuseEntry(10 * 1024);
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyReuseInternalEntry) {
   SetMemoryOnlyMode();
   SetMaxSize(100 * 1024);
   InitCache();
   ReuseEntry(10 * 1024);
 }
 
 // Reading somewhere that was not written should return zeros.
 void DiskCacheEntryTest::InvalidData() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize1 = 20000;
   const int kSize2 = 20000;
   const int kSize3 = 20000;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
   scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
 
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   memset(buffer2->data(), 0, kSize2);
 
   // Simple data grow:
   EXPECT_EQ(200, WriteData(entry, 0, 400, buffer1.get(), 200, false));
   EXPECT_EQ(600, entry->GetDataSize(0));
   EXPECT_EQ(100, ReadData(entry, 0, 300, buffer3.get(), 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
   entry->Close();
+  WaitForEntryToClose(key);
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // The entry is now on disk. Load it and extend it.
   EXPECT_EQ(200, WriteData(entry, 0, 800, buffer1.get(), 200, false));
   EXPECT_EQ(1000, entry->GetDataSize(0));
   EXPECT_EQ(100, ReadData(entry, 0, 700, buffer3.get(), 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
   entry->Close();
+  WaitForEntryToClose(key);
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // This time using truncate.
   EXPECT_EQ(200, WriteData(entry, 0, 1800, buffer1.get(), 200, true));
   EXPECT_EQ(2000, entry->GetDataSize(0));
   EXPECT_EQ(100, ReadData(entry, 0, 1500, buffer3.get(), 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
 
   // Go to an external file.
   EXPECT_EQ(200, WriteData(entry, 0, 19800, buffer1.get(), 200, false));
@@ skipping 20 matching lines @@
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, InvalidData) {
   InitCache();
   InvalidData();
 }
 
+TEST_F(DiskCacheEntryTest, V3InvalidData) {
+  UseVersion3();
+  InitCache();
+  InvalidData();
+}
+
 TEST_F(DiskCacheEntryTest, InvalidDataNoBuffer) {
   InitCache();
-  cache_impl_->SetFlags(disk_cache::kNoBuffering);
+  SetNoBuffering();
+  InvalidData();
+}
+
+TEST_F(DiskCacheEntryTest, V3InvalidDataNoBuffer) {
+  UseVersion3();
+  InitCache();
+  SetNoBuffering();
   InvalidData();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) {
   SetMemoryOnlyMode();
   InitCache();
   InvalidData();
 }
 
 // Tests that the cache preserves the buffer of an IO operation.
 void DiskCacheEntryTest::ReadWriteDestroyBuffer() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
-  const int kSize = 200;
+  const int kSize = 20000;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
 
   net::TestCompletionCallback cb;
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry->WriteData(0, 0, buffer.get(), kSize, cb.callback(), false));
 
   // Release our reference to the buffer.
   buffer = NULL;
   EXPECT_EQ(kSize, cb.WaitForResult());
 
   // And now test with a Read().
   buffer = new net::IOBuffer(kSize);
   CacheTestFillBuffer(buffer->data(), kSize, false);
 
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry->ReadData(0, 0, buffer.get(), kSize, cb.callback()));
   buffer = NULL;
   EXPECT_EQ(kSize, cb.WaitForResult());
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ReadWriteDestroyBuffer) {
   InitCache();
   ReadWriteDestroyBuffer();
 }
 
+TEST_F(DiskCacheEntryTest, V3ReadWriteDestroyBuffer) {
+  UseVersion3();
+  InitCache();
+  SetNoBuffering();
+  ReadWriteDestroyBuffer();
+}
+
 void DiskCacheEntryTest::DoomNormalEntry() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   entry->Doom();
   entry->Close();
 
   const int kSize = 20000;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, true);
   buffer->data()[19999] = '\0';
 
   key = buffer->data();
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer.get(), kSize, false));
   EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer.get(), kSize, false));
   entry->Doom();
   entry->Close();
 
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, DoomEntry) {
   InitCache();
   DoomNormalEntry();
 }
 
+TEST_F(DiskCacheEntryTest, V3DoomEntry) {
+  UseVersion3();
+  InitCache();
+  DoomNormalEntry();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomNormalEntry();
 }
 
 // Tests dooming an entry that's linked to an open entry.
 void DiskCacheEntryTest::DoomEntryNextToOpenEntry() {
   disk_cache::Entry* entry1;
   disk_cache::Entry* entry2;
@@ skipping 16 matching lines @@
 
   ASSERT_EQ(net::OK, OpenEntry("fixed", &entry1));
   entry1->Close();
 }
 
 TEST_F(DiskCacheEntryTest, DoomEntryNextToOpenEntry) {
   InitCache();
   DoomEntryNextToOpenEntry();
 }
 
+TEST_F(DiskCacheEntryTest, V3DoomEntryNextToOpenEntry) {
+  UseVersion3();
+  InitCache();
+  DoomEntryNextToOpenEntry();
+}
+
 TEST_F(DiskCacheEntryTest, NewEvictionDoomEntryNextToOpenEntry) {
   SetNewEviction();
   InitCache();
   DoomEntryNextToOpenEntry();
 }
 
 TEST_F(DiskCacheEntryTest, AppCacheDoomEntryNextToOpenEntry) {
   SetCacheType(net::APP_CACHE);
   InitCache();
   DoomEntryNextToOpenEntry();
@@ skipping 26 matching lines @@
   EXPECT_TRUE(initial < entry->GetLastUsed());
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, DoomedEntry) {
   InitCache();
   DoomedEntry();
 }
 
+TEST_F(DiskCacheEntryTest, V3DoomedEntry) {
+  UseVersion3();
+  InitCache();
+  DoomedEntry();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomedEntry();
 }
 
-// Tests that we discard entries if the data is missing.
-TEST_F(DiskCacheEntryTest, MissingData) {
+void DiskCacheEntryTest::MissingData() {
   InitCache();
 
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   // Write to an external file.
   const int kSize = 20000;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer.get(), kSize, false));
   entry->Close();
   FlushQueueForTest();
 
   disk_cache::Addr address(0x80000001);
-  base::FilePath name = cache_impl_->GetFileName(address);
+  if (cache_impl_v3_)
+    address.set_value(0x80040000);
+
+  std::string tmp = base::StringPrintf("f_%06x", address.FileNumber());
+  base::FilePath name = cache_path_.AppendASCII(tmp);
   EXPECT_TRUE(base::DeleteFile(name, false));
 
   // Attempt to read the data.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND,
-            ReadData(entry, 0, 0, buffer.get(), kSize));
+            ReadData(entry, 1, 0, buffer.get(), kSize));
   entry->Close();
 
   // The entry should be gone.
   ASSERT_NE(net::OK, OpenEntry(key, &entry));
 }
 
+TEST_F(DiskCacheEntryTest, MissingData) {
+  MissingData();
+}
+
+TEST_F(DiskCacheEntryTest, V3MissingData) {
+  UseVersion3();
+  MissingData();
+}
+
 // Test that child entries in a memory cache backend are not visible from
 // enumerations.
 TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
   SetMemoryOnlyMode();
   InitCache();
 
   const int kSize = 4096;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   std::string key("the first key");
   disk_cache::Entry* parent_entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &parent_entry));
 
   // Writes to the parent entry.
-  EXPECT_EQ(kSize,
-            parent_entry->WriteSparseData(
-                0, buf.get(), kSize, net::CompletionCallback()));
+  EXPECT_EQ(kSize, parent_entry->WriteSparseData(0, buf, kSize,
+                                                 net::CompletionCallback()));
 
   // This write creates a child entry and writes to it.
-  EXPECT_EQ(kSize,
-            parent_entry->WriteSparseData(
-                8192, buf.get(), kSize, net::CompletionCallback()));
+  EXPECT_EQ(kSize, parent_entry->WriteSparseData(8192, buf, kSize,
+                                                 net::CompletionCallback()));
 
   parent_entry->Close();
 
   // Perform the enumerations.
   void* iter = NULL;
   disk_cache::Entry* entry = NULL;
   int count = 0;
   while (OpenNextEntry(&iter, &entry) == net::OK) {
     ASSERT_TRUE(entry != NULL);
     ++count;
@@ skipping 24 matching lines @@
 }
 
 // Reads |size| bytes from |entry| at |offset| and verifies that they are the
 // same as the content of the provided |buffer|.
 void VerifyContentSparseIO(disk_cache::Entry* entry, int64 offset, char* buffer,
                            int size) {
   net::TestCompletionCallback cb;
 
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(size));
   memset(buf_1->data(), 0, size);
-  int ret = entry->ReadSparseData(offset, buf_1.get(), size, cb.callback());
+  int ret = entry->ReadSparseData(offset, buf_1, size, cb.callback());
   EXPECT_EQ(size, cb.GetResult(ret));
   EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size));
 }
 
 void DiskCacheEntryTest::BasicSparseIO() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 2048;
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   // Write at offset 0.
-  VerifySparseIO(entry, 0, buf_1.get(), kSize, buf_2.get());
+  VerifySparseIO(entry, 0, buf_1, kSize, buf_2);
 
   // Write at offset 0x400000 (4 MB).
-  VerifySparseIO(entry, 0x400000, buf_1.get(), kSize, buf_2.get());
+  VerifySparseIO(entry, 0x400000, buf_1, kSize, buf_2);
 
   // Write at offset 0x800000000 (32 GB).
-  VerifySparseIO(entry, 0x800000000LL, buf_1.get(), kSize, buf_2.get());
+  VerifySparseIO(entry, 0x800000000LL, buf_1, kSize, buf_2);
 
   entry->Close();
+  AddDelayForTest(40);  // We need to close multiple entries.
+  WaitForEntryToClose(key);
 
   // Check everything again.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
   VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize);
   VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize);
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, BasicSparseIO) {
   InitCache();
   BasicSparseIO();
 }
 
+TEST_F(DiskCacheEntryTest, V3BasicSparseIO) {
+  UseVersion3();
+  InitCache();
+  BasicSparseIO();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseIO) {
   SetMemoryOnlyMode();
   InitCache();
   BasicSparseIO();
 }
 
 void DiskCacheEntryTest::HugeSparseIO() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   // Write 1.2 MB so that we cover multiple entries.
   const int kSize = 1200 * 1024;
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB).
-  VerifySparseIO(entry, 0x20F0000, buf_1.get(), kSize, buf_2.get());
+  VerifySparseIO(entry, 0x20F0000, buf_1, kSize, buf_2);
   entry->Close();
+  WaitForEntryToClose(key);
 
   // Check it again.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize);
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, HugeSparseIO) {
   InitCache();
   HugeSparseIO();
 }
 
+TEST_F(DiskCacheEntryTest, V3HugeSparseIO) {
+  UseVersion3();
+  InitCache();
+  HugeSparseIO();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseIO) {
   SetMemoryOnlyMode();
   InitCache();
   HugeSparseIO();
 }
 
-void DiskCacheEntryTest::GetAvailableRange() {
+void DiskCacheEntryTest::SparseGetAvailableRange() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 16 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB).
-  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf.get(), kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf, kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf, kSize));
 
   // We stop at the first empty block.
   int64 start;
   net::TestCompletionCallback cb;
-  int rv = entry->GetAvailableRange(
-      0x20F0000, kSize * 2, &start, cb.callback());
+  int rv = entry->GetAvailableRange(0x20F0000, kSize * 2, &start,
+                                    cb.callback());
   EXPECT_EQ(kSize, cb.GetResult(rv));
   EXPECT_EQ(0x20F0000, start);
 
   start = 0;
-  rv = entry->GetAvailableRange(0, kSize, &start, cb.callback());
-  EXPECT_EQ(0, cb.GetResult(rv));
-  rv = entry->GetAvailableRange(
-      0x20F0000 - kSize, kSize, &start, cb.callback());
-  EXPECT_EQ(0, cb.GetResult(rv));
-  rv = entry->GetAvailableRange(0, 0x2100000, &start, cb.callback());
-  EXPECT_EQ(kSize, cb.GetResult(rv));
+  EXPECT_EQ(0, GetAvailableRange(entry, 0, kSize, &start));
+  EXPECT_EQ(0, GetAvailableRange(entry, 0x20F0000 - kSize, kSize, &start));
+  EXPECT_EQ(kSize, GetAvailableRange(entry, 0, 0x2100000, &start));
   EXPECT_EQ(0x20F0000, start);
 
   // We should be able to Read based on the results of GetAvailableRange.
   start = -1;
-  rv = entry->GetAvailableRange(0x2100000, kSize, &start, cb.callback());
-  EXPECT_EQ(0, cb.GetResult(rv));
-  rv = entry->ReadSparseData(start, buf.get(), kSize, cb.callback());
-  EXPECT_EQ(0, cb.GetResult(rv));
+  EXPECT_EQ(0, GetAvailableRange(entry, 0x2100000, kSize, &start));
+  EXPECT_EQ(0, ReadSparseData(entry, start, buf, kSize));
 
   start = 0;
-  rv = entry->GetAvailableRange(0x20F2000, kSize, &start, cb.callback());
-  EXPECT_EQ(0x2000, cb.GetResult(rv));
+  EXPECT_EQ(0x2000, GetAvailableRange(entry, 0x20F2000, kSize, &start));
   EXPECT_EQ(0x20F2000, start);
-  EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf.get(), kSize));
+  EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf, kSize));
 
   // Make sure that we respect the |len| argument.
   start = 0;
-  rv = entry->GetAvailableRange(
-      0x20F0001 - kSize, kSize, &start, cb.callback());
-  EXPECT_EQ(1, cb.GetResult(rv));
+  EXPECT_EQ(1, GetAvailableRange(entry, 0x20F0001 - kSize, kSize, &start));
   EXPECT_EQ(0x20F0000, start);
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, GetAvailableRange) {
   InitCache();
-  GetAvailableRange();
+  SparseGetAvailableRange();
+}
+
+TEST_F(DiskCacheEntryTest, V3GetAvailableRange) {
+  UseVersion3();
+  InitCache();
+  SparseGetAvailableRange();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyGetAvailableRange) {
   SetMemoryOnlyMode();
   InitCache();
-  GetAvailableRange();
+  SparseGetAvailableRange();
 }
 
 void DiskCacheEntryTest::CouldBeSparse() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 16 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB).
-  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf, kSize));
 
   EXPECT_TRUE(entry->CouldBeSparse());
   entry->Close();
+  WaitForEntryToClose(key);
 
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_TRUE(entry->CouldBeSparse());
   entry->Close();
+  WaitForEntryToClose(key);
 
   // Now verify a regular entry.
   key.assign("another key");
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_FALSE(entry->CouldBeSparse());
 
   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf.get(), kSize, false));
   EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf.get(), kSize, false));
   EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf.get(), kSize, false));
 
   EXPECT_FALSE(entry->CouldBeSparse());
   entry->Close();
+  WaitForEntryToClose(key);
 
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_FALSE(entry->CouldBeSparse());
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, CouldBeSparse) {
   InitCache();
   CouldBeSparse();
 }
 
+TEST_F(DiskCacheEntryTest, V3CouldBeSparse) {
+  UseVersion3();
+  InitCache();
+  CouldBeSparse();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryCouldBeSparse) {
   SetMemoryOnlyMode();
   InitCache();
   CouldBeSparse();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) {
   SetMemoryOnlyMode();
   InitCache();
 
   const int kSize = 8192;
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   // This loop writes back to back starting from offset 0 and 9000.
   for (int i = 0; i < kSize; i += 1024) {
     scoped_refptr<net::WrappedIOBuffer> buf_3(
       new net::WrappedIOBuffer(buf_1->data() + i));
-    VerifySparseIO(entry, i, buf_3.get(), 1024, buf_2.get());
-    VerifySparseIO(entry, 9000 + i, buf_3.get(), 1024, buf_2.get());
+    VerifySparseIO(entry, i, buf_3, 1024, buf_2);
+    VerifySparseIO(entry, 9000 + i, buf_3, 1024, buf_2);
   }
 
   // Make sure we have data written.
   VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
   VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize);
 
   // This tests a large write that spans 3 entries from a misaligned offset.
-  VerifySparseIO(entry, 20481, buf_1.get(), 8192, buf_2.get());
+  VerifySparseIO(entry, 20481, buf_1, 8192, buf_2);
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) {
   SetMemoryOnlyMode();
   InitCache();
 
   const int kSize = 8192;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   disk_cache::Entry* entry;
   std::string key("the first key");
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   // Writes in the middle of an entry.
-  EXPECT_EQ(
-      1024,
-      entry->WriteSparseData(0, buf.get(), 1024, net::CompletionCallback()));
-  EXPECT_EQ(
-      1024,
-      entry->WriteSparseData(5120, buf.get(), 1024, net::CompletionCallback()));
-  EXPECT_EQ(1024,
-            entry->WriteSparseData(
-                10000, buf.get(), 1024, net::CompletionCallback()));
+  EXPECT_EQ(1024, entry->WriteSparseData(0, buf, 1024,
+                                         net::CompletionCallback()));
+  EXPECT_EQ(1024, entry->WriteSparseData(5120, buf, 1024,
+                                         net::CompletionCallback()));
+  EXPECT_EQ(1024, entry->WriteSparseData(10000, buf, 1024,
+                                         net::CompletionCallback()));
 
   // Writes in the middle of an entry and spans 2 child entries.
-  EXPECT_EQ(8192,
-            entry->WriteSparseData(
-                50000, buf.get(), 8192, net::CompletionCallback()));
+  EXPECT_EQ(8192, entry->WriteSparseData(50000, buf, 8192,
+                                         net::CompletionCallback()));
 
   int64 start;
   net::TestCompletionCallback cb;
   // Test that we stop at a discontinuous child at the second block.
   int rv = entry->GetAvailableRange(0, 10000, &start, cb.callback());
   EXPECT_EQ(1024, cb.GetResult(rv));
   EXPECT_EQ(0, start);
 
   // Test that number of bytes is reported correctly when we start from the
   // middle of a filled region.
@@ skipping 30 matching lines @@
   std::string key("the first key");
   disk_cache::Entry* entry1;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
 
   const int kSize = 2048;
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   // Write at offset 0.
-  VerifySparseIO(entry1, 0, buf_1.get(), kSize, buf_2.get());
+  VerifySparseIO(entry1, 0, buf_1, kSize, buf_2);
   entry1->Close();
 
   // Write at offset 2048.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
-  VerifySparseIO(entry1, 2048, buf_1.get(), kSize, buf_2.get());
+  VerifySparseIO(entry1, 2048, buf_1, kSize, buf_2);
 
   disk_cache::Entry* entry2;
   ASSERT_EQ(net::OK, CreateEntry("the second key", &entry2));
 
   entry1->Close();
   entry2->Close();
   FlushQueueForTest();
   if (memory_only_ || simple_cache_mode_)
     EXPECT_EQ(2, cache_->GetEntryCount());
   else
     EXPECT_EQ(3, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, UpdateSparseEntry) {
   SetCacheType(net::MEDIA_CACHE);
   InitCache();
   UpdateSparseEntry();
 }
 
+TEST_F(DiskCacheEntryTest, V3UpdateSparseEntry) {
+  UseVersion3();
+  SetCacheType(net::MEDIA_CACHE);
+  InitCache();
+  UpdateSparseEntry();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) {
   SetMemoryOnlyMode();
   SetCacheType(net::MEDIA_CACHE);
   InitCache();
   UpdateSparseEntry();
 }
 
 void DiskCacheEntryTest::DoomSparseEntry() {
   std::string key1("the first key");
   std::string key2("the second key");
@@ skipping 18 matching lines @@
 
   if (memory_only_ || simple_cache_mode_)
     EXPECT_EQ(2, cache_->GetEntryCount());
   else
     EXPECT_EQ(15, cache_->GetEntryCount());
 
   // Doom the first entry while it's still open.
   entry1->Doom();
   entry1->Close();
   entry2->Close();
+  WaitForEntryToClose(key1);
+  WaitForEntryToClose(key2);
 
   // Doom the second entry after it's fully saved.
   EXPECT_EQ(net::OK, DoomEntry(key2));
 
   // Make sure we do all needed work. This may fail for entry2 if between Close
   // and DoomEntry the system decides to remove all traces of the file from the
   // system cache so we don't see that there is pending IO.
-  base::MessageLoop::current()->RunUntilIdle();
+  WaitForEntryToClose(key2);
 
   if (memory_only_) {
     EXPECT_EQ(0, cache_->GetEntryCount());
   } else {
     if (5 == cache_->GetEntryCount()) {
       // Most likely we are waiting for the result of reading the sparse info
       // (it's always async on Posix so it is easy to miss). Unfortunately we
       // don't have any signal to watch for so we can only wait.
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
-      base::MessageLoop::current()->RunUntilIdle();
+      FlushQueueForTest();
     }
     EXPECT_EQ(0, cache_->GetEntryCount());
   }
 }
 
 TEST_F(DiskCacheEntryTest, DoomSparseEntry) {
   UseCurrentThread();
   InitCache();
   DoomSparseEntry();
 }
 
+TEST_F(DiskCacheEntryTest, V3DoomSparseEntry) {
+  UseVersion3();
+  UseCurrentThread();
+  InitCache();
+  DoomSparseEntry();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomSparseEntry();
 }
 
 // A CompletionCallback wrapper that deletes the cache from within the callback.
 // The way a CompletionCallback works means that all tasks (even new ones)
 // are executed by the message loop before returning to the caller so the only
 // way to simulate a race is to execute what we want on the callback.
 class SparseTestCompletionCallback: public net::TestCompletionCallback {
  public:
   explicit SparseTestCompletionCallback(scoped_ptr<disk_cache::Backend> cache)
       : cache_(cache.Pass()) {
   }
 
  private:
   virtual void SetResult(int result) OVERRIDE {
     cache_.reset();
     TestCompletionCallback::SetResult(result);
   }
 
   scoped_ptr<disk_cache::Backend> cache_;
   DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback);
 };
 
 // Tests that we don't crash when the backend is deleted while we are working
 // deleting the sub-entries of a sparse entry.
-TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
+void DiskCacheEntryTest::DoomSparseEntry2() {
   UseCurrentThread();
+  ForceRandomCacheDir();
   InitCache();
   std::string key("the key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 4 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   int64 offset = 1024;
   // Write to a bunch of ranges.
   for (int i = 0; i < 12; i++) {
-    EXPECT_EQ(kSize,
-              entry->WriteSparseData(
-                  offset, buf.get(), kSize, net::CompletionCallback()));
+    EXPECT_EQ(kSize, entry->WriteSparseData(offset, buf, kSize,
+                                            net::CompletionCallback()));
     offset *= 4;
   }
   EXPECT_EQ(9, cache_->GetEntryCount());
 
   entry->Close();
+  WaitForEntryToClose(key);
+
   disk_cache::Backend* cache = cache_.get();
   SparseTestCompletionCallback cb(cache_.Pass());
   int rv = cache->DoomEntry(key, cb.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
   EXPECT_EQ(net::OK, cb.WaitForResult());
+
+  cache_impl_ = NULL;
+  cache_impl_v3_ = NULL;
+}
+
+TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
+  DoomSparseEntry2();
+}
+
+TEST_F(DiskCacheEntryTest, V3DoomSparseEntry2) {
+  UseVersion3();
+  DoomSparseEntry2();
 }
 
 void DiskCacheEntryTest::PartialSparseEntry() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   // We should be able to deal with IO that is not aligned to the block size
   // of a sparse entry, at least to write a big range without leaving holes.
   const int kSize = 4 * 1024;
   const int kSmallSize = 128;
   scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf1->data(), kSize, false);
 
   // The first write is just to extend the entry. The third write occupies
   // a 1KB block partially, it may not be written internally depending on the
   // implementation.
-  EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1.get(), kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1.get(), kSize));
-  EXPECT_EQ(kSmallSize,
-            WriteSparseData(entry, 1080321, buf1.get(), kSmallSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1, kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1, kSize));
+  EXPECT_EQ(kSmallSize, WriteSparseData(entry, 1080321, buf1, kSmallSize));
   entry->Close();
+  WaitForEntryToClose(key);
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   scoped_refptr<net::IOBuffer> buf2(new net::IOBuffer(kSize));
   memset(buf2->data(), 0, kSize);
-  EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2.get(), kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2, kSize));
 
-  EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
+  EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2, kSize));
   EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
-  EXPECT_EQ(0, ReadSparseData(entry, 0, buf2.get(), kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, 0, buf2, kSize));
 
   // This read should not change anything.
-  EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2.get(), kSize));
-  EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
-  EXPECT_EQ(0, ReadSparseData(entry, 99, buf2.get(), kSize));
+  EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2, kSize));
+  EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2, kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, 99, buf2, kSize));
 
   int rv;
   int64 start;
   net::TestCompletionCallback cb;
   if (memory_only_ || simple_cache_mode_) {
     rv = entry->GetAvailableRange(0, 600, &start, cb.callback());
     EXPECT_EQ(100, cb.GetResult(rv));
     EXPECT_EQ(500, start);
   } else {
     rv = entry->GetAvailableRange(0, 2048, &start, cb.callback());
@@ skipping 20 matching lines @@
     EXPECT_EQ(20480, start);
   }
   rv = entry->GetAvailableRange(3073, kSize, &start, cb.callback());
   EXPECT_EQ(1523, cb.GetResult(rv));
   EXPECT_EQ(3073, start);
   rv = entry->GetAvailableRange(4600, kSize, &start, cb.callback());
   EXPECT_EQ(0, cb.GetResult(rv));
   EXPECT_EQ(4600, start);
 
   // Now make another write and verify that there is no hole in between.
-  EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1.get(), kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1, kSize));
   rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback());
   EXPECT_EQ(7 * 1024 + 500, cb.GetResult(rv));
   EXPECT_EQ(1024, start);
-  EXPECT_EQ(kSize, ReadSparseData(entry, kSize, buf2.get(), kSize));
+  EXPECT_EQ(kSize, ReadSparseData(entry, kSize, buf2, kSize));
   EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
   EXPECT_EQ(0, memcmp(buf2->data() + 500, buf1->data(), kSize - 500));
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, PartialSparseEntry) {
   InitCache();
   PartialSparseEntry();
 }
 
+TEST_F(DiskCacheEntryTest, V3PartialSparseEntry) {
+  UseVersion3();
+  InitCache();
+  PartialSparseEntry();
+}
+
 TEST_F(DiskCacheEntryTest, MemoryPartialSparseEntry) {
   SetMemoryOnlyMode();
   InitCache();
   PartialSparseEntry();
 }
 
 // Tests that corrupt sparse children are removed automatically.
-TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
+void DiskCacheEntryTest::CleanupSparseEntry() {
   InitCache();
+  SetNoBuffering();
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 4 * 1024;
   scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf1->data(), kSize, false);
 
   const int k1Meg = 1024 * 1024;
-  EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1.get(), kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1, kSize));
+  AddDelayForTest(70);
+  EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1, kSize));
+  AddDelayForTest(70);
+  EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1, kSize));
+  AddDelayForTest(70);
   entry->Close();
   EXPECT_EQ(4, cache_->GetEntryCount());
 
   void* iter = NULL;
   int count = 0;
   std::string child_key[2];
   while (OpenNextEntry(&iter, &entry) == net::OK) {
     ASSERT_TRUE(entry != NULL);
     // Writing to an entry will alter the LRU list and invalidate the iterator.
     if (entry->GetKey() != key && count < 2)
       child_key[count++] = entry->GetKey();
     entry->Close();
   }
   for (int i = 0; i < 2; i++) {
     ASSERT_EQ(net::OK, OpenEntry(child_key[i], &entry));
     // Overwrite the header's magic and signature.
     EXPECT_EQ(12, WriteData(entry, 2, 0, buf1.get(), 12, false));
     entry->Close();
   }
 
   EXPECT_EQ(4, cache_->GetEntryCount());
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // Two children should be gone. One while reading and one while writing.
-  EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
-  EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1.get(), kSize));
-  EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1, kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1, kSize));
+  EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1, kSize));
 
   // We never touched this one.
-  EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1.get(), kSize));
+  EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1, kSize));
   entry->Close();
 
   // We re-created one of the corrupt children.
   EXPECT_EQ(3, cache_->GetEntryCount());
 }
 
-TEST_F(DiskCacheEntryTest, CancelSparseIO) {
-  UseCurrentThread();
+TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
+  CleanupSparseEntry();
+}
+
+TEST_F(DiskCacheEntryTest, V3CleanupSparseEntry) {
+  UseVersion3();
+  CleanupSparseEntry();
+}
+
+void DiskCacheEntryTest::CancelSparseIO() {
   InitCache();
+  SetNoBuffering();
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 40 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // This will open and write two "real" entries.
   net::TestCompletionCallback cb1, cb2, cb3, cb4, cb5;
-  int rv = entry->WriteSparseData(
-      1024 * 1024 - 4096, buf.get(), kSize, cb1.callback());
+  int rv = entry->WriteSparseData(1024 * 1024 - kSize / 2, buf, kSize,
+                                  cb1.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   int64 offset = 0;
   rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback());
   rv = cb5.GetResult(rv);
   if (!cb1.have_result()) {
     // We may or may not have finished writing to the entry. If we have not,
     // we cannot start another operation at this time.
     EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, rv);
   }
 
   // We cancel the pending operation, and register multiple notifications.
   entry->CancelSparseIO();
   EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb2.callback()));
   EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb3.callback()));
   entry->CancelSparseIO();  // Should be a no op at this point.
   EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb4.callback()));
 
   if (!cb1.have_result()) {
     EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
-              entry->ReadSparseData(
-                  offset, buf.get(), kSize, net::CompletionCallback()));
+              entry->ReadSparseData(offset, buf, kSize,
+                                    net::CompletionCallback()));
     EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
-              entry->WriteSparseData(
-                  offset, buf.get(), kSize, net::CompletionCallback()));
+              entry->WriteSparseData(offset, buf, kSize,
+                                     net::CompletionCallback()));
   }
 
   // Now see if we receive all notifications. Note that we should not be able
   // to write everything (unless the timing of the system is really weird).
   rv = cb1.WaitForResult();
-  EXPECT_TRUE(rv == 4096 || rv == kSize);
+  EXPECT_TRUE(rv == kSize / 2 || rv == kSize);
   EXPECT_EQ(net::OK, cb2.WaitForResult());
   EXPECT_EQ(net::OK, cb3.WaitForResult());
   EXPECT_EQ(net::OK, cb4.WaitForResult());
 
   rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback());
   EXPECT_EQ(0, cb5.GetResult(rv));
   entry->Close();
 }
 
+TEST_F(DiskCacheEntryTest, CancelSparseIO) {
+  UseCurrentThread();
+  CancelSparseIO();
+}
+
+TEST_F(DiskCacheEntryTest, V3CancelSparseIO) {
+  UseVersion3();
+  CancelSparseIO();
+}
+
+// Tests a squence of Close + Open + ReadyForSparseIO + ReadSparseData.
+void DiskCacheEntryTest::ReadyForSparseIONoCancel() {
+  InitCache();
+  SetNoBuffering();
+  std::string key("the key");
+  disk_cache::Entry* entry;
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+
+  const int kSize = 4 * 1024;
+  scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
+  CacheTestFillBuffer(buf1->data(), kSize, false);
+  EXPECT_EQ(kSize, WriteSparseData(entry, 1024 * 1024 - kSize, buf1, kSize));
+
+  entry->Close();
+  WaitForEntryToClose(key);
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  net::TestCompletionCallback cb;
+  EXPECT_EQ(net::OK, cb.GetResult(entry->ReadyForSparseIO(cb.callback())));
+  EXPECT_EQ(kSize, ReadSparseData(entry, 1024 * 1024 - kSize, buf1, kSize));
+  entry->Close();
+}
+
+TEST_F(DiskCacheEntryTest, ReadyForSparseIONoCancel) {
+  UseVersion3();
+  ReadyForSparseIONoCancel();
+}
+
+TEST_F(DiskCacheEntryTest, V3ReadyForSparseIONoCancel) {
+  UseVersion3();
+  ReadyForSparseIONoCancel();
+}
+
 // Tests that we perform sanity checks on an entry's key. Note that there are
 // other tests that exercise sanity checks by using saved corrupt files.
 TEST_F(DiskCacheEntryTest, KeySanityCheck) {
   UseCurrentThread();
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   disk_cache::EntryImpl* entry_impl =
@@ skipping 1610 matching lines @@
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
   // Make sure the first range was removed when the second was written.
   ret = entry->ReadSparseData(0, buffer, kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
 
   entry->Close();
 }
 
 #endif  // defined(OS_POSIX)