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

net/http/disk_based_cert_cache_unittest.cc

 // Copyright (c) 2014 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 "net/http/disk_based_cert_cache.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
@@ skipping 126 matching lines @@
       X509Certificate::GetDEREncoded(cert->os_cert_handle(), &write_data);
   ASSERT_TRUE(encoded);
   if (corrupt_data) {
     for (size_t i = 0; i < write_data.size(); i += 20)
       ++write_data[i];
   }
   scoped_refptr<IOBuffer> buffer(new IOBuffer(write_data.size()));
   memcpy(buffer->data(), write_data.data(), write_data.size());
   rv = entry->WriteData(0 /* index */,
                         0 /* offset */,
-                        buffer,
+                        buffer.get(),
                         write_data.size(),
                         callback.callback(),
                         true /* truncate */);
   ASSERT_EQ(static_cast<int>(write_data.size()), callback.GetResult(rv));
   entry->Close();
 }
 
 // Checks that the the certificate corresponding to |cert_data| is an existing,
 // correctly cached entry in |backend|.
 void CheckCertCached(disk_cache::Backend* backend,
                      const TestCertMetaData& cert_data) {
   disk_cache::Entry* entry;
   TestCompletionCallback callback;
   int rv = backend->OpenEntry(cert_data.cache_key, &entry, callback.callback());
   EXPECT_EQ(OK, callback.GetResult(rv));
   scoped_refptr<X509Certificate> cert(
       ImportCertFromFile(GetTestCertsDirectory(), cert_data.file_name));
   std::string write_data;
   bool encoded =
       X509Certificate::GetDEREncoded(cert->os_cert_handle(), &write_data);
   ASSERT_TRUE(encoded);
   int entry_size = entry->GetDataSize(0 /* index */);
   scoped_refptr<IOBuffer> buffer(new IOBuffer(entry_size));
-  rv = entry->ReadData(
-      0 /* index */, 0 /* offset */, buffer, entry_size, callback.callback());
+  rv = entry->ReadData(0 /* index */,
+                       0 /* offset */,
+                       buffer.get(),
+                       entry_size,
+                       callback.callback());
   EXPECT_EQ(entry_size, callback.GetResult(rv));
   entry->Close();
   X509Certificate::OSCertHandle cached_cert_handle =
       X509Certificate::CreateOSCertHandleFromBytes(buffer->data(), entry_size);
   EXPECT_TRUE(X509Certificate::IsSameOSCert(cached_cert_handle,
                                             cert->os_cert_handle()));
   X509Certificate::FreeOSCertHandle(cached_cert_handle);
 }
 
 }  // namespace
@@ skipping 340 matching lines @@
 
   cache.GetCertificate(kCert1.cache_key, get_callback2.callback());
   get_callback2.WaitForResult();
   EXPECT_TRUE(X509Certificate::IsSameOSCert(get_callback2.cert_handle(),
                                             cert->os_cert_handle()));
   EXPECT_EQ(1U, cache.mem_cache_hits_for_testing());
   ASSERT_NO_FATAL_FAILURE(CheckCertCached(&backend, kCert1));
 }
 
 }  // namespace net