Custom hosts in QuicTestPacketMaker.

* Add host parameter to QuicTestPacketMaker constructor to allow for non-default
  hostnames in generated packets.
* Change hostname in QuicNetworkTransactionTest.SecureResourceOver* in
  anticipation for a future CL that will enforce certificate validation in these
  unittests.
* s/kServerHostname/kDefaultServerHostName/ in QuicHttpStreamTest to match
  QuicStreamFactoryTest.

BUG=474217

Review URL: https://codereview.chromium.org/1142523004

Cr-Commit-Position: refs/heads/master@{#329890}

net/quic/quic_http_stream_test.cc

@@ -50,8 +50,8 @@ namespace test {
 namespace {
 
 const char kUploadData[] = "Really nifty data!";
-const char kServerHostname[] = "www.google.com";
-const uint16 kServerPort = 80;
+const char kDefaultServerHostName[] = "www.google.com";
+const uint16 kDefaultServerPort = 80;
 
 class TestQuicConnection : public QuicConnection {
  public:
@@ -135,7 +135,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
         read_buffer_(new IOBufferWithSize(4096)),
         connection_id_(2),
         stream_id_(kClientDataStreamId1),
-        maker_(GetParam(), connection_id_, &clock_),
+        maker_(GetParam(), connection_id_, &clock_, kDefaultServerHostName),
         random_generator_(0) {
     IPAddressNumber ip;
     CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
@@ -210,11 +210,10 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
         &transport_security_state_, make_scoped_ptr((QuicServerInfo*)nullptr),
         DefaultQuicConfig(), "CONNECTION_UNKNOWN", base::TimeTicks::Now(),
         base::MessageLoop::current()->message_loop_proxy().get(), nullptr));
-    session_->InitializeSession(QuicServerId(kServerHostname, kServerPort,
-                                             /*is_secure=*/false,
-                                             PRIVACY_MODE_DISABLED),
-                                &crypto_config_,
-                                &crypto_client_stream_factory_);
+    session_->InitializeSession(
+        QuicServerId(kDefaultServerHostName, kDefaultServerPort,
+                     /*is_secure=*/false, PRIVACY_MODE_DISABLED),
+        &crypto_config_, &crypto_client_stream_factory_);
     session_->GetCryptoStream()->CryptoConnect();
     EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed());
     stream_.reset(use_closing_stream_ ?

net/quic/quic_network_transaction_unittest.cc

@@ -63,6 +63,8 @@ static const char kQuicAlternateProtocolDifferentPortHttpHeader[] =
 static const char kQuicAlternateProtocolHttpsHeader[] =
     "Alternate-Protocol: 443:quic\r\n\r\n";
 
+const char kDefaultServerHostName[] = "www.google.com";
+
 }  // namespace
 
 // Helper class to encapsulate MockReads and MockWrites for QUIC.
@@ -134,7 +136,7 @@ class QuicNetworkTransactionTest
  protected:
   QuicNetworkTransactionTest()
       : clock_(new MockClock),
-        maker_(GetParam(), 0, clock_),
+        maker_(GetParam(), 0, clock_, kDefaultServerHostName),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_service_(ProxyService::CreateDirect()),
         auth_handler_factory_(
@@ -142,7 +144,9 @@ class QuicNetworkTransactionTest
         random_generator_(0),
         hanging_data_(nullptr, 0, nullptr, 0) {
     request_.method = "GET";
-    request_.url = GURL("http://www.google.com/");
+    std::string url("http://");
+    url.append(kDefaultServerHostName);
+    request_.url = GURL(url);
     request_.load_flags = 0;
     clock_->AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
   }
@@ -1205,6 +1209,7 @@ TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) {
 // the appropriate error code.  Note that this never happens in production,
 // because the handshake (which this test mocks) would fail in this scenario.
 TEST_P(QuicNetworkTransactionTest, SecureResourceOverInsecureQuic) {
+  maker_.set_hostname("www.example.org");
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
@@ -1217,7 +1222,7 @@ TEST_P(QuicNetworkTransactionTest, SecureResourceOverInsecureQuic) {
   mock_quic_data.AddRead(SYNCHRONOUS, 0);
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
-  request_.url = GURL("https://www.google.com:443");
+  request_.url = GURL("https://www.example.org:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
@@ -1230,6 +1235,7 @@ TEST_P(QuicNetworkTransactionTest, SecureResourceOverInsecureQuic) {
 }
 
 TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) {
+  maker_.set_hostname("www.example.org");
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
@@ -1245,11 +1251,14 @@ TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) {
   scoped_refptr<X509Certificate> cert(
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
   ASSERT_TRUE(cert.get());
+  bool common_name_fallback_used;
+  EXPECT_TRUE(
+      cert->VerifyNameMatch("www.example.org", &common_name_fallback_used));
   ProofVerifyDetailsChromium verify_details;
   verify_details.cert_verify_result.verified_cert = cert;
   crypto_client_stream_factory_.set_proof_verify_details(&verify_details);
 
-  request_.url = GURL("https://www.google.com:443");
+  request_.url = GURL("https://www.example.org:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);

net/quic/quic_stream_factory_test.cc

@@ -197,7 +197,7 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
       : random_generator_(0),
         clock_(new MockClock()),
         runner_(new TestTaskRunner(clock_)),
-        maker_(GetParam().version, 0, clock_),
+        maker_(GetParam().version, 0, clock_, kDefaultServerHostName),
         cert_verifier_(CertVerifier::CreateDefault()),
         channel_id_service_(
             new ChannelIDService(new DefaultChannelIDStore(nullptr),

net/quic/test_tools/quic_test_packet_maker.cc

@@ -18,10 +18,12 @@ namespace test {
 
 QuicTestPacketMaker::QuicTestPacketMaker(QuicVersion version,
                                          QuicConnectionId connection_id,
-                                         MockClock* clock)
+                                         MockClock* clock,
+                                         const std::string& host)
     : version_(version),
       connection_id_(connection_id),
       clock_(clock),
+      host_(host),
       spdy_request_framer_(SPDY4),
       spdy_response_framer_(SPDY4) {
 }
@@ -29,6 +31,10 @@ QuicTestPacketMaker::QuicTestPacketMaker(QuicVersion version,
 QuicTestPacketMaker::~QuicTestPacketMaker() {
 }
 
+void QuicTestPacketMaker::set_hostname(const std::string& host) {
+  host_.assign(host);
+}
+
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRstPacket(
     QuicPacketSequenceNumber num,
     bool include_version,
@@ -226,9 +232,9 @@ SpdyHeaderBlock QuicTestPacketMaker::GetRequestHeaders(
   SpdyHeaderBlock headers;
   headers[":method"] = method;
   if (version_ <= QUIC_VERSION_24) {
-    headers[":host"] = "www.google.com";
+    headers[":host"] = host_;
   } else {
-    headers[":authority"] = "www.google.com";
+    headers[":authority"] = host_;
   }
   headers[":path"] = path;
   headers[":scheme"] = scheme;

net/quic/test_tools/quic_test_packet_maker.h

@@ -22,9 +22,11 @@ class QuicTestPacketMaker {
  public:
   QuicTestPacketMaker(QuicVersion version,
                       QuicConnectionId connection_id,
-                      MockClock* clock);
+                      MockClock* clock,
+                      const std::string& host);
   ~QuicTestPacketMaker();
 
+  void set_hostname(const std::string& host);
   scoped_ptr<QuicEncryptedPacket> MakeRstPacket(
       QuicPacketSequenceNumber num,
       bool include_version,
@@ -82,6 +84,7 @@ class QuicTestPacketMaker {
   QuicVersion version_;
   QuicConnectionId connection_id_;
   MockClock* clock_;  // Owned by QuicStreamFactory.
+  std::string host_;
   SpdyFramer spdy_request_framer_;
   SpdyFramer spdy_response_framer_;
   MockRandom random_generator_;