Convert implicit scoped_refptr constructor calls to explicit ones, part 1

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 58 matching lines @@
       : SyncIOTask(test, entry) {}
 
   virtual void Run() {
     test_->InternalSyncIOBackground(entry_);
   }
 };
 
 // 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);
+  scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   EXPECT_EQ(0, entry->ReadData(0, 0, buffer1, kSize1, NULL));
   base::strlcpy(buffer1->data(), "the data", kSize1);
   EXPECT_EQ(10, entry->WriteData(0, 0, buffer1, kSize1, NULL, false));
   memset(buffer1->data(), 0, kSize1);
   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);
+  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, kSize2, NULL, false));
   memset(buffer2->data(), 0, kSize2);
   EXPECT_EQ(4989, entry->ReadData(1, 1511, buffer2, kSize2, NULL));
   EXPECT_STREQ("big data goes here", buffer2->data());
   EXPECT_EQ(5000, entry->ReadData(1, 0, buffer2, kSize2, NULL));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
   EXPECT_EQ(1500, entry->ReadData(1, 5000, buffer2, kSize2, NULL));
@@ skipping 70 matching lines @@
   CallbackTest callback13(false);
 
   g_cache_tests_error = false;
   g_cache_tests_received = 0;
 
   MessageLoopHelper helper;
 
   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);
+  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, kSize1, &callback1));
   base::strlcpy(buffer1->data(), "the data", kSize1);
   int expected = 0;
   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)
@@ skipping 96 matching lines @@
 
   virtual void Run() {
     test_->ExternalSyncIOBackground(entry_);
   }
 };
 
 // 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);
+  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, kSize1, NULL, false));
   memset(buffer1->data(), 0, kSize1);
   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, entry->WriteData(1, 10000, buffer2, kSize2, NULL, false));
@@ skipping 63 matching lines @@
 
   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);
+  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, kSize1, &callback1, false);
   EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
@@ skipping 75 matching lines @@
   InitCache();
   ExternalAsyncIO();
 }
 
 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;
-  scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kBufferSize);
-  scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kBufferSize);
+  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, WriteData(entry, i, 0, buffer1, kBufferSize, false));
     memset(buffer2->data(), 0, kBufferSize);
     EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer2, kBufferSize));
     EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kBufferSize));
   }
 
@@ skipping 76 matching lines @@
     EXPECT_TRUE(entry->GetLastModified() < t2);
   } else {
     EXPECT_TRUE(entry->GetLastModified() >= t2);
   }
   EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed());
 
   PlatformThread::Sleep(20);
   Time t3 = Time::Now();
   EXPECT_TRUE(t3 > t2);
   const int kSize = 200;
-  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer, kSize));
   if (type_ == net::APP_CACHE) {
     EXPECT_TRUE(entry->GetLastUsed() < t2);
     EXPECT_TRUE(entry->GetLastModified() < t2);
   } else {
     EXPECT_TRUE(entry->GetLastUsed() >= t3);
     EXPECT_TRUE(entry->GetLastModified() < t3);
   }
   entry->Close();
 }
@@ skipping 14 matching lines @@
   InitCache();
   GetTimes();
 }
 
 void DiskCacheEntryTest::GrowData() {
   std::string key1("the first key");
   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);
+  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, 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, entry->GetDataSize(0));
 
   EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
@@ skipping 63 matching lines @@
   GrowData();
 }
 
 void DiskCacheEntryTest::TruncateData() {
   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);
+  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, WriteData(entry, 0, 0, buffer1, 200, false));
   EXPECT_EQ(200, entry->GetDataSize(0));
   EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1, 100, false));
   EXPECT_EQ(200, entry->GetDataSize(0));
   EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1, 100, true));
@@ skipping 80 matching lines @@
   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);
+  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);
@@ skipping 21 matching lines @@
   ZeroLengthIO();
 }
 
 // Tests that we handle the content correctly when buffering.
 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);
+  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));
@@ skipping 59 matching lines @@
 
 // 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);
+  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));
@@ skipping 67 matching lines @@
 // 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);
+  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, 0, true));
     EXPECT_EQ(size, WriteData(entry, 0, 0, buffer, size, false));
     entry->Close();
     ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
   }
 
   entry->Close();
@@ skipping 33 matching lines @@
 
 // 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);
+  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, 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));
   entry->Close();
