Remove implicit conversions from scoped_refptr to T* in net/disk_cache/

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file.h"
 #include "base/strings/string_util.h"
@@ skipping 3741 matching lines @@
   const char key[] = "key";
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kHalfSize, false);
 
   disk_cache::Entry* entry;
 
   // Create entry, write empty buffer to third stream, and close: third stream
   // should still be omitted, since the entry ignores writes that don't modify
   // data or change the length.
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
-  EXPECT_EQ(0, WriteData(entry, 2, 0, buffer, 0, true));
+  EXPECT_EQ(0, WriteData(entry, 2, 0, buffer.get(), 0, true));
   entry->Close();
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 
   SyncDoomEntry(key);
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 }
 
 // Check that we can read back data written to the third stream.
 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream3) {
   SetSimpleCacheMode();
   InitCache();
 
   const int kHalfSize = 8;
   const int kSize = kHalfSize * 2;
   const char key[] = "key";
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
 
   disk_cache::Entry* entry;
 
   // Create entry, write data to third stream, and close: third stream should
   // not be omitted, since it contains data.  Re-open entry and ensure there
   // are that many bytes in the third stream.
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
-  EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1, kHalfSize, true));
+  EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1.get(), kHalfSize, true));
   entry->Close();
   EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
 
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
-  EXPECT_EQ(kHalfSize, ReadData(entry, 2, 0, buffer2, kSize));
+  EXPECT_EQ(kHalfSize, ReadData(entry, 2, 0, buffer2.get(), kSize));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kHalfSize));
   entry->Close();
   EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
 
   SyncDoomEntry(key);
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 }
 
 // Check that we remove the third stream file upon opening an entry and finding
 // the third stream empty.  (This is the upgrade path for entries written
@@ skipping 10 matching lines @@
   CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
 
   disk_cache::Entry* entry;
 
   // Create entry, write data to third stream, truncate third stream back to
   // empty, and close: third stream will not initially be omitted, since entry
   // creates the file when the first significant write comes in, and only
   // removes it on open if it is empty.  Reopen, ensure that the file is
   // deleted, and that there's no data in the third stream.
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
-  EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1, kHalfSize, true));
-  EXPECT_EQ(0, WriteData(entry, 2, 0, buffer1, 0, true));
+  EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1.get(), kHalfSize, true));
+  EXPECT_EQ(0, WriteData(entry, 2, 0, buffer1.get(), 0, true));
   entry->Close();
   EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
 
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
-  EXPECT_EQ(0, ReadData(entry, 2, 0, buffer2, kSize));
+  EXPECT_EQ(0, ReadData(entry, 2, 0, buffer2.get(), kSize));
   entry->Close();
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 
   SyncDoomEntry(key);
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 }
 
 // Check that we don't accidentally create the third stream file once the entry
 // has been doomed.
 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream5) {
   SetSimpleCacheMode();
   InitCache();
 
   const int kHalfSize = 8;
   const int kSize = kHalfSize * 2;
   const char key[] = "key";
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kHalfSize, false);
 
   disk_cache::Entry* entry;
 
   // Create entry, doom entry, write data to third stream, and close: third
   // stream should not exist.  (Note: We don't care if the write fails, just
   // that it doesn't cause the file to be created on disk.)
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   entry->Doom();
-  WriteData(entry, 2, 0, buffer, kHalfSize, true);
+  WriteData(entry, 2, 0, buffer.get(), kHalfSize, true);
   entry->Close();
   EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
 }
 
 // There could be a race between Doom and an optimistic write.
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomOptimisticWritesRace) {
   // Test sequence:
   // Create, first Write, second Write, Close.
   // Open, Close.
   SetSimpleCacheMode();
@@ skipping 97 matching lines @@
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_NE(null, entry);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   net::TestCompletionCallback callback;
   int ret;
 
   // Verify initial conditions.
-  ret = entry->ReadSparseData(0, buffer, kSize, callback.callback());
+  ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
 
-  ret = entry->ReadSparseData(kSize, buffer, kSize, callback.callback());
+  ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
 
   // Write a range and make sure it reads back.
-  ret = entry->WriteSparseData(0, buffer, kSize, callback.callback());
+  ret = entry->WriteSparseData(0, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
-  ret = entry->ReadSparseData(0, buffer, kSize, callback.callback());
+  ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
   // Write another range and make sure it reads back.
-  ret = entry->WriteSparseData(kSize, buffer, kSize, callback.callback());
+  ret = entry->WriteSparseData(kSize, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
-  ret = entry->ReadSparseData(kSize, buffer, kSize, callback.callback());
+  ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
   // Make sure the first range was removed when the second was written.
-  ret = entry->ReadSparseData(0, buffer, kSize, callback.callback());
+  ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
 
   entry->Close();
 }
 
 #endif  // defined(OS_POSIX)