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

net/quic/quic_network_transaction_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/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/base/capturing_net_log.h"
 #include "net/base/net_log_unittest.h"
@@ skipping 218 matching lines @@
     params_.ssl_config_service = ssl_config_service_.get();
     params_.http_auth_handler_factory = auth_handler_factory_.get();
     params_.http_server_properties = &http_server_properties;
 
     session_ = new HttpNetworkSession(params_);
   }
 
   void CheckWasQuicResponse(const scoped_ptr<HttpNetworkTransaction>& trans) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
-    ASSERT_TRUE(response->headers != NULL);
+    ASSERT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
     EXPECT_TRUE(response->was_fetched_via_spdy);
     EXPECT_TRUE(response->was_npn_negotiated);
     EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3,
               response->connection_info);
   }
 
   void CheckWasHttpResponse(const scoped_ptr<HttpNetworkTransaction>& trans) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
-    ASSERT_TRUE(response->headers != NULL);
+    ASSERT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
     EXPECT_FALSE(response->was_fetched_via_spdy);
     EXPECT_FALSE(response->was_npn_negotiated);
     EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1,
               response->connection_info);
   }
 
   void CheckResponseData(HttpNetworkTransaction* trans,
                          const std::string& expected) {
     std::string response_data;
     ASSERT_EQ(OK, ReadTransaction(trans, &response_data));
     EXPECT_EQ(expected, response_data);
   }
 
   void RunTransaction(HttpNetworkTransaction* trans) {
     TestCompletionCallback callback;
     int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_EQ(OK, callback.WaitForResult());
   }
 
   void SendRequestAndExpectHttpResponse(const std::string& expected) {
     scoped_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session_));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
     RunTransaction(trans.get());
     CheckWasHttpResponse(trans);
     CheckResponseData(trans.get(), expected);
   }
 
   void SendRequestAndExpectQuicResponse(const std::string& expected) {
     scoped_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session_));
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
     RunTransaction(trans.get());
     CheckWasQuicResponse(trans);
     CheckResponseData(trans.get(), expected);
   }
 
   void AddQuicAlternateProtocolMapping(
       MockCryptoClientStream::HandshakeMode handshake_mode) {
     crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
     session_->http_server_properties()->SetAlternateProtocol(
         HostPortPair::FromURL(request_.url), 80, QUIC);
@@ skipping 112 matching lines @@
   MockRead quic_reads[] = {
     MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
   };
   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
                                      NULL, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   CreateSession();
 
   scoped_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session_));
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, callback.WaitForResult());
 }
 
 TEST_F(QuicNetworkTransactionTest, DoNotForceQuicForHttps) {
   // Attempt to "force" quic on 443, which will not be honored.
   params_.origin_port_to_force_quic_on = 443;
 
@@ skipping 184 matching lines @@
 
   CreateSession();
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
   SendRequestAndExpectHttpResponse("hello from http");
   ExpectBrokenAlternateProtocolMapping();
 }
 
 }  // namespace test
 }  // namespace net