@@ skipping 59 matching lines @@
 }
 
 // Tests that the cache preserves the buffer of an IO operation.
 TEST_F(DiskCacheEntryTest, ReadWriteDestroyBuffer) {
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 200;
-  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
 
   TestCompletionCallback cb;
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry->WriteData(0, 0, buffer, kSize, &cb, 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, kSize, &cb));
   buffer = NULL;
   EXPECT_EQ(kSize, cb.WaitForResult());
 
   entry->Close();
 }
 
 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);
+  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, kSize, false));
   EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer, kSize, false));
   entry->Doom();
   entry->Close();
 
@@ skipping 20 matching lines @@
   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);
+  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, 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());
 
@@ skipping 12 matching lines @@
   DoomedEntry();
 }
 
 // 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);
+  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, kSize, NULL));
 
   // This write creates a child entry and writes to it.
@@ skipping 33 matching lines @@
 
   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) {
   TestCompletionCallback cb;
 
-  scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(size);
+  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);
   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);
+  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, buf_2);
 
   // Write at offset 0x400000 (4 MB).
   VerifySparseIO(entry, 0x400000, buf_1, kSize, buf_2);
 
   // Write at offset 0x800000000 (32 GB).
   VerifySparseIO(entry, 0x800000000LL, buf_1, kSize, buf_2);
@@ skipping 19 matching lines @@
   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);
+  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, buf_2);
   entry->Close();
 
   // 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, MemoryOnlyHugeSparseIO) {
   SetMemoryOnlyMode();
   InitCache();
   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);
+  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, 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);
@@ skipping 41 matching lines @@
   InitCache();
   GetAvailableRange();
 }
 
 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);
+  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, kSize));
 
   EXPECT_TRUE(entry->CouldBeSparse());
   entry->Close();
 
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_TRUE(entry->CouldBeSparse());
@@ skipping 25 matching lines @@
   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);
+  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);
+    scoped_refptr<net::WrappedIOBuffer> buf_3(
+      new net::WrappedIOBuffer(buf_1->data() + i));
     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, 8192, buf_2);
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) {
   SetMemoryOnlyMode();
   InitCache();
 
   const int kSize = 8192;
-  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+  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, 1024, NULL));
   EXPECT_EQ(1024, entry->WriteSparseData(5120, buf, 1024, NULL));
   EXPECT_EQ(1024, entry->WriteSparseData(10000, buf, 1024, NULL));
@@ skipping 40 matching lines @@
 }
 
 void DiskCacheEntryTest::DoomSparseEntry() {
   std::string key1("the first key");
   std::string key2("the second key");
   disk_cache::Entry *entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
 
   const int kSize = 4 * 1024;
-  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+  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, entry1->WriteSparseData(offset, buf, kSize, NULL));
     // Keep the second map under the default size.
     if (i < 9)
       EXPECT_EQ(kSize, entry2->WriteSparseData(offset, buf, kSize, NULL));
     offset *= 4;
@@ skipping 66 matching lines @@
 // deleting the sub-entries of a sparse entry.
 TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
   SetDirectMode();
   UseCurrentThread();
   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);
+  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, kSize, NULL));
     offset *= 4;
   }
   EXPECT_EQ(9, cache_->GetEntryCount());
 
   entry->Close();
   SparseTestCompletionCallback cb(cache_);
   int rv = cache_->DoomEntry(key, &cb);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
   EXPECT_EQ(net::OK, cb.WaitForResult());
 
   // TearDown will attempt to delete the cache_.
   cache_ = NULL;
 }
 
 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);
+  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, 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);
+  scoped_refptr<net::IOBuffer> buf2(new net::IOBuffer(kSize));
   memset(buf2->data(), 0, kSize);
   EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2, 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, kSize));
 
   // This read should not change anything.
   EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2, kSize));
   EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2, kSize));
@@ skipping 61 matching lines @@
 }
 
 // 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);
+  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, 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;
@@ skipping 30 matching lines @@
 }
 
 TEST_F(DiskCacheEntryTest, CancelSparseIO) {
   UseCurrentThread();
   InitCache();
   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);
+  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // This will open and write two "real" entries.
   TestCompletionCallback cb1, cb2, cb3, cb4, cb5;
   int rv = entry->WriteSparseData(1024 * 1024 - 4096, buf, kSize, &cb1);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   int64 offset = 0;
   rv = entry->GetAvailableRange(offset, kSize, &offset, &cb5);
   rv = cb5.GetResult(rv);
@@ skipping 22 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();
 }