net/quic/quic_network_transaction_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/basictypes.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/stl_util.h"
  11 #include "net/base/test_completion_callback.h"
  12 #include "net/base/test_data_directory.h"
  13 #include "net/cert/mock_cert_verifier.h"
  14 #include "net/dns/mock_host_resolver.h"
  15 #include "net/http/http_auth_handler_factory.h"
  16 #include "net/http/http_network_session.h"
  17 #include "net/http/http_network_transaction.h"
  18 #include "net/http/http_server_properties_impl.h"
  19 #include "net/http/http_stream.h"
  20 #include "net/http/http_stream_factory.h"
  21 #include "net/http/http_transaction_test_util.h"
  22 #include "net/http/transport_security_state.h"
  23 #include "net/log/test_net_log.h"
  24 #include "net/log/test_net_log_entry.h"
  25 #include "net/log/test_net_log_util.h"
  26 #include "net/proxy/proxy_config_service_fixed.h"
  27 #include "net/proxy/proxy_resolver.h"
  28 #include "net/proxy/proxy_service.h"
  29 #include "net/quic/crypto/proof_verifier_chromium.h"
  30 #include "net/quic/crypto/quic_decrypter.h"
  31 #include "net/quic/crypto/quic_encrypter.h"
  32 #include "net/quic/quic_framer.h"
  33 #include "net/quic/quic_http_utils.h"
  34 #include "net/quic/test_tools/crypto_test_utils.h"
  35 #include "net/quic/test_tools/mock_clock.h"
  36 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
  37 #include "net/quic/test_tools/mock_random.h"
  38 #include "net/quic/test_tools/quic_test_packet_maker.h"
  39 #include "net/quic/test_tools/quic_test_utils.h"
  40 #include "net/socket/client_socket_factory.h"
  41 #include "net/socket/mock_client_socket_pool_manager.h"
  42 #include "net/socket/socket_test_util.h"
  43 #include "net/socket/ssl_client_socket.h"
  44 #include "net/spdy/spdy_frame_builder.h"
  45 #include "net/spdy/spdy_framer.h"
  46 #include "net/ssl/ssl_config_service_defaults.h"
  47 #include "net/test/cert_test_util.h"
  48 #include "testing/gtest/include/gtest/gtest.h"
  49 #include "testing/platform_test.h"
  50
  51 namespace net {
  52 namespace test {
  53
  54 namespace {
  55
  56 // This is the expected return from a current server advertising QUIC.
  57 static const char kQuicAlternateProtocolHttpHeader[] =
  58     "Alternate-Protocol: 80:quic\r\n\r\n";
  59 static const char kQuicAlternateProtocol50pctHttpHeader[] =
  60     "Alternate-Protocol: 80:quic,p=.5\r\n\r\n";
  61 static const char kQuicAlternateProtocolDifferentPortHttpHeader[] =
  62     "Alternate-Protocol: 137:quic\r\n\r\n";
  63 static const char kQuicAlternateProtocolHttpsHeader[] =
  64     "Alternate-Protocol: 443:quic\r\n\r\n";
  65
  66 const char kDefaultServerHostName[] = "www.google.com";
  67
  68 }  // namespace
  69
  70 // Helper class to encapsulate MockReads and MockWrites for QUIC.
  71 // Simplify ownership issues and the interaction with the MockSocketFactory.
  72 class MockQuicData {
  73  public:
  74   MockQuicData() : sequence_number_(0) {}
  75
  76   ~MockQuicData() {
  77     STLDeleteElements(&packets_);
  78   }
  79
  80   void AddSynchronousRead(scoped_ptr<QuicEncryptedPacket> packet) {
  81     reads_.push_back(MockRead(SYNCHRONOUS, packet->data(), packet->length(),
  82                               sequence_number_++));
  83     packets_.push_back(packet.release());
  84   }
  85
  86   void AddRead(scoped_ptr<QuicEncryptedPacket> packet) {
  87     reads_.push_back(
  88         MockRead(ASYNC, packet->data(), packet->length(), sequence_number_++));
  89     packets_.push_back(packet.release());
  90   }
  91
  92   void AddRead(IoMode mode, int rv) {
  93     reads_.push_back(MockRead(mode, rv, sequence_number_++));
  94   }
  95
  96   void AddWrite(scoped_ptr<QuicEncryptedPacket> packet) {
  97     writes_.push_back(MockWrite(SYNCHRONOUS, packet->data(), packet->length(),
  98                                 sequence_number_++));
  99     packets_.push_back(packet.release());
 100   }
 101
 102   void AddSocketDataToFactory(MockClientSocketFactory* factory) {
 103     MockRead* reads = reads_.empty() ? nullptr  : &reads_[0];
 104     MockWrite* writes = writes_.empty() ? nullptr  : &writes_[0];
 105     socket_data_.reset(
 106         new SequencedSocketData(reads, reads_.size(), writes, writes_.size()));
 107     factory->AddSocketDataProvider(socket_data_.get());
 108   }
 109
 110  private:
 111   std::vector<QuicEncryptedPacket*> packets_;
 112   std::vector<MockWrite> writes_;
 113   std::vector<MockRead> reads_;
 114   size_t sequence_number_;
 115   scoped_ptr<SocketDataProvider> socket_data_;
 116 };
 117
 118 class ProxyHeadersHandler {
 119  public:
 120   ProxyHeadersHandler() : was_called_(false) {}
 121
 122   bool was_called() { return was_called_; }
 123
 124   void OnBeforeProxyHeadersSent(const ProxyInfo& proxy_info,
 125                                 HttpRequestHeaders* request_headers) {
 126     was_called_ = true;
 127   }
 128
 129  private:
 130   bool was_called_;
 131 };
 132
 133 class QuicNetworkTransactionTest
 134     : public PlatformTest,
 135       public ::testing::WithParamInterface<QuicVersion> {
 136  protected:
 137   QuicNetworkTransactionTest()
 138       : clock_(new MockClock),
 139         maker_(GetParam(), 0, clock_, kDefaultServerHostName),
 140         ssl_config_service_(new SSLConfigServiceDefaults),
 141         proxy_service_(ProxyService::CreateDirect()),
 142         auth_handler_factory_(
 143             HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
 144         random_generator_(0),
 145         hanging_data_(nullptr, 0, nullptr, 0) {
 146     request_.method = "GET";
 147     std::string url("http://");
 148     url.append(kDefaultServerHostName);
 149     request_.url = GURL(url);
 150     request_.load_flags = 0;
 151     clock_->AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
 152   }
 153
 154   void SetUp() override {
 155     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
 156     base::MessageLoop::current()->RunUntilIdle();
 157   }
 158
 159   void TearDown() override {
 160     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
 161     // Empty the current queue.
 162     base::MessageLoop::current()->RunUntilIdle();
 163     PlatformTest::TearDown();
 164     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
 165     base::MessageLoop::current()->RunUntilIdle();
 166   }
 167
 168   scoped_ptr<QuicEncryptedPacket> ConstructConnectionClosePacket(
 169       QuicPacketSequenceNumber num) {
 170     return maker_.MakeConnectionClosePacket(num);
 171   }
 172
 173   scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
 174       QuicPacketSequenceNumber largest_received,
 175       QuicPacketSequenceNumber least_unacked) {
 176     return maker_.MakeAckPacket(2, largest_received, least_unacked, true);
 177   }
 178
 179   SpdyHeaderBlock GetRequestHeaders(const std::string& method,
 180                                     const std::string& scheme,
 181                                     const std::string& path) {
 182     return maker_.GetRequestHeaders(method, scheme, path);
 183   }
 184
 185   SpdyHeaderBlock GetResponseHeaders(const std::string& status) {
 186     return maker_.GetResponseHeaders(status);
 187   }
 188
 189   scoped_ptr<QuicEncryptedPacket> ConstructDataPacket(
 190       QuicPacketSequenceNumber sequence_number,
 191       QuicStreamId stream_id,
 192       bool should_include_version,
 193       bool fin,
 194       QuicStreamOffset offset,
 195       base::StringPiece data) {
 196     return maker_.MakeDataPacket(
 197         sequence_number, stream_id, should_include_version, fin, offset, data);
 198   }
 199
 200   scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
 201       QuicPacketSequenceNumber sequence_number,
 202       QuicStreamId stream_id,
 203       bool should_include_version,
 204       bool fin,
 205       const SpdyHeaderBlock& headers) {
 206     QuicPriority priority =
 207         ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 208     return maker_.MakeRequestHeadersPacket(sequence_number, stream_id,
 209                                            should_include_version, fin,
 210                                            priority, headers);
 211   }
 212
 213   scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
 214       QuicPacketSequenceNumber sequence_number,
 215       QuicStreamId stream_id,
 216       bool should_include_version,
 217       bool fin,
 218       const SpdyHeaderBlock& headers) {
 219     return maker_.MakeResponseHeadersPacket(
 220         sequence_number, stream_id, should_include_version, fin, headers);
 221   }
 222
 223   void CreateSession() {
 224     CreateSessionWithFactory(&socket_factory_, false);
 225   }
 226
 227   void CreateSessionWithNextProtos() {
 228     CreateSessionWithFactory(&socket_factory_, true);
 229   }
 230
 231   // If |use_next_protos| is true, enables SPDY and QUIC.
 232   void CreateSessionWithFactory(ClientSocketFactory* socket_factory,
 233                                 bool use_next_protos) {
 234     params_.enable_quic = true;
 235     params_.quic_clock = clock_;
 236     params_.quic_random = &random_generator_;
 237     params_.client_socket_factory = socket_factory;
 238     params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
 239     params_.host_resolver = &host_resolver_;
 240     params_.cert_verifier = &cert_verifier_;
 241     params_.transport_security_state = &transport_security_state_;
 242     params_.proxy_service = proxy_service_.get();
 243     params_.ssl_config_service = ssl_config_service_.get();
 244     params_.http_auth_handler_factory = auth_handler_factory_.get();
 245     params_.http_server_properties = http_server_properties_.GetWeakPtr();
 246     params_.quic_supported_versions = SupportedVersions(GetParam());
 247
 248     if (use_next_protos) {
 249       params_.use_alternate_protocols = true;
 250       params_.next_protos = NextProtosWithSpdyAndQuic(true, true);
 251     }
 252
 253     session_ = new HttpNetworkSession(params_);
 254     session_->quic_stream_factory()->set_require_confirmation(false);
 255   }
 256
 257   void CheckWasQuicResponse(const scoped_ptr<HttpNetworkTransaction>& trans) {
 258     const HttpResponseInfo* response = trans->GetResponseInfo();
 259     ASSERT_TRUE(response != nullptr);
 260     ASSERT_TRUE(response->headers.get() != nullptr);
 261     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 262     EXPECT_TRUE(response->was_fetched_via_spdy);
 263     EXPECT_TRUE(response->was_npn_negotiated);
 264     EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3,
 265               response->connection_info);
 266   }
 267
 268   void CheckResponsePort(const scoped_ptr<HttpNetworkTransaction>& trans,
 269                          uint16 port) {
 270     const HttpResponseInfo* response = trans->GetResponseInfo();
 271     ASSERT_TRUE(response != nullptr);
 272     EXPECT_EQ(port, response->socket_address.port());
 273   }
 274
 275   void CheckWasHttpResponse(const scoped_ptr<HttpNetworkTransaction>& trans) {
 276     const HttpResponseInfo* response = trans->GetResponseInfo();
 277     ASSERT_TRUE(response != nullptr);
 278     ASSERT_TRUE(response->headers.get() != nullptr);
 279     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 280     EXPECT_FALSE(response->was_fetched_via_spdy);
 281     EXPECT_FALSE(response->was_npn_negotiated);
 282     EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1,
 283               response->connection_info);
 284   }
 285
 286   void CheckResponseData(const scoped_ptr<HttpNetworkTransaction>& trans,
 287                          const std::string& expected) {
 288     std::string response_data;
 289     ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
 290     EXPECT_EQ(expected, response_data);
 291   }
 292
 293   void RunTransaction(const scoped_ptr<HttpNetworkTransaction>& trans) {
 294     TestCompletionCallback callback;
 295     int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
 296     EXPECT_EQ(ERR_IO_PENDING, rv);
 297     EXPECT_EQ(OK, callback.WaitForResult());
 298   }
 299
 300   void SendRequestAndExpectHttpResponse(const std::string& expected) {
 301     scoped_ptr<HttpNetworkTransaction> trans(
 302         new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 303     RunTransaction(trans);
 304     CheckWasHttpResponse(trans);
 305     CheckResponseData(trans, expected);
 306   }
 307
 308   void SendRequestAndExpectQuicResponse(const std::string& expected) {
 309     SendRequestAndExpectQuicResponseMaybeFromProxy(expected, false, 80);
 310   }
 311
 312   void SendRequestAndExpectQuicResponseOnPort(const std::string& expected,
 313                                               uint16 port) {
 314     SendRequestAndExpectQuicResponseMaybeFromProxy(expected, false, port);
 315   }
 316
 317   void SendRequestAndExpectQuicResponseFromProxyOnPort(
 318       const std::string& expected,
 319       uint16 port) {
 320     SendRequestAndExpectQuicResponseMaybeFromProxy(expected, true, port);
 321   }
 322
 323   void AddQuicAlternateProtocolMapping(
 324       MockCryptoClientStream::HandshakeMode handshake_mode) {
 325     crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
 326     HostPortPair host_port_pair = HostPortPair::FromURL(request_.url);
 327     AlternativeService alternative_service(QUIC, host_port_pair.host(), 80);
 328     http_server_properties_.SetAlternativeService(host_port_pair,
 329                                                   alternative_service, 1.0);
 330   }
 331
 332   void ExpectBrokenAlternateProtocolMapping() {
 333     const HostPortPair origin = HostPortPair::FromURL(request_.url);
 334     const AlternativeService alternative_service =
 335         http_server_properties_.GetAlternativeService(origin);
 336     EXPECT_NE(UNINITIALIZED_ALTERNATE_PROTOCOL, alternative_service.protocol);
 337     EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken(
 338         alternative_service));
 339   }
 340
 341   void ExpectQuicAlternateProtocolMapping() {
 342     const AlternativeService alternative_service =
 343         http_server_properties_.GetAlternativeService(
 344             HostPortPair::FromURL(request_.url));
 345     EXPECT_EQ(QUIC, alternative_service.protocol);
 346   }
 347
 348   void AddHangingNonAlternateProtocolSocketData() {
 349     MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
 350     hanging_data_.set_connect_data(hanging_connect);
 351     socket_factory_.AddSocketDataProvider(&hanging_data_);
 352   }
 353
 354   MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
 355   QuicTestPacketMaker maker_;
 356   scoped_refptr<HttpNetworkSession> session_;
 357   MockClientSocketFactory socket_factory_;
 358   MockCryptoClientStreamFactory crypto_client_stream_factory_;
 359   MockHostResolver host_resolver_;
 360   MockCertVerifier cert_verifier_;
 361   TransportSecurityState transport_security_state_;
 362   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
 363   scoped_ptr<ProxyService> proxy_service_;
 364   scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
 365   MockRandom random_generator_;
 366   HttpServerPropertiesImpl http_server_properties_;
 367   HttpNetworkSession::Params params_;
 368   HttpRequestInfo request_;
 369   BoundTestNetLog net_log_;
 370   StaticSocketDataProvider hanging_data_;
 371
 372  private:
 373   void SendRequestAndExpectQuicResponseMaybeFromProxy(
 374       const std::string& expected,
 375       bool used_proxy,
 376       uint16 port) {
 377     scoped_ptr<HttpNetworkTransaction> trans(
 378         new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 379     ProxyHeadersHandler proxy_headers_handler;
 380     trans->SetBeforeProxyHeadersSentCallback(
 381         base::Bind(&ProxyHeadersHandler::OnBeforeProxyHeadersSent,
 382                    base::Unretained(&proxy_headers_handler)));
 383     RunTransaction(trans);
 384     CheckWasQuicResponse(trans);
 385     CheckResponsePort(trans, port);
 386     CheckResponseData(trans, expected);
 387     EXPECT_EQ(used_proxy, proxy_headers_handler.was_called());
 388   }
 389 };
 390
 391 INSTANTIATE_TEST_CASE_P(Version, QuicNetworkTransactionTest,
 392                         ::testing::ValuesIn(QuicSupportedVersions()));
 393
 394 TEST_P(QuicNetworkTransactionTest, ForceQuic) {
 395   params_.origin_to_force_quic_on =
 396       HostPortPair::FromString("www.google.com:80");
 397
 398   MockQuicData mock_quic_data;
 399   mock_quic_data.AddWrite(
 400       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 401                                     GetRequestHeaders("GET", "http", "/")));
 402   mock_quic_data.AddRead(
 403       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
 404                                      GetResponseHeaders("200 OK")));
 405   mock_quic_data.AddRead(
 406       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 407   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 408   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 409
 410   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 411
 412   // The non-alternate protocol job needs to hang in order to guarantee that
 413   // the alternate-protocol job will "win".
 414   AddHangingNonAlternateProtocolSocketData();
 415
 416   CreateSession();
 417
 418   SendRequestAndExpectQuicResponse("hello!");
 419
 420   // Check that the NetLog was filled reasonably.
 421   TestNetLogEntry::List entries;
 422   net_log_.GetEntries(&entries);
 423   EXPECT_LT(0u, entries.size());
 424
 425   // Check that we logged a QUIC_SESSION_PACKET_RECEIVED.
 426   int pos = ExpectLogContainsSomewhere(
 427       entries, 0, NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
 428       NetLog::PHASE_NONE);
 429   EXPECT_LT(0, pos);
 430
 431   // ... and also a TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED.
 432   pos = ExpectLogContainsSomewhere(
 433       entries, 0, NetLog::TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED,
 434       NetLog::PHASE_NONE);
 435   EXPECT_LT(0, pos);
 436
 437   std::string packet_sequence_number;
 438   ASSERT_TRUE(entries[pos].GetStringValue(
 439       "packet_sequence_number", &packet_sequence_number));
 440   EXPECT_EQ("1", packet_sequence_number);
 441
 442   // ... and also a QUIC_SESSION_STREAM_FRAME_RECEIVED.
 443   pos = ExpectLogContainsSomewhere(
 444       entries, 0, NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
 445       NetLog::PHASE_NONE);
 446   EXPECT_LT(0, pos);
 447
 448   int log_stream_id;
 449   ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &log_stream_id));
 450   EXPECT_EQ(3, log_stream_id);
 451 }
 452
 453 TEST_P(QuicNetworkTransactionTest, QuicProxy) {
 454   params_.enable_quic_for_proxies = true;
 455   proxy_service_.reset(
 456       ProxyService::CreateFixedFromPacResult("QUIC myproxy:70"));
 457
 458   MockQuicData mock_quic_data;
 459   mock_quic_data.AddWrite(
 460       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 461                                     GetRequestHeaders("GET", "http", "/")));
 462   mock_quic_data.AddRead(
 463       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
 464                                      GetResponseHeaders("200 OK")));
 465   mock_quic_data.AddRead(
 466       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 467   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 468   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 469
 470   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 471
 472   // There is no need to set up an alternate protocol job, because
 473   // no attempt will be made to speak to the proxy over TCP.
 474
 475   CreateSession();
 476
 477   SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70);
 478 }
 479
 480 TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) {
 481   params_.origin_to_force_quic_on =
 482       HostPortPair::FromString("www.google.com:80");
 483
 484   MockQuicData mock_quic_data;
 485   mock_quic_data.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
 486
 487   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 488
 489   CreateSession();
 490
 491   scoped_ptr<HttpNetworkTransaction> trans(
 492       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 493   TestCompletionCallback callback;
 494   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
 495   EXPECT_EQ(ERR_IO_PENDING, rv);
 496   EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
 497 }
 498
 499 TEST_P(QuicNetworkTransactionTest, DoNotForceQuicForHttps) {
 500   // Attempt to "force" quic on 443, which will not be honored.
 501   params_.origin_to_force_quic_on =
 502       HostPortPair::FromString("www.google.com:443");
 503
 504   MockRead http_reads[] = {
 505     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
 506     MockRead("hello world"),
 507     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
 508     MockRead(ASYNC, OK)
 509   };
 510
 511   StaticSocketDataProvider data(http_reads, arraysize(http_reads), nullptr, 0);
 512   socket_factory_.AddSocketDataProvider(&data);
 513   SSLSocketDataProvider ssl(ASYNC, OK);
 514   socket_factory_.AddSSLSocketDataProvider(&ssl);
 515
 516   CreateSession();
 517
 518   SendRequestAndExpectHttpResponse("hello world");
 519 }
 520
 521 TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolForQuic) {
 522   MockRead http_reads[] = {
 523     MockRead("HTTP/1.1 200 OK\r\n"),
 524     MockRead(kQuicAlternateProtocolHttpHeader),
 525     MockRead("hello world"),
 526     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
 527     MockRead(ASYNC, OK)
 528   };
 529
 530   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
 531                                      nullptr, 0);
 532   socket_factory_.AddSocketDataProvider(&http_data);
 533
 534   MockQuicData mock_quic_data;
 535   mock_quic_data.AddWrite(
 536       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 537                                     GetRequestHeaders("GET", "http", "/")));
 538   mock_quic_data.AddRead(
 539       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
 540                                      GetResponseHeaders("200 OK")));
 541   mock_quic_data.AddRead(
 542       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 543   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 544   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 545
 546   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 547
 548   // The non-alternate protocol job needs to hang in order to guarantee that
 549   // the alternate-protocol job will "win".
 550   AddHangingNonAlternateProtocolSocketData();
 551
 552   CreateSessionWithNextProtos();
 553
 554   SendRequestAndExpectHttpResponse("hello world");
 555   SendRequestAndExpectQuicResponse("hello!");
 556 }
 557
 558 TEST_P(QuicNetworkTransactionTest, AlternateProtocolDifferentPort) {
 559   MockRead http_reads[] = {
 560       MockRead("HTTP/1.1 200 OK\r\n"),
 561       MockRead(kQuicAlternateProtocolDifferentPortHttpHeader),
 562       MockRead("hello world"),
 563       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
 564       MockRead(ASYNC, OK)};
 565
 566   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
 567                                      0);
 568   socket_factory_.AddSocketDataProvider(&http_data);
 569
 570   MockQuicData mock_quic_data;
 571   mock_quic_data.AddWrite(
 572       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 573                                     GetRequestHeaders("GET", "http", "/")));
 574   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
 575       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
 576   mock_quic_data.AddRead(
 577       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 578   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 579   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 580
 581   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 582
 583   // The non-alternate protocol job needs to hang in order to guarantee that
 584   // the alternate-protocol job will "win".
 585   AddHangingNonAlternateProtocolSocketData();
 586
 587   CreateSessionWithNextProtos();
 588
 589   SendRequestAndExpectHttpResponse("hello world");
 590   SendRequestAndExpectQuicResponseOnPort("hello!", 137);
 591 }
 592
 593 TEST_P(QuicNetworkTransactionTest, ConfirmAlternativeService) {
 594   MockRead http_reads[] = {
 595       MockRead("HTTP/1.1 200 OK\r\n"),
 596       MockRead(kQuicAlternateProtocolHttpHeader),
 597       MockRead("hello world"),
 598       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
 599       MockRead(ASYNC, OK)};
 600
 601   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
 602                                      0);
 603   socket_factory_.AddSocketDataProvider(&http_data);
 604
 605   MockQuicData mock_quic_data;
 606   mock_quic_data.AddWrite(
 607       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 608                                     GetRequestHeaders("GET", "http", "/")));
 609   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
 610       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
 611   mock_quic_data.AddRead(
 612       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 613   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 614   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 615
 616   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 617
 618   // The non-alternate protocol job needs to hang in order to guarantee that
 619   // the alternate-protocol job will "win".
 620   AddHangingNonAlternateProtocolSocketData();
 621
 622   CreateSessionWithNextProtos();
 623
 624   AlternativeService alternative_service(QUIC,
 625                                          HostPortPair::FromURL(request_.url));
 626   http_server_properties_.MarkAlternativeServiceRecentlyBroken(
 627       alternative_service);
 628   EXPECT_TRUE(http_server_properties_.WasAlternativeServiceRecentlyBroken(
 629       alternative_service));
 630
 631   SendRequestAndExpectHttpResponse("hello world");
 632   SendRequestAndExpectQuicResponse("hello!");
 633
 634   EXPECT_FALSE(http_server_properties_.WasAlternativeServiceRecentlyBroken(
 635       alternative_service));
 636 }
 637
 638 TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolProbabilityForQuic) {
 639   MockRead http_reads[] = {
 640     MockRead("HTTP/1.1 200 OK\r\n"),
 641     MockRead(kQuicAlternateProtocol50pctHttpHeader),
 642     MockRead("hello world"),
 643     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
 644     MockRead(ASYNC, OK)
 645   };
 646
 647   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
 648                                      nullptr, 0);
 649   socket_factory_.AddSocketDataProvider(&http_data);
 650
 651   MockQuicData mock_quic_data;
 652   mock_quic_data.AddWrite(
 653       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 654                                     GetRequestHeaders("GET", "http", "/")));
 655   mock_quic_data.AddRead(
 656       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
 657                                      GetResponseHeaders("200 OK")));
 658   mock_quic_data.AddRead(
 659       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 660   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 661   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 662
 663   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 664
 665   // The non-alternate protocol job needs to hang in order to guarantee that
 666   // the alternate-protocol job will "win".
 667   AddHangingNonAlternateProtocolSocketData();
 668
 669   params_.alternative_service_probability_threshold = .25;
 670   CreateSessionWithNextProtos();
 671
 672   SendRequestAndExpectHttpResponse("hello world");
 673   SendRequestAndExpectQuicResponse("hello!");
 674 }
 675
 676 TEST_P(QuicNetworkTransactionTest, DontUseAlternateProtocolProbabilityForQuic) {
 677   MockRead http_reads[] = {
 678     MockRead("HTTP/1.1 200 OK\r\n"),
 679     MockRead(kQuicAlternateProtocol50pctHttpHeader),
 680     MockRead("hello world"),
 681     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
 682     MockRead(ASYNC, OK)
 683   };
 684
 685   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
 686                                      nullptr, 0);
 687   socket_factory_.AddSocketDataProvider(&http_data);
 688   socket_factory_.AddSocketDataProvider(&http_data);
 689
 690   params_.alternative_service_probability_threshold = .75;
 691   CreateSessionWithNextProtos();
 692
 693   SendRequestAndExpectHttpResponse("hello world");
 694   SendRequestAndExpectHttpResponse("hello world");
 695 }
 696
 697 TEST_P(QuicNetworkTransactionTest, DontUseAlternateProtocolForInsecureQuic) {
 698   MockRead http_reads[] = {MockRead("HTTP/1.1 200 OK\r\n"),
 699                            MockRead("Content-length: 11\r\n"),
 700                            MockRead("Alternate-Protocol: 443:quic\r\n\r\n"),
 701                            MockRead("hello world"),
 702                            MockRead("HTTP/1.1 200 OK\r\n"),
 703                            MockRead("Content-length: 11\r\n"),
 704                            MockRead("Alternate-Protocol: 443:quic\r\n\r\n"),
 705                            MockRead("hello world"),
 706                            MockRead(ASYNC, OK)};
 707
 708   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
 709                                      0);
 710   socket_factory_.AddSocketDataProvider(&http_data);
 711   socket_factory_.AddSocketDataProvider(&http_data);
 712
 713   params_.disable_insecure_quic = true;
 714   CreateSessionWithNextProtos();
 715
 716   SendRequestAndExpectHttpResponse("hello world");
 717   SendRequestAndExpectHttpResponse("hello world");
 718 }
 719
 720 TEST_P(QuicNetworkTransactionTest,
 721        DontUseAlternateProtocolWithBadProbabilityForQuic) {
 722   MockRead http_reads[] = {
 723     MockRead("HTTP/1.1 200 OK\r\n"),
 724     MockRead("Alternate-Protocol: 443:quic,p=2\r\n\r\n"),
 725     MockRead("hello world"),
 726     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
 727     MockRead(ASYNC, OK)
 728   };
 729
 730   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
 731                                      nullptr, 0);
 732   socket_factory_.AddSocketDataProvider(&http_data);
 733   socket_factory_.AddSocketDataProvider(&http_data);
 734
 735   params_.alternative_service_probability_threshold = .75;
 736   CreateSessionWithNextProtos();
 737
 738   SendRequestAndExpectHttpResponse("hello world");
 739   SendRequestAndExpectHttpResponse("hello world");
 740 }
 741
 742 TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolForQuicForHttps) {
 743   params_.origin_to_force_quic_on =
 744       HostPortPair::FromString("www.google.com:443");
 745
 746   MockRead http_reads[] = {
 747     MockRead("HTTP/1.1 200 OK\r\n"),
 748     MockRead(kQuicAlternateProtocolHttpsHeader),
 749     MockRead("hello world"),
 750     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
 751     MockRead(ASYNC, OK)
 752   };
 753
 754   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
 755                                      nullptr, 0);
 756   socket_factory_.AddSocketDataProvider(&http_data);
 757
 758   MockQuicData mock_quic_data;
 759   mock_quic_data.AddWrite(
 760       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 761                                     GetRequestHeaders("GET", "http", "/")));
 762   mock_quic_data.AddRead(
 763       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
 764                                      GetResponseHeaders("200 OK")));
 765   mock_quic_data.AddRead(
 766       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 767   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 768   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 769
 770   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 771
 772   // The non-alternate protocol job needs to hang in order to guarantee that
 773   // the alternate-protocol job will "win".
 774   AddHangingNonAlternateProtocolSocketData();
 775
 776   CreateSessionWithNextProtos();
 777
 778   // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo().
 779   SendRequestAndExpectHttpResponse("hello world");
 780 }
 781
 782 class QuicAltSvcCertificateVerificationTest
 783     : public QuicNetworkTransactionTest {
 784  public:
 785   void Run(bool valid) {
 786     HostPortPair origin(valid ? "mail.example.org" : "invalid.example.org",
 787                         443);
 788     HostPortPair alternative("www.example.org", 443);
 789     std::string url("https://");
 790     url.append(origin.host());
 791     url.append(":443");
 792     request_.url = GURL(url);
 793
 794     maker_.set_hostname(origin.host());
 795     MockQuicData mock_quic_data;
 796     mock_quic_data.AddWrite(
 797         ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 798                                       GetRequestHeaders("GET", "https", "/")));
 799     mock_quic_data.AddRead(ConstructResponseHeadersPacket(
 800         1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
 801     mock_quic_data.AddRead(
 802         ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 803     mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 804     mock_quic_data.AddRead(SYNCHRONOUS, 0);
 805     mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 806
 807     scoped_refptr<X509Certificate> cert(
 808         ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
 809     ASSERT_TRUE(cert.get());
 810     bool common_name_fallback_used;
 811     EXPECT_EQ(valid,
 812               cert->VerifyNameMatch(origin.host(), &common_name_fallback_used));
 813     EXPECT_TRUE(
 814         cert->VerifyNameMatch(alternative.host(), &common_name_fallback_used));
 815     ProofVerifyDetailsChromium verify_details;
 816     verify_details.cert_verify_result.verified_cert = cert;
 817     verify_details.cert_verify_result.is_issued_by_known_root = true;
 818     crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 819     crypto_client_stream_factory_.set_handshake_mode(
 820         MockCryptoClientStream::CONFIRM_HANDSHAKE);
 821
 822     // Connection to |origin| fails, so that success of |request| depends on
 823     // connection to |alternate| only.
 824     MockConnect refused_connect(ASYNC, ERR_CONNECTION_REFUSED);
 825     StaticSocketDataProvider refused_data;
 826     refused_data.set_connect_data(refused_connect);
 827     socket_factory_.AddSocketDataProvider(&refused_data);
 828
 829     CreateSessionWithNextProtos();
 830     AlternativeService alternative_service(QUIC, alternative);
 831     session_->http_server_properties()->SetAlternativeService(
 832         origin, alternative_service, 1.0);
 833     scoped_ptr<HttpNetworkTransaction> trans(
 834         new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 835     TestCompletionCallback callback;
 836     int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
 837     EXPECT_EQ(ERR_IO_PENDING, rv);
 838     rv = callback.WaitForResult();
 839     if (valid) {
 840       EXPECT_EQ(OK, rv);
 841       CheckWasQuicResponse(trans);
 842       CheckResponsePort(trans, 443);
 843       CheckResponseData(trans, "hello!");
 844     } else {
 845       EXPECT_EQ(ERR_CONNECTION_REFUSED, rv);
 846     }
 847   }
 848 };
 849
 850 INSTANTIATE_TEST_CASE_P(Version,
 851                         QuicAltSvcCertificateVerificationTest,
 852                         ::testing::ValuesIn(QuicSupportedVersions()));
 853
 854 TEST_P(QuicAltSvcCertificateVerificationTest,
 855        RequestSucceedsWithValidCertificate) {
 856   Run(true);
 857 }
 858
 859 TEST_P(QuicAltSvcCertificateVerificationTest,
 860        RequestFailsWithInvalidCertificate) {
 861   Run(false);
 862 }
 863
 864 TEST_P(QuicNetworkTransactionTest, HungAlternateProtocol) {
 865   crypto_client_stream_factory_.set_handshake_mode(
 866       MockCryptoClientStream::COLD_START);
 867
 868   MockWrite http_writes[] = {
 869     MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
 870     MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"),
 871     MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")
 872   };
 873
 874   MockRead http_reads[] = {
 875     MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
 876     MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHttpHeader),
 877     MockRead(SYNCHRONOUS, 5, "hello world"),
 878     MockRead(SYNCHRONOUS, OK, 6)
 879   };
 880
 881   DeterministicMockClientSocketFactory socket_factory;
 882
 883   DeterministicSocketData http_data(http_reads, arraysize(http_reads),
 884                                     http_writes, arraysize(http_writes));
 885   socket_factory.AddSocketDataProvider(&http_data);
 886
 887   // The QUIC transaction will not be allowed to complete.
 888   MockWrite quic_writes[] = {
 889     MockWrite(ASYNC, ERR_IO_PENDING, 0)
 890   };
 891   MockRead quic_reads[] = {
 892     MockRead(ASYNC, ERR_IO_PENDING, 1),
 893   };
 894   DeterministicSocketData quic_data(quic_reads, arraysize(quic_reads),
 895                                     quic_writes, arraysize(quic_writes));
 896   socket_factory.AddSocketDataProvider(&quic_data);
 897
 898   // The HTTP transaction will complete.
 899   DeterministicSocketData http_data2(http_reads, arraysize(http_reads),
 900                                      http_writes, arraysize(http_writes));
 901   socket_factory.AddSocketDataProvider(&http_data2);
 902
 903   CreateSessionWithFactory(&socket_factory, true);
 904
 905   // Run the first request.
 906   http_data.StopAfter(arraysize(http_reads) + arraysize(http_writes));
 907   SendRequestAndExpectHttpResponse("hello world");
 908   ASSERT_TRUE(http_data.AllReadDataConsumed());
 909   ASSERT_TRUE(http_data.AllWriteDataConsumed());
 910
 911   // Now run the second request in which the QUIC socket hangs,
 912   // and verify the the transaction continues over HTTP.
 913   http_data2.StopAfter(arraysize(http_reads) + arraysize(http_writes));
 914   SendRequestAndExpectHttpResponse("hello world");
 915
 916   ASSERT_TRUE(http_data2.AllReadDataConsumed());
 917   ASSERT_TRUE(http_data2.AllWriteDataConsumed());
 918   ASSERT_TRUE(!quic_data.AllReadDataConsumed());
 919   ASSERT_TRUE(!quic_data.AllWriteDataConsumed());
 920 }
 921
 922 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) {
 923   MockQuicData mock_quic_data;
 924   mock_quic_data.AddWrite(
 925       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 926                                     GetRequestHeaders("GET", "http", "/")));
 927   mock_quic_data.AddRead(
 928       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
 929                                      GetResponseHeaders("200 OK")));
 930   mock_quic_data.AddRead(
 931       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 932   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 933   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 934
 935   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 936
 937   // The non-alternate protocol job needs to hang in order to guarantee that
 938   // the alternate-protocol job will "win".
 939   AddHangingNonAlternateProtocolSocketData();
 940
 941   CreateSessionWithNextProtos();
 942   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 943   SendRequestAndExpectQuicResponse("hello!");
 944 }
 945
 946 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) {
 947   MockQuicData mock_quic_data;
 948   mock_quic_data.AddWrite(
 949       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
 950                                     GetRequestHeaders("GET", "http", "/")));
 951   mock_quic_data.AddRead(
 952       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
 953                                      GetResponseHeaders("200 OK")));
 954   mock_quic_data.AddRead(
 955       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
 956   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
 957   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 958   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 959
 960   // In order for a new QUIC session to be established via alternate-protocol
 961   // without racing an HTTP connection, we need the host resolution to happen
 962   // synchronously.
 963   host_resolver_.set_synchronous_mode(true);
 964   host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", "");
 965   HostResolver::RequestInfo info(HostPortPair("www.google.com", 80));
 966   AddressList address;
 967   host_resolver_.Resolve(info,
 968                          DEFAULT_PRIORITY,
 969                          &address,
 970                          CompletionCallback(),
 971                          nullptr,
 972                          net_log_.bound());
 973
 974   CreateSessionWithNextProtos();
 975   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 976   SendRequestAndExpectQuicResponse("hello!");
 977 }
 978
 979 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) {
 980   proxy_service_.reset(
 981       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
 982
 983   // Since we are using a proxy, the QUIC job will not succeed.
 984   MockWrite http_writes[] = {
 985     MockWrite(SYNCHRONOUS, 0, "GET http://www.google.com/ HTTP/1.1\r\n"),
 986     MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"),
 987     MockWrite(SYNCHRONOUS, 2, "Proxy-Connection: keep-alive\r\n\r\n")
 988   };
 989
 990   MockRead http_reads[] = {
 991     MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
 992     MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHttpHeader),
 993     MockRead(SYNCHRONOUS, 5, "hello world"),
 994     MockRead(SYNCHRONOUS, OK, 6)
 995   };
 996
 997   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
 998                                      http_writes, arraysize(http_writes));
 999   socket_factory_.AddSocketDataProvider(&http_data);
