Disk cache: Extend the internal buffering performed by each entry...

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2006-2010 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/platform_thread.h"
 #include "base/timer.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 18 matching lines @@
   void ExternalAsyncIO();
   void StreamAccess();
   void GetKey();
   void GrowData();
   void TruncateData();
   void ZeroLengthIO();
   void ReuseEntry(int size);
   void InvalidData();
   void DoomNormalEntry();
   void DoomedEntry();
-  void BasicSparseIO(bool async);
-  void HugeSparseIO(bool async);
+  void BasicSparseIO();
+  void HugeSparseIO();
   void GetAvailableRange();
   void CouldBeSparse();
   void DoomSparseEntry();
   void PartialSparseEntry();
 };
 
+// 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 *entry1 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
-  ASSERT_TRUE(NULL != entry1);
+  disk_cache::Entry* entry = NULL;
+  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+  ASSERT_TRUE(NULL != entry);
 
   const int kSize1 = 10;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
-  EXPECT_EQ(0, entry1->ReadData(0, 0, buffer1, kSize1, NULL));
+  EXPECT_EQ(0, entry->ReadData(0, 0, buffer1, kSize1, NULL));
   base::strlcpy(buffer1->data(), "the data", kSize1);
-  EXPECT_EQ(10, entry1->WriteData(0, 0, buffer1, kSize1, NULL, false));
+  EXPECT_EQ(10, entry->WriteData(0, 0, buffer1, kSize1, NULL, false));
   memset(buffer1->data(), 0, kSize1);
-  EXPECT_EQ(10, entry1->ReadData(0, 0, buffer1, kSize1, NULL));
+  EXPECT_EQ(10, entry->ReadData(0, 0, buffer1, kSize1, NULL));
   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, entry1->WriteData(1, 1500, buffer2, kSize2, NULL, false));
+  EXPECT_EQ(5000, entry->WriteData(1, 1500, buffer2, kSize2, NULL, false));
   memset(buffer2->data(), 0, kSize2);
-  EXPECT_EQ(4989, entry1->ReadData(1, 1511, buffer2, kSize2, NULL));
+  EXPECT_EQ(4989, entry->ReadData(1, 1511, buffer2, kSize2, NULL));
   EXPECT_STREQ("big data goes here", buffer2->data());
-  EXPECT_EQ(5000, entry1->ReadData(1, 0, buffer2, kSize2, NULL));
+  EXPECT_EQ(5000, entry->ReadData(1, 0, buffer2, kSize2, NULL));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
-  EXPECT_EQ(1500, entry1->ReadData(1, 5000, buffer2, kSize2, NULL));
+  EXPECT_EQ(1500, entry->ReadData(1, 5000, buffer2, kSize2, NULL));
 
-  EXPECT_EQ(0, entry1->ReadData(1, 6500, buffer2, kSize2, NULL));
-  EXPECT_EQ(6500, entry1->ReadData(1, 0, buffer3, kSize3, NULL));
-  EXPECT_EQ(8192, entry1->WriteData(1, 0, buffer3, 8192, NULL, false));
-  EXPECT_EQ(8192, entry1->ReadData(1, 0, buffer3, kSize3, NULL));
-  EXPECT_EQ(8192, entry1->GetDataSize(1));
+  EXPECT_EQ(0, entry->ReadData(1, 6500, buffer2, kSize2, NULL));
+  EXPECT_EQ(6500, entry->ReadData(1, 0, buffer3, kSize3, NULL));
+  EXPECT_EQ(8192, entry->WriteData(1, 0, buffer3, 8192, NULL, false));
+  EXPECT_EQ(8192, entry->ReadData(1, 0, buffer3, kSize3, NULL));
+  EXPECT_EQ(8192, entry->GetDataSize(1));
 
-  entry1->Doom();
-  entry1->Close();
+  // We need to delete the memory buffer on this thread.
+  EXPECT_EQ(0, entry->WriteData(0, 0, NULL, 0, NULL, true));
+  EXPECT_EQ(0, entry->WriteData(1, 0, NULL, 0, NULL, true));
+
+  entry->Doom();
+  entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, InternalSyncIO) {
   SetDirectMode();
   InitCache();
   InternalSyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   InternalSyncIO();
 }
 
 void DiskCacheEntryTest::InternalAsyncIO() {
-  disk_cache::Entry *entry1 = NULL;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
-  ASSERT_TRUE(NULL != entry1);
+  disk_cache::Entry* entry = NULL;
+  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
+  ASSERT_TRUE(NULL != entry);
 
   // Avoid using internal buffers for the test. We have to write something to
   // the entry and close it so that we flush the internal buffer to disk. After
   // 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, entry1->WriteData(0, 15 * 1024, NULL, 0, NULL, false));
-  EXPECT_EQ(0, entry1->WriteData(1, 15 * 1024, NULL, 0, NULL, false));
-  entry1->Close();
-  ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
+  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));
 
   // Let's verify that each IO goes to the right callback object.
   CallbackTest callback1(false);
   CallbackTest callback2(false);
   CallbackTest callback3(false);
   CallbackTest callback4(false);
   CallbackTest callback5(false);
   CallbackTest callback6(false);
   CallbackTest callback7(false);
   CallbackTest callback8(false);
@@ skipping 11 matching lines @@
   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, entry1->ReadData(0, 15 * 1024, buffer1, kSize1, &callback1));
+  EXPECT_EQ(0, entry->ReadData(0, 15 * 1024, buffer1, kSize1, &callback1));
   base::strlcpy(buffer1->data(), "the data", kSize1);
   int expected = 0;
