Make QUIC tests use certs which are valid for the hosts they connect to.

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/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 54 matching lines @@
     "Alternate-Protocol: 443:quic,p=.5\r\n\r\n";
 static const char kQuicAlternateProtocolDifferentPortHeader[] =
     "Alternate-Protocol: 137:quic\r\n\r\n";
 static const char kQuicAlternativeServiceHeader[] =
     "Alt-Svc: quic=\":443\"\r\n\r\n";
 static const char kQuicAlternativeService50pctHeader[] =
     "Alt-Svc: quic=\":443\";p=\".5\"\r\n\r\n";
 static const char kQuicAlternativeServiceDifferentPortHeader[] =
     "Alt-Svc: quic=\":137\"\r\n\r\n";
 
-const char kDefaultServerHostName[] = "mail.example.com";
+const char kDefaultServerHostName[] = "mail.example.org";
 
 }  // namespace
 
 // Helper class to encapsulate MockReads and MockWrites for QUIC.
 // Simplify ownership issues and the interaction with the MockSocketFactory.
 class MockQuicData {
  public:
   MockQuicData() : packet_number_(0) {}
 
   ~MockQuicData() { STLDeleteElements(&packets_); }
@@ skipping 112 matching lines @@
         random_generator_(0),
         ssl_data_(ASYNC, OK) {
     request_.method = "GET";
     std::string url("https://");
     url.append(kDefaultServerHostName);
     request_.url = GURL(url);
     request_.load_flags = 0;
     clock_->AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
 
     scoped_refptr<X509Certificate> cert(
-        ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
+        ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
     verify_details_.cert_verify_result.verified_cert = cert;
     verify_details_.cert_verify_result.is_issued_by_known_root = true;
     crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
   }
 
   void SetUp() override {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
@@ skipping 207 matching lines @@
     params_.transport_security_state = &transport_security_state_;
     params_.cert_transparency_verifier = cert_transparency_verifier_.get();
     params_.socket_performance_watcher_factory =
         test_network_quality_estimator_.get();
     params_.proxy_service = proxy_service_.get();
     params_.ssl_config_service = ssl_config_service_.get();
     params_.http_auth_handler_factory = auth_handler_factory_.get();
     params_.http_server_properties = http_server_properties_.GetWeakPtr();
     params_.quic_supported_versions = SupportedVersions(GetParam());
     for (const char* host :
-         {kDefaultServerHostName, "www.example.com", "news.example.com",
-          "bar.example.com", "foo.example.com", "www.example.org",
-          "invalid.example.org", "docs.example.org"}) {
+         {kDefaultServerHostName, "www.example.org", "news.example.org",
+          "bar.example.org", "foo.example.org", "invalid.example.org",
+          "mail.example.com"}) {
       params_.quic_host_whitelist.insert(host);
     }
 
     test_network_quality_estimator_->AddRTTObserver(&rtt_observer_);
 
     if (use_next_protos) {
       params_.parse_alternative_services = true;
       params_.enable_alternative_service_with_different_host = true;
     }
 
@@ skipping 147 matching lines @@
     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("mail.example.com:443");
+      HostPortPair::FromString("mail.example.org:443");
 
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "https", "/")));
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
@@ skipping 46 matching lines @@
   EXPECT_LT(0, pos);
 
   int log_stream_id;
   ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &log_stream_id));
   EXPECT_EQ(3, log_stream_id);
 }
 
 TEST_P(QuicNetworkTransactionTest, QuicProxy) {
   params_.enable_quic_for_proxies = true;
   proxy_service_ =
-      ProxyService::CreateFixedFromPacResult("QUIC mail.example.com:70");
+      ProxyService::CreateFixedFromPacResult("QUIC mail.example.org:70");
 
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "http", "/")));
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   EXPECT_FALSE(rtt_observer_.rtt_notification_received());
   // There is no need to set up an alternate protocol job, because
   // no attempt will be made to speak to the proxy over TCP.
 
