Fix use-after-scope issues in HttpNetworkTransactionTest.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 829 matching lines @@
 TEST_F(HttpNetworkTransactionTest, SimpleGETNoHeadersWeirdPort) {
   MockRead data_reads[] = {
       MockRead("hello world"), MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), nullptr, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
+  HttpRequestInfo request;
   std::unique_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
-  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.com:2000/");
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsError(ERR_INVALID_HTTP_RESPONSE));
 }
 
 // Response with no status line, and a weird port.  Option to allow weird ports
 // enabled.
 TEST_F(HttpNetworkTransactionTest, SimpleGETNoHeadersWeirdPortAllowed) {
   MockRead data_reads[] = {
       MockRead("hello world"), MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), nullptr, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   session_deps_.http_09_on_non_default_ports_enabled = true;
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
+  HttpRequestInfo request;
   std::unique_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
-  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.com:2000/");
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* info = trans->GetResponseInfo();
   ASSERT_TRUE(info->headers);
   EXPECT_EQ("HTTP/0.9 200 OK", info->headers->GetStatusLine());
 
@@ skipping 9499 matching lines @@
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoQUIC, alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(server, alternative_service,
                                                 expiration);
   // Mark the QUIC alternative service as broken.
   http_server_properties->MarkAlternativeServiceBroken(alternative_service);
 
+  HttpRequestInfo request;
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
-  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(origin_url);
   TestCompletionCallback callback;
   NetErrorDetails details;
   EXPECT_FALSE(details.quic_broken);
 
   trans.Start(&request, callback.callback(), NetLogWithSource());
   trans.PopulateNetErrorDetails(&details);
   EXPECT_TRUE(details.quic_broken);
 }
@@ skipping 51 matching lines @@
 
   http_server_properties->SetAlternativeServices(
       server, alternative_service_info_vector);
 
   // Mark one of the QUIC alternative service as broken.
   http_server_properties->MarkAlternativeServiceBroken(alternative_service1);
 
   const AlternativeServiceVector alternative_service_vector =
       http_server_properties->GetAlternativeServices(server);
 
+  HttpRequestInfo request;
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
-  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(origin_url);
   TestCompletionCallback callback;
   NetErrorDetails details;
   EXPECT_FALSE(details.quic_broken);
 
   trans.Start(&request, callback.callback(), NetLogWithSource());
   trans.PopulateNetErrorDetails(&details);
   EXPECT_FALSE(details.quic_broken);
 }
@@ skipping 3330 matching lines @@
 
   // Set up alternative service for server.
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoHTTP2, alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(server, alternative_service,
                                                 expiration);
 
+  HttpRequestInfo request;
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
-  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org:443");
   TestCompletionCallback callback;
 
   // HTTP/2 (or SPDY) is required for alternative service, if HTTP/1.1 is
   // negotiated, the alternate Job should fail with ERR_ALPN_NEGOTIATION_FAILED.
   int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsError(ERR_ALPN_NEGOTIATION_FAILED));
 }
 
@@ skipping 153 matching lines @@
   // Set up alternative service for server.
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoHTTP2, alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(server, alternative_service,
                                                 expiration);
 
   // First transaction to alternative to open an HTTP/1.1 socket.
+  HttpRequestInfo request1;
   HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
-  HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL(alternative_url);
   request1.load_flags = 0;
   TestCompletionCallback callback1;
 
   int rv = trans1.Start(&request1, callback1.callback(), NetLogWithSource());
   EXPECT_THAT(callback1.GetResult(rv), IsOk());
   const HttpResponseInfo* response1 = trans1.GetResponseInfo();
   ASSERT_TRUE(response1);
   ASSERT_TRUE(response1->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response1->headers->GetStatusLine());
   EXPECT_TRUE(response1->was_alpn_negotiated);
   EXPECT_FALSE(response1->was_fetched_via_spdy);
   std::string response_data1;
   ASSERT_THAT(ReadTransaction(&trans1, &response_data1), IsOk());
   EXPECT_EQ("first HTTP/1.1 response from alternative", response_data1);
 
   // Request for origin.example.org, which has an alternative service.  This
   // will start two Jobs: the alternative looks for connections to pool to,
   // finds one which is HTTP/1.1, and should ignore it, and should not try to
   // open other connections to alternative server.  The Job to server fails, so
   // this request fails.
+  HttpRequestInfo request2;
   HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
-  HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL(origin_url);
   request2.load_flags = 0;
   TestCompletionCallback callback2;
 
   rv = trans2.Start(&request2, callback2.callback(), NetLogWithSource());
   EXPECT_THAT(callback2.GetResult(rv), IsError(ERR_CONNECTION_REFUSED));
 
   // Another transaction to alternative.  This is to test that the HTTP/1.1
   // socket is still open and in the pool.
+  HttpRequestInfo request3;
   HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session.get());
