Change HostResolver::Resolve() to take an std::unique_ptr<Request>* rather than a RequestHandle*

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 <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 1127 matching lines @@
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.  Of course, even though QUIC *could* perform a 0-RTT
   // connection to the the server, in this test we require confirmation
   // before encrypting so the HTTP job will still start.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
   HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
+  std::unique_ptr<HostResolver::Request> request;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
-                         nullptr, net_log_.bound());
+                         &request, net_log_.bound());
 
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   std::unique_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
@@ skipping 524 matching lines @@
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
   HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
+  std::unique_ptr<HostResolver::Request> request;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
-                         nullptr, net_log_.bound());
+                         &request, net_log_.bound());
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) {
   proxy_service_ = ProxyService::CreateFixedFromPacResult("PROXY myproxy:70");
 
@@ skipping 13 matching lines @@
   socket_factory_.AddSocketDataProvider(&http_data);
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
   HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
+  std::unique_ptr<HostResolver::Request> request;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
-                         nullptr, net_log_.bound());
+                         &request, net_log_.bound());
 
   request_.url = GURL("http://mail.example.org/");
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
@@ skipping 14 matching lines @@
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.  Of course, even though QUIC *could* perform a 0-RTT
   // connection to the the server, in this test we require confirmation
   // before encrypting so the HTTP job will still start.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
   HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
+  std::unique_ptr<HostResolver::Request> request;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
-                         nullptr, net_log_.bound());
+                         &request, net_log_.bound());
 
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   std::unique_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
@@ skipping 24 matching lines @@
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.  Of course, even though QUIC *could* perform a 0-RTT
   // connection to the the server, in this test we require confirmation
   // before encrypting so the HTTP job will still start.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
   HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
+  std::unique_ptr<HostResolver::Request> request;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
-                         nullptr, net_log_.bound());
+                         &request, net_log_.bound());
 
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   std::unique_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
@@ skipping 33 matching lines @@
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.  Of course, even though QUIC *could* perform a 0-RTT
   // connection to the the server, in this test we require confirmation
   // before encrypting so the HTTP job will still start.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
   HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
+  std::unique_ptr<HostResolver::Request> request;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
-                         nullptr, net_log_.bound());
+                         &request, net_log_.bound());
 
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   std::unique_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
@@ skipping 29 matching lines @@
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.  Of course, even though QUIC *could* perform a 0-RTT
   // connection to the the server, in this test we require confirmation
   // before encrypting so the HTTP job will still start.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
   HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
+  std::unique_ptr<HostResolver::Request> request;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
-                         nullptr, net_log_.bound());
+                         &request, net_log_.bound());
 
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   std::unique_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
@@ skipping 34 matching lines @@
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.  Of course, even though QUIC *could* perform a 0-RTT
   // connection to the the server, in this test we require confirmation
   // before encrypting so the HTTP job will still start.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
   HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
+  std::unique_ptr<HostResolver::Request> request;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
-                         nullptr, net_log_.bound());
+                         &request, net_log_.bound());
 
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   std::unique_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
@@ skipping 206 matching lines @@
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
   HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
+  std::unique_ptr<HostResolver::Request> request;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
-                         nullptr, net_log_.bound());
+                         &request, net_log_.bound());
 
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) {
   client_maker_.set_hostname("www.example.org");
   EXPECT_FALSE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
@@ skipping 568 matching lines @@
   AddHangingSocketData();
 
   SendRequestAndExpectQuicResponse(origin1_);
   SendRequestAndExpectQuicResponse(origin2_);
 
   EXPECT_TRUE(AllDataConsumed());
 }
 
 }  // namespace test
 }  // namespace net