-  int ret = entry1->WriteData(0, 0, buffer1, kSize1, &callback2, false);
+  int ret = entry->WriteData(0, 0, buffer1, kSize1, &callback2, 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 = entry1->ReadData(0, 0, buffer2, kSize1, &callback3);
+  ret = entry->ReadData(0, 0, buffer2, kSize1, &callback3);
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_STREQ("the data", buffer2->data());
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
-  ret = entry1->WriteData(1, 1500, buffer2, kSize2, &callback4, true);
+  ret = entry->WriteData(1, 1500, buffer2, kSize2, &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 = entry1->ReadData(1, 1511, buffer3, kSize2, &callback5);
+  ret = entry->ReadData(1, 1511, buffer3, kSize2, &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 = entry1->ReadData(1, 0, buffer2, kSize2, &callback6);
+  ret = entry->ReadData(1, 0, buffer2, kSize2, &callback6);
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   memset(buffer3->data(), 0, kSize3);
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
-  ret = entry1->ReadData(1, 5000, buffer2, kSize2, &callback7);
+  ret = entry->ReadData(1, 5000, buffer2, kSize2, &callback7);
   EXPECT_TRUE(1500 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  ret = entry1->ReadData(1, 0, buffer3, kSize3, &callback9);
+  ret = entry->ReadData(1, 0, buffer3, kSize3, &callback9);
   EXPECT_TRUE(6500 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  ret = entry1->WriteData(1, 0, buffer3, 8192, &callback10, true);
+  ret = entry->WriteData(1, 0, buffer3, 8192, &callback10, true);
   EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
-  ret = entry1->ReadData(1, 0, buffer3, kSize3, &callback11);
+  ret = entry->ReadData(1, 0, buffer3, kSize3, &callback11);
   EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  EXPECT_EQ(8192, entry1->GetDataSize(1));
+  EXPECT_EQ(8192, entry->GetDataSize(1));
 
-  ret = entry1->ReadData(0, 0, buffer1, kSize1, &callback12);
+  ret = entry->ReadData(0, 0, buffer1, kSize1, &callback12);
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  ret = entry1->ReadData(1, 0, buffer2, kSize2, &callback13);
+  ret = entry->ReadData(1, 0, buffer2, kSize2, &callback13);
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
 
   EXPECT_FALSE(g_cache_tests_error);
   EXPECT_EQ(expected, g_cache_tests_received);
 
-  entry1->Doom();
-  entry1->Close();
+  entry->Doom();
+  entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, InternalAsyncIO) {
   SetDirectMode();
   InitCache();
   InternalAsyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   InternalAsyncIO();
 }
 
 void DiskCacheEntryTest::ExternalSyncIO() {
-  disk_cache::Entry *entry1;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
+  disk_cache::Entry* entry;
+  ASSERT_EQ(net::OK, CreateEntry("the first key", &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, entry1->WriteData(0, 0, buffer1, kSize1, NULL, false));
+  EXPECT_EQ(17000, entry->WriteData(0, 0, buffer1, kSize1, NULL, false));
   memset(buffer1->data(), 0, kSize1);
-  EXPECT_EQ(17000, entry1->ReadData(0, 0, buffer1, kSize1, NULL));
+  EXPECT_EQ(17000, entry->ReadData(0, 0, buffer1, kSize1, NULL));
   EXPECT_STREQ("the data", buffer1->data());
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
-  EXPECT_EQ(25000, entry1->WriteData(1, 10000, buffer2, kSize2, NULL, false));
+  EXPECT_EQ(25000, entry->WriteData(1, 10000, buffer2, kSize2, NULL, false));
   memset(buffer2->data(), 0, kSize2);
-  EXPECT_EQ(24989, entry1->ReadData(1, 10011, buffer2, kSize2, NULL));
+  EXPECT_EQ(24989, entry->ReadData(1, 10011, buffer2, kSize2, NULL));
   EXPECT_STREQ("big data goes here", buffer2->data());
-  EXPECT_EQ(25000, entry1->ReadData(1, 0, buffer2, kSize2, NULL));
+  EXPECT_EQ(25000, entry->ReadData(1, 0, buffer2, kSize2, NULL));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer2->data(), 10000));
-  EXPECT_EQ(5000, entry1->ReadData(1, 30000, buffer2, kSize2, NULL));
+  EXPECT_EQ(5000, entry->ReadData(1, 30000, buffer2, kSize2, NULL));
 
-  EXPECT_EQ(0, entry1->ReadData(1, 35000, buffer2, kSize2, NULL));
-  EXPECT_EQ(17000, entry1->ReadData(1, 0, buffer1, kSize1, NULL));
-  EXPECT_EQ(17000, entry1->WriteData(1, 20000, buffer1, kSize1, NULL, false));
-  EXPECT_EQ(37000, entry1->GetDataSize(1));
+  EXPECT_EQ(0, entry->ReadData(1, 35000, buffer2, kSize2, NULL));
+  EXPECT_EQ(17000, entry->ReadData(1, 0, buffer1, kSize1, NULL));
+  EXPECT_EQ(17000, entry->WriteData(1, 20000, buffer1, kSize1, NULL, false));
+  EXPECT_EQ(37000, entry->GetDataSize(1));
 
-  entry1->Doom();
-  entry1->Close();
+  // We need to delete the memory buffer on this thread.
+  EXPECT_EQ(0, entry->WriteData(0, 0, NULL, 0, NULL, true));
+  EXPECT_EQ(0, entry->WriteData(1, 0, NULL, 0, NULL, true));
+
+  entry->Doom();
+  entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, ExternalSyncIO) {
   SetDirectMode();
   InitCache();
   ExternalSyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   ExternalSyncIO();
 }
 
 void DiskCacheEntryTest::ExternalAsyncIO() {
-  disk_cache::Entry *entry1;
-  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
+  disk_cache::Entry* entry;
+  ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
 
   // Let's verify that each IO goes to the right callback object.
   CallbackTest callback1(false);
   CallbackTest callback2(false);
   CallbackTest callback3(false);
   CallbackTest callback4(false);
   CallbackTest callback5(false);
   CallbackTest callback6(false);
   CallbackTest callback7(false);
   CallbackTest callback8(false);
   CallbackTest callback9(false);
 
   g_cache_tests_error = false;
   g_cache_tests_received = 0;
   int expected = 0;
 
   MessageLoopHelper helper;
 
   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 = entry1->WriteData(0, 0, buffer1, kSize1, &callback1, false);
+  int ret = entry->WriteData(0, 0, buffer1, kSize1, &callback1, false);
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
 
   memset(buffer2->data(), 0, kSize1);
-  ret = entry1->ReadData(0, 0, buffer2, kSize1, &callback2);
+  ret = entry->ReadData(0, 0, buffer2, kSize1, &callback2);
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_STREQ("the data", buffer1->data());
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
-  ret = entry1->WriteData(1, 10000, buffer2, kSize2, &callback3, false);
+  ret = entry->WriteData(1, 10000, buffer2, kSize2, &callback3, false);
   EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
 
   memset(buffer3->data(), 0, kSize3);
-  ret = entry1->ReadData(1, 10011, buffer3, kSize3, &callback4);
+  ret = entry->ReadData(1, 10011, buffer3, kSize3, &callback4);
   EXPECT_TRUE(24989 == 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 = entry1->ReadData(1, 0, buffer2, kSize2, &callback5);
+  ret = entry->ReadData(1, 0, buffer2, kSize2, &callback5);
   EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer2->data(), 10000));
-  ret = entry1->ReadData(1, 30000, buffer2, kSize2, &callback6);
+  ret = entry->ReadData(1, 30000, buffer2, kSize2, &callback6);
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  EXPECT_EQ(0, entry1->ReadData(1, 35000, buffer2, kSize2, &callback7));
-  ret = entry1->ReadData(1, 0, buffer1, kSize1, &callback8);
+  EXPECT_EQ(0, entry->ReadData(1, 35000, buffer2, kSize2, &callback7));
+  ret = entry->ReadData(1, 0, buffer1, kSize1, &callback8);
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
-  ret = entry1->WriteData(1, 20000, buffer1, kSize1, &callback9, false);
+  ret = entry->WriteData(1, 20000, buffer1, kSize1, &callback9, 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, entry1->GetDataSize(1));
+  EXPECT_EQ(37000, entry->GetDataSize(1));
 
   EXPECT_FALSE(g_cache_tests_error);
   EXPECT_EQ(expected, g_cache_tests_received);
 
-  entry1->Doom();
-  entry1->Close();
+  entry->Doom();
+  entry->Close();
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, ExternalAsyncIO) {
   SetDirectMode();
   InitCache();
   ExternalAsyncIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   ExternalAsyncIO();
 }
 
 void DiskCacheEntryTest::StreamAccess() {
-  disk_cache::Entry *entry = NULL;
+  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> buffer1 = new net::IOBuffer(kBufferSize);
   scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kBufferSize);
 
   const int kNumStreams = 3;
   for (int i = 0; i < kNumStreams; i++) {
     CacheTestFillBuffer(buffer1->data(), kBufferSize, false);
-    EXPECT_EQ(kBufferSize, entry->WriteData(i, 0, buffer1, kBufferSize, NULL,
-                                            false));
+    EXPECT_EQ(kBufferSize, WriteData(entry, i, 0, buffer1, kBufferSize, false));
     memset(buffer2->data(), 0, kBufferSize);
-    EXPECT_EQ(kBufferSize, entry->ReadData(i, 0, buffer2, kBufferSize, NULL));
+    EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer2, kBufferSize));
     EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kBufferSize));
   }
 
   EXPECT_EQ(net::ERR_INVALID_ARGUMENT,
-            entry->ReadData(kNumStreams, 0, buffer1, kBufferSize, NULL));
+            ReadData(entry, kNumStreams, 0, buffer1, kBufferSize));
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, StreamAccess) {
   InitCache();
   StreamAccess();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) {
   SetMemoryOnlyMode();
   InitCache();
   StreamAccess();
 }
 
 void DiskCacheEntryTest::GetKey() {
-  std::string key1("the first key");
-  disk_cache::Entry *entry1;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
-  EXPECT_EQ(key1, entry1->GetKey()) << "short key";
-  entry1->Close();
+  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();
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
   char key_buffer[20000];
 
   CacheTestFillBuffer(key_buffer, 3000, true);
   key_buffer[1000] = '\0';
 
-  key1 = key_buffer;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
-  EXPECT_TRUE(key1 == entry1->GetKey()) << "1000 bytes key";
-  entry1->Close();
+  key = key_buffer;
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  EXPECT_TRUE(key == entry->GetKey()) << "1000 bytes key";
+  entry->Close();
 
   key_buffer[1000] = 'p';
   key_buffer[3000] = '\0';
-  key1 = key_buffer;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
-  EXPECT_TRUE(key1 == entry1->GetKey()) << "medium size key";
-  entry1->Close();
+  key = key_buffer;
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  EXPECT_TRUE(key == entry->GetKey()) << "medium size key";
+  entry->Close();
 
   CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true);
   key_buffer[19999] = '\0';
 