1000
1001   // In order for a new QUIC session to be established via alternate-protocol
1002   // without racing an HTTP connection, we need the host resolution to happen
1003   // synchronously.
1004   host_resolver_.set_synchronous_mode(true);
1005   host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", "");
1006   HostResolver::RequestInfo info(HostPortPair("www.google.com", 80));
1007   AddressList address;
1008   host_resolver_.Resolve(info,
1009                          DEFAULT_PRIORITY,
1010                          &address,
1011                          CompletionCallback(),
1012                          nullptr,
1013                          net_log_.bound());
1014
1015   CreateSessionWithNextProtos();
1016   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1017   SendRequestAndExpectHttpResponse("hello world");
1018 }
1019
1020 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
1021   MockQuicData mock_quic_data;
1022   mock_quic_data.AddWrite(
1023       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
1024                                     GetRequestHeaders("GET", "http", "/")));
1025   mock_quic_data.AddRead(
1026       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
1027                                      GetResponseHeaders("200 OK")));
1028   mock_quic_data.AddRead(
1029       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
1030   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
1031   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
1032   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1033
1034   // The non-alternate protocol job needs to hang in order to guarantee that
1035   // the alternate-protocol job will "win".
1036   AddHangingNonAlternateProtocolSocketData();
1037
1038   // In order for a new QUIC session to be established via alternate-protocol
1039   // without racing an HTTP connection, we need the host resolution to happen
1040   // synchronously.  Of course, even though QUIC *could* perform a 0-RTT
1041   // connection to the the server, in this test we require confirmation
1042   // before encrypting so the HTTP job will still start.
1043   host_resolver_.set_synchronous_mode(true);
1044   host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", "");
1045   HostResolver::RequestInfo info(HostPortPair("www.google.com", 80));
1046   AddressList address;
1047   host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address,
1048                          CompletionCallback(), nullptr, net_log_.bound());
1049
1050   CreateSessionWithNextProtos();
1051   session_->quic_stream_factory()->set_require_confirmation(true);
1052   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1053
1054   scoped_ptr<HttpNetworkTransaction> trans(
1055       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1056   TestCompletionCallback callback;
1057   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
1058   EXPECT_EQ(ERR_IO_PENDING, rv);
1059
1060   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
1061       QuicSession::HANDSHAKE_CONFIRMED);
1062   EXPECT_EQ(OK, callback.WaitForResult());
1063 }
1064
1065 TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocol) {
1066   // Alternate-protocol job
1067   scoped_ptr<QuicEncryptedPacket> close(ConstructConnectionClosePacket(1));
1068   MockRead quic_reads[] = {
1069     MockRead(ASYNC, close->data(), close->length()),
1070     MockRead(ASYNC, OK),  // EOF
1071   };
1072   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
1073                                      nullptr, 0);
1074   socket_factory_.AddSocketDataProvider(&quic_data);
1075
1076   // Main job which will succeed even though the alternate job fails.
1077   MockRead http_reads[] = {
1078     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
1079     MockRead("hello from http"),
1080     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1081     MockRead(ASYNC, OK)
1082   };
1083
1084   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
1085                                      nullptr, 0);
1086   socket_factory_.AddSocketDataProvider(&http_data);
1087
1088   CreateSessionWithNextProtos();
1089   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
1090   SendRequestAndExpectHttpResponse("hello from http");
1091   ExpectBrokenAlternateProtocolMapping();
1092 }
1093
1094 TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolReadError) {
1095   // Alternate-protocol job
1096   MockRead quic_reads[] = {
1097     MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
1098   };
1099   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
1100                                      nullptr, 0);
1101   socket_factory_.AddSocketDataProvider(&quic_data);
1102
1103   // Main job which will succeed even though the alternate job fails.
1104   MockRead http_reads[] = {
1105     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
1106     MockRead("hello from http"),
1107     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1108     MockRead(ASYNC, OK)
1109   };
1110
1111   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
1112                                      nullptr, 0);
1113   socket_factory_.AddSocketDataProvider(&http_data);
1114
1115   CreateSessionWithNextProtos();
1116
1117   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
1118   SendRequestAndExpectHttpResponse("hello from http");
1119   ExpectBrokenAlternateProtocolMapping();
1120 }
1121
1122 TEST_P(QuicNetworkTransactionTest, NoBrokenAlternateProtocolIfTcpFails) {
1123   // Alternate-protocol job will fail when the session attempts to read.
1124   MockRead quic_reads[] = {
1125     MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
1126   };
1127   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
1128                                      nullptr, 0);
1129   socket_factory_.AddSocketDataProvider(&quic_data);
1130
1131   // Main job will also fail.
1132   MockRead http_reads[] = {
1133     MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
1134   };
1135
1136   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
1137                                      nullptr, 0);
1138   http_data.set_connect_data(MockConnect(ASYNC, ERR_SOCKET_NOT_CONNECTED));
1139   socket_factory_.AddSocketDataProvider(&http_data);
1140
1141   CreateSessionWithNextProtos();
1142
1143   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
1144   scoped_ptr<HttpNetworkTransaction> trans(
1145       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1146   TestCompletionCallback callback;
1147   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
1148   EXPECT_EQ(ERR_IO_PENDING, rv);
1149   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, callback.WaitForResult());
1150   ExpectQuicAlternateProtocolMapping();
1151 }
1152
1153 TEST_P(QuicNetworkTransactionTest, FailedZeroRttBrokenAlternateProtocol) {
1154   // Alternate-protocol job
1155   MockRead quic_reads[] = {
1156     MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
1157   };
1158   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
1159                                      nullptr, 0);
1160   socket_factory_.AddSocketDataProvider(&quic_data);
1161
1162   AddHangingNonAlternateProtocolSocketData();
1163
1164   // Second Alternate-protocol job which will race with the TCP job.
1165   StaticSocketDataProvider quic_data2(quic_reads, arraysize(quic_reads),
1166                                       nullptr, 0);
1167   socket_factory_.AddSocketDataProvider(&quic_data2);
1168
1169   // Final job that will proceed when the QUIC job fails.
1170   MockRead http_reads[] = {
1171     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
1172     MockRead("hello from http"),
1173     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1174     MockRead(ASYNC, OK)
1175   };
1176
1177   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
1178                                      nullptr, 0);
1179   socket_factory_.AddSocketDataProvider(&http_data);
1180
1181   CreateSessionWithNextProtos();
1182
1183   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1184
1185   SendRequestAndExpectHttpResponse("hello from http");
1186
1187   ExpectBrokenAlternateProtocolMapping();
1188
1189   EXPECT_TRUE(quic_data.AllReadDataConsumed());
1190   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
1191 }
1192
1193 TEST_P(QuicNetworkTransactionTest, DISABLED_HangingZeroRttFallback) {
1194   // Alternate-protocol job
1195   MockRead quic_reads[] = {
1196     MockRead(ASYNC, ERR_IO_PENDING),
1197   };
1198   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
1199                                      nullptr, 0);
1200   socket_factory_.AddSocketDataProvider(&quic_data);
1201
1202   // Main job that will proceed when the QUIC job fails.
1203   MockRead http_reads[] = {
1204     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
1205     MockRead("hello from http"),
1206     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1207     MockRead(ASYNC, OK)
1208   };
1209
1210   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
1211                                      nullptr, 0);
1212   socket_factory_.AddSocketDataProvider(&http_data);
1213
1214   CreateSessionWithNextProtos();
1215
1216   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1217
1218   SendRequestAndExpectHttpResponse("hello from http");
1219 }
1220
1221 TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolOnConnectFailure) {
1222   // Alternate-protocol job will fail before creating a QUIC session.
1223   StaticSocketDataProvider quic_data(nullptr, 0, nullptr, 0);
1224   quic_data.set_connect_data(MockConnect(SYNCHRONOUS,
1225                                          ERR_INTERNET_DISCONNECTED));
1226   socket_factory_.AddSocketDataProvider(&quic_data);
1227
1228   // Main job which will succeed even though the alternate job fails.
1229   MockRead http_reads[] = {
1230     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
1231     MockRead("hello from http"),
1232     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1233     MockRead(ASYNC, OK)
1234   };
1235
1236   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
1237                                      nullptr, 0);
1238   socket_factory_.AddSocketDataProvider(&http_data);
1239
1240   CreateSessionWithNextProtos();
1241   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
1242   SendRequestAndExpectHttpResponse("hello from http");
1243
1244   ExpectBrokenAlternateProtocolMapping();
1245 }
1246
1247 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) {
1248   MockQuicData mock_quic_data;
1249   mock_quic_data.AddSynchronousRead(ConstructConnectionClosePacket(1));
1250   mock_quic_data.AddWrite(
1251       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
1252                                     GetRequestHeaders("GET", "http", "/")));
1253   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
1254   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1255
1256   // When the QUIC connection fails, we will try the request again over HTTP.
1257   MockRead http_reads[] = {
1258     MockRead("HTTP/1.1 200 OK\r\n"),
1259     MockRead(kQuicAlternateProtocolHttpHeader),
1260     MockRead("hello world"),
1261     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1262     MockRead(ASYNC, OK)
1263   };
1264
1265   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
1266                                      nullptr, 0);
1267   socket_factory_.AddSocketDataProvider(&http_data);
1268
1269   // In order for a new QUIC session to be established via alternate-protocol
1270   // without racing an HTTP connection, we need the host resolution to happen
1271   // synchronously.
1272   host_resolver_.set_synchronous_mode(true);
1273   host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", "");
1274   HostResolver::RequestInfo info(HostPortPair("www.google.com", 80));
1275   AddressList address;
1276   host_resolver_.Resolve(info,
1277                          DEFAULT_PRIORITY,
1278                          &address,
1279                          CompletionCallback(),
1280                          nullptr,
1281                          net_log_.bound());
1282
1283   CreateSessionWithNextProtos();
1284   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1285   SendRequestAndExpectHttpResponse("hello world");
1286 }
1287
1288 // Test that a secure request over an insecure QUIC connection fails with
1289 // the appropriate error code.  Note that this never happens in production,
1290 // because the handshake (which this test mocks) would fail in this scenario.
1291 TEST_P(QuicNetworkTransactionTest, SecureResourceOverInsecureQuic) {
1292   maker_.set_hostname("www.example.org");
1293   MockQuicData mock_quic_data;
1294   mock_quic_data.AddWrite(
1295       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
1296                                     GetRequestHeaders("GET", "https", "/")));
1297   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
1298       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
1299   mock_quic_data.AddRead(
1300       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
1301   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
1302   mock_quic_data.AddRead(SYNCHRONOUS, 0);
1303   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1304
1305   request_.url = GURL("https://www.example.org:443");
1306   AddHangingNonAlternateProtocolSocketData();
1307   CreateSessionWithNextProtos();
1308   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
1309   scoped_ptr<HttpNetworkTransaction> trans(
1310       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1311   TestCompletionCallback callback;
1312   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
1313   EXPECT_EQ(ERR_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC,
1314             callback.GetResult(rv));
1315 }
1316
1317 TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) {
1318   maker_.set_hostname("www.example.org");
1319   MockQuicData mock_quic_data;
1320   mock_quic_data.AddWrite(
1321       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
1322                                     GetRequestHeaders("GET", "https", "/")));
1323   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
1324       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
1325   mock_quic_data.AddRead(
1326       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
1327   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
1328   mock_quic_data.AddRead(SYNCHRONOUS, 0);
1329   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1330
1331   scoped_refptr<X509Certificate> cert(
1332       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
1333   ASSERT_TRUE(cert.get());
1334   bool common_name_fallback_used;
1335   EXPECT_TRUE(
1336       cert->VerifyNameMatch("www.example.org", &common_name_fallback_used));
1337   ProofVerifyDetailsChromium verify_details;
1338   verify_details.cert_verify_result.verified_cert = cert;
1339   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1340
1341   request_.url = GURL("https://www.example.org:443");
1342   AddHangingNonAlternateProtocolSocketData();
1343   CreateSessionWithNextProtos();
1344   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
1345   SendRequestAndExpectQuicResponse("hello!");
1346 }
1347
1348 }  // namespace test
1349 }  // namespace net