-  HttpRequestInfo request3;
   request3.method = "GET";
   request3.url = GURL(alternative_url);
   request3.load_flags = 0;
   TestCompletionCallback callback3;
 
   rv = trans3.Start(&request3, callback3.callback(), NetLogWithSource());
   EXPECT_THAT(callback3.GetResult(rv), IsOk());
   const HttpResponseInfo* response3 = trans3.GetResponseInfo();
   ASSERT_TRUE(response3);
   ASSERT_TRUE(response3->headers);
@@ skipping 1089 matching lines @@
 }  // namespace
 
 // Make sure that HttpNetworkTransaction passes on its priority to its
 // stream request on start.
 TEST_F(HttpNetworkTransactionTest, SetStreamRequestPriorityOnStart) {
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpNetworkSessionPeer peer(session.get());
   FakeStreamFactory* fake_factory = new FakeStreamFactory();
   peer.SetHttpStreamFactory(std::unique_ptr<HttpStreamFactory>(fake_factory));
 
+  HttpRequestInfo request;
   HttpNetworkTransaction trans(LOW, session.get());
 
   ASSERT_FALSE(fake_factory->last_stream_request());
 
-  HttpRequestInfo request;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             trans.Start(&request, callback.callback(), NetLogWithSource()));
 
   base::WeakPtr<FakeStreamRequest> fake_request =
       fake_factory->last_stream_request();
   ASSERT_TRUE(fake_request);
   EXPECT_EQ(LOW, fake_request->priority());
 }
 
 // Make sure that HttpNetworkTransaction passes on its priority
 // updates to its stream request.
 TEST_F(HttpNetworkTransactionTest, SetStreamRequestPriority) {
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpNetworkSessionPeer peer(session.get());
   FakeStreamFactory* fake_factory = new FakeStreamFactory();
   peer.SetHttpStreamFactory(std::unique_ptr<HttpStreamFactory>(fake_factory));
 
+  HttpRequestInfo request;
   HttpNetworkTransaction trans(LOW, session.get());
 
-  HttpRequestInfo request;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             trans.Start(&request, callback.callback(), NetLogWithSource()));
 
   base::WeakPtr<FakeStreamRequest> fake_request =
       fake_factory->last_stream_request();
   ASSERT_TRUE(fake_request);
   EXPECT_EQ(LOW, fake_request->priority());
 
   trans.SetPriority(LOWEST);
   ASSERT_TRUE(fake_request);
   EXPECT_EQ(LOWEST, fake_request->priority());
 }
 
 // Make sure that HttpNetworkTransaction passes on its priority
 // updates to its stream.
 TEST_F(HttpNetworkTransactionTest, SetStreamPriority) {
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpNetworkSessionPeer peer(session.get());
   FakeStreamFactory* fake_factory = new FakeStreamFactory();
   peer.SetHttpStreamFactory(std::unique_ptr<HttpStreamFactory>(fake_factory));
 
+  HttpRequestInfo request;
   HttpNetworkTransaction trans(LOW, session.get());
 
-  HttpRequestInfo request;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             trans.Start(&request, callback.callback(), NetLogWithSource()));
 
   base::WeakPtr<FakeStreamRequest> fake_request =
       fake_factory->last_stream_request();
   ASSERT_TRUE(fake_request);
   base::WeakPtr<FakeStream> fake_stream = fake_request->FinishStreamRequest();
   ASSERT_TRUE(fake_stream);
   EXPECT_EQ(LOW, fake_stream->priority());
 
   trans.SetPriority(LOWEST);
   EXPECT_EQ(LOWEST, fake_stream->priority());
 }
 
 TEST_F(HttpNetworkTransactionTest, CreateWebSocketHandshakeStream) {
   // The same logic needs to be tested for both ws: and wss: schemes, but this
   // test is already parameterised on NextProto, so it uses a loop to verify
   // that the different schemes work.
   std::string test_cases[] = {"ws://www.example.org/",
                               "wss://www.example.org/"};
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
     HttpNetworkSessionPeer peer(session.get());
     FakeStreamFactory* fake_factory = new FakeStreamFactory();
     FakeWebSocketStreamCreateHelper websocket_stream_create_helper;
     peer.SetHttpStreamFactoryForWebSocket(
         std::unique_ptr<HttpStreamFactory>(fake_factory));
 
+    HttpRequestInfo request;
     HttpNetworkTransaction trans(LOW, session.get());
     trans.SetWebSocketHandshakeStreamCreateHelper(
         &websocket_stream_create_helper);
 
-    HttpRequestInfo request;
     TestCompletionCallback callback;
     request.method = "GET";
     request.url = GURL(test_cases[i]);
 
     EXPECT_EQ(ERR_IO_PENDING,
               trans.Start(&request, callback.callback(), NetLogWithSource()));
 
     base::WeakPtr<FakeStreamRequest> fake_request =
         fake_factory->last_stream_request();
     ASSERT_TRUE(fake_request);
@@ skipping 1263 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy);
   HttpRequestHeaders headers;
   ASSERT_TRUE(trans.GetFullRequestHeaders(&headers));
   EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding));
 }
 #endif  // !defined(OS_IOS)
 
 }  // namespace net