Disable 0RTT if server and origin have different hosts.

net/quic/quic_stream_factory_test.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/quic/quic_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_verifier.h"
@@ skipping 247 matching lines @@
 
     MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
     };
     DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
     socket_data.StopAfter(1);
     socket_factory_.AddSocketDataProvider(&socket_data);
 
     QuicStreamRequest request(&factory_);
     EXPECT_EQ(ERR_IO_PENDING,
-              request.Request(destination,
-                              is_https_,
-                              privacy_mode_,
-                              "GET",
-                              net_log_,
+              request.Request(destination, is_https_, privacy_mode_,
+                              destination.host(), "GET", net_log_,
                               callback_.callback()));
 
     EXPECT_EQ(OK, callback_.WaitForResult());
     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
     EXPECT_TRUE(stream.get());
     stream.reset();
 
     QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
         &factory_, destination, is_https_);
 
@@ skipping 55 matching lines @@
 TEST_P(QuicStreamFactoryTest, Create) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   // Will reset stream 3.
   stream = CreateIfSessionExists(host_port_pair_, net_log_);
   EXPECT_TRUE(stream.get());
 
   // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
   // in streams on different sessions.
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(OK,
-            request2.Request(host_port_pair_,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, is_https_, privacy_mode_,
+                                 host_port_pair_.host(), "GET", net_log_,
+                                 callback_.callback()));
   stream = request2.ReleaseStream();  // Will reset stream 5.
   stream.reset();  // Will reset stream 7.
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   crypto_client_stream_factory_.set_handshake_mode(
       MockCryptoClientStream::ZERO_RTT);
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(OK,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
+                                host_port_pair_.host(), "GET", net_log_,
+                                callback_.callback()));
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   crypto_client_stream_factory_.set_handshake_mode(
       MockCryptoClientStream::ZERO_RTT);
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
   // Posts require handshake confirmation, so this will return asynchronously.
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "POST",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "POST", net_log_,
                             callback_.callback()));
 
   // Confirm the handshake and verify that the stream is created.
   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
       QuicSession::HANDSHAKE_CONFIRMED);
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
+TEST_P(QuicStreamFactoryTest, NoZeroRttForDifferentHost) {
+  MockRead reads[] = {
+      MockRead(ASYNC, OK, 0),
+  };
+  DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
+  socket_factory_.AddSocketDataProvider(&socket_data);
+  socket_data.StopAfter(1);
+
+  crypto_client_stream_factory_.set_handshake_mode(
+      MockCryptoClientStream::ZERO_RTT);
+  host_resolver_.set_synchronous_mode(true);
+  host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
+                                           "192.168.0.1", "");
+
+  QuicStreamRequest request(&factory_);
+  int rv = request.Request(host_port_pair_, is_https_, privacy_mode_,
+                           "different.host.example.com", "GET", net_log_,
+                           callback_.callback());
+  // If server and origin have different hostnames, then handshake confirmation
+  // should be required, so Request will return asynchronously.
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  // Confirm handshake.
+  crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
+      QuicSession::HANDSHAKE_CONFIRMED);
+  EXPECT_EQ(OK, callback_.WaitForResult());
+
+  scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
+  EXPECT_TRUE(stream.get());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+}
+
 TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data1);
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data1.StopAfter(1);
   socket_data2.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_,
-                             !is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
+            request2.Request(host_port_pair_, !is_https_, privacy_mode_,
+                             host_port_pair_.host(), "GET", net_log_,
                              callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();
   EXPECT_TRUE(stream.get());
   stream.reset();
 
   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, host_port_pair_, is_https_),
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, host_port_pair_, !is_https_));
@@ skipping 13 matching lines @@
   socket_data.StopAfter(1);
 
   HostPortPair server2("mail.google.com", kDefaultServerPort);
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(
       kDefaultServerHostName, "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(
       "mail.google.com", "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(OK,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
+                                host_port_pair_.host(), "GET", net_log_,
+                                callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
-            request2.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback.callback()));
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_EQ(
       QuicStreamFactoryPeer::GetActiveSession(
           &factory_, host_port_pair_, is_https_),
       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ skipping 14 matching lines @@
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(
       kDefaultServerHostName, "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(
       "mail.google.com", "192.168.0.1", "");
 
   // Disable connection pooling.
   QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(OK,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
+                                host_port_pair_.host(), "GET", net_log_,
+                                callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
-            request2.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback.callback()));
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_NE(
       QuicStreamFactoryPeer::GetActiveSession(
           &factory_, host_port_pair_, is_https_),
       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
@@ skipping 13 matching lines @@
   socket_data2.StopAfter(1);
 
   HostPortPair server2("mail.google.com", kDefaultServerPort);
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(
       kDefaultServerHostName, "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(
       "mail.google.com", "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(OK,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
+                                host_port_pair_.host(), "GET", net_log_,
+                                callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
-            request2.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback.callback()));
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   factory_.OnSessionGoingAway(QuicStreamFactoryPeer::GetActiveSession(
       &factory_, host_port_pair_, is_https_));
   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
       &factory_, host_port_pair_, is_https_));
   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
       &factory_, server2, is_https_));
 
   TestCompletionCallback callback3;
   QuicStreamRequest request3(&factory_);
   EXPECT_EQ(OK,
-            request3.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback3.callback()));
+            request3.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback3.callback()));
   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
   EXPECT_TRUE(stream3.get());
 
   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
       &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