-  key1 = key_buffer;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
-  EXPECT_TRUE(key1 == entry1->GetKey()) << "long key";
-  entry1->Close();
+  key = key_buffer;
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  EXPECT_TRUE(key == entry->GetKey()) << "long key";
+  entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, GetKey) {
   InitCache();
   GetKey();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) {
   SetMemoryOnlyMode();
   InitCache();
   GetKey();
 }
 
 void DiskCacheEntryTest::GrowData() {
   std::string key1("the first key");
-  disk_cache::Entry *entry1, *entry2;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
+  disk_cache::Entry* entry;
+  ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
 
   const int kSize = 20000;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
   scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize);
   CacheTestFillBuffer(buffer1->data(), kSize, false);
   memset(buffer2->data(), 0, kSize);
 
   base::strlcpy(buffer1->data(), "the data", kSize);
-  EXPECT_EQ(10, entry1->WriteData(0, 0, buffer1, 10, NULL, false));
-  EXPECT_EQ(10, entry1->ReadData(0, 0, buffer2, 10, NULL));
+  EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1, 10, false));
+  EXPECT_EQ(10, ReadData(entry, 0, 0, buffer2, 10));
   EXPECT_STREQ("the data", buffer2->data());
-  EXPECT_EQ(10, entry1->GetDataSize(0));
+  EXPECT_EQ(10, entry->GetDataSize(0));
 
-  EXPECT_EQ(2000, entry1->WriteData(0, 0, buffer1, 2000, NULL, false));
-  EXPECT_EQ(2000, entry1->GetDataSize(0));
-  EXPECT_EQ(2000, entry1->ReadData(0, 0, buffer2, 2000, NULL));
+  EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
+  EXPECT_EQ(2000, entry->GetDataSize(0));
+  EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
 
-  EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer1, kSize, NULL, false));
-  EXPECT_EQ(20000, entry1->GetDataSize(0));
-  EXPECT_EQ(20000, entry1->ReadData(0, 0, buffer2, kSize, NULL));
+  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(20000, entry->GetDataSize(0));
+  EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, kSize));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
-  entry1->Close();
+  entry->Close();
 
   memset(buffer2->data(), 0, kSize);