-  request_.url = GURL("http://mail.example.com/");
+  request_.url = GURL("http://mail.example.org/");
   CreateSession();
 
   SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70);
   EXPECT_TRUE(rtt_observer_.rtt_notification_received());
 }
 
 // Regression test for https://crbug.com/492458.  Test that for an HTTP
 // connection through a QUIC proxy, the certificate exhibited by the proxy is
 // checked against the proxy hostname, not the origin hostname.
 TEST_P(QuicNetworkTransactionTest, QuicProxyWithCert) {
-  const std::string origin_host = "news.example.com";
+  const std::string origin_host = "mail.example.com";
   const std::string proxy_host = "www.example.org";
 
   params_.enable_quic_for_proxies = true;
   proxy_service_ =
       ProxyService::CreateFixedFromPacResult("QUIC " + proxy_host + ":70");
 
   maker_.set_hostname(origin_host);
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "http", "/")));
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   scoped_refptr<X509Certificate> cert(
-      ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
+      ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
   ASSERT_TRUE(cert.get());
   // This certificate is valid for the proxy, but not for the origin.
   bool common_name_fallback_used;
   EXPECT_TRUE(cert->VerifyNameMatch(proxy_host, &common_name_fallback_used));
   EXPECT_FALSE(cert->VerifyNameMatch(origin_host, &common_name_fallback_used));
   ProofVerifyDetailsChromium verify_details;
   verify_details.cert_verify_result.verified_cert = cert;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
   ProofVerifyDetailsChromium verify_details2;
   verify_details2.cert_verify_result.verified_cert = cert;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
 
   request_.url = GURL("http://" + origin_host);
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
   SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70);
 }
 
 TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) {
   params_.origin_to_force_quic_on =
-      HostPortPair::FromString("mail.example.com:443");
+      HostPortPair::FromString("mail.example.org:443");
 
   MockQuicData mock_quic_data1;
   mock_quic_data1.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
 
   MockQuicData mock_quic_data2;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
   mock_quic_data2.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
 
   mock_quic_data1.AddSocketDataToFactory(&socket_factory_);
@@ skipping 125 matching lines @@
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 // When multiple alternative services are advertised,
 // HttpStreamFactoryImpl::RequestStreamInternal() should select the alternative
 // service which uses existing QUIC session if available. If no existing QUIC
 // session can be used, use the first alternative service from the list.
 TEST_P(QuicNetworkTransactionTest, UseExistingAlternativeServiceForQuic) {
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead("Alt-Svc: quic=\"foo.example.com:443\", quic=\":444\"\r\n\r\n"),
+      MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   QuicStreamOffset request_header_offset = 0;
   QuicStreamOffset response_header_offset = 0;
   // First QUIC request data.
-  // Open a session to foo.example.com:443 using the first entry of the
+  // Open a session to foo.example.org:443 using the first entry of the
   // alternative service list.
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
       1, kClientDataStreamId1, true, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
 
   std::string alt_svc_list =
-      "quic=\"mail.example.com:444\", quic=\"foo.example.com:443\", "
-      "quic=\"bar.example.com:445\"";
+      "quic=\"mail.example.org:444\", quic=\"foo.example.org:443\", "
+      "quic=\"bar.example.org:445\"";
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false,
       GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 
   // Second QUIC request data.
   // Connection pooling, using existing session, no need to include version
   // as version negotiation has been completed.
@@ skipping 19 matching lines @@
   SendRequestAndExpectQuicResponseOnPort("hello!", 443);
   SendRequestAndExpectQuicResponseOnPort("hello!", 443);
 }
 
 // When multiple alternative services that has existing QUIC session.
 // HttpStreamFactoryImpl::RequestStreamInternal() should select the first
 // alternative service which uses existing QUIC session.
 TEST_P(QuicNetworkTransactionTest, UseFirstExistingAlternativeServiceForQuic) {
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead("Alt-Svc: quic=\"foo.example.com:443\", quic=\":446\"\r\n\r\n"),
+      MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":446\"\r\n\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   QuicStreamOffset request_header_offset = 0;
   QuicStreamOffset response_header_offset = 0;
 
   QuicTestPacketMaker maker(GetParam(), 0, clock_, kDefaultServerHostName);
 
   MockQuicData mock_quic_data;
   MockQuicData mock_quic_data2;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
   // First QUIC request data.
-  // Open a QUIC session to foo.example.com:443.
+  // Open a QUIC session to foo.example.org:443.
   mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
       1, kClientDataStreamId1, true, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
 
   std::string alt_svc_list =
-      "quic=\"bar.example.com:444\", quic=\"frog.example.com:445\", "
-      "quic=\"mail.example.com:446\"";
+      "quic=\"bar.example.org:444\", quic=\"frog.example.org:445\", "
+      "quic=\"mail.example.org:446\"";
   // Response header from the server resets the alt_svc list for the origin.
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false,
       GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset));
   mock_quic_data.AddRead(ConstructDataPacket(2, kClientDataStreamId1, false,
                                              true, 0, "hello from foo!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 
   // Second QUIC request data.
-  // Existing QUIC session to foo.example.com is not viable from the updated
+  // Existing QUIC session to foo.example.org is not viable from the updated
   // alt_svc. Unable to pool the existing QUIC session.
-  // Open a new QUIC session to bar.example.com:443.
+  // Open a new QUIC session to bar.example.org:443.
   mock_quic_data2.AddWrite(ConstructRequestHeadersPacket(
       1, kClientDataStreamId1, true, true,
       GetRequestHeaders("GET", "https", "/"), &maker));
   alt_svc_list =
-      "quic=\"foo.example.com:443\", quic=\"mail.example.com:446\", "
-      "quic=\"bar.example.com:444\"";
+      "quic=\"foo.example.org:443\", quic=\"mail.example.org:446\", "
+      "quic=\"bar.example.org:444\"";
   // Response header from the server resets the alt_svc list for the origin.
   mock_quic_data2.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false,
       GetResponseHeaders("200 OK", alt_svc_list), &maker));
   mock_quic_data2.AddRead(ConstructDataPacket(2, kClientDataStreamId1, false,
                                               true, 0, "hello from bar!"));
   mock_quic_data2.AddWrite(ConstructAckPacket(2, 1, &maker));
   mock_quic_data2.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data2.AddRead(ASYNC, 0);               // EOF
 
   // Third QUIC request data.