@@ skipping 23 matching lines @@
   verify_details.cert_verify_result.is_issued_by_known_root = true;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
   is_https_ = true;
   EXPECT_EQ(OK,
-            request.Request(server1,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+            request.Request(server1, is_https_, privacy_mode_, server1.host(),
+                            "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
-            request2.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback_.callback()));
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server1, is_https_),
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ skipping 29 matching lines @@
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   // Disable connection pooling.
   QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
 
   QuicStreamRequest request(&factory_);
   is_https_ = true;
   EXPECT_EQ(OK,
-            request.Request(server1,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+            request.Request(server1, is_https_, privacy_mode_, server1.host(),
+                            "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
-            request2.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback_.callback()));
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server1, is_https_),
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
@@ skipping 28 matching lines @@
   verify_details.cert_verify_result.verified_cert = test_cert;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
   is_https_ = true;
   EXPECT_EQ(OK,
-            request.Request(server1,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+            request.Request(server1, is_https_, privacy_mode_, server1.host(),
+                            "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
-            request2.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback_.callback()));
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server1, is_https_),
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
@@ skipping 30 matching lines @@
       test::GetTestHashValue(primary_pin));
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
   is_https_ = true;
   EXPECT_EQ(OK,
-            request.Request(server1,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+            request.Request(server1, is_https_, privacy_mode_, server1.host(),
+                            "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
-            request2.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback_.callback()));
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server1, is_https_),
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ skipping 34 matching lines @@
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   // Disable connection pooling.
   QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
 
   QuicStreamRequest request(&factory_);
   is_https_ = true;
   EXPECT_EQ(OK,
-            request.Request(server1,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+            request.Request(server1, is_https_, privacy_mode_, server1.host(),
+                            "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
-            request2.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback_.callback()));
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server1, is_https_),
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
@@ skipping 42 matching lines @@
       test::GetTestHashValue(primary_pin));
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
 
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
   is_https_ = true;
   EXPECT_EQ(OK,
-            request.Request(server1,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            callback_.callback()));
+            request.Request(server1, is_https_, privacy_mode_, server1.host(),
+                            "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
-            request2.Request(server2,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
-                             callback_.callback()));
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server1, is_https_),
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, Goaway) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
   socket_data.StopAfter(1);
   socket_factory_.AddSocketDataProvider(&socket_data);
   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
   socket_data2.StopAfter(1);
   socket_factory_.AddSocketDataProvider(&socket_data2);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   // Mark the session as going away.  Ensure that while it is still alive
   // that it is no longer active.
   QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
       &factory_, host_port_pair_, is_https_);
   factory_.OnSessionGoingAway(session);
   EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
       &factory_, host_port_pair_, is_https_));
   EXPECT_EQ(nullptr, CreateIfSessionExists(host_port_pair_, net_log_).get());
 
   // Create a new request for the same destination and verify that a
   // new session is created.
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
+            request2.Request(host_port_pair_, is_https_, privacy_mode_,
+                             host_port_pair_.host(), "GET", net_log_,
                              callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_,
                                                       host_port_pair_,
                                                       is_https_));
   EXPECT_NE(session,
             QuicStreamFactoryPeer::GetActiveSession(
@@ skipping 23 matching lines @@
                                       writes, arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   HttpRequestInfo request_info;
   std::vector<QuicHttpStream*> streams;
   // The MockCryptoClientStream sets max_open_streams to be
   // kDefaultMaxStreamsPerConnection / 2.
   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection / 2; i++) {
     QuicStreamRequest request(&factory_);
-    int rv = request.Request(host_port_pair_,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
+    int rv = request.Request(host_port_pair_, is_https_, privacy_mode_,
+                             host_port_pair_.host(), "GET", net_log_,
                              callback_.callback());
     if (i == 0) {
       EXPECT_EQ(ERR_IO_PENDING, rv);
       EXPECT_EQ(OK, callback_.WaitForResult());
     } else {
       EXPECT_EQ(OK, rv);
     }
     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
     EXPECT_TRUE(stream);
     EXPECT_EQ(OK, stream->InitializeStream(
         &request_info, DEFAULT_PRIORITY, net_log_, CompletionCallback()));
     streams.push_back(stream.release());
   }
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(OK,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
-                            CompletionCallback()));
+  EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
+                                host_port_pair_.host(), "GET", net_log_,
+                                CompletionCallback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream);
   EXPECT_EQ(ERR_IO_PENDING, stream->InitializeStream(
         &request_info, DEFAULT_PRIORITY, net_log_, callback_.callback()));
 
   // Close the first stream.
   streams.front()->Close(false);
 
   ASSERT_TRUE(callback_.have_result());
 
   EXPECT_EQ(OK, callback_.WaitForResult());
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   STLDeleteElements(&streams);
 }
 
 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
   DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
   MockConnect connect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
   DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
   socket_data.set_connect_data(connect);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(ERR_ADDRESS_IN_USE, callback_.WaitForResult());
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, CancelCreate) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   {
     QuicStreamRequest request(&factory_);
     EXPECT_EQ(ERR_IO_PENDING,
-              request.Request(host_port_pair_,
-                              is_https_,
-                              privacy_mode_,
-                              "GET",
-                              net_log_,
+              request.Request(host_port_pair_, is_https_, privacy_mode_,
+                              host_port_pair_.host(), "GET", net_log_,
                               callback_.callback()));
   }
 
   socket_data.StopAfter(1);
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
   scoped_ptr<QuicHttpStream> stream(
       CreateIfSessionExists(host_port_pair_, net_log_));
   EXPECT_TRUE(stream.get());
@@ skipping 42 matching lines @@
 
   MockRead reads2[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   HttpRequestInfo request_info;
   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
                                          DEFAULT_PRIORITY,
                                          net_log_, CompletionCallback()));
 
   // Close the session and verify that stream saw the error.
   factory_.CloseAllSessions(ERR_INTERNET_DISCONNECTED);
   EXPECT_EQ(ERR_INTERNET_DISCONNECTED,
             stream->ReadResponseHeaders(callback_.callback()));
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
+            request2.Request(host_port_pair_, is_https_, privacy_mode_,
+                             host_port_pair_.host(), "GET", net_log_,
                              callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
@@ skipping 14 matching lines @@
 
   MockRead reads2[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   HttpRequestInfo request_info;
   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
                                          DEFAULT_PRIORITY,
                                          net_log_, CompletionCallback()));
 
   // Change the IP address and verify that stream saw the error.
   factory_.OnIPAddressChanged();
   EXPECT_EQ(ERR_NETWORK_CHANGED,
             stream->ReadResponseHeaders(callback_.callback()));
   EXPECT_TRUE(factory_.require_confirmation());
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
+            request2.Request(host_port_pair_, is_https_, privacy_mode_,
+                             host_port_pair_.host(), "GET", net_log_,
                              callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
@@ skipping 14 matching lines @@
 
   MockRead reads2[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   HttpRequestInfo request_info;
   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
                                          DEFAULT_PRIORITY,
                                          net_log_, CompletionCallback()));
 
   // Add a cert and verify that stream saw the event.
   factory_.OnCertAdded(nullptr);
   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
             stream->ReadResponseHeaders(callback_.callback()));
   EXPECT_FALSE(factory_.require_confirmation());
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
+            request2.Request(host_port_pair_, is_https_, privacy_mode_,
+                             host_port_pair_.host(), "GET", net_log_,
                              callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
@@ skipping 14 matching lines @@
 
   MockRead reads2[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_,
-                            is_https_,
-                            privacy_mode_,
-                            "GET",
-                            net_log_,
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   HttpRequestInfo request_info;
   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
                                          DEFAULT_PRIORITY,
                                          net_log_, CompletionCallback()));
 
   // Change the CA cert and verify that stream saw the event.
   factory_.OnCACertChanged(nullptr);
   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
             stream->ReadResponseHeaders(callback_.callback()));
   EXPECT_FALSE(factory_.require_confirmation());
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_,
-                             is_https_,
-                             privacy_mode_,
-                             "GET",
-                             net_log_,
+            request2.Request(host_port_pair_, is_https_, privacy_mode_,
+                             host_port_pair_.host(), "GET", net_log_,
                              callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
@@ skipping 89 matching lines @@
 
   crypto_client_stream_factory_.set_handshake_mode(
       MockCryptoClientStream::ZERO_RTT);
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
   QuicServerId server_id(host_port_pair_, is_https_, privacy_mode_);
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, is_https_, privacy_mode_, "GET",
-                            net_log_, callback_.callback()));
+            request.Request(host_port_pair_, is_https_, privacy_mode_,
+                            host_port_pair_.host(), "GET", net_log_,
+                            callback_.callback()));
   EXPECT_EQ(2u,
             QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
 
   runner_->RunNextTask();
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   EXPECT_EQ(0u,
@@ skipping 13 matching lines @@
   socket_data.StopAfter(1);
 
   crypto_client_stream_factory_.set_handshake_mode(
       MockCryptoClientStream::ZERO_RTT);
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
-                                "GET", net_log_, callback_.callback()));
+                                host_port_pair_.host(), "GET", net_log_,
+                                callback_.callback()));
 
   // If we are waiting for disk cache, we would have posted a task. Verify that
   // the CancelWaitForDataReady task hasn't been posted.
   ASSERT_EQ(0u, runner_->GetPostedTasks().size());
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
@@ skipping 29 matching lines @@
   crypto_client_stream_factory_.set_handshake_mode(
       MockCryptoClientStream::ZERO_RTT);
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
-                                "GET", net_log_, callback_.callback()));
+                                host_port_pair_.host(), "GET", net_log_,
+                                callback_.callback()));
 
   QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
       &factory_, host_port_pair_, is_https_);
 
   DVLOG(1) << "Create 1st session and test packet loss";
 
   // Set packet_loss_rate to a lower value than packet_loss_threshold.
   EXPECT_FALSE(
       factory_.OnHandshakeConfirmed(session, /*packet_loss_rate=*/0.9f));
   EXPECT_TRUE(session->connection()->connected());