-  ASSERT_EQ(net::OK, CreateEntry("Second key", &entry2));
-  EXPECT_EQ(10, entry2->WriteData(0, 0, buffer1, 10, NULL, false));
-  EXPECT_EQ(10, entry2->GetDataSize(0));
-  entry2->Close();
+  std::string key2("Second key");
+  ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
+  EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1, 10, false));
+  EXPECT_EQ(10, entry->GetDataSize(0));
+  entry->Close();
 
   // Go from an internal address to a bigger block size.
-  ASSERT_EQ(net::OK, OpenEntry("Second key", &entry2));
-  EXPECT_EQ(2000, entry2->WriteData(0, 0, buffer1, 2000, NULL, false));
-  EXPECT_EQ(2000, entry2->GetDataSize(0));
-  EXPECT_EQ(2000, entry2->ReadData(0, 0, buffer2, 2000, NULL));
+  ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
+  EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
+  EXPECT_EQ(2000, entry->GetDataSize(0));
+  EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
-  entry2->Close();
+  entry->Close();
   memset(buffer2->data(), 0, kSize);
 
   // Go from an internal address to an external one.
-  ASSERT_EQ(net::OK, OpenEntry("Second key", &entry2));
-  EXPECT_EQ(20000, entry2->WriteData(0, 0, buffer1, kSize, NULL, false));
-  EXPECT_EQ(20000, entry2->GetDataSize(0));
-  EXPECT_EQ(20000, entry2->ReadData(0, 0, buffer2, kSize, NULL));
+  ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
+  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, kSize, false));
+  EXPECT_EQ(20000, entry->GetDataSize(0));
+  EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, kSize));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
-  entry2->Close();
+  entry->Close();
+
+  // 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, 0, false));
+  entry->Close();
+
+  // 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, MemoryOnlyGrowData) {
   SetMemoryOnlyMode();
   InitCache();
   GrowData();
 }
 
 void DiskCacheEntryTest::TruncateData() {
-  std::string key1("the first key");
-  disk_cache::Entry *entry1;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
+  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;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
   scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2);
 
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   memset(buffer2->data(), 0, kSize2);
 
   // Simple truncation:
-  EXPECT_EQ(200, entry1->WriteData(0, 0, buffer1, 200, NULL, false));
-  EXPECT_EQ(200, entry1->GetDataSize(0));
-  EXPECT_EQ(100, entry1->WriteData(0, 0, buffer1, 100, NULL, false));
-  EXPECT_EQ(200, entry1->GetDataSize(0));
-  EXPECT_EQ(100, entry1->WriteData(0, 0, buffer1, 100, NULL, true));
-  EXPECT_EQ(100, entry1->GetDataSize(0));
-  EXPECT_EQ(0, entry1->WriteData(0, 50, buffer1, 0, NULL, true));
-  EXPECT_EQ(50, entry1->GetDataSize(0));
-  EXPECT_EQ(0, entry1->WriteData(0, 0, buffer1, 0, NULL, true));
-  EXPECT_EQ(0, entry1->GetDataSize(0));
-  entry1->Close();
-  ASSERT_EQ(net::OK, OpenEntry(key1, &entry1));
+  EXPECT_EQ(200, entry->WriteData(0, 0, buffer1, 200, NULL, false));
+  EXPECT_EQ(200, entry->GetDataSize(0));
+  EXPECT_EQ(100, entry->WriteData(0, 0, buffer1, 100, NULL, false));
+  EXPECT_EQ(200, entry->GetDataSize(0));
+  EXPECT_EQ(100, entry->WriteData(0, 0, buffer1, 100, NULL, true));
+  EXPECT_EQ(100, entry->GetDataSize(0));
+  EXPECT_EQ(0, entry->WriteData(0, 50, buffer1, 0, NULL, true));
+  EXPECT_EQ(50, entry->GetDataSize(0));
+  EXPECT_EQ(0, entry->WriteData(0, 0, buffer1, 0, NULL, true));
+  EXPECT_EQ(0, entry->GetDataSize(0));
+  entry->Close();
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // Go to an external file.
-  EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer1, 20000, NULL, true));
-  EXPECT_EQ(20000, entry1->GetDataSize(0));
-  EXPECT_EQ(20000, entry1->ReadData(0, 0, buffer2, 20000, NULL));
+  EXPECT_EQ(20000, entry->WriteData(0, 0, buffer1, 20000, NULL, true));
+  EXPECT_EQ(20000, entry->GetDataSize(0));
+  EXPECT_EQ(20000, entry->ReadData(0, 0, buffer2, 20000, NULL));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000));
   memset(buffer2->data(), 0, kSize2);
 
   // External file truncation
-  EXPECT_EQ(18000, entry1->WriteData(0, 0, buffer1, 18000, NULL, false));
-  EXPECT_EQ(20000, entry1->GetDataSize(0));
-  EXPECT_EQ(18000, entry1->WriteData(0, 0, buffer1, 18000, NULL, true));
-  EXPECT_EQ(18000, entry1->GetDataSize(0));
-  EXPECT_EQ(0, entry1->WriteData(0, 17500, buffer1, 0, NULL, true));
-  EXPECT_EQ(17500, entry1->GetDataSize(0));
+  EXPECT_EQ(18000, entry->WriteData(0, 0, buffer1, 18000, NULL, false));
+  EXPECT_EQ(20000, entry->GetDataSize(0));
+  EXPECT_EQ(18000, entry->WriteData(0, 0, buffer1, 18000, NULL, true));
+  EXPECT_EQ(18000, entry->GetDataSize(0));
+  EXPECT_EQ(0, entry->WriteData(0, 17500, buffer1, 0, NULL, true));
+  EXPECT_EQ(17500, entry->GetDataSize(0));
 
   // And back to an internal block.