-  // Connection pooling, using the first existing session to foo.example.com
+  // Connection pooling, using the first existing session to foo.example.org
   mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
       3, kClientDataStreamId2, false, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
       &response_header_offset));
   mock_quic_data.AddRead(ConstructDataPacket(4, kClientDataStreamId2, false,
                                              true, 0, "hello from foo!"));
   mock_quic_data.AddWrite(ConstructAckAndConnectionClosePacket(4, 4, 3, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
@@ skipping 13 matching lines @@
   SendRequestAndExpectQuicResponseOnPort("hello from bar!", 444);
   SendRequestAndExpectQuicResponseOnPort("hello from foo!", 443);
 }
 
 // Multiple origins have listed the same alternative services. When there's a
 // existing QUIC session opened by a request to other origin,
 // if the cert is valid, should select this QUIC session to make the request
 // if this is also the first existing QUIC session.
 TEST_P(QuicNetworkTransactionTest,
        UseSharedExistingAlternativeServiceForQuicWithValidCert) {
-  // Default cert is valid for the following origins:
-  // mail.example.com, mail.example.org, and www.example.org.
+  // Default cert is valid for *.example.org
 
-  // HTTP data for request to mail.example.com.
+  // HTTP data for request to www.example.org.
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead("Alt-Svc: quic=\":443\"\r\n\r\n"),
-      MockRead("hello world from mail.example.com"),
+      MockRead("hello world from www.example.org"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   // HTTP data for request to mail.example.org.
   MockRead http_reads2[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead("Alt-Svc: quic=\":444\", quic=\"mail.example.com:443\"\r\n\r\n"),
+      MockRead("Alt-Svc: quic=\":444\", quic=\"www.example.org:443\"\r\n\r\n"),
       MockRead("hello world from mail.example.org"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider http_data2(http_reads2, arraysize(http_reads2),
                                       nullptr, 0);
   socket_factory_.AddSocketDataProvider(&http_data2);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   QuicStreamOffset request_header_offset = 0;
   QuicStreamOffset response_header_offset = 0;
 
-  QuicTestPacketMaker maker(GetParam(), 0, clock_, kDefaultServerHostName);
-  maker.set_hostname("mail.example.org");
+  QuicTestPacketMaker maker(GetParam(), 0, clock_, "mail.example.org");
+  maker_.set_hostname("www.example.org");
   MockQuicData mock_quic_data;
 
   // First QUIC request data.
   mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
       1, kClientDataStreamId1, true, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
 
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
       &response_header_offset));
   mock_quic_data.AddRead(ConstructDataPacket(2, kClientDataStreamId1, false,
                                              true, 0, "hello from mail QUIC!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
-
   // Second QUIC request data.
   mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
       3, kClientDataStreamId2, false, true,
       GetRequestHeaders("GET", "https", "/", maker), &request_header_offset,
       &maker));
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
       &response_header_offset));
   mock_quic_data.AddRead(ConstructDataPacket(4, kClientDataStreamId2, false,
                                              true, 0, "hello from mail QUIC!"));
   mock_quic_data.AddWrite(ConstructAckAndConnectionClosePacket(4, 4, 3, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSessionWithNextProtos();
 
   // Send two HTTP requests, responses set up alt-svc lists for the origins.
-  SendRequestAndExpectHttpResponse("hello world from mail.example.com");
+  request_.url = GURL("https://www.example.org/");
+  SendRequestAndExpectHttpResponse("hello world from www.example.org");
   request_.url = GURL("https://mail.example.org/");
   SendRequestAndExpectHttpResponse("hello world from mail.example.org");
 
-  // Open a QUIC session to mail.example.com:443 when making request
-  // to mail.example.com.
-  request_.url = GURL("https://mail.example.com/");
+  // Open a QUIC session to mail.example.org:443 when making request
+  // to mail.example.org.
+  request_.url = GURL("https://www.example.org/");
   SendRequestAndExpectQuicResponseOnPort("hello from mail QUIC!", 443);
 
-  // Uses the existing QUIC session when making request to mail.example.org.
+  // Uses the existing QUIC session when making request to www.example.org.
   request_.url = GURL("https://mail.example.org/");
   SendRequestAndExpectQuicResponseOnPort("hello from mail QUIC!", 443);
 }
 
 // Multiple origins have listed the same alternative services. When there's a
 // existing QUIC session opened by a request to other origin,
 // if the cert is NOT valid, should ignore this QUIC session.
 TEST_P(QuicNetworkTransactionTest,
        DoNotUseSharedExistingAlternativeServiceForQuicWithInvalidCert) {
-  // Default cert is only valid for the following origins:
-  // mail.example.com, mail.example.org, and www.example.org.
-  // NOT valid for docs.example.org.
+  // Default cert is valid *.example.org
+  // NOT valid for mail.example.com.
 
-  // HTTP data for request to mail.example.com.
+  // HTTP data for request to mail.example.org.
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead("Alt-Svc: quic=\":443\"\r\n\r\n"),
-      MockRead("hello world from mail.example.com"),
+      MockRead("hello world from mail.example.org"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
-  // HTTP data for request to docs.example.org.
+  // HTTP data for request to mail.example.com.
   MockRead http_reads2[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead("Alt-Svc: quic=\":444\", quic=\"mail.example.com:443\"\r\n\r\n"),
-      MockRead("hello world from docs.example.org"),
+      MockRead("Alt-Svc: quic=\":444\", quic=\"mail.example.org:443\"\r\n\r\n"),
+      MockRead("hello world from mail.example.com"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider http_data2(http_reads2, arraysize(http_reads2),
                                       nullptr, 0);
   socket_factory_.AddSocketDataProvider(&http_data2);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
-  QuicTestPacketMaker maker(GetParam(), 0, clock_, kDefaultServerHostName);
-  maker.set_hostname("docs.example.org");
+  QuicTestPacketMaker maker(GetParam(), 0, clock_, "mail.example.org");
+  maker.set_hostname("mail.example.com");
   MockQuicData mock_quic_data;
   MockQuicData mock_quic_data2;
 
   // Adding a valid cert for *.example.org but not mail.example.com.
   ProofVerifyDetailsChromium verify_details;
   scoped_refptr<X509Certificate> cert(
-      ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
+      ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
   verify_details.cert_verify_result.verified_cert = cert;
   verify_details.cert_verify_result.is_issued_by_known_root = true;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 
   // First QUIC request data.
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "https", "/")));
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
@@ skipping 18 matching lines @@
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
   AddHangingNonAlternateProtocolSocketData();
 
   mock_quic_data2.AddSocketDataToFactory(&socket_factory_);
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSessionWithNextProtos();
 
   // Send HTTP requests, responses set up the alt-svc lists for the origins.
+  SendRequestAndExpectHttpResponse("hello world from mail.example.org");
+  request_.url = GURL("https://mail.example.com/");
   SendRequestAndExpectHttpResponse("hello world from mail.example.com");
-  request_.url = GURL("https://docs.example.org/");
-  SendRequestAndExpectHttpResponse("hello world from docs.example.org");
 
-  // Open a QUIC session to mail.example.com:443 when making request
-  // to mail.example.com.
-  request_.url = GURL("https://mail.example.com/");
+  // Open a QUIC session to mail.example.org:443 when making request
+  // to mail.example.org.
+  request_.url = GURL("https://mail.example.org/");
   SendRequestAndExpectQuicResponseOnPort("hello from mail QUIC!", 443);
 
-  // Open another new QUIC session to docs.example.org:444.
-  request_.url = GURL("https://docs.example.org/");
+  // Open another new QUIC session to mail.example.com:444.
+  request_.url = GURL("https://mail.example.com/");
   SendRequestAndExpectQuicResponseOnPort("hello from docs QUIC!", 444);
 }
 
 TEST_P(QuicNetworkTransactionTest, AlternativeServiceDifferentPort) {
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead(kQuicAlternativeServiceDifferentPortHeader),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
@@ skipping 412 matching lines @@
   CreateSessionWithNextProtos();
 
   // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo().
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 class QuicAltSvcCertificateVerificationTest
     : public QuicNetworkTransactionTest {
  public:
   void Run(bool valid) {
-    HostPortPair origin(valid ? "mail.example.org" : "invalid.example.org",
-                        443);
+    HostPortPair origin(valid ? "mail.example.org" : "mail.example.com", 443);
     HostPortPair alternative("www.example.org", 443);
     std::string url("https://");
     url.append(origin.host());
     url.append(":443");
     request_.url = GURL(url);
 
     maker_.set_hostname(origin.host());
     MockQuicData mock_quic_data;
     mock_quic_data.AddWrite(
         ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                       GetRequestHeaders("GET", "https", "/")));
     mock_quic_data.AddRead(ConstructResponseHeadersPacket(
         1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
     mock_quic_data.AddRead(
         ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
     mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
     mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
     mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
     scoped_refptr<X509Certificate> cert(
-        ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
+        ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
     ASSERT_TRUE(cert.get());
     bool common_name_fallback_used;
     EXPECT_EQ(valid,
               cert->VerifyNameMatch(origin.host(), &common_name_fallback_used));
     EXPECT_TRUE(
         cert->VerifyNameMatch(alternative.host(), &common_name_fallback_used));
     ProofVerifyDetailsChromium verify_details;
     verify_details.cert_verify_result.verified_cert = cert;
     verify_details.cert_verify_result.is_issued_by_known_root = true;
     crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
@@ skipping 42 matching lines @@
        RequestFailsWithInvalidCertificate) {
   Run(false);
 }
 
 TEST_P(QuicNetworkTransactionTest, HungAlternateProtocol) {
   crypto_client_stream_factory_.set_handshake_mode(
       MockCryptoClientStream::COLD_START);
 
   MockWrite http_writes[] = {
       MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
-      MockWrite(SYNCHRONOUS, 1, "Host: mail.example.com\r\n"),
+      MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"),
       MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")};
 
   MockRead http_reads[] = {
       MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
       MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHeader),
       MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)};
 
   MockClientSocketFactory socket_factory;
 
   SequencedSocketData http_data(http_reads, arraysize(http_reads), http_writes,
@@ skipping 68 matching lines @@
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
   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.com", "192.168.0.1",
+  host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
-  HostResolver::RequestInfo info(HostPortPair("mail.example.com", 443));
+  HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
                          nullptr, net_log_.bound());
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) {
   proxy_service_ = ProxyService::CreateFixedFromPacResult("PROXY myproxy:70");
 
   // Since we are using a proxy, the QUIC job will not succeed.
   MockWrite http_writes[] = {
-      MockWrite(SYNCHRONOUS, 0, "GET http://mail.example.com/ HTTP/1.1\r\n"),
-      MockWrite(SYNCHRONOUS, 1, "Host: mail.example.com\r\n"),
+      MockWrite(SYNCHRONOUS, 0, "GET http://mail.example.org/ HTTP/1.1\r\n"),
+      MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"),
       MockWrite(SYNCHRONOUS, 2, "Proxy-Connection: keep-alive\r\n\r\n")};
 
   MockRead http_reads[] = {
       MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
       MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHeader),
       MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)};
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      http_writes, arraysize(http_writes));
   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.com", "192.168.0.1",
+  host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
-  HostResolver::RequestInfo info(HostPortPair("mail.example.com", 443));
+  HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
                          nullptr, net_log_.bound());
 
-  request_.url = GURL("http://mail.example.com/");
+  request_.url = GURL("http://mail.example.org/");
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "https", "/")));
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   // 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.com", "192.168.0.1",
+  host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
-  HostResolver::RequestInfo info(HostPortPair("mail.example.com", 443));
+  HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
                          nullptr, net_log_.bound());
 
   CreateSessionWithNextProtos();
   session_->quic_stream_factory()->set_require_confirmation(true);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   scoped_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
