Remove implicit scoped_refptr 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_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 78 matching lines @@
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_NoBody) {
   // Shouldn't be merged if upload data is non-existent.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", NULL));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_EmptyBody) {
   scoped_refptr<UploadData> upload_data = new UploadData;
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data.get()));
   ASSERT_EQ(OK, body->InitSync());
   // Shouldn't be merged if upload data is empty.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_ChunkedBody) {
   scoped_refptr<UploadData> upload_data = new UploadData;
   upload_data->set_is_chunked(true);
   const std::string payload = "123";
   upload_data->AppendChunk(payload.data(), payload.size(), true);
 
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data.get()));
   ASSERT_EQ(OK, body->InitSync());
   // Shouldn't be merged if upload data carries chunked data.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_FileBody) {
   scoped_refptr<UploadData> upload_data = new UploadData;
 
   // Create an empty temporary file.
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath temp_file_path;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir.path(),
                                                   &temp_file_path));
 
   upload_data->AppendFileRange(temp_file_path, 0, 0, base::Time());
 
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data.get()));
   ASSERT_EQ(OK, body->InitSync());
   // Shouldn't be merged if upload data carries a file, as it's not in-memory.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_SmallBodyInMemory) {
   scoped_refptr<UploadData> upload_data = new UploadData;
   const std::string payload = "123";
   upload_data->AppendBytes(payload.data(), payload.size());
 
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data.get()));
   ASSERT_EQ(OK, body->InitSync());
   // Yes, should be merged if the in-memory body is small here.
   ASSERT_TRUE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_LargeBodyInMemory) {
   scoped_refptr<UploadData> upload_data = new UploadData;
   const std::string payload(10000, 'a');  // 'a' x 10000.
   upload_data->AppendBytes(payload.data(), payload.size());
 
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data.get()));
   ASSERT_EQ(OK, body->InitSync());
   // Shouldn't be merged if the in-memory body is large here.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
 }
 
 // Test to ensure the HttpStreamParser state machine does not get confused
 // when sending a request with a chunked body, where chunks become available
 // asynchronously, over a socket where writes may also complete
 // asynchronously.
@@ skipping 43 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;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
-  HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer,
+  HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
                           BoundNetLog());
 
   scoped_refptr<UploadData> upload_data(new UploadData);
   upload_data->set_is_chunked(true);
 
   upload_data->AppendChunk(kChunk1, arraysize(kChunk1) - 1, false);
 
   scoped_ptr<UploadDataStream> upload_stream(
-      new UploadDataStream(upload_data));
+      new UploadDataStream(upload_data.get()));
   ASSERT_EQ(OK, upload_stream->InitSync());
 
   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.
@@ skipping 47 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);
 }
 
 }  // namespace net