-  EXPECT_EQ(600, entry1->WriteData(0, 1000, buffer1, 600, NULL, true));
-  EXPECT_EQ(1600, entry1->GetDataSize(0));
-  EXPECT_EQ(600, entry1->ReadData(0, 1000, buffer2, 600, NULL));
+  EXPECT_EQ(600, entry->WriteData(0, 1000, buffer1, 600, NULL, true));
+  EXPECT_EQ(1600, entry->GetDataSize(0));
+  EXPECT_EQ(600, entry->ReadData(0, 1000, buffer2, 600, NULL));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 600));
-  EXPECT_EQ(1000, entry1->ReadData(0, 0, buffer2, 1000, NULL));
+  EXPECT_EQ(1000, entry->ReadData(0, 0, buffer2, 1000, NULL));
   EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000)) <<
       "Preserves previous data";
 
   // Go from external file to zero length.
-  EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer1, 20000, NULL, true));
-  EXPECT_EQ(20000, entry1->GetDataSize(0));
-  EXPECT_EQ(0, entry1->WriteData(0, 0, buffer1, 0, NULL, true));
-  EXPECT_EQ(0, entry1->GetDataSize(0));
+  EXPECT_EQ(20000, entry->WriteData(0, 0, buffer1, 20000, NULL, true));
+  EXPECT_EQ(20000, entry->GetDataSize(0));
+  EXPECT_EQ(0, entry->WriteData(0, 0, buffer1, 0, NULL, true));
+  EXPECT_EQ(0, entry->GetDataSize(0));
 
-  entry1->Close();
+  entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, TruncateData) {
   InitCache();
   TruncateData();
 
   // We generate asynchronous IO that is not really tracked until completion
   // so we just wait here before running the next test.
   MessageLoopHelper helper;
   helper.WaitUntilCacheIoFinished(1);
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) {
   SetMemoryOnlyMode();
   InitCache();
   TruncateData();
 }
 
 void DiskCacheEntryTest::ZeroLengthIO() {
-  std::string key1("the first key");
-  disk_cache::Entry *entry1;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
+  std::string key("the first key");
+  disk_cache::Entry* entry;
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
-  EXPECT_EQ(0, entry1->ReadData(0, 0, NULL, 0, NULL));
-  EXPECT_EQ(0, entry1->WriteData(0, 0, NULL, 0, NULL, false));
+  EXPECT_EQ(0, ReadData(entry, 0, 0, NULL, 0));
+  EXPECT_EQ(0, WriteData(entry, 0, 0, NULL, 0, false));
 
   // This write should extend the entry.
-  EXPECT_EQ(0, entry1->WriteData(0, 1000, NULL, 0, NULL, false));
-  EXPECT_EQ(0, entry1->ReadData(0, 500, NULL, 0, NULL));
-  EXPECT_EQ(0, entry1->ReadData(0, 2000, NULL, 0, NULL));
-  EXPECT_EQ(1000, entry1->GetDataSize(0));
-  entry1->Close();
+  EXPECT_EQ(0, WriteData(entry, 0, 1000, NULL, 0, false));
+  EXPECT_EQ(0, ReadData(entry, 0, 500, NULL, 0));
+  EXPECT_EQ(0, ReadData(entry, 0, 2000, NULL, 0));
+  EXPECT_EQ(1000, entry->GetDataSize(0));
+
+  EXPECT_EQ(0, WriteData(entry, 0, 100000, NULL, 0, true));
+  EXPECT_EQ(0, ReadData(entry, 0, 50000, NULL, 0));
+  EXPECT_EQ(100000, entry->GetDataSize(0));
+
+  // Lets verify the actual content.
+  const int kSize = 20;
+  const char zeros[kSize] = {};
+  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+
+  CacheTestFillBuffer(buffer->data(), kSize, false);
+  EXPECT_EQ(kSize, ReadData(entry, 0, 500, buffer, kSize));
+  EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
+
+  CacheTestFillBuffer(buffer->data(), kSize, false);
+  EXPECT_EQ(kSize, ReadData(entry, 0, 5000, buffer, kSize));
+  EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
+
+  CacheTestFillBuffer(buffer->data(), kSize, false);
+  EXPECT_EQ(kSize, ReadData(entry, 0, 50000, buffer, kSize));
+  EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
+
+  entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ZeroLengthIO) {
   InitCache();
   ZeroLengthIO();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) {
   SetMemoryOnlyMode();
   InitCache();
   ZeroLengthIO();
 }
 
