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

net/spdy/spdy_http_stream_spdy2_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/spdy/spdy_http_stream.h"
 
 #include "crypto/ec_private_key.h"
 #include "crypto/ec_signature_creator.h"
 #include "crypto/signature_creator.h"
 #include "net/base/capturing_net_log.h"
@@ skipping 278 matching lines @@
   TestLoadTimingReused(*http_stream2);
   EXPECT_TRUE(http_stream2->GetLoadTimingInfo(&load_timing_info2));
   EXPECT_EQ(load_timing_info1.socket_log_id, load_timing_info2.socket_log_id);
 
   // All the reads.
   deterministic_data()->RunFor(6);
 
   // Read stream 1 to completion, before making sure we can still read load
   // timing from both streams.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(1));
-  ASSERT_EQ(0, http_stream1->ReadResponseBody(buf1, 1, callback1.callback()));
+  ASSERT_EQ(
+      0, http_stream1->ReadResponseBody(buf1.get(), 1, callback1.callback()));
 
   // Stream 1 has been read to completion.
   TestLoadTimingNotReused(*http_stream1);
   // Stream 2 still has queued body data.
   TestLoadTimingReused(*http_stream2);
 }
 
 TEST_F(SpdyHttpStreamSpdy2Test, SendChunkedPost) {
   scoped_ptr<SpdyFrame> req(ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
@@ skipping 127 matching lines @@
   deterministic_data()->RunFor(2);
 
   // Read response headers.
   deterministic_data()->RunFor(1);
   ASSERT_EQ(OK, http_stream->ReadResponseHeaders(callback.callback()));
 
   // Read and check |chunk1| response.
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
-            http_stream->ReadResponseBody(buf1,
-                                          kUploadDataSize,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   // Read and check |chunk2| response.
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf2(new IOBuffer(kUploadData1Size));
   ASSERT_EQ(kUploadData1Size,
-            http_stream->ReadResponseBody(buf2,
-                                          kUploadData1Size,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf2.get(), kUploadData1Size, callback.callback()));
   EXPECT_EQ(kUploadData1, std::string(buf2->data(), kUploadData1Size));
 
   // Read and check |chunk3| response.
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf3(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
-            http_stream->ReadResponseBody(buf3,
-                                          kUploadDataSize,
-                                          callback.callback()));
+            http_stream->ReadResponseBody(
+                buf3.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf3->data(), kUploadDataSize));
 
   // Finish reading the |EOF|.
   deterministic_data()->RunFor(1);
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
   EXPECT_TRUE(deterministic_data()->at_read_eof());
   EXPECT_TRUE(deterministic_data()->at_write_eof());
 }
 
@@ skipping 18 matching lines @@
   EXPECT_EQ(OK, InitSession(reads, arraysize(reads), writes, arraysize(writes),
       host_port_pair));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(full_url);
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
-  scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
-  ASSERT_EQ(
-      OK,
-      http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
-                                    net_log, CompletionCallback()));
+  scoped_ptr<SpdyHttpStream> http_stream(
+      new SpdyHttpStream(session_.get(), true));
+  ASSERT_EQ(OK,
+            http_stream->InitializeStream(
+                &request, DEFAULT_PRIORITY, net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
 
   EXPECT_EQ(base_url, http_stream->stream()->GetUrl().spec());
 
   // This triggers the MockWrite and read 2
   callback.WaitForResult();
 
   // This triggers read 3. The empty read causes the session to shut down.
   data()->CompleteRead();
 
   // Because we abandoned the stream, we don't expect to find a session in the
   // pool anymore.
   EXPECT_FALSE(http_session_->spdy_session_pool()->HasSession(key));
   EXPECT_TRUE(data()->at_read_eof());
   EXPECT_TRUE(data()->at_write_eof());
 }
 
 // TODO(willchan): Write a longer test for SpdyStream that exercises all
 // methods.
 
 }  // namespace net