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/capturing_net_log.h" 12 #include "net/base/net_log_unittest.h" 13 #include "net/base/test_completion_callback.h" 14 #include "net/cert/mock_cert_verifier.h" 15 #include "net/dns/mock_host_resolver.h" 16 #include "net/http/http_auth_handler_factory.h" 17 #include "net/http/http_network_session.h" 18 #include "net/http/http_network_transaction.h" 19 #include "net/http/http_server_properties_impl.h" 20 #include "net/http/http_stream.h" 21 #include "net/http/http_stream_factory.h" 22 #include "net/http/http_transaction_test_util.h" 23 #include "net/http/transport_security_state.h" 24 #include "net/proxy/proxy_config_service_fixed.h" 25 #include "net/proxy/proxy_resolver.h" 26 #include "net/proxy/proxy_service.h" 27 #include "net/quic/crypto/quic_decrypter.h" 28 #include "net/quic/crypto/quic_encrypter.h" 29 #include "net/quic/quic_framer.h" 30 #include "net/quic/quic_http_utils.h" 31 #include "net/quic/test_tools/crypto_test_utils.h" 32 #include "net/quic/test_tools/mock_clock.h" 33 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h" 34 #include "net/quic/test_tools/mock_random.h" 35 #include "net/quic/test_tools/quic_test_packet_maker.h" 36 #include "net/quic/test_tools/quic_test_utils.h" 37 #include "net/socket/client_socket_factory.h" 38 #include "net/socket/mock_client_socket_pool_manager.h" 39 #include "net/socket/socket_test_util.h" 40 #include "net/socket/ssl_client_socket.h" 41 #include "net/spdy/spdy_frame_builder.h" 42 #include "net/spdy/spdy_framer.h" 43 #include "net/ssl/ssl_config_service_defaults.h" 44 #include "testing/gtest/include/gtest/gtest.h" 45 #include "testing/platform_test.h" 46 47 //----------------------------------------------------------------------------- 48 49 namespace { 50 51 // This is the expected return from a current server advertising QUIC. 52 static const char kQuicAlternateProtocolHttpHeader[] = 53 "Alternate-Protocol: 80:quic\r\n\r\n"; 54 static const char kQuicAlternateProtocol50pctHttpHeader[] = 55 "Alternate-Protocol: 80:quic,p=.5\r\n\r\n"; 56 static const char kQuicAlternateProtocolHttpsHeader[] = 57 "Alternate-Protocol: 443:quic\r\n\r\n"; 58 59 } // namespace 60 61 namespace net { 62 namespace test { 63 64 // Helper class to encapsulate MockReads and MockWrites for QUIC. 65 // Simplify ownership issues and the interaction with the MockSocketFactory. 66 class MockQuicData { 67 public: 68 ~MockQuicData() { 69 STLDeleteElements(&packets_); 70 } 71 72 void AddRead(scoped_ptr<QuicEncryptedPacket> packet) { 73 reads_.push_back(MockRead(SYNCHRONOUS, packet->data(), packet->length(), 74 sequence_number_++)); 75 packets_.push_back(packet.release()); 76 } 77 78 void AddRead(IoMode mode, int rv) { 79 reads_.push_back(MockRead(mode, rv)); 80 } 81 82 void AddWrite(scoped_ptr<QuicEncryptedPacket> packet) { 83 writes_.push_back(MockWrite(SYNCHRONOUS, packet->data(), packet->length(), 84 sequence_number_++)); 85 packets_.push_back(packet.release()); 86 } 87 88 void AddDelayedSocketDataToFactory(MockClientSocketFactory* factory, 89 size_t delay) { 90 MockRead* reads = reads_.empty() ? NULL : &reads_[0]; 91 MockWrite* writes = writes_.empty() ? NULL : &writes_[0]; 92 socket_data_.reset(new DelayedSocketData( 93 delay, reads, reads_.size(), writes, writes_.size())); 94 factory->AddSocketDataProvider(socket_data_.get()); 95 } 96 97 private: 98 std::vector<QuicEncryptedPacket*> packets_; 99 std::vector<MockWrite> writes_; 100 std::vector<MockRead> reads_; 101 size_t sequence_number_; 102 scoped_ptr<SocketDataProvider> socket_data_; 103 }; 104 105 class QuicNetworkTransactionTest 106 : public PlatformTest, 107 public ::testing::WithParamInterface<QuicVersion> { 108 protected: 109 QuicNetworkTransactionTest() 110 : clock_(new MockClock), 111 maker_(GetParam(), 0, clock_), 112 ssl_config_service_(new SSLConfigServiceDefaults), 113 proxy_service_(ProxyService::CreateDirect()), 114 auth_handler_factory_( 115 HttpAuthHandlerFactory::CreateDefault(&host_resolver_)), 116 random_generator_(0), 117 hanging_data_(NULL, 0, NULL, 0) { 118 request_.method = "GET"; 119 request_.url = GURL("http://www.google.com/"); 120 request_.load_flags = 0; 121 clock_->AdvanceTime(QuicTime::Delta::FromMilliseconds(20)); 122 } 123 124 virtual void SetUp() { 125 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 126 base::MessageLoop::current()->RunUntilIdle(); 127 } 128 129 virtual void TearDown() { 130 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 131 // Empty the current queue. 132 base::MessageLoop::current()->RunUntilIdle(); 133 PlatformTest::TearDown(); 134 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 135 base::MessageLoop::current()->RunUntilIdle(); 136 } 137 138 scoped_ptr<QuicEncryptedPacket> ConstructConnectionClosePacket( 139 QuicPacketSequenceNumber num) { 140 return maker_.MakeConnectionClosePacket(num); 141 } 142 143 scoped_ptr<QuicEncryptedPacket> ConstructAckPacket( 144 QuicPacketSequenceNumber largest_received, 145 QuicPacketSequenceNumber least_unacked) { 146 return maker_.MakeAckPacket(2, largest_received, least_unacked, true); 147 } 148 149 SpdyHeaderBlock GetRequestHeaders(const std::string& method, 150 const std::string& scheme, 151 const std::string& path) { 152 return maker_.GetRequestHeaders(method, scheme, path); 153 } 154 155 SpdyHeaderBlock GetResponseHeaders(const std::string& status) { 156 return maker_.GetResponseHeaders(status); 157 } 158 159 scoped_ptr<QuicEncryptedPacket> ConstructDataPacket( 160 QuicPacketSequenceNumber sequence_number, 161 QuicStreamId stream_id, 162 bool should_include_version, 163 bool fin, 164 QuicStreamOffset offset, 165 base::StringPiece data) { 166 return maker_.MakeDataPacket( 167 sequence_number, stream_id, should_include_version, fin, offset, data); 168 } 169 170 scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket( 171 QuicPacketSequenceNumber sequence_number, 172 QuicStreamId stream_id, 173 bool should_include_version, 174 bool fin, 175 const SpdyHeaderBlock& headers) { 176 return maker_.MakeRequestHeadersPacket( 177 sequence_number, stream_id, should_include_version, fin, headers); 178 } 179 180 scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket( 181 QuicPacketSequenceNumber sequence_number, 182 QuicStreamId stream_id, 183 bool should_include_version, 184 bool fin, 185 const SpdyHeaderBlock& headers) { 186 return maker_.MakeResponseHeadersPacket( 187 sequence_number, stream_id, should_include_version, fin, headers); 188 } 189 190 void CreateSession() { 191 CreateSessionWithFactory(&socket_factory_, false); 192 } 193 194 void CreateSessionWithNextProtos() { 195 CreateSessionWithFactory(&socket_factory_, true); 196 } 197 198 // If |use_next_protos| is true, enables SPDY and QUIC. 199 void CreateSessionWithFactory(ClientSocketFactory* socket_factory, 200 bool use_next_protos) { 201 params_.enable_quic = true; 202 params_.quic_clock = clock_; 203 params_.quic_random = &random_generator_; 204 params_.client_socket_factory = socket_factory; 205 params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_; 206 params_.host_resolver = &host_resolver_; 207 params_.cert_verifier = &cert_verifier_; 208 params_.transport_security_state = &transport_security_state_; 209 params_.proxy_service = proxy_service_.get(); 210 params_.ssl_config_service = ssl_config_service_.get(); 211 params_.http_auth_handler_factory = auth_handler_factory_.get(); 212 params_.http_server_properties = http_server_properties.GetWeakPtr(); 213 params_.quic_supported_versions = SupportedVersions(GetParam()); 214 215 if (use_next_protos) { 216 params_.use_alternate_protocols = true; 217 params_.next_protos = NextProtosSpdy3(); 218 } 219 220 session_ = new HttpNetworkSession(params_); 221 session_->quic_stream_factory()->set_require_confirmation(false); 222 } 223 224 void CheckWasQuicResponse(const scoped_ptr<HttpNetworkTransaction>& trans) { 225 const HttpResponseInfo* response = trans->GetResponseInfo(); 226 ASSERT_TRUE(response != NULL); 227 ASSERT_TRUE(response->headers.get() != NULL); 228 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 229 EXPECT_TRUE(response->was_fetched_via_spdy); 230 EXPECT_TRUE(response->was_npn_negotiated); 231 EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3, 232 response->connection_info); 233 } 234 235 void CheckWasHttpResponse(const scoped_ptr<HttpNetworkTransaction>& trans) { 236 const HttpResponseInfo* response = trans->GetResponseInfo(); 237 ASSERT_TRUE(response != NULL); 238 ASSERT_TRUE(response->headers.get() != NULL); 239 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 240 EXPECT_FALSE(response->was_fetched_via_spdy); 241 EXPECT_FALSE(response->was_npn_negotiated); 242 EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1, 243 response->connection_info); 244 } 245 246 void CheckResponseData(HttpNetworkTransaction* trans, 247 const std::string& expected) { 248 std::string response_data; 249 ASSERT_EQ(OK, ReadTransaction(trans, &response_data)); 250 EXPECT_EQ(expected, response_data); 251 } 252 253 void RunTransaction(HttpNetworkTransaction* trans) { 254 TestCompletionCallback callback; 255 int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); 256 EXPECT_EQ(ERR_IO_PENDING, rv); 257 EXPECT_EQ(OK, callback.WaitForResult()); 258 } 259 260 void SendRequestAndExpectHttpResponse(const std::string& expected) { 261 scoped_ptr<HttpNetworkTransaction> trans( 262 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get())); 263 RunTransaction(trans.get()); 264 CheckWasHttpResponse(trans); 265 CheckResponseData(trans.get(), expected); 266 } 267 268 void SendRequestAndExpectQuicResponse(const std::string& expected) { 269 scoped_ptr<HttpNetworkTransaction> trans( 270 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get())); 271 RunTransaction(trans.get()); 272 CheckWasQuicResponse(trans); 273 CheckResponseData(trans.get(), expected); 274 } 275 276 void AddQuicAlternateProtocolMapping( 277 MockCryptoClientStream::HandshakeMode handshake_mode) { 278 crypto_client_stream_factory_.set_handshake_mode(handshake_mode); 279 session_->http_server_properties()->SetAlternateProtocol( 280 HostPortPair::FromURL(request_.url), 80, QUIC, 1); 281 } 282 283 void ExpectBrokenAlternateProtocolMapping() { 284 ASSERT_TRUE(session_->http_server_properties()->HasAlternateProtocol( 285 HostPortPair::FromURL(request_.url))); 286 const AlternateProtocolInfo alternate = 287 session_->http_server_properties()->GetAlternateProtocol( 288 HostPortPair::FromURL(request_.url)); 289 EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate.protocol); 290 } 291 292 void ExpectQuicAlternateProtocolMapping() { 293 ASSERT_TRUE(session_->http_server_properties()->HasAlternateProtocol( 294 HostPortPair::FromURL(request_.url))); 295 const AlternateProtocolInfo alternate = 296 session_->http_server_properties()->GetAlternateProtocol( 297 HostPortPair::FromURL(request_.url)); 298 EXPECT_EQ(QUIC, alternate.protocol); 299 } 300 301 void AddHangingNonAlternateProtocolSocketData() { 302 MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING); 303 hanging_data_.set_connect_data(hanging_connect); 304 socket_factory_.AddSocketDataProvider(&hanging_data_); 305 } 306 307 MockClock* clock_; // Owned by QuicStreamFactory after CreateSession. 308 QuicTestPacketMaker maker_; 309 scoped_refptr<HttpNetworkSession> session_; 310 MockClientSocketFactory socket_factory_; 311 MockCryptoClientStreamFactory crypto_client_stream_factory_; 312 MockHostResolver host_resolver_; 313 MockCertVerifier cert_verifier_; 314 TransportSecurityState transport_security_state_; 315 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_; 316 scoped_ptr<ProxyService> proxy_service_; 317 scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_; 318 MockRandom random_generator_; 319 HttpServerPropertiesImpl http_server_properties; 320 HttpNetworkSession::Params params_; 321 HttpRequestInfo request_; 322 CapturingBoundNetLog net_log_; 323 StaticSocketDataProvider hanging_data_; 324 }; 325 326 INSTANTIATE_TEST_CASE_P(Version, QuicNetworkTransactionTest, 327 ::testing::ValuesIn(QuicSupportedVersions())); 328 329 TEST_P(QuicNetworkTransactionTest, ForceQuic) { 330 params_.origin_to_force_quic_on = 331 HostPortPair::FromString("www.google.com:80"); 332 333 MockQuicData mock_quic_data; 334 mock_quic_data.AddWrite( 335 ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true, 336 GetRequestHeaders("GET", "http", "/"))); 337 mock_quic_data.AddRead( 338 ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false, 339 GetResponseHeaders("200 OK"))); 340 mock_quic_data.AddRead( 341 ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!")); 342 mock_quic_data.AddWrite(ConstructAckPacket(2, 1)); 343 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF 344 345 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1); 346 347 // The non-alternate protocol job needs to hang in order to guarantee that 348 // the alternate-protocol job will "win". 349 AddHangingNonAlternateProtocolSocketData(); 350 351 CreateSession(); 352 353 SendRequestAndExpectQuicResponse("hello!"); 354 355 // Check that the NetLog was filled reasonably. 356 net::CapturingNetLog::CapturedEntryList entries; 357 net_log_.GetEntries(&entries); 358 EXPECT_LT(0u, entries.size()); 359 360 // Check that we logged a QUIC_SESSION_PACKET_RECEIVED. 361 int pos = net::ExpectLogContainsSomewhere( 362 entries, 0, 363 net::NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED, 364 net::NetLog::PHASE_NONE); 365 EXPECT_LT(0, pos); 366 367 // ... and also a TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED. 368 pos = net::ExpectLogContainsSomewhere( 369 entries, 0, 370 net::NetLog::TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED, 371 net::NetLog::PHASE_NONE); 372 EXPECT_LT(0, pos); 373 374 std::string packet_sequence_number; 375 ASSERT_TRUE(entries[pos].GetStringValue( 376 "packet_sequence_number", &packet_sequence_number)); 377 EXPECT_EQ("1", packet_sequence_number); 378 379 // ... and also a QUIC_SESSION_STREAM_FRAME_RECEIVED. 380 pos = net::ExpectLogContainsSomewhere( 381 entries, 0, 382 net::NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED, 383 net::NetLog::PHASE_NONE); 384 EXPECT_LT(0, pos); 385 386 int log_stream_id; 387 ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &log_stream_id)); 388 EXPECT_EQ(3, log_stream_id); 389 } 390 391 TEST_P(QuicNetworkTransactionTest, QuicProxy) { 392 proxy_service_.reset( 393 ProxyService::CreateFixedFromPacResult("QUIC myproxy:70")); 394 395 MockQuicData mock_quic_data; 396 mock_quic_data.AddWrite( 397 ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true, 398 GetRequestHeaders("GET", "http", "/"))); 399 mock_quic_data.AddRead( 400 ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false, 401 GetResponseHeaders("200 OK"))); 402 mock_quic_data.AddRead( 403 ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!")); 404 mock_quic_data.AddWrite(ConstructAckPacket(2, 1)); 405 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF 406 407 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1); 408 409 // There is no need to set up an alternate protocol job, because 410 // no attempt will be made to speak to the proxy over TCP. 411 412 CreateSession(); 413 414 SendRequestAndExpectQuicResponse("hello!"); 415 } 416 417 TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) { 418 params_.origin_to_force_quic_on = 419 HostPortPair::FromString("www.google.com:80"); 420 421 MockQuicData mock_quic_data; 422 mock_quic_data.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED); 423 424 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 0); 425 426 CreateSession(); 427 428 scoped_ptr<HttpNetworkTransaction> trans( 429 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get())); 430 TestCompletionCallback callback; 431 int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); 432 EXPECT_EQ(ERR_IO_PENDING, rv); 433 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); 434 } 435 436 TEST_P(QuicNetworkTransactionTest, DoNotForceQuicForHttps) { 437 // Attempt to "force" quic on 443, which will not be honored. 438 params_.origin_to_force_quic_on = 439 HostPortPair::FromString("www.google.com:443"); 440 441 MockRead http_reads[] = { 442 MockRead("HTTP/1.1 200 OK\r\n\r\n"), 443 MockRead("hello world"), 444 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 445 MockRead(ASYNC, OK) 446 }; 447 448 StaticSocketDataProvider data(http_reads, arraysize(http_reads), NULL, 0); 449 socket_factory_.AddSocketDataProvider(&data); 450 SSLSocketDataProvider ssl(ASYNC, OK); 451 socket_factory_.AddSSLSocketDataProvider(&ssl); 452 453 CreateSession(); 454 455 SendRequestAndExpectHttpResponse("hello world"); 456 } 457 458 TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolForQuic) { 459 MockRead http_reads[] = { 460 MockRead("HTTP/1.1 200 OK\r\n"), 461 MockRead(kQuicAlternateProtocolHttpHeader), 462 MockRead("hello world"), 463 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 464 MockRead(ASYNC, OK) 465 }; 466 467 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 468 NULL, 0); 469 socket_factory_.AddSocketDataProvider(&http_data); 470 471 MockQuicData mock_quic_data; 472 mock_quic_data.AddWrite( 473 ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true, 474 GetRequestHeaders("GET", "http", "/"))); 475 mock_quic_data.AddRead( 476 ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false, 477 GetResponseHeaders("200 OK"))); 478 mock_quic_data.AddRead( 479 ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!")); 480 mock_quic_data.AddWrite(ConstructAckPacket(2, 1)); 481 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF 482 483 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1); 484 485 // The non-alternate protocol job needs to hang in order to guarantee that 486 // the alternate-protocol job will "win". 487 AddHangingNonAlternateProtocolSocketData(); 488 489 CreateSessionWithNextProtos(); 490 491 SendRequestAndExpectHttpResponse("hello world"); 492 SendRequestAndExpectQuicResponse("hello!"); 493 } 494 495 TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolProbabilityForQuic) { 496 MockRead http_reads[] = { 497 MockRead("HTTP/1.1 200 OK\r\n"), 498 MockRead(kQuicAlternateProtocol50pctHttpHeader), 499 MockRead("hello world"), 500 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 501 MockRead(ASYNC, OK) 502 }; 503 504 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 505 NULL, 0); 506 socket_factory_.AddSocketDataProvider(&http_data); 507 508 MockQuicData mock_quic_data; 509 mock_quic_data.AddWrite( 510 ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true, 511 GetRequestHeaders("GET", "http", "/"))); 512 mock_quic_data.AddRead( 513 ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false, 514 GetResponseHeaders("200 OK"))); 515 mock_quic_data.AddRead( 516 ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!")); 517 mock_quic_data.AddWrite(ConstructAckPacket(2, 1)); 518 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF 519 520 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1); 521 522 // The non-alternate protocol job needs to hang in order to guarantee that 523 // the alternate-protocol job will "win". 524 AddHangingNonAlternateProtocolSocketData(); 525 526 params_.alternate_protocol_probability_threshold = .25; 527 CreateSessionWithNextProtos(); 528 529 SendRequestAndExpectHttpResponse("hello world"); 530 SendRequestAndExpectQuicResponse("hello!"); 531 } 532 533 TEST_P(QuicNetworkTransactionTest, DontUseAlternateProtocolProbabilityForQuic) { 534 MockRead http_reads[] = { 535 MockRead("HTTP/1.1 200 OK\r\n"), 536 MockRead(kQuicAlternateProtocol50pctHttpHeader), 537 MockRead("hello world"), 538 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 539 MockRead(ASYNC, OK) 540 }; 541 542 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 543 NULL, 0); 544 socket_factory_.AddSocketDataProvider(&http_data); 545 socket_factory_.AddSocketDataProvider(&http_data); 546 547 params_.alternate_protocol_probability_threshold = .75; 548 CreateSessionWithNextProtos(); 549 550 SendRequestAndExpectHttpResponse("hello world"); 551 SendRequestAndExpectHttpResponse("hello world"); 552 } 553 554 TEST_P(QuicNetworkTransactionTest, 555 DontUseAlternateProtocolWithBadProbabilityForQuic) { 556 MockRead http_reads[] = { 557 MockRead("HTTP/1.1 200 OK\r\n"), 558 MockRead("Alternate-Protocol: 443:quic,p=2\r\n\r\n"), 559 MockRead("hello world"), 560 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 561 MockRead(ASYNC, OK) 562 }; 563 564 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 565 NULL, 0); 566 socket_factory_.AddSocketDataProvider(&http_data); 567 socket_factory_.AddSocketDataProvider(&http_data); 568 569 params_.alternate_protocol_probability_threshold = .75; 570 CreateSessionWithNextProtos(); 571 572 SendRequestAndExpectHttpResponse("hello world"); 573 SendRequestAndExpectHttpResponse("hello world"); 574 } 575 576 TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolForQuicForHttps) { 577 params_.origin_to_force_quic_on = 578 HostPortPair::FromString("www.google.com:443"); 579 580 MockRead http_reads[] = { 581 MockRead("HTTP/1.1 200 OK\r\n"), 582 MockRead(kQuicAlternateProtocolHttpsHeader), 583 MockRead("hello world"), 584 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 585 MockRead(ASYNC, OK) 586 }; 587 588 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 589 NULL, 0); 590 socket_factory_.AddSocketDataProvider(&http_data); 591 592 MockQuicData mock_quic_data; 593 mock_quic_data.AddWrite( 594 ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true, 595 GetRequestHeaders("GET", "http", "/"))); 596 mock_quic_data.AddRead( 597 ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false, 598 GetResponseHeaders("200 OK"))); 599 mock_quic_data.AddRead( 600 ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!")); 601 mock_quic_data.AddWrite(ConstructAckPacket(2, 1)); 602 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF 603 604 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1); 605 606 // The non-alternate protocol job needs to hang in order to guarantee that 607 // the alternate-protocol job will "win". 608 AddHangingNonAlternateProtocolSocketData(); 609 610 CreateSessionWithNextProtos(); 611 612 // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo(). 613 SendRequestAndExpectHttpResponse("hello world"); 614 } 615 616 TEST_P(QuicNetworkTransactionTest, HungAlternateProtocol) { 617 crypto_client_stream_factory_.set_handshake_mode( 618 MockCryptoClientStream::COLD_START); 619 620 MockWrite http_writes[] = { 621 MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), 622 MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"), 623 MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n") 624 }; 625 626 MockRead http_reads[] = { 627 MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), 628 MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHttpHeader), 629 MockRead(SYNCHRONOUS, 5, "hello world"), 630 MockRead(SYNCHRONOUS, OK, 6) 631 }; 632 633 DeterministicMockClientSocketFactory socket_factory; 634 635 DeterministicSocketData http_data(http_reads, arraysize(http_reads), 636 http_writes, arraysize(http_writes)); 637 socket_factory.AddSocketDataProvider(&http_data); 638 639 // The QUIC transaction will not be allowed to complete. 640 MockWrite quic_writes[] = { 641 MockWrite(ASYNC, ERR_IO_PENDING, 0) 642 }; 643 MockRead quic_reads[] = { 644 MockRead(ASYNC, ERR_IO_PENDING, 1), 645 }; 646 DeterministicSocketData quic_data(quic_reads, arraysize(quic_reads), 647 quic_writes, arraysize(quic_writes)); 648 socket_factory.AddSocketDataProvider(&quic_data); 649 650 // The HTTP transaction will complete. 651 DeterministicSocketData http_data2(http_reads, arraysize(http_reads), 652 http_writes, arraysize(http_writes)); 653 socket_factory.AddSocketDataProvider(&http_data2); 654 655 CreateSessionWithFactory(&socket_factory, true); 656 657 // Run the first request. 658 http_data.StopAfter(arraysize(http_reads) + arraysize(http_writes)); 659 SendRequestAndExpectHttpResponse("hello world"); 660 ASSERT_TRUE(http_data.at_read_eof()); 661 ASSERT_TRUE(http_data.at_write_eof()); 662 663 // Now run the second request in which the QUIC socket hangs, 664 // and verify the the transaction continues over HTTP. 665 http_data2.StopAfter(arraysize(http_reads) + arraysize(http_writes)); 666 SendRequestAndExpectHttpResponse("hello world"); 667 668 ASSERT_TRUE(http_data2.at_read_eof()); 669 ASSERT_TRUE(http_data2.at_write_eof()); 670 ASSERT_TRUE(!quic_data.at_read_eof()); 671 ASSERT_TRUE(!quic_data.at_write_eof()); 672 } 673 674 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) { 675 MockQuicData mock_quic_data; 676 mock_quic_data.AddWrite( 677 ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true, 678 GetRequestHeaders("GET", "http", "/"))); 679 mock_quic_data.AddRead( 680 ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false, 681 GetResponseHeaders("200 OK"))); 682 mock_quic_data.AddRead( 683 ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!")); 684 mock_quic_data.AddWrite(ConstructAckPacket(2, 1)); 685 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF 686 687 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1); 688 689 // The non-alternate protocol job needs to hang in order to guarantee that 690 // the alternate-protocol job will "win". 691 AddHangingNonAlternateProtocolSocketData(); 692 693 CreateSessionWithNextProtos(); 694 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); 695 SendRequestAndExpectQuicResponse("hello!"); 696 } 697 698 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) { 699 MockQuicData mock_quic_data; 700 mock_quic_data.AddWrite( 701 ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true, 702 GetRequestHeaders("GET", "http", "/"))); 703 mock_quic_data.AddRead( 704 ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false, 705 GetResponseHeaders("200 OK"))); 706 mock_quic_data.AddRead( 707 ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!")); 708 mock_quic_data.AddWrite(ConstructAckPacket(2, 1)); 709 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF 710 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1); 711 712 // In order for a new QUIC session to be established via alternate-protocol 713 // without racing an HTTP connection, we need the host resolution to happen 714 // synchronously. 715 host_resolver_.set_synchronous_mode(true); 716 host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", ""); 717 HostResolver::RequestInfo info(HostPortPair("www.google.com", 80)); 718 AddressList address; 719 host_resolver_.Resolve(info, 720 DEFAULT_PRIORITY, 721 &address, 722 CompletionCallback(), 723 NULL, 724 net_log_.bound()); 725 726 CreateSessionWithNextProtos(); 727 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); 728 SendRequestAndExpectQuicResponse("hello!"); 729 } 730 731 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) { 732 proxy_service_.reset( 733 ProxyService::CreateFixedFromPacResult("PROXY myproxy:70")); 734 735 // Since we are using a proxy, the QUIC job will not succeed. 736 MockWrite http_writes[] = { 737 MockWrite(SYNCHRONOUS, 0, "GET http://www.google.com/ HTTP/1.1\r\n"), 738 MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"), 739 MockWrite(SYNCHRONOUS, 2, "Proxy-Connection: keep-alive\r\n\r\n") 740 }; 741 742 MockRead http_reads[] = { 743 MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), 744 MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHttpHeader), 745 MockRead(SYNCHRONOUS, 5, "hello world"), 746 MockRead(SYNCHRONOUS, OK, 6) 747 }; 748 749 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 750 http_writes, arraysize(http_writes)); 751 socket_factory_.AddSocketDataProvider(&http_data); 752 753 // In order for a new QUIC session to be established via alternate-protocol 754 // without racing an HTTP connection, we need the host resolution to happen 755 // synchronously. 756 host_resolver_.set_synchronous_mode(true); 757 host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", ""); 758 HostResolver::RequestInfo info(HostPortPair("www.google.com", 80)); 759 AddressList address; 760 host_resolver_.Resolve(info, 761 DEFAULT_PRIORITY, 762 &address, 763 CompletionCallback(), 764 NULL, 765 net_log_.bound()); 766 767 CreateSessionWithNextProtos(); 768 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); 769 SendRequestAndExpectHttpResponse("hello world"); 770 } 771 772 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) { 773 MockQuicData mock_quic_data; 774 mock_quic_data.AddWrite( 775 ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true, 776 GetRequestHeaders("GET", "http", "/"))); 777 mock_quic_data.AddRead( 778 ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false, 779 GetResponseHeaders("200 OK"))); 780 mock_quic_data.AddRead( 781 ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!")); 782 mock_quic_data.AddWrite(ConstructAckPacket(2, 1)); 783 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF 784 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1); 785 786 // The non-alternate protocol job needs to hang in order to guarantee that 787 // the alternate-protocol job will "win". 788 AddHangingNonAlternateProtocolSocketData(); 789 790 // In order for a new QUIC session to be established via alternate-protocol 791 // without racing an HTTP connection, we need the host resolution to happen 792 // synchronously. Of course, even though QUIC *could* perform a 0-RTT 793 // connection to the the server, in this test we require confirmation 794 // before encrypting so the HTTP job will still start. 795 host_resolver_.set_synchronous_mode(true); 796 host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", ""); 797 HostResolver::RequestInfo info(HostPortPair("www.google.com", 80)); 798 AddressList address; 799 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, 800 CompletionCallback(), NULL, net_log_.bound()); 801 802 CreateSessionWithNextProtos(); 803 session_->quic_stream_factory()->set_require_confirmation(true); 804 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); 805 806 scoped_ptr<HttpNetworkTransaction> trans( 807 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get())); 808 TestCompletionCallback callback; 809 int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); 810 EXPECT_EQ(ERR_IO_PENDING, rv); 811 812 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( 813 QuicSession::HANDSHAKE_CONFIRMED); 814 EXPECT_EQ(OK, callback.WaitForResult()); 815 } 816 817 TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocol) { 818 // Alternate-protocol job 819 scoped_ptr<QuicEncryptedPacket> close(ConstructConnectionClosePacket(1)); 820 MockRead quic_reads[] = { 821 MockRead(ASYNC, close->data(), close->length()), 822 MockRead(ASYNC, OK), // EOF 823 }; 824 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), 825 NULL, 0); 826 socket_factory_.AddSocketDataProvider(&quic_data); 827 828 // Main job which will succeed even though the alternate job fails. 829 MockRead http_reads[] = { 830 MockRead("HTTP/1.1 200 OK\r\n\r\n"), 831 MockRead("hello from http"), 832 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 833 MockRead(ASYNC, OK) 834 }; 835 836 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 837 NULL, 0); 838 socket_factory_.AddSocketDataProvider(&http_data); 839 840 CreateSessionWithNextProtos(); 841 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); 842 SendRequestAndExpectHttpResponse("hello from http"); 843 ExpectBrokenAlternateProtocolMapping(); 844 } 845 846 TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolReadError) { 847 // Alternate-protocol job 848 MockRead quic_reads[] = { 849 MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), 850 }; 851 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), 852 NULL, 0); 853 socket_factory_.AddSocketDataProvider(&quic_data); 854 855 // Main job which will succeed even though the alternate job fails. 856 MockRead http_reads[] = { 857 MockRead("HTTP/1.1 200 OK\r\n\r\n"), 858 MockRead("hello from http"), 859 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 860 MockRead(ASYNC, OK) 861 }; 862 863 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 864 NULL, 0); 865 socket_factory_.AddSocketDataProvider(&http_data); 866 867 CreateSessionWithNextProtos(); 868 869 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); 870 SendRequestAndExpectHttpResponse("hello from http"); 871 ExpectBrokenAlternateProtocolMapping(); 872 } 873 874 TEST_P(QuicNetworkTransactionTest, NoBrokenAlternateProtocolIfTcpFails) { 875 // Alternate-protocol job will fail when the session attempts to read. 876 MockRead quic_reads[] = { 877 MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), 878 }; 879 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), 880 NULL, 0); 881 socket_factory_.AddSocketDataProvider(&quic_data); 882 883 // Main job will also fail. 884 MockRead http_reads[] = { 885 MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), 886 }; 887 888 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 889 NULL, 0); 890 http_data.set_connect_data(MockConnect(ASYNC, ERR_SOCKET_NOT_CONNECTED)); 891 socket_factory_.AddSocketDataProvider(&http_data); 892 893 CreateSessionWithNextProtos(); 894 895 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); 896 scoped_ptr<HttpNetworkTransaction> trans( 897 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get())); 898 TestCompletionCallback callback; 899 int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); 900 EXPECT_EQ(ERR_IO_PENDING, rv); 901 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, callback.WaitForResult()); 902 ExpectQuicAlternateProtocolMapping(); 903 } 904 905 TEST_P(QuicNetworkTransactionTest, FailedZeroRttBrokenAlternateProtocol) { 906 // Alternate-protocol job 907 MockRead quic_reads[] = { 908 MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), 909 }; 910 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), 911 NULL, 0); 912 socket_factory_.AddSocketDataProvider(&quic_data); 913 914 AddHangingNonAlternateProtocolSocketData(); 915 916 // Second Alternate-protocol job which will race with the TCP job. 917 StaticSocketDataProvider quic_data2(quic_reads, arraysize(quic_reads), 918 NULL, 0); 919 socket_factory_.AddSocketDataProvider(&quic_data2); 920 921 // Final job that will proceed when the QUIC job fails. 922 MockRead http_reads[] = { 923 MockRead("HTTP/1.1 200 OK\r\n\r\n"), 924 MockRead("hello from http"), 925 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 926 MockRead(ASYNC, OK) 927 }; 928 929 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 930 NULL, 0); 931 socket_factory_.AddSocketDataProvider(&http_data); 932 933 CreateSessionWithNextProtos(); 934 935 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); 936 937 SendRequestAndExpectHttpResponse("hello from http"); 938 939 ExpectBrokenAlternateProtocolMapping(); 940 941 EXPECT_TRUE(quic_data.at_read_eof()); 942 EXPECT_TRUE(quic_data.at_write_eof()); 943 } 944 945 TEST_P(QuicNetworkTransactionTest, DISABLED_HangingZeroRttFallback) { 946 // Alternate-protocol job 947 MockRead quic_reads[] = { 948 MockRead(ASYNC, ERR_IO_PENDING), 949 }; 950 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), 951 NULL, 0); 952 socket_factory_.AddSocketDataProvider(&quic_data); 953 954 // Main job that will proceed when the QUIC job fails. 955 MockRead http_reads[] = { 956 MockRead("HTTP/1.1 200 OK\r\n\r\n"), 957 MockRead("hello from http"), 958 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 959 MockRead(ASYNC, OK) 960 }; 961 962 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 963 NULL, 0); 964 socket_factory_.AddSocketDataProvider(&http_data); 965 966 CreateSessionWithNextProtos(); 967 968 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); 969 970 SendRequestAndExpectHttpResponse("hello from http"); 971 } 972 973 TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolOnConnectFailure) { 974 // Alternate-protocol job will fail before creating a QUIC session. 975 StaticSocketDataProvider quic_data(NULL, 0, NULL, 0); 976 quic_data.set_connect_data(MockConnect(SYNCHRONOUS, 977 ERR_INTERNET_DISCONNECTED)); 978 socket_factory_.AddSocketDataProvider(&quic_data); 979 980 // Main job which will succeed even though the alternate job fails. 981 MockRead http_reads[] = { 982 MockRead("HTTP/1.1 200 OK\r\n\r\n"), 983 MockRead("hello from http"), 984 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 985 MockRead(ASYNC, OK) 986 }; 987 988 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 989 NULL, 0); 990 socket_factory_.AddSocketDataProvider(&http_data); 991 992 CreateSessionWithNextProtos(); 993 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); 994 SendRequestAndExpectHttpResponse("hello from http"); 995 996 ExpectBrokenAlternateProtocolMapping(); 997 } 998 999 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) { 1000 MockQuicData mock_quic_data; 1001 mock_quic_data.AddRead(ConstructConnectionClosePacket(1)); 1002 mock_quic_data.AddWrite( 1003 ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true, 1004 GetRequestHeaders("GET", "http", "/"))); 1005 mock_quic_data.AddWrite(ConstructAckPacket(2, 1)); 1006 mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 0); 1007 1008 // When the QUIC connection fails, we will try the request again over HTTP. 1009 MockRead http_reads[] = { 1010 MockRead("HTTP/1.1 200 OK\r\n"), 1011 MockRead(kQuicAlternateProtocolHttpHeader), 1012 MockRead("hello world"), 1013 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), 1014 MockRead(ASYNC, OK) 1015 }; 1016 1017 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 1018 NULL, 0); 1019 socket_factory_.AddSocketDataProvider(&http_data); 1020 1021 // In order for a new QUIC session to be established via alternate-protocol 1022 // without racing an HTTP connection, we need the host resolution to happen 1023 // synchronously. 1024 host_resolver_.set_synchronous_mode(true); 1025 host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", ""); 1026 HostResolver::RequestInfo info(HostPortPair("www.google.com", 80)); 1027 AddressList address; 1028 host_resolver_.Resolve(info, 1029 DEFAULT_PRIORITY, 1030 &address, 1031 CompletionCallback(), 1032 NULL, 1033 net_log_.bound()); 1034 1035 CreateSessionWithNextProtos(); 1036 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); 1037 SendRequestAndExpectHttpResponse("hello world"); 1038 } 1039 1040 } // namespace test 1041 } // namespace net 1042