+// Tests that we handle the content correctly when buffering.
+TEST_F(DiskCacheEntryTest, Buffering) {
+  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> 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, kSize, false));
+  entry->Close();
+
+  // 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, kSize, false));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
+
+  // Now go to an external file.
+  EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1, kSize, false));
+  entry->Close();
+
+  // Write something else and verify old data.
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1, kSize, false));
+  CacheTestFillBuffer(buffer2->data(), kSize, true);
+  EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
+  CacheTestFillBuffer(buffer2->data(), kSize, true);
+  EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
+  CacheTestFillBuffer(buffer2->data(), kSize, true);
+  EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
+
+  // Extend the file some more.
+  EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1, kSize, false));
+  entry->Close();
+
+  // 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, kSize, false));
+
+  // We should not overwrite the data at 18000 with this.
+  EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1, kSize, false));
+  CacheTestFillBuffer(buffer2->data(), kSize, true);
+  EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
+  CacheTestFillBuffer(buffer2->data(), kSize, true);
+  EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
+
+  EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1, kSize, false));
+  CacheTestFillBuffer(buffer2->data(), kSize, true);
+  EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));
+
+  CacheTestFillBuffer(buffer2->data(), kSize, true);
+  EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));
+
+  entry->Close();
+}
+
+// Some extra tests to make sure that buffering works properly when changing
+// the entry size.
+TEST_F(DiskCacheEntryTest, SizeChanges) {
+  InitCache();
+  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, kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1, kSize, true));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1, kSize, true));
+  entry->Close();
+
+  // 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, kSize, true));
+  EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 24000, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), zeros, kSize));
+
+  // Read at the end of the old file size.
+  EXPECT_EQ(35, ReadData(entry, 1, 23000 + kSize - 35, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 35, 35));
+
+  // Read slightly before the last write.
+  CacheTestFillBuffer(buffer2->data(), kSize, true);
+  EXPECT_EQ(kSize, ReadData(entry, 1, 24900, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
+  EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
+
+  // Extend the entry a little more.
+  EXPECT_EQ(kSize, WriteData(entry, 1, 26000, buffer1, kSize, true));
+  EXPECT_EQ(26000 + kSize, entry->GetDataSize(1));
+  CacheTestFillBuffer(buffer2->data(), kSize, true);
+  EXPECT_EQ(kSize, ReadData(entry, 1, 25900, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
+  EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
+
+  // And now reduce the size.
+  EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, true));
+  EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
+  EXPECT_EQ(28, ReadData(entry, 1, 25000 + kSize - 28, buffer2, kSize));
+  EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 28, 28));
+
+  // Reduce the size with a buffer that is not extending the size.
+  EXPECT_EQ(kSize, WriteData(entry, 1, 24000, buffer1, kSize, false));
+  EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 24500, buffer1, kSize, true));
+  EXPECT_EQ(24500 + kSize, entry->GetDataSize(1));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 23900, buffer2, 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, kSize, true));
+  EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
+  EXPECT_EQ(kSize, ReadData(entry, 1, 18900, buffer2, 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();
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
+
+  entry->Close();
+}
+
 // 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;
+  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, entry->WriteData(0, 0, buffer, 0, NULL, true));
-    EXPECT_EQ(size, entry->WriteData(0, 0, buffer, size, NULL, false));
+    EXPECT_EQ(0, WriteData(entry, 0, 0, buffer, 0, true));
+    EXPECT_EQ(size, WriteData(entry, 0, 0, buffer, size, false));
     entry->Close();
     ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
   }
 
   entry->Close();
   ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry";
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, ReuseExternalEntry) {
@@ skipping 21 matching lines @@
 TEST_F(DiskCacheEntryTest, MemoryOnlyReuseInternalEntry) {
   SetDirectMode();
   SetMemoryOnlyMode();
   SetMaxSize(100 * 1024);
   InitCache();
   ReuseEntry(10 * 1024);
 }
 
 // Reading somewhere that was not written should return zeros.
 void DiskCacheEntryTest::InvalidData() {
-  std::string key1("the first key");
-  disk_cache::Entry *entry1;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
+  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, entry1->WriteData(0, 400, buffer1, 200, NULL, false));
-  EXPECT_EQ(600, entry1->GetDataSize(0));
-  EXPECT_EQ(100, entry1->ReadData(0, 300, buffer3, 100, NULL));
+  EXPECT_EQ(200, WriteData(entry, 0, 400, buffer1, 200, false));
+  EXPECT_EQ(600, entry->GetDataSize(0));
+  EXPECT_EQ(100, ReadData(entry, 0, 300, buffer3, 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
-  entry1->Close();
-  ASSERT_EQ(net::OK, OpenEntry(key1, &entry1));
+  entry->Close();
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // The entry is now on disk. Load it and extend it.
-  EXPECT_EQ(200, entry1->WriteData(0, 800, buffer1, 200, NULL, false));
-  EXPECT_EQ(1000, entry1->GetDataSize(0));
-  EXPECT_EQ(100, entry1->ReadData(0, 700, buffer3, 100, NULL));
+  EXPECT_EQ(200, WriteData(entry, 0, 800, buffer1, 200, false));
+  EXPECT_EQ(1000, entry->GetDataSize(0));
+  EXPECT_EQ(100, ReadData(entry, 0, 700, buffer3, 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
-  entry1->Close();
-  ASSERT_EQ(net::OK, OpenEntry(key1, &entry1));
+  entry->Close();
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   // This time using truncate.
-  EXPECT_EQ(200, entry1->WriteData(0, 1800, buffer1, 200, NULL, true));
-  EXPECT_EQ(2000, entry1->GetDataSize(0));
-  EXPECT_EQ(100, entry1->ReadData(0, 1500, buffer3, 100, NULL));
+  EXPECT_EQ(200, WriteData(entry, 0, 1800, buffer1, 200, true));
+  EXPECT_EQ(2000, entry->GetDataSize(0));
+  EXPECT_EQ(100, ReadData(entry, 0, 1500, buffer3, 100));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
 
   // Go to an external file.
-  EXPECT_EQ(200, entry1->WriteData(0, 19800, buffer1, 200, NULL, false));
-  EXPECT_EQ(20000, entry1->GetDataSize(0));
-  EXPECT_EQ(4000, entry1->ReadData(0, 14000, buffer3, 4000, NULL));
+  EXPECT_EQ(200, WriteData(entry, 0, 19800, buffer1, 200, false));
+  EXPECT_EQ(20000, entry->GetDataSize(0));
+  EXPECT_EQ(4000, ReadData(entry, 0, 14000, buffer3, 4000));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 4000));
 
   // And back to an internal block.
-  EXPECT_EQ(600, entry1->WriteData(0, 1000, buffer1, 600, NULL, true));
-  EXPECT_EQ(1600, entry1->GetDataSize(0));
-  EXPECT_EQ(600, entry1->ReadData(0, 1000, buffer3, 600, NULL));
+  EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1, 600, true));
+  EXPECT_EQ(1600, entry->GetDataSize(0));
+  EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer3, 600));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer1->data(), 600));
 
   // Extend it again.
-  EXPECT_EQ(600, entry1->WriteData(0, 2000, buffer1, 600, NULL, false));
-  EXPECT_EQ(2600, entry1->GetDataSize(0));
-  EXPECT_EQ(200, entry1->ReadData(0, 1800, buffer3, 200, NULL));
+  EXPECT_EQ(600, WriteData(entry, 0, 2000, buffer1, 600, false));
+  EXPECT_EQ(2600, entry->GetDataSize(0));
+  EXPECT_EQ(200, ReadData(entry, 0, 1800, buffer3, 200));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));
 
   // And again (with truncation flag).
-  EXPECT_EQ(600, entry1->WriteData(0, 3000, buffer1, 600, NULL, true));
-  EXPECT_EQ(3600, entry1->GetDataSize(0));
-  EXPECT_EQ(200, entry1->ReadData(0, 2800, buffer3, 200, NULL));
+  EXPECT_EQ(600, WriteData(entry, 0, 3000, buffer1, 600, true));
+  EXPECT_EQ(3600, entry->GetDataSize(0));
+  EXPECT_EQ(200, ReadData(entry, 0, 2800, buffer3, 200));
   EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));
 
