Update net/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

net/http/http_stream_parser_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 "net/http/http_stream_parser.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
@@ skipping 207 matching lines @@
   scoped_ptr<ClientSocketHandle> socket_handle(new ClientSocketHandle);
   socket_handle->set_socket(transport.release());
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.load_flags = LOAD_NORMAL;
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
-  HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer,
-                          BoundNetLog());
+  HttpStreamParser parser(
+      socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Host", "localhost");
   request_headers.SetHeader("Transfer-Encoding", "chunked");
   request_headers.SetHeader("Connection", "keep-alive");
 
   HttpResponseInfo response_info;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   rv = parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
@@ skipping 45 matching lines @@
   rv = parser.ReadResponseHeaders(callback.callback());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data.RunFor(2);
 
   ASSERT_TRUE(callback.have_result());
   rv = callback.WaitForResult();
   ASSERT_GT(rv, 0);
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
-  rv = parser.ReadResponseBody(body_buffer, kBodySize, callback.callback());
+  rv = parser.ReadResponseBody(
+      body_buffer.get(), kBodySize, callback.callback());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data.RunFor(1);
 
   ASSERT_TRUE(callback.have_result());
   rv = callback.WaitForResult();
   ASSERT_EQ(kBodySize, rv);
 }
 
 TEST(HttpStreamParser, TruncatedHeaders) {
   MockRead truncated_status_reads[] = {
@@ skipping 69 matching lines @@
       HttpRequestInfo request_info;
       request_info.method = "GET";
       if (protocol == HTTP) {
         request_info.url = GURL("http://localhost");
       } else {
         request_info.url = GURL("https://localhost");
       }
       request_info.load_flags = LOAD_NORMAL;
 
       scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
-      HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer,
-                              BoundNetLog());
+      HttpStreamParser parser(
+          socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
 
       HttpRequestHeaders request_headers;
       HttpResponseInfo response_info;
       rv = parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
                               &response_info, callback.callback());
       ASSERT_EQ(OK, rv);
 
       rv = parser.ReadResponseHeaders(callback.callback());
       if (i == arraysize(reads) - 1) {
         EXPECT_EQ(OK, rv);
         EXPECT_TRUE(response_info.headers.get());
       } else {
         if (protocol == HTTP) {
           EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
           EXPECT_TRUE(response_info.headers.get());
         } else {
           EXPECT_EQ(ERR_HEADERS_TRUNCATED, rv);
           EXPECT_FALSE(response_info.headers.get());
         }
       }
     }
   }
 }
 
 }  // namespace net