@@ skipping 15 matching lines @@
   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
       &factory_, host_port_pair_, is_https_));
   EXPECT_EQ(nullptr, CreateIfSessionExists(host_port_pair_, net_log_).get());
 
   // Test N-in-a-row high packet loss connections.
 
   DVLOG(1) << "Create 2nd session and test packet loss";
 
   TestCompletionCallback callback2;
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_, "GET",
-                                 net_log_, callback2.callback()));
+  EXPECT_EQ(OK,
+            request2.Request(server2, is_https_, privacy_mode_, server2.host(),
+                             "GET", net_log_, callback2.callback()));
   QuicClientSession* session2 =
       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_);
 
   // If there is no packet loss during handshake confirmation, number of lossy
   // connections for the port should be 0.
   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
                    &factory_, server2.port()));
   EXPECT_FALSE(
       factory_.OnHandshakeConfirmed(session2, /*packet_loss_rate=*/0.9f));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
@@ skipping 11 matching lines @@
   EXPECT_FALSE(
       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server2.port()));
   EXPECT_FALSE(
       QuicStreamFactoryPeer::HasActiveSession(&factory_, server2, is_https_));
   EXPECT_EQ(nullptr, CreateIfSessionExists(server2, net_log_).get());
 
   DVLOG(1) << "Create 3rd session which also has packet loss";
 
   TestCompletionCallback callback3;
   QuicStreamRequest request3(&factory_);
-  EXPECT_EQ(OK, request3.Request(server3, is_https_, privacy_mode_, "GET",
-                                 net_log_, callback3.callback()));
+  EXPECT_EQ(OK,
+            request3.Request(server3, is_https_, privacy_mode_, server3.host(),
+                             "GET", net_log_, callback3.callback()));
   QuicClientSession* session3 =
       QuicStreamFactoryPeer::GetActiveSession(&factory_, server3, is_https_);
 
   // Set packet_loss_rate to higher value than packet_loss_threshold 2nd time in
   // a row and that should close the session and disable QUIC.
   EXPECT_TRUE(
       factory_.OnHandshakeConfirmed(session3, /*packet_loss_rate=*/1.0f));
   EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
                    &factory_, server3.port()));
   EXPECT_FALSE(session2->connection()->connected());
@@ skipping 11 matching lines @@
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data3.AllReadDataConsumed());
   EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
 }
 
 }  // namespace test
 }  // namespace net