-  entry1->Close();
+  entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, InvalidData) {
   InitCache();
   InvalidData();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) {
   SetMemoryOnlyMode();
   InitCache();
   InvalidData();
 }
 
 void DiskCacheEntryTest::DoomNormalEntry() {
-  std::string key1("the first key");
-  disk_cache::Entry *entry1;
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
-  entry1->Doom();
-  entry1->Close();
+  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';
 
-  key1 = buffer->data();
-  ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
-  EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer, kSize, NULL, false));
-  EXPECT_EQ(20000, entry1->WriteData(1, 0, buffer, kSize, NULL, false));
-  entry1->Doom();
-  entry1->Close();
+  key = buffer->data();
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer, kSize, false));
+  EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer, kSize, false));
+  entry->Doom();
+  entry->Close();
 
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
 }
 
 TEST_F(DiskCacheEntryTest, DoomEntry) {
   SetDirectMode();
   InitCache();
   DoomNormalEntry();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomNormalEntry();
 }
 
 // Verify that basic operations work as expected with doomed entries.
 void DiskCacheEntryTest::DoomedEntry() {
   std::string key("the first key");
-  disk_cache::Entry *entry;
+  disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   entry->Doom();
 
   FlushQueueForTest();
   EXPECT_EQ(0, cache_->GetEntryCount());
   Time initial = Time::Now();
   PlatformThread::Sleep(20);
 
   const int kSize1 = 2000;
   const int kSize2 = 2000;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
   scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2);
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   memset(buffer2->data(), 0, kSize2);
 
-  EXPECT_EQ(2000, entry->WriteData(0, 0, buffer1, 2000, NULL, false));
-  EXPECT_EQ(2000, entry->ReadData(0, 0, buffer2, 2000, NULL));
+  EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
+  EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1));
   EXPECT_EQ(key, entry->GetKey());
   EXPECT_TRUE(initial < entry->GetLastModified());
   EXPECT_TRUE(initial < entry->GetLastUsed());
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, DoomedEntry) {
   SetDirectMode();
@@ skipping 39 matching lines @@
     disk_cache::MemEntryImpl* mem_entry =
         reinterpret_cast<disk_cache::MemEntryImpl*>(entry);
     EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, mem_entry->type());
     mem_entry->Close();
   }
   EXPECT_EQ(1, count);
 }
 
 // Writes |buf_1| to offset and reads it back as |buf_2|.
 void VerifySparseIO(disk_cache::Entry* entry, int64 offset,
-                    net::IOBuffer* buf_1, int size, bool async,
-                    net::IOBuffer* buf_2) {
-  TestCompletionCallback callback;
-  TestCompletionCallback* cb = async ? &callback : NULL;
+                    net::IOBuffer* buf_1, int size, net::IOBuffer* buf_2) {
+  TestCompletionCallback cb;
 
   memset(buf_2->data(), 0, size);
-  int ret = entry->ReadSparseData(offset, buf_2, size, cb);
-  ret = callback.GetResult(ret);
-  EXPECT_EQ(0, ret);
+  int ret = entry->ReadSparseData(offset, buf_2, size, &cb);
+  EXPECT_EQ(0, cb.GetResult(ret));
 
-  ret = entry->WriteSparseData(offset, buf_1, size, cb);
-  ret = callback.GetResult(ret);
-  EXPECT_EQ(size, ret);
+  ret = entry->WriteSparseData(offset, buf_1, size, &cb);
+  EXPECT_EQ(size, cb.GetResult(ret));
 
-  ret = entry->ReadSparseData(offset, buf_2, size, cb);
-  ret = callback.GetResult(ret);
-  EXPECT_EQ(size, ret);
+  ret = entry->ReadSparseData(offset, buf_2, size, &cb);
+  EXPECT_EQ(size, cb.GetResult(ret));
 
   EXPECT_EQ(0, memcmp(buf_1->data(), buf_2->data(), size));
 }
 
 // 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, bool async) {
-  TestCompletionCallback callback;
-  TestCompletionCallback* cb = async ? &callback : NULL;
+                           int size) {
+  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, size, cb);
-  ret = callback.GetResult(ret);
-  EXPECT_EQ(size, ret);
+  int ret = entry->ReadSparseData(offset, buf_1, size, &cb);
+  EXPECT_EQ(size, cb.GetResult(ret));
 
   EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size));
 }
 
-void DiskCacheEntryTest::BasicSparseIO(bool async) {
+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, kSize, async, buf_2);
+  VerifySparseIO(entry, 0, buf_1, kSize, buf_2);
 
   // Write at offset 0x400000 (4 MB).
-  VerifySparseIO(entry, 0x400000, buf_1, kSize, async, buf_2);
+  VerifySparseIO(entry, 0x400000, buf_1, kSize, buf_2);
 
   // Write at offset 0x800000000 (32 GB).
-  VerifySparseIO(entry, 0x800000000LL, buf_1, kSize, async, buf_2);
+  VerifySparseIO(entry, 0x800000000LL, buf_1, kSize, buf_2);
 
   entry->Close();
 
   // Check everything again.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
-  VerifyContentSparseIO(entry, 0, buf_1->data(), kSize, async);
-  VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize, async);
-  VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize, async);
+  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, BasicSparseSyncIO) {
+TEST_F(DiskCacheEntryTest, BasicSparseIO) {
   InitCache();
-  BasicSparseIO(false);
+  BasicSparseIO();
 }
 
-TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseSyncIO) {
+TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseIO) {
   SetMemoryOnlyMode();
   InitCache();
-  BasicSparseIO(false);
+  BasicSparseIO();
 }
 
-TEST_F(DiskCacheEntryTest, BasicSparseAsyncIO) {
-  InitCache();
-  BasicSparseIO(true);
-}
-
-TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseAsyncIO) {
-  SetMemoryOnlyMode();
-  InitCache();
-  BasicSparseIO(true);
-}
-
-void DiskCacheEntryTest::HugeSparseIO(bool async) {
+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, kSize, async, buf_2);
+  VerifySparseIO(entry, 0x20F0000, buf_1, kSize, buf_2);
   entry->Close();
 
   // Check it again.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
-  VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize, async);
+  VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize);
   entry->Close();
 }
 
