Change QuicNetworkTransactionTest member signatures.

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 <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 261 matching lines @@
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != nullptr);
     ASSERT_TRUE(response->headers.get() != nullptr);
     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,
+  void CheckResponseData(const scoped_ptr<HttpNetworkTransaction>& trans,
                          const std::string& expected) {
     std::string response_data;
-    ASSERT_EQ(OK, ReadTransaction(trans, &response_data));
+    ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
     EXPECT_EQ(expected, response_data);
   }
 
-  void RunTransaction(HttpNetworkTransaction* trans) {
+  void RunTransaction(const scoped_ptr<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_.get()));
-    RunTransaction(trans.get());
+    RunTransaction(trans);
     CheckWasHttpResponse(trans);
-    CheckResponseData(trans.get(), expected);
+    CheckResponseData(trans, expected);
   }
 
   void SendRequestAndExpectQuicResponse(const std::string& expected) {
     SendRequestAndExpectQuicResponseMaybeFromProxy(expected, false, 80);
   }
 
   void SendRequestAndExpectQuicResponseOnPort(const std::string& expected,
                                               uint16 port) {
     SendRequestAndExpectQuicResponseMaybeFromProxy(expected, false, port);
   }
@@ skipping 57 matching lines @@
   void SendRequestAndExpectQuicResponseMaybeFromProxy(
       const std::string& expected,
       bool used_proxy,
       uint16 port) {
     scoped_ptr<HttpNetworkTransaction> trans(
         new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
     ProxyHeadersHandler proxy_headers_handler;
     trans->SetBeforeProxyHeadersSentCallback(
         base::Bind(&ProxyHeadersHandler::OnBeforeProxyHeadersSent,
                    base::Unretained(&proxy_headers_handler)));
-    RunTransaction(trans.get());
+    RunTransaction(trans);
     CheckWasQuicResponse(trans);
     CheckResponsePort(trans, port);
-    CheckResponseData(trans.get(), expected);
+    CheckResponseData(trans, expected);
     EXPECT_EQ(used_proxy, proxy_headers_handler.was_called());
   }
 };
 
 INSTANTIATE_TEST_CASE_P(Version, QuicNetworkTransactionTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicNetworkTransactionTest, ForceQuic) {
   params_.origin_to_force_quic_on =
       HostPortPair::FromString("www.google.com:80");
@@ skipping 858 matching lines @@
 
   request_.url = GURL("https://www.google.com:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 }  // namespace test
 }  // namespace net