@@ skipping 23 matching lines @@
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   // 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.com", "192.168.0.1",
+  host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
-  HostResolver::RequestInfo info(HostPortPair("mail.example.com", 443));
+  HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
                          nullptr, net_log_.bound());
 
   CreateSessionWithNextProtos();
   session_->quic_stream_factory()->set_require_confirmation(true);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   scoped_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
@@ skipping 32 matching lines @@
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   // 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.com", "192.168.0.1",
+  host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
-  HostResolver::RequestInfo info(HostPortPair("mail.example.com", 443));
+  HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
                          nullptr, net_log_.bound());
 
   CreateSessionWithNextProtos();
   session_->quic_stream_factory()->set_require_confirmation(true);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   scoped_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
@@ skipping 207 matching lines @@
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   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.com", "192.168.0.1",
+  host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
                                            "");
-  HostResolver::RequestInfo info(HostPortPair("mail.example.com", 443));
+  HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
   AddressList address;
   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
                          nullptr, net_log_.bound());
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) {
@@ skipping 14 matching lines @@
   request_.url = GURL("https://www.example.org:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
   SendRequestAndExpectQuicResponse("hello!");
   EXPECT_TRUE(rtt_observer_.rtt_notification_received());
 }
 
 TEST_P(QuicNetworkTransactionTest, QuicUpload) {
   params_.origin_to_force_quic_on =
-      HostPortPair::FromString("mail.example.com:443");
+      HostPortPair::FromString("mail.example.org:443");
 
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   MockWrite writes[] = {MockWrite(SYNCHRONOUS, ERR_FAILED, 1)};
   SequencedSocketData socket_data(reads, arraysize(reads), writes,
                                   arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
   request_.method = "POST";
   ChunkedUploadDataStream upload_data(0);
   upload_data.AppendData("1", 1, true);
 
   request_.upload_data_stream = &upload_data;
 
   scoped_ptr<HttpNetworkTransaction> trans(
       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_NE(OK, callback.WaitForResult());
 }
 
 }  // namespace test
 }  // namespace net