-TEST_F(DiskCacheEntryTest, HugeSparseSyncIO) {
+TEST_F(DiskCacheEntryTest, HugeSparseIO) {
   InitCache();
-  HugeSparseIO(false);
+  HugeSparseIO();
 }
 
-TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseSyncIO) {
+TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseIO) {
   SetMemoryOnlyMode();
   InitCache();
-  HugeSparseIO(false);
-}
-
-TEST_F(DiskCacheEntryTest, HugeSparseAsyncIO) {
-  InitCache();
-  HugeSparseIO(true);
-}
-
-TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseAsyncIO) {
-  SetMemoryOnlyMode();
-  InitCache();
-  HugeSparseIO(true);
+  HugeSparseIO();
 }
 
 void DiskCacheEntryTest::GetAvailableRange() {
   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, entry->WriteSparseData(0x20F0000, buf, kSize, NULL));
-  EXPECT_EQ(kSize, entry->WriteSparseData(0x20F4400, buf, kSize, NULL));
+  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;
   TestCompletionCallback cb;
   int rv = entry->GetAvailableRange(0x20F0000, kSize * 2, &start, &cb);
   EXPECT_EQ(kSize, cb.GetResult(rv));
   EXPECT_EQ(0x20F0000, start);
 
   start = 0;
   rv = entry->GetAvailableRange(0, kSize, &start, &cb);
@@ skipping 40 matching lines @@
 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, entry->WriteSparseData(0x20F0000, buf, kSize, NULL));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf, kSize));
 
   EXPECT_TRUE(entry->CouldBeSparse());
   entry->Close();
 
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_TRUE(entry->CouldBeSparse());
   entry->Close();
 
   // Now verify a regular entry.
   key.assign("another key");
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_FALSE(entry->CouldBeSparse());
 
-  EXPECT_EQ(kSize, entry->WriteData(0, 0, buf, kSize, NULL, false));
-  EXPECT_EQ(kSize, entry->WriteData(1, 0, buf, kSize, NULL, false));
-  EXPECT_EQ(kSize, entry->WriteData(2, 0, buf, kSize, NULL, false));
+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf, kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf, kSize, false));
 
   EXPECT_FALSE(entry->CouldBeSparse());
   entry->Close();
 
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_FALSE(entry->CouldBeSparse());
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, CouldBeSparse) {
@@ skipping 17 matching lines @@
   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, 1024, false, buf_2);
-    VerifySparseIO(entry, 9000 + i, buf_3, 1024, false, buf_2);
+    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, false);
-  VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize, false);
+  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, 8192, false, buf_2);
+  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);
@@ skipping 173 matching lines @@
   // 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, entry->WriteSparseData(20000, buf1, kSize, NULL));
-  EXPECT_EQ(kSize, entry->WriteSparseData(500, buf1, kSize, NULL));
-  EXPECT_EQ(kSmallSize,
-            entry->WriteSparseData(1080321, buf1, kSmallSize, NULL));
+  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();
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   scoped_refptr<net::IOBuffer> buf2 = new net::IOBuffer(kSize);
   memset(buf2->data(), 0, kSize);
   EXPECT_EQ(0, entry->ReadSparseData(8000, buf2, kSize, NULL));
 
-  EXPECT_EQ(500, entry->ReadSparseData(kSize, buf2, kSize, NULL));
+  EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2, kSize));
   EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
-  EXPECT_EQ(0, entry->ReadSparseData(0, buf2, kSize, NULL));
+  EXPECT_EQ(0, ReadSparseData(entry, 0, buf2, kSize));
 
   // This read should not change anything.
-  EXPECT_EQ(96, entry->ReadSparseData(24000, buf2, kSize, NULL));
-  EXPECT_EQ(500, entry->ReadSparseData(kSize, buf2, kSize, NULL));
-  EXPECT_EQ(0, entry->ReadSparseData(499, buf2, kSize, NULL));
+  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;
   TestCompletionCallback cb;
   if (memory_only_) {
     rv = entry->GetAvailableRange(0, 600, &start, &cb);
     EXPECT_EQ(100, cb.GetResult(rv));
     EXPECT_EQ(500, start);
   } else {
     rv = entry->GetAvailableRange(0, 2048, &start, &cb);
@@ skipping 20 matching lines @@
     EXPECT_EQ(20480, start);
   }
   rv = entry->GetAvailableRange(3073, kSize, &start, &cb);
   EXPECT_EQ(1523, cb.GetResult(rv));
   EXPECT_EQ(3073, start);
   rv = entry->GetAvailableRange(4600, kSize, &start, &cb);
   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, entry->WriteSparseData(500 + kSize, buf1, kSize, NULL));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1, kSize));
   rv = entry->GetAvailableRange(1024, 10000, &start, &cb);
   EXPECT_EQ(7 * 1024 + 500, cb.GetResult(rv));
   EXPECT_EQ(1024, start);
-  EXPECT_EQ(kSize, entry->ReadSparseData(kSize, buf2, kSize, NULL));
+  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, MemoryPartialSparseEntry) {
   SetMemoryOnlyMode();
   InitCache();
   PartialSparseEntry();
 }
 
 // Tests that corrupt sparse children are removed automatically.
 TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
   InitCache();
   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, entry->WriteSparseData(8192, buf1, kSize, NULL));
-  EXPECT_EQ(kSize, entry->WriteSparseData(k1Meg + 8192, buf1, kSize, NULL));
-  EXPECT_EQ(kSize, entry->WriteSparseData(2 * k1Meg + 8192, buf1, kSize, NULL));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1, kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1, kSize));
+  EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1, kSize));
   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, entry->WriteData(2, 0, buf1, 12, NULL, false));
+    EXPECT_EQ(12, WriteData(entry, 2, 0, buf1, 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, entry->ReadSparseData(2 * k1Meg + 8192, buf1, kSize, NULL));
-  EXPECT_EQ(kSize, entry->WriteSparseData(k1Meg + 16384, buf1, kSize, NULL));
-  EXPECT_EQ(0, entry->ReadSparseData(k1Meg + 8192, buf1, kSize, NULL));
+  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, entry->ReadSparseData(8192, buf1, kSize, NULL));
+  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();
   InitCache();
   std::string key("the first key");
@@ skipping 37 matching lines @@
   rv = cb1.WaitForResult();
   EXPECT_TRUE(rv == 4096 || 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);
   EXPECT_EQ(0, cb5.GetResult(rv));
   entry->Close();
 }