| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <algorithm> |
| #include <ostream> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/bind.h" |
| #include "base/compiler_specific.h" |
| #include "base/macros.h" |
| #include "base/run_loop.h" |
| #include "base/stl_util.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/string_piece.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "net/base/chunked_upload_data_stream.h" |
| #include "net/base/completion_once_callback.h" |
| #include "net/base/ip_endpoint.h" |
| #include "net/base/mock_network_change_notifier.h" |
| #include "net/base/test_completion_callback.h" |
| #include "net/base/test_proxy_delegate.h" |
| #include "net/cert/ct_policy_enforcer.h" |
| #include "net/cert/mock_cert_verifier.h" |
| #include "net/cert/multi_log_ct_verifier.h" |
| #include "net/dns/mock_host_resolver.h" |
| #include "net/http/http_auth_handler_factory.h" |
| #include "net/http/http_network_session.h" |
| #include "net/http/http_network_transaction.h" |
| #include "net/http/http_server_properties_impl.h" |
| #include "net/http/http_stream.h" |
| #include "net/http/http_stream_factory.h" |
| #include "net/http/http_transaction_test_util.h" |
| #include "net/http/transport_security_state.h" |
| #include "net/log/net_log_event_type.h" |
| #include "net/log/test_net_log.h" |
| #include "net/log/test_net_log_entry.h" |
| #include "net/log/test_net_log_util.h" |
| #include "net/proxy_resolution/proxy_config_service_fixed.h" |
| #include "net/proxy_resolution/proxy_resolution_service.h" |
| #include "net/proxy_resolution/proxy_resolver.h" |
| #include "net/quic/crypto/proof_verifier_chromium.h" |
| #include "net/quic/mock_crypto_client_stream_factory.h" |
| #include "net/quic/mock_quic_data.h" |
| #include "net/quic/quic_chromium_alarm_factory.h" |
| #include "net/quic/quic_http_stream.h" |
| #include "net/quic/quic_http_utils.h" |
| #include "net/quic/quic_stream_factory_peer.h" |
| #include "net/quic/quic_test_packet_maker.h" |
| #include "net/quic/test_task_runner.h" |
| #include "net/socket/client_socket_factory.h" |
| #include "net/socket/mock_client_socket_pool_manager.h" |
| #include "net/socket/next_proto.h" |
| #include "net/socket/socket_performance_watcher.h" |
| #include "net/socket/socket_performance_watcher_factory.h" |
| #include "net/socket/socket_test_util.h" |
| #include "net/spdy/spdy_test_util_common.h" |
| #include "net/ssl/ssl_config_service_defaults.h" |
| #include "net/test/cert_test_util.h" |
| #include "net/test/gtest_util.h" |
| #include "net/test/test_data_directory.h" |
| #include "net/test/test_with_scoped_task_environment.h" |
| #include "net/third_party/quic/core/crypto/quic_decrypter.h" |
| #include "net/third_party/quic/core/crypto/quic_encrypter.h" |
| #include "net/third_party/quic/core/quic_framer.h" |
| #include "net/third_party/quic/core/quic_utils.h" |
| #include "net/third_party/quic/platform/api/quic_str_cat.h" |
| #include "net/third_party/quic/platform/api/quic_string_piece.h" |
| #include "net/third_party/quic/platform/api/quic_test.h" |
| #include "net/third_party/quic/test_tools/crypto_test_utils.h" |
| #include "net/third_party/quic/test_tools/mock_clock.h" |
| #include "net/third_party/quic/test_tools/mock_random.h" |
| #include "net/third_party/quic/test_tools/quic_spdy_session_peer.h" |
| #include "net/third_party/quic/test_tools/quic_test_utils.h" |
| #include "net/third_party/quiche/src/spdy/core/spdy_frame_builder.h" |
| #include "net/third_party/quiche/src/spdy/core/spdy_framer.h" |
| #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" |
| #include "net/url_request/url_request.h" |
| #include "net/url_request/url_request_job_factory_impl.h" |
| #include "net/url_request/url_request_test_util.h" |
| #include "starboard/string.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "testing/platform_test.h" |
| #include "url/gurl.h" |
| |
| using ::testing::ElementsAre; |
| using ::testing::Key; |
| |
| namespace net { |
| namespace test { |
| |
| namespace { |
| |
| enum DestinationType { |
| // In pooling tests with two requests for different origins to the same |
| // destination, the destination should be |
| SAME_AS_FIRST, // the same as the first origin, |
| SAME_AS_SECOND, // the same as the second origin, or |
| DIFFERENT, // different from both. |
| }; |
| |
| static const char kQuicAlternativeServiceHeader[] = |
| "Alt-Svc: quic=\":443\"\r\n\r\n"; |
| static const char kQuicAlternativeServiceWithProbabilityHeader[] = |
| "Alt-Svc: quic=\":443\";p=\".5\"\r\n\r\n"; |
| static const char kQuicAlternativeServiceDifferentPortHeader[] = |
| "Alt-Svc: quic=\":137\"\r\n\r\n"; |
| |
| const char kDefaultServerHostName[] = "mail.example.org"; |
| const char kDifferentHostname[] = "different.example.com"; |
| |
| // Run QuicNetworkTransactionWithDestinationTest instances with all value |
| // combinations of version and destination_type. |
| struct PoolingTestParams { |
| friend std::ostream& operator<<(std::ostream& os, |
| const PoolingTestParams& p) { |
| os << "{ version: " << QuicVersionToString(p.version) |
| << ", destination_type: "; |
| switch (p.destination_type) { |
| case SAME_AS_FIRST: |
| os << "SAME_AS_FIRST"; |
| break; |
| case SAME_AS_SECOND: |
| os << "SAME_AS_SECOND"; |
| break; |
| case DIFFERENT: |
| os << "DIFFERENT"; |
| break; |
| } |
| os << ", client_headers_include_h2_stream_dependency: " |
| << p.client_headers_include_h2_stream_dependency; |
| os << " }"; |
| return os; |
| } |
| |
| quic::QuicTransportVersion version; |
| DestinationType destination_type; |
| bool client_headers_include_h2_stream_dependency; |
| }; |
| |
| std::string GenerateQuicVersionsListForAltSvcHeader( |
| const quic::QuicTransportVersionVector& versions) { |
| std::string result = ""; |
| for (const quic::QuicTransportVersion& version : versions) { |
| if (!result.empty()) |
| result.append(","); |
| result.append(base::NumberToString(version)); |
| } |
| return result; |
| } |
| |
| std::vector<PoolingTestParams> GetPoolingTestParams() { |
| std::vector<PoolingTestParams> params; |
| quic::QuicTransportVersionVector all_supported_versions = |
| quic::AllSupportedTransportVersions(); |
| for (const quic::QuicTransportVersion version : all_supported_versions) { |
| params.push_back(PoolingTestParams{version, SAME_AS_FIRST, false}); |
| params.push_back(PoolingTestParams{version, SAME_AS_FIRST, true}); |
| params.push_back(PoolingTestParams{version, SAME_AS_SECOND, false}); |
| params.push_back(PoolingTestParams{version, SAME_AS_SECOND, true}); |
| params.push_back(PoolingTestParams{version, DIFFERENT, false}); |
| params.push_back(PoolingTestParams{version, DIFFERENT, true}); |
| } |
| return params; |
| } |
| |
| } // namespace |
| |
| class HeadersHandler { |
| public: |
| HeadersHandler() : was_proxied_(false) {} |
| |
| bool was_proxied() { return was_proxied_; } |
| |
| void OnBeforeHeadersSent(const ProxyInfo& proxy_info, |
| HttpRequestHeaders* request_headers) { |
| if (!proxy_info.is_http() && !proxy_info.is_https() && |
| !proxy_info.is_quic()) { |
| return; |
| } |
| was_proxied_ = true; |
| } |
| |
| private: |
| bool was_proxied_; |
| }; |
| |
| class TestSocketPerformanceWatcher : public SocketPerformanceWatcher { |
| public: |
| TestSocketPerformanceWatcher(bool* should_notify_updated_rtt, |
| bool* rtt_notification_received) |
| : should_notify_updated_rtt_(should_notify_updated_rtt), |
| rtt_notification_received_(rtt_notification_received) {} |
| ~TestSocketPerformanceWatcher() override {} |
| |
| bool ShouldNotifyUpdatedRTT() const override { |
| return *should_notify_updated_rtt_; |
| } |
| |
| void OnUpdatedRTTAvailable(const base::TimeDelta& rtt) override { |
| *rtt_notification_received_ = true; |
| } |
| |
| void OnConnectionChanged() override {} |
| |
| private: |
| bool* should_notify_updated_rtt_; |
| bool* rtt_notification_received_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcher); |
| }; |
| |
| class TestSocketPerformanceWatcherFactory |
| : public SocketPerformanceWatcherFactory { |
| public: |
| TestSocketPerformanceWatcherFactory() |
| : watcher_count_(0u), |
| should_notify_updated_rtt_(true), |
| rtt_notification_received_(false) {} |
| ~TestSocketPerformanceWatcherFactory() override {} |
| |
| // SocketPerformanceWatcherFactory implementation: |
| std::unique_ptr<SocketPerformanceWatcher> CreateSocketPerformanceWatcher( |
| const Protocol protocol, |
| const AddressList& /* address_list */) override { |
| if (protocol != PROTOCOL_QUIC) { |
| return nullptr; |
| } |
| ++watcher_count_; |
| return std::unique_ptr<SocketPerformanceWatcher>( |
| new TestSocketPerformanceWatcher(&should_notify_updated_rtt_, |
| &rtt_notification_received_)); |
| } |
| |
| size_t watcher_count() const { return watcher_count_; } |
| |
| bool rtt_notification_received() const { return rtt_notification_received_; } |
| |
| void set_should_notify_updated_rtt(bool should_notify_updated_rtt) { |
| should_notify_updated_rtt_ = should_notify_updated_rtt; |
| } |
| |
| private: |
| size_t watcher_count_; |
| bool should_notify_updated_rtt_; |
| bool rtt_notification_received_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcherFactory); |
| }; |
| |
| class QuicNetworkTransactionTest |
| : public PlatformTest, |
| public ::testing::WithParamInterface< |
| std::tuple<quic::QuicTransportVersion, bool>>, |
| public WithScopedTaskEnvironment { |
| protected: |
| QuicNetworkTransactionTest() |
| : version_(std::get<0>(GetParam())), |
| client_headers_include_h2_stream_dependency_(std::get<1>(GetParam())), |
| supported_versions_(quic::test::SupportedTransportVersions(version_)), |
| random_generator_(0), |
| client_maker_( |
| version_, |
| quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| &clock_, |
| kDefaultServerHostName, |
| quic::Perspective::IS_CLIENT, |
| client_headers_include_h2_stream_dependency_), |
| server_maker_( |
| version_, |
| quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| &clock_, |
| kDefaultServerHostName, |
| quic::Perspective::IS_SERVER, |
| false), |
| cert_transparency_verifier_(new MultiLogCTVerifier()), |
| ssl_config_service_(new SSLConfigServiceDefaults), |
| proxy_resolution_service_(ProxyResolutionService::CreateDirect()), |
| #if defined(COBALT_QUIC46) |
| // m70 code. |
| auth_handler_factory_( |
| HttpAuthHandlerFactory::CreateDefault(nullptr)), |
| #else |
| auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()), |
| #endif |
| ssl_data_(ASYNC, OK) { |
| request_.method = "GET"; |
| std::string url("https://"); |
| url.append(kDefaultServerHostName); |
| request_.url = GURL(url); |
| request_.load_flags = 0; |
| request_.traffic_annotation = |
| net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
| clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20)); |
| |
| scoped_refptr<X509Certificate> cert( |
| ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
| verify_details_.cert_verify_result.verified_cert = cert; |
| verify_details_.cert_verify_result.is_issued_by_known_root = true; |
| crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
| } |
| |
| void SetUp() override { |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| void TearDown() override { |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| // Empty the current queue. |
| base::RunLoop().RunUntilIdle(); |
| PlatformTest::TearDown(); |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| base::RunLoop().RunUntilIdle(); |
| session_.reset(); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientConnectionClosePacket(uint64_t num) { |
| return client_maker_.MakeConnectionClosePacket( |
| num, false, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructServerConnectionClosePacket(uint64_t num) { |
| return server_maker_.MakeConnectionClosePacket( |
| num, false, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerGoAwayPacket( |
| uint64_t num, |
| quic::QuicErrorCode error_code, |
| std::string reason_phrase) { |
| return server_maker_.MakeGoAwayPacket(num, error_code, reason_phrase); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket( |
| uint64_t packet_number, |
| uint64_t largest_received, |
| uint64_t smallest_received, |
| uint64_t least_unacked) { |
| return client_maker_.MakeAckPacket(packet_number, largest_received, |
| smallest_received, least_unacked, true); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket( |
| uint64_t packet_number, |
| uint64_t largest_received, |
| uint64_t smallest_received, |
| uint64_t least_unacked, |
| quic::QuicTime::Delta ack_delay_time) { |
| return client_maker_.MakeAckPacket(packet_number, largest_received, |
| smallest_received, least_unacked, true, |
| ack_delay_time); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckAndRstPacket( |
| uint64_t num, |
| quic::QuicStreamId stream_id, |
| quic::QuicRstStreamErrorCode error_code, |
| uint64_t largest_received, |
| uint64_t smallest_received, |
| uint64_t least_unacked) { |
| return client_maker_.MakeAckAndRstPacket( |
| num, false, stream_id, error_code, largest_received, smallest_received, |
| least_unacked, true); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientRstPacket( |
| uint64_t num, |
| quic::QuicStreamId stream_id, |
| quic::QuicRstStreamErrorCode error_code, |
| size_t bytes_written) { |
| return client_maker_.MakeRstPacket(num, false, stream_id, error_code, |
| bytes_written, |
| /*include_stop_sending_if_v99=*/true); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientAckAndConnectionClosePacket(uint64_t packet_number, |
| uint64_t largest_received, |
| uint64_t smallest_received, |
| uint64_t least_unacked) { |
| return client_maker_.MakeAckPacket(packet_number, largest_received, |
| smallest_received, least_unacked, true); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientAckAndConnectionClosePacket( |
| uint64_t num, |
| quic::QuicTime::Delta delta_time_largest_observed, |
| uint64_t largest_received, |
| uint64_t smallest_received, |
| uint64_t least_unacked, |
| quic::QuicErrorCode quic_error, |
| const std::string& quic_error_details) { |
| return client_maker_.MakeAckAndConnectionClosePacket( |
| num, false, delta_time_largest_observed, largest_received, |
| smallest_received, least_unacked, quic_error, quic_error_details); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerRstPacket( |
| uint64_t num, |
| bool include_version, |
| quic::QuicStreamId stream_id, |
| quic::QuicRstStreamErrorCode error_code) { |
| return server_maker_.MakeRstPacket(num, include_version, stream_id, |
| error_code); |
| } |
| |
| std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket( |
| uint64_t packet_number, |
| quic::QuicStreamOffset* offset) { |
| return client_maker_.MakeInitialSettingsPacket(packet_number, offset); |
| } |
| |
| std::unique_ptr<quic::QuicReceivedPacket> ConstructServerAckPacket( |
| uint64_t packet_number, |
| uint64_t largest_received, |
| uint64_t smallest_received, |
| uint64_t least_unacked) { |
| return server_maker_.MakeAckPacket(packet_number, largest_received, |
| smallest_received, least_unacked, false); |
| } |
| |
| std::unique_ptr<quic::QuicReceivedPacket> ConstructClientPriorityPacket( |
| uint64_t packet_number, |
| bool should_include_version, |
| quic::QuicStreamId id, |
| quic::QuicStreamId parent_stream_id, |
| RequestPriority request_priority, |
| quic::QuicStreamOffset* offset) { |
| return client_maker_.MakePriorityPacket( |
| packet_number, should_include_version, id, parent_stream_id, |
| ConvertRequestPriorityToQuicPriority(request_priority), offset); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientAckAndPriorityFramesPacket( |
| uint64_t packet_number, |
| bool should_include_version, |
| uint64_t largest_received, |
| uint64_t smallest_received, |
| uint64_t least_unacked, |
| const std::vector<QuicTestPacketMaker::Http2StreamDependency>& |
| priority_frames, |
| quic::QuicStreamOffset* offset) { |
| return client_maker_.MakeAckAndMultiplePriorityFramesPacket( |
| packet_number, should_include_version, largest_received, |
| smallest_received, least_unacked, priority_frames, offset); |
| } |
| |
| // Uses default QuicTestPacketMaker. |
| spdy::SpdyHeaderBlock GetRequestHeaders(const std::string& method, |
| const std::string& scheme, |
| const std::string& path) { |
| return GetRequestHeaders(method, scheme, path, &client_maker_); |
| } |
| |
| // Uses customized QuicTestPacketMaker. |
| spdy::SpdyHeaderBlock GetRequestHeaders(const std::string& method, |
| const std::string& scheme, |
| const std::string& path, |
| QuicTestPacketMaker* maker) { |
| return maker->GetRequestHeaders(method, scheme, path); |
| } |
| |
| spdy::SpdyHeaderBlock ConnectRequestHeaders(const std::string& host_port) { |
| return client_maker_.ConnectRequestHeaders(host_port); |
| } |
| |
| spdy::SpdyHeaderBlock GetResponseHeaders(const std::string& status) { |
| return server_maker_.GetResponseHeaders(status); |
| } |
| |
| // Appends alt_svc headers in the response headers. |
| spdy::SpdyHeaderBlock GetResponseHeaders(const std::string& status, |
| const std::string& alt_svc) { |
| return server_maker_.GetResponseHeaders(status, alt_svc); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerDataPacket( |
| uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| quic::QuicStreamOffset offset, |
| quic::QuicStringPiece data) { |
| return server_maker_.MakeDataPacket( |
| packet_number, stream_id, should_include_version, fin, offset, data); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientDataPacket( |
| uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| quic::QuicStreamOffset offset, |
| quic::QuicStringPiece data) { |
| return client_maker_.MakeDataPacket( |
| packet_number, stream_id, should_include_version, fin, offset, data); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientMultipleDataFramesPacket( |
| uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| quic::QuicStreamOffset offset, |
| const std::vector<std::string> data_writes) { |
| return client_maker_.MakeMultipleDataFramesPacket(packet_number, stream_id, |
| should_include_version, |
| fin, offset, data_writes); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckAndDataPacket( |
| uint64_t packet_number, |
| bool include_version, |
| quic::QuicStreamId stream_id, |
| uint64_t largest_received, |
| uint64_t smallest_received, |
| uint64_t least_unacked, |
| bool fin, |
| quic::QuicStreamOffset offset, |
| quic::QuicStringPiece data) { |
| return client_maker_.MakeAckAndDataPacket( |
| packet_number, include_version, stream_id, largest_received, |
| smallest_received, least_unacked, fin, offset, data); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientAckAndMultipleDataFramesPacket( |
| uint64_t packet_number, |
| bool include_version, |
| quic::QuicStreamId stream_id, |
| uint64_t largest_received, |
| uint64_t smallest_received, |
| uint64_t least_unacked, |
| bool fin, |
| quic::QuicStreamOffset offset, |
| const std::vector<std::string> data_writes) { |
| return client_maker_.MakeAckAndMultipleDataFramesPacket( |
| packet_number, include_version, stream_id, largest_received, |
| smallest_received, least_unacked, fin, offset, data_writes); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientForceHolDataPacket( |
| uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| quic::QuicStreamOffset* offset, |
| quic::QuicStringPiece data) { |
| return client_maker_.MakeForceHolDataPacket( |
| packet_number, stream_id, should_include_version, fin, offset, data); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientRequestHeadersPacket(uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| spdy::SpdyHeaderBlock headers) { |
| return ConstructClientRequestHeadersPacket(packet_number, stream_id, |
| should_include_version, fin, |
| std::move(headers), nullptr); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientRequestHeadersPacket(uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| spdy::SpdyHeaderBlock headers, |
| quic::QuicStreamOffset* offset) { |
| return ConstructClientRequestHeadersPacket(packet_number, stream_id, |
| should_include_version, fin, |
| std::move(headers), 0, offset); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientRequestHeadersPacket(uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| spdy::SpdyHeaderBlock headers, |
| quic::QuicStreamId parent_stream_id, |
| quic::QuicStreamOffset* offset) { |
| return ConstructClientRequestHeadersPacket( |
| packet_number, stream_id, should_include_version, fin, DEFAULT_PRIORITY, |
| std::move(headers), parent_stream_id, offset); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientRequestHeadersPacket(uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| RequestPriority request_priority, |
| spdy::SpdyHeaderBlock headers, |
| quic::QuicStreamId parent_stream_id, |
| quic::QuicStreamOffset* offset) { |
| spdy::SpdyPriority priority = |
| ConvertRequestPriorityToQuicPriority(request_priority); |
| return client_maker_.MakeRequestHeadersPacketWithOffsetTracking( |
| packet_number, stream_id, should_include_version, fin, priority, |
| std::move(headers), parent_stream_id, offset); |
| } |
| |
| std::unique_ptr<quic::QuicReceivedPacket> |
| ConstructClientRequestHeadersAndDataFramesPacket( |
| uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| RequestPriority request_priority, |
| spdy::SpdyHeaderBlock headers, |
| quic::QuicStreamId parent_stream_id, |
| quic::QuicStreamOffset* offset, |
| size_t* spdy_headers_frame_length, |
| const std::vector<std::string>& data_writes) { |
| spdy::SpdyPriority priority = |
| ConvertRequestPriorityToQuicPriority(request_priority); |
| return client_maker_.MakeRequestHeadersAndMultipleDataFramesPacket( |
| packet_number, stream_id, should_include_version, fin, priority, |
| std::move(headers), parent_stream_id, offset, spdy_headers_frame_length, |
| data_writes); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructClientMultipleDataFramesPacket(uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| const std::vector<std::string>& data, |
| quic::QuicStreamOffset offset) { |
| return client_maker_.MakeMultipleDataFramesPacket( |
| packet_number, stream_id, should_include_version, fin, offset, data); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerPushPromisePacket( |
| uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| quic::QuicStreamId promised_stream_id, |
| bool should_include_version, |
| spdy::SpdyHeaderBlock headers, |
| quic::QuicStreamOffset* offset, |
| QuicTestPacketMaker* maker) { |
| return maker->MakePushPromisePacket( |
| packet_number, stream_id, promised_stream_id, should_include_version, |
| false, std::move(headers), nullptr, offset); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructServerResponseHeadersPacket(uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| spdy::SpdyHeaderBlock headers) { |
| return ConstructServerResponseHeadersPacket(packet_number, stream_id, |
| should_include_version, fin, |
| std::move(headers), nullptr); |
| } |
| |
| std::unique_ptr<quic::QuicEncryptedPacket> |
| ConstructServerResponseHeadersPacket(uint64_t packet_number, |
| quic::QuicStreamId stream_id, |
| bool should_include_version, |
| bool fin, |
| spdy::SpdyHeaderBlock headers, |
| quic::QuicStreamOffset* offset) { |
| return server_maker_.MakeResponseHeadersPacketWithOffsetTracking( |
| packet_number, stream_id, should_include_version, fin, |
| std::move(headers), offset); |
| } |
| |
| quic::QuicString ConstructDataHeader(size_t body_len) { |
| if (version_ != quic::QUIC_VERSION_99) { |
| return ""; |
| } |
| quic::HttpEncoder encoder; |
| std::unique_ptr<char[]> buffer; |
| auto header_length = encoder.SerializeDataFrameHeader(body_len, &buffer); |
| return quic::QuicString(buffer.get(), header_length); |
| } |
| |
| void CreateSession( |
| const quic::QuicTransportVersionVector& supported_versions) { |
| session_params_.enable_quic = true; |
| session_params_.quic_supported_versions = supported_versions; |
| session_params_.quic_headers_include_h2_stream_dependency = |
| client_headers_include_h2_stream_dependency_; |
| |
| session_context_.quic_clock = &clock_; |
| session_context_.quic_random = &random_generator_; |
| session_context_.client_socket_factory = &socket_factory_; |
| session_context_.quic_crypto_client_stream_factory = |
| &crypto_client_stream_factory_; |
| session_context_.host_resolver = &host_resolver_; |
| session_context_.cert_verifier = &cert_verifier_; |
| session_context_.transport_security_state = &transport_security_state_; |
| session_context_.cert_transparency_verifier = |
| cert_transparency_verifier_.get(); |
| session_context_.ct_policy_enforcer = &ct_policy_enforcer_; |
| session_context_.socket_performance_watcher_factory = |
| &test_socket_performance_watcher_factory_; |
| session_context_.proxy_resolution_service = proxy_resolution_service_.get(); |
| session_context_.ssl_config_service = ssl_config_service_.get(); |
| session_context_.http_auth_handler_factory = auth_handler_factory_.get(); |
| session_context_.http_server_properties = &http_server_properties_; |
| session_context_.net_log = net_log_.bound().net_log(); |
| |
| session_.reset(new HttpNetworkSession(session_params_, session_context_)); |
| session_->quic_stream_factory()->set_require_confirmation(false); |
| SpdySessionPoolPeer spdy_pool_peer(session_->spdy_session_pool()); |
| spdy_pool_peer.SetEnableSendingInitialData(false); |
| } |
| |
| void CreateSession() { return CreateSession(supported_versions_); } |
| |
| void CheckWasQuicResponse(HttpNetworkTransaction* trans) { |
| const HttpResponseInfo* response = trans->GetResponseInfo(); |
| ASSERT_TRUE(response != nullptr); |
| ASSERT_TRUE(response->headers.get() != nullptr); |
| EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| EXPECT_TRUE(response->was_fetched_via_spdy); |
| EXPECT_TRUE(response->was_alpn_negotiated); |
| EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_), |
| response->connection_info); |
| } |
| |
| void CheckResponsePort(HttpNetworkTransaction* trans, uint16_t port) { |
| const HttpResponseInfo* response = trans->GetResponseInfo(); |
| ASSERT_TRUE(response != nullptr); |
| #if defined(COBALT_QUIC46) |
| EXPECT_EQ(port, response->socket_address.port()); |
| #else |
| EXPECT_EQ(port, response->remote_endpoint.port()); |
| #endif |
| } |
| |
| void CheckWasHttpResponse(HttpNetworkTransaction* trans) { |
| const HttpResponseInfo* response = trans->GetResponseInfo(); |
| ASSERT_TRUE(response != nullptr); |
| ASSERT_TRUE(response->headers.get() != nullptr); |
| EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| EXPECT_FALSE(response->was_fetched_via_spdy); |
| EXPECT_FALSE(response->was_alpn_negotiated); |
| EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1_1, |
| response->connection_info); |
| } |
| |
| void CheckWasSpdyResponse(HttpNetworkTransaction* trans) { |
| const HttpResponseInfo* response = trans->GetResponseInfo(); |
| ASSERT_TRUE(response != nullptr); |
| ASSERT_TRUE(response->headers.get() != nullptr); |
| EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); |
| EXPECT_TRUE(response->was_fetched_via_spdy); |
| EXPECT_TRUE(response->was_alpn_negotiated); |
| EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP2, |
| response->connection_info); |
| } |
| |
| void CheckResponseData(HttpNetworkTransaction* trans, |
| const std::string& expected) { |
| std::string response_data; |
| ASSERT_THAT(ReadTransaction(trans, &response_data), IsOk()); |
| EXPECT_EQ(expected, response_data); |
| } |
| |
| void RunTransaction(HttpNetworkTransaction* trans) { |
| TestCompletionCallback callback; |
| int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| } |
| |
| void SendRequestAndExpectHttpResponse(const std::string& expected) { |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| RunTransaction(&trans); |
| CheckWasHttpResponse(&trans); |
| CheckResponseData(&trans, expected); |
| } |
| |
| void SendRequestAndExpectHttpResponseFromProxy(const std::string& expected, |
| bool used_proxy, |
| uint16_t port) { |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| HeadersHandler headers_handler; |
| trans.SetBeforeHeadersSentCallback( |
| base::Bind(&HeadersHandler::OnBeforeHeadersSent, |
| base::Unretained(&headers_handler))); |
| RunTransaction(&trans); |
| CheckWasHttpResponse(&trans); |
| CheckResponsePort(&trans, port); |
| CheckResponseData(&trans, expected); |
| EXPECT_EQ(used_proxy, headers_handler.was_proxied()); |
| if (used_proxy) { |
| EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_https()); |
| } else { |
| EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_direct()); |
| } |
| } |
| |
| void SendRequestAndExpectQuicResponse(const std::string& expected) { |
| SendRequestAndExpectQuicResponseMaybeFromProxy(expected, false, 443); |
| } |
| |
| void SendRequestAndExpectQuicResponseFromProxyOnPort( |
| const std::string& expected, |
| uint16_t port) { |
| SendRequestAndExpectQuicResponseMaybeFromProxy(expected, true, port); |
| } |
| |
| void AddQuicAlternateProtocolMapping( |
| MockCryptoClientStream::HandshakeMode handshake_mode) { |
| crypto_client_stream_factory_.set_handshake_mode(handshake_mode); |
| url::SchemeHostPort server(request_.url); |
| AlternativeService alternative_service(kProtoQUIC, server.host(), 443); |
| base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
| http_server_properties_.SetQuicAlternativeService( |
| server, alternative_service, expiration, supported_versions_); |
| } |
| |
| void AddQuicRemoteAlternativeServiceMapping( |
| MockCryptoClientStream::HandshakeMode handshake_mode, |
| const HostPortPair& alternative) { |
| crypto_client_stream_factory_.set_handshake_mode(handshake_mode); |
| url::SchemeHostPort server(request_.url); |
| AlternativeService alternative_service(kProtoQUIC, alternative.host(), |
| alternative.port()); |
| base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
| http_server_properties_.SetQuicAlternativeService( |
| server, alternative_service, expiration, supported_versions_); |
| } |
| |
| void ExpectBrokenAlternateProtocolMapping() { |
| const url::SchemeHostPort server(request_.url); |
| const AlternativeServiceInfoVector alternative_service_info_vector = |
| http_server_properties_.GetAlternativeServiceInfos(server); |
| EXPECT_EQ(1u, alternative_service_info_vector.size()); |
| EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken( |
| alternative_service_info_vector[0].alternative_service())); |
| } |
| |
| void ExpectQuicAlternateProtocolMapping() { |
| const url::SchemeHostPort server(request_.url); |
| const AlternativeServiceInfoVector alternative_service_info_vector = |
| http_server_properties_.GetAlternativeServiceInfos(server); |
| EXPECT_EQ(1u, alternative_service_info_vector.size()); |
| EXPECT_EQ( |
| kProtoQUIC, |
| alternative_service_info_vector[0].alternative_service().protocol); |
| EXPECT_FALSE(http_server_properties_.IsAlternativeServiceBroken( |
| alternative_service_info_vector[0].alternative_service())); |
| } |
| |
| void AddHangingNonAlternateProtocolSocketData() { |
| std::unique_ptr<StaticSocketDataProvider> hanging_data; |
| hanging_data.reset(new StaticSocketDataProvider()); |
| MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING); |
| hanging_data->set_connect_data(hanging_connect); |
| hanging_data_.push_back(std::move(hanging_data)); |
| socket_factory_.AddSocketDataProvider(hanging_data_.back().get()); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| } |
| |
| void SetUpTestForRetryConnectionOnAlternateNetwork() { |
| session_params_.quic_migrate_sessions_on_network_change_v2 = true; |
| session_params_.quic_migrate_sessions_early_v2 = true; |
| session_params_.quic_retry_on_alternate_network_before_handshake = true; |
| scoped_mock_change_notifier_.reset(new ScopedMockNetworkChangeNotifier()); |
| MockNetworkChangeNotifier* mock_ncn = |
| scoped_mock_change_notifier_->mock_network_change_notifier(); |
| mock_ncn->ForceNetworkHandlesSupported(); |
| mock_ncn->SetConnectedNetworksList( |
| {kDefaultNetworkForTests, kNewNetworkForTests}); |
| } |
| |
| // Fetches two non-cryptographic URL requests via a HTTPS proxy with a QUIC |
| // alternative proxy. Verifies that if the alternative proxy job returns |
| // |error_code|, the request is fetched successfully by the main job. |
| void TestAlternativeProxy(int error_code) { |
| // Use a non-cryptographic scheme for the request URL since this request |
| // will be fetched via proxy with QUIC as the alternative service. |
| request_.url = GURL("http://example.org/"); |
| // Data for the alternative proxy server job. |
| MockWrite quic_writes[] = {MockWrite(SYNCHRONOUS, error_code, 1)}; |
| MockRead quic_reads[] = { |
| MockRead(SYNCHRONOUS, error_code, 0), |
| }; |
| |
| SequencedSocketData quic_data(quic_reads, quic_writes); |
| socket_factory_.AddSocketDataProvider(&quic_data); |
| |
| // Main job succeeds and the alternative job fails. |
| // Add data for two requests that will be read by the main job. |
| MockRead http_reads_1[] = { |
| MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| MockRead http_reads_2[] = { |
| MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data_1(http_reads_1, base::span<MockWrite>()); |
| StaticSocketDataProvider http_data_2(http_reads_2, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&http_data_1); |
| socket_factory_.AddSocketDataProvider(&http_data_2); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| TestProxyDelegate test_proxy_delegate; |
| // Proxy URL is different from the request URL. |
| test_proxy_delegate.set_alternative_proxy_server( |
| ProxyServer::FromPacString("QUIC myproxy.org:443")); |
| |
| proxy_resolution_service_ = |
| ProxyResolutionService::CreateFixedFromPacResult( |
| "HTTPS myproxy.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
| proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
| |
| CreateSession(); |
| EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_valid()); |
| |
| // The first request should be fetched via the HTTPS proxy. |
| SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443); |
| |
| // Since the main job succeeded only the alternative proxy server should be |
| // marked as bad. |
| EXPECT_THAT(session_->proxy_resolution_service()->proxy_retry_info(), |
| ElementsAre(Key("quic://myproxy.org:443"))); |
| |
| // Verify that the second request completes successfully, and the |
| // alternative proxy server job is not started. |
| SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443); |
| } |
| |
| quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) { |
| return quic::test::GetNthClientInitiatedBidirectionalStreamId(version_, n); |
| } |
| |
| quic::QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(int n) { |
| return quic::test::GetNthServerInitiatedUnidirectionalStreamId(version_, n); |
| } |
| |
| static void AddCertificate(SSLSocketDataProvider* ssl_data) { |
| ssl_data->ssl_info.cert = |
| ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"); |
| ASSERT_TRUE(ssl_data->ssl_info.cert); |
| } |
| |
| const quic::QuicTransportVersion version_; |
| const bool client_headers_include_h2_stream_dependency_; |
| quic::QuicTransportVersionVector supported_versions_; |
| QuicFlagSaver flags_; // Save/restore all QUIC flag values. |
| quic::MockClock clock_; |
| quic::test::MockRandom random_generator_; |
| QuicTestPacketMaker client_maker_; |
| QuicTestPacketMaker server_maker_; |
| std::unique_ptr<HttpNetworkSession> session_; |
| MockClientSocketFactory socket_factory_; |
| ProofVerifyDetailsChromium verify_details_; |
| MockCryptoClientStreamFactory crypto_client_stream_factory_; |
| MockHostResolver host_resolver_; |
| MockCertVerifier cert_verifier_; |
| TransportSecurityState transport_security_state_; |
| std::unique_ptr<CTVerifier> cert_transparency_verifier_; |
| DefaultCTPolicyEnforcer ct_policy_enforcer_; |
| TestSocketPerformanceWatcherFactory test_socket_performance_watcher_factory_; |
| std::unique_ptr<SSLConfigServiceDefaults> ssl_config_service_; |
| std::unique_ptr<ProxyResolutionService> proxy_resolution_service_; |
| std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_; |
| HttpServerPropertiesImpl http_server_properties_; |
| HttpNetworkSession::Params session_params_; |
| HttpNetworkSession::Context session_context_; |
| HttpRequestInfo request_; |
| BoundTestNetLog net_log_; |
| std::vector<std::unique_ptr<StaticSocketDataProvider>> hanging_data_; |
| SSLSocketDataProvider ssl_data_; |
| std::unique_ptr<ScopedMockNetworkChangeNotifier> scoped_mock_change_notifier_; |
| |
| private: |
| void SendRequestAndExpectQuicResponseMaybeFromProxy( |
| const std::string& expected, |
| bool used_proxy, |
| uint16_t port) { |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| HeadersHandler headers_handler; |
| trans.SetBeforeHeadersSentCallback( |
| base::Bind(&HeadersHandler::OnBeforeHeadersSent, |
| base::Unretained(&headers_handler))); |
| RunTransaction(&trans); |
| CheckWasQuicResponse(&trans); |
| CheckResponsePort(&trans, port); |
| CheckResponseData(&trans, expected); |
| EXPECT_EQ(used_proxy, headers_handler.was_proxied()); |
| if (used_proxy) { |
| EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_quic()); |
| } else { |
| EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_direct()); |
| } |
| } |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P( |
| VersionIncludeStreamDependencySequence, |
| QuicNetworkTransactionTest, |
| ::testing::Combine( |
| ::testing::ValuesIn(quic::AllSupportedTransportVersions()), |
| ::testing::Bool())); |
| |
| TEST_P(QuicNetworkTransactionTest, WriteErrorHandshakeConfirmed) { |
| session_params_.retry_without_alt_svc_on_quic_errors = false; |
| base::HistogramTester histograms; |
| session_params_.origins_to_force_quic_on.insert( |
| HostPortPair::FromString("mail.example.org:443")); |
| crypto_client_stream_factory_.set_handshake_mode( |
| MockCryptoClientStream::CONFIRM_HANDSHAKE); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause |
| mock_quic_data.AddRead(ASYNC, OK); // No more data to read |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| CreateSession(); |
| |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| |
| histograms.ExpectBucketCount("Net.QuicSession.WriteError", |
| -ERR_INTERNET_DISCONNECTED, 1); |
| histograms.ExpectBucketCount("Net.QuicSession.WriteError.HandshakeConfirmed", |
| -ERR_INTERNET_DISCONNECTED, 1); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, WriteErrorHandshakeConfirmedAsync) { |
| session_params_.retry_without_alt_svc_on_quic_errors = false; |
| base::HistogramTester histograms; |
| session_params_.origins_to_force_quic_on.insert( |
| HostPortPair::FromString("mail.example.org:443")); |
| crypto_client_stream_factory_.set_handshake_mode( |
| MockCryptoClientStream::CONFIRM_HANDSHAKE); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite(ASYNC, ERR_INTERNET_DISCONNECTED); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause |
| mock_quic_data.AddRead(ASYNC, OK); // No more data to read |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| CreateSession(); |
| |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| |
| histograms.ExpectBucketCount("Net.QuicSession.WriteError", |
| -ERR_INTERNET_DISCONNECTED, 1); |
| histograms.ExpectBucketCount("Net.QuicSession.WriteError.HandshakeConfirmed", |
| -ERR_INTERNET_DISCONNECTED, 1); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, SocketWatcherEnabled) { |
| session_params_.origins_to_force_quic_on.insert( |
| HostPortPair::FromString("mail.example.org:443")); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| CreateSession(); |
| test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(true); |
| |
| EXPECT_FALSE( |
| test_socket_performance_watcher_factory_.rtt_notification_received()); |
| SendRequestAndExpectQuicResponse("hello!"); |
| EXPECT_TRUE( |
| test_socket_performance_watcher_factory_.rtt_notification_received()); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, SocketWatcherDisabled) { |
| session_params_.origins_to_force_quic_on.insert( |
| HostPortPair::FromString("mail.example.org:443")); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| CreateSession(); |
| test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(false); |
| |
| EXPECT_FALSE( |
| test_socket_performance_watcher_factory_.rtt_notification_received()); |
| SendRequestAndExpectQuicResponse("hello!"); |
| EXPECT_FALSE( |
| test_socket_performance_watcher_factory_.rtt_notification_received()); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, ForceQuic) { |
| session_params_.origins_to_force_quic_on.insert( |
| HostPortPair::FromString("mail.example.org:443")); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| CreateSession(); |
| |
| SendRequestAndExpectQuicResponse("hello!"); |
| |
| // Check that the NetLog was filled reasonably. |
| TestNetLogEntry::List entries; |
| net_log_.GetEntries(&entries); |
| EXPECT_LT(0u, entries.size()); |
| |
| // Check that we logged a QUIC_SESSION_PACKET_RECEIVED. |
| int pos = ExpectLogContainsSomewhere( |
| entries, 0, NetLogEventType::QUIC_SESSION_PACKET_RECEIVED, |
| NetLogEventPhase::NONE); |
| EXPECT_LT(0, pos); |
| |
| // ... and also a TYPE_QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED. |
| pos = ExpectLogContainsSomewhere( |
| entries, 0, |
| NetLogEventType::QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED, |
| NetLogEventPhase::NONE); |
| EXPECT_LT(0, pos); |
| |
| int packet_number; |
| ASSERT_TRUE(entries[pos].GetIntegerValue("packet_number", &packet_number)); |
| EXPECT_EQ(1, packet_number); |
| |
| // ... and also a TYPE_QUIC_SESSION_PACKET_AUTHENTICATED. |
| pos = ExpectLogContainsSomewhere( |
| entries, 0, NetLogEventType::QUIC_SESSION_PACKET_AUTHENTICATED, |
| NetLogEventPhase::NONE); |
| EXPECT_LT(0, pos); |
| |
| // ... and also a QUIC_SESSION_STREAM_FRAME_RECEIVED. |
| pos = ExpectLogContainsSomewhere( |
| entries, 0, NetLogEventType::QUIC_SESSION_STREAM_FRAME_RECEIVED, |
| NetLogEventPhase::NONE); |
| EXPECT_LT(0, pos); |
| |
| int log_stream_id; |
| ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &log_stream_id)); |
| EXPECT_EQ(quic::QuicUtils::GetHeadersStreamId(version_), |
| static_cast<quic::QuicStreamId>(log_stream_id)); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, LargeResponseHeaders) { |
| session_params_.origins_to_force_quic_on.insert( |
| HostPortPair::FromString("mail.example.org:443")); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| spdy::SpdyHeaderBlock response_headers = GetResponseHeaders("200 OK"); |
| response_headers["key1"] = std::string(30000, 'A'); |
| response_headers["key2"] = std::string(30000, 'A'); |
| response_headers["key3"] = std::string(30000, 'A'); |
| response_headers["key4"] = std::string(30000, 'A'); |
| response_headers["key5"] = std::string(30000, 'A'); |
| response_headers["key6"] = std::string(30000, 'A'); |
| response_headers["key7"] = std::string(30000, 'A'); |
| response_headers["key8"] = std::string(30000, 'A'); |
| spdy::SpdyHeadersIR headers_frame( |
| GetNthClientInitiatedBidirectionalStreamId(0), |
| std::move(response_headers)); |
| spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION); |
| spdy::SpdySerializedFrame spdy_frame = |
| response_framer.SerializeFrame(headers_frame); |
| |
| uint64_t packet_number = 1; |
| size_t chunk_size = 1200; |
| for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) { |
| size_t len = std::min(chunk_size, spdy_frame.size() - offset); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| packet_number++, |
| quic::QuicUtils::GetHeadersStreamId(version_), false, false, |
| offset, base::StringPiece(spdy_frame.data() + offset, len))); |
| } |
| |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| packet_number, GetNthClientInitiatedBidirectionalStreamId(0), |
| false, true, 0, header + "hello!")); |
| mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddWrite(ASYNC, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddWrite(ASYNC, |
| ConstructClientAckPacket(4, packet_number, 3, 1)); |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| CreateSession(); |
| |
| SendRequestAndExpectQuicResponse("hello!"); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, TooLargeResponseHeaders) { |
| session_params_.retry_without_alt_svc_on_quic_errors = false; |
| session_params_.origins_to_force_quic_on.insert( |
| HostPortPair::FromString("mail.example.org:443")); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| spdy::SpdyHeaderBlock response_headers = GetResponseHeaders("200 OK"); |
| response_headers["key1"] = std::string(30000, 'A'); |
| response_headers["key2"] = std::string(30000, 'A'); |
| response_headers["key3"] = std::string(30000, 'A'); |
| response_headers["key4"] = std::string(30000, 'A'); |
| response_headers["key5"] = std::string(30000, 'A'); |
| response_headers["key6"] = std::string(30000, 'A'); |
| response_headers["key7"] = std::string(30000, 'A'); |
| response_headers["key8"] = std::string(30000, 'A'); |
| response_headers["key9"] = std::string(30000, 'A'); |
| spdy::SpdyHeadersIR headers_frame( |
| GetNthClientInitiatedBidirectionalStreamId(0), |
| std::move(response_headers)); |
| spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION); |
| spdy::SpdySerializedFrame spdy_frame = |
| response_framer.SerializeFrame(headers_frame); |
| |
| uint64_t packet_number = 1; |
| size_t chunk_size = 1200; |
| for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) { |
| size_t len = std::min(chunk_size, spdy_frame.size() - offset); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| packet_number++, |
| quic::QuicUtils::GetHeadersStreamId(version_), false, false, |
| offset, base::StringPiece(spdy_frame.data() + offset, len))); |
| } |
| |
| quic::QuicString header = ConstructDataHeader(6); |
| |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| packet_number, GetNthClientInitiatedBidirectionalStreamId(0), |
| false, true, 0, header + "hello!")); |
| mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddWrite(ASYNC, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddWrite( |
| ASYNC, ConstructClientAckAndRstPacket( |
| 4, GetNthClientInitiatedBidirectionalStreamId(0), |
| quic::QUIC_HEADERS_TOO_LARGE, packet_number, 3, 1)); |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| CreateSession(); |
| |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, ForceQuicForAll) { |
| session_params_.origins_to_force_quic_on.insert(HostPortPair()); |
| |
| AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| CreateSession(); |
| |
| SendRequestAndExpectQuicResponse("hello!"); |
| EXPECT_TRUE( |
| test_socket_performance_watcher_factory_.rtt_notification_received()); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, QuicProxy) { |
| session_params_.enable_quic = true; |
| proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
| "QUIC mail.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); // EOF |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| EXPECT_FALSE( |
| test_socket_performance_watcher_factory_.rtt_notification_received()); |
| // There is no need to set up an alternate protocol job, because |
| // no attempt will be made to speak to the proxy over TCP. |
| |
| request_.url = GURL("http://mail.example.org/"); |
| CreateSession(); |
| |
| SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70); |
| EXPECT_TRUE( |
| test_socket_performance_watcher_factory_.rtt_notification_received()); |
| } |
| |
| // Regression test for https://crbug.com/492458. Test that for an HTTP |
| // connection through a QUIC proxy, the certificate exhibited by the proxy is |
| // checked against the proxy hostname, not the origin hostname. |
| TEST_P(QuicNetworkTransactionTest, QuicProxyWithCert) { |
| const std::string origin_host = "mail.example.com"; |
| const std::string proxy_host = "www.example.org"; |
| |
| session_params_.enable_quic = true; |
| proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
| "QUIC " + proxy_host + ":70", TRAFFIC_ANNOTATION_FOR_TESTS); |
| |
| client_maker_.set_hostname(origin_host); |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| scoped_refptr<X509Certificate> cert( |
| ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
| ASSERT_TRUE(cert.get()); |
| // This certificate is valid for the proxy, but not for the origin. |
| EXPECT_TRUE(cert->VerifyNameMatch(proxy_host)); |
| EXPECT_FALSE(cert->VerifyNameMatch(origin_host)); |
| ProofVerifyDetailsChromium verify_details; |
| verify_details.cert_verify_result.verified_cert = cert; |
| crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| ProofVerifyDetailsChromium verify_details2; |
| verify_details2.cert_verify_result.verified_cert = cert; |
| crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); |
| |
| request_.url = GURL("http://" + origin_host); |
| AddHangingNonAlternateProtocolSocketData(); |
| CreateSession(); |
| AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
| SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, AlternativeServicesDifferentHost) { |
| session_params_.quic_allow_remote_alt_svc = true; |
| HostPortPair origin("www.example.org", 443); |
| HostPortPair alternative("mail.example.org", 443); |
| |
| base::FilePath certs_dir = GetTestCertsDirectory(); |
| scoped_refptr<X509Certificate> cert( |
| ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
| ASSERT_TRUE(cert.get()); |
| // TODO(rch): the connection should be "to" the origin, so if the cert is |
| // valid for the origin but not the alternative, that should work too. |
| EXPECT_TRUE(cert->VerifyNameMatch(origin.host())); |
| EXPECT_TRUE(cert->VerifyNameMatch(alternative.host())); |
| ProofVerifyDetailsChromium verify_details; |
| verify_details.cert_verify_result.verified_cert = cert; |
| crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| |
| client_maker_.set_hostname(origin.host()); |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| request_.url = GURL("https://" + origin.host()); |
| AddQuicRemoteAlternativeServiceMapping( |
| MockCryptoClientStream::CONFIRM_HANDSHAKE, alternative); |
| AddHangingNonAlternateProtocolSocketData(); |
| CreateSession(); |
| |
| SendRequestAndExpectQuicResponse("hello!"); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, DoNotUseQuicForUnsupportedVersion) { |
| quic::QuicTransportVersion unsupported_version = |
| quic::QUIC_VERSION_UNSUPPORTED; |
| // Add support for another QUIC version besides |version_|. Also find a |
| // unsupported version. |
| for (const quic::QuicTransportVersion& version : |
| quic::AllSupportedTransportVersions()) { |
| if (version == version_) |
| continue; |
| if (supported_versions_.size() != 2) { |
| supported_versions_.push_back(version); |
| continue; |
| } |
| unsupported_version = version; |
| break; |
| } |
| DCHECK_NE(unsupported_version, quic::QUIC_VERSION_UNSUPPORTED); |
| |
| // Set up alternative service to use QUIC with a version that is not |
| // supported. |
| url::SchemeHostPort server(request_.url); |
| AlternativeService alternative_service(kProtoQUIC, kDefaultServerHostName, |
| 443); |
| base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
| http_server_properties_.SetQuicAlternativeService( |
| server, alternative_service, expiration, {unsupported_version}); |
| |
| AlternativeServiceInfoVector alt_svc_info_vector = |
| http_server_properties_.GetAlternativeServiceInfos(server); |
| EXPECT_EQ(1u, alt_svc_info_vector.size()); |
| EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); |
| EXPECT_EQ(1u, alt_svc_info_vector[0].advertised_versions().size()); |
| EXPECT_EQ(unsupported_version, |
| alt_svc_info_vector[0].advertised_versions()[0]); |
| |
| // First request should still be sent via TCP as the QUIC version advertised |
| // in the stored AlternativeService is not supported by the client. However, |
| // the response from the server will advertise new Alt-Svc with supported |
| // versions. |
| std::string advertised_versions_list_str = |
| GenerateQuicVersionsListForAltSvcHeader( |
| quic::AllSupportedTransportVersions()); |
| std::string altsvc_header = |
| base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%s\"\r\n\r\n", |
| advertised_versions_list_str.c_str()); |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| AddCertificate(&ssl_data_); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| // Second request should be sent via QUIC as a new list of verions supported |
| // by the client has been advertised by the server. |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); // EOF |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| AddHangingNonAlternateProtocolSocketData(); |
| |
| CreateSession(supported_versions_); |
| |
| SendRequestAndExpectHttpResponse("hello world"); |
| SendRequestAndExpectQuicResponse("hello!"); |
| |
| // Check alternative service list is updated with new versions. |
| alt_svc_info_vector = |
| session_->http_server_properties()->GetAlternativeServiceInfos(server); |
| EXPECT_EQ(1u, alt_svc_info_vector.size()); |
| EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); |
| EXPECT_EQ(2u, alt_svc_info_vector[0].advertised_versions().size()); |
| // Advertised versions will be lised in a sorted order. |
| std::sort(supported_versions_.begin(), supported_versions_.end()); |
| EXPECT_EQ(supported_versions_[0], |
| alt_svc_info_vector[0].advertised_versions()[0]); |
| EXPECT_EQ(supported_versions_[1], |
| alt_svc_info_vector[0].advertised_versions()[1]); |
| } |
| |
| // Regression test for https://crbug.com/546991. |
| // The server might not be able to serve a request on an alternative connection, |
| // and might send a 421 Misdirected Request response status to indicate this. |
| // HttpNetworkTransaction should reset the request and retry without using |
| // alternative services. |
| TEST_P(QuicNetworkTransactionTest, RetryMisdirectedRequest) { |
| // Set up alternative service to use QUIC. |
| // Note that |origins_to_force_quic_on| cannot be used in this test, because |
| // that overrides |enable_alternative_services|. |
| url::SchemeHostPort server(request_.url); |
| AlternativeService alternative_service(kProtoQUIC, kDefaultServerHostName, |
| 443); |
| base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
| http_server_properties_.SetQuicAlternativeService( |
| server, alternative_service, expiration, supported_versions_); |
| |
| // First try: The alternative job uses QUIC and reports an HTTP 421 |
| // Misdirected Request error. The main job uses TCP, but |http_data| below is |
| // paused at Connect(), so it will never exit the socket pool. This ensures |
| // that the alternate job always wins the race and keeps whether the |
| // |http_data| exits the socket pool before the main job is aborted |
| // deterministic. The first main job gets aborted without the socket pool ever |
| // dispensing the socket, making it available for the second try. |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset request_header_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &request_header_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| GetResponseHeaders("421"), nullptr)); |
| mock_quic_data.AddRead(ASYNC, OK); |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| // Second try: The main job uses TCP, and there is no alternate job. Once the |
| // Connect() is unblocked, |http_data| will leave the socket pool, binding to |
| // the main job of the second request. It then succeeds over HTTP/1.1. |
| // Note that if there was an alternative QUIC Job created for the second try, |
| // that would read these data, and would fail with ERR_QUIC_PROTOCOL_ERROR. |
| // Therefore this test ensures that no alternative Job is created on retry. |
| MockWrite writes[] = {MockWrite(ASYNC, 0, "GET / HTTP/1.1\r\n"), |
| MockWrite(ASYNC, 1, "Host: mail.example.org\r\n"), |
| MockWrite(ASYNC, 2, "Connection: keep-alive\r\n\r\n")}; |
| MockRead reads[] = {MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n\r\n"), |
| MockRead(ASYNC, 4, "hello!"), MockRead(ASYNC, OK, 5)}; |
| SequencedSocketData http_data(MockConnect(ASYNC, ERR_IO_PENDING) /* pause */, |
| reads, writes); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| CreateSession(); |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| |
| // Run until |mock_quic_data| has failed and |http_data| has paused. |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| base::RunLoop().RunUntilIdle(); |
| |
| // |mock_quic_data| must have run to completion. |
| EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| |
| // Now that the QUIC data has been consumed, unblock |http_data|. |
| http_data.socket()->OnConnectComplete(MockConnect()); |
| |
| // The retry logic must hide the 421 status. The transaction succeeds on |
| // |http_data|. |
| EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| CheckWasHttpResponse(&trans); |
| CheckResponsePort(&trans, 443); |
| CheckResponseData(&trans, "hello!"); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) { |
| session_params_.origins_to_force_quic_on.insert( |
| HostPortPair::FromString("mail.example.org:443")); |
| |
| MockQuicData mock_quic_data1; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data1.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data1.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED); |
| MockQuicData mock_quic_data2; |
| header_stream_offset = 0; |
| mock_quic_data2.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
| mock_quic_data2.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED); |
| crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
| |
| mock_quic_data1.AddSocketDataToFactory(&socket_factory_); |
| mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
| |
| CreateSession(); |
| |
| EXPECT_EQ(0U, test_socket_performance_watcher_factory_.watcher_count()); |
| for (size_t i = 0; i < 2; ++i) { |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED)); |
| EXPECT_EQ(1 + i, test_socket_performance_watcher_factory_.watcher_count()); |
| |
| NetErrorDetails details; |
| trans.PopulateNetErrorDetails(&details); |
| EXPECT_EQ(quic::QUIC_PACKET_READ_ERROR, details.quic_connection_error); |
| } |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, DoNotForceQuicForHttps) { |
| // Attempt to "force" quic on 443, which will not be honored. |
| session_params_.origins_to_force_quic_on.insert( |
| HostPortPair::FromString("www.google.com:443")); |
| |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider data(http_reads, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&data); |
| SSLSocketDataProvider ssl(ASYNC, OK); |
| socket_factory_.AddSSLSocketDataProvider(&ssl); |
| |
| CreateSession(); |
| |
| SendRequestAndExpectHttpResponse("hello world"); |
| EXPECT_EQ(0U, test_socket_performance_watcher_factory_.watcher_count()); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuic) { |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| AddCertificate(&ssl_data_); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); // EOF |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| AddHangingNonAlternateProtocolSocketData(); |
| CreateSession(); |
| |
| SendRequestAndExpectHttpResponse("hello world"); |
| SendRequestAndExpectQuicResponse("hello!"); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceWithVersionForQuic1) { |
| // Both server advertises and client supports two QUIC versions. |
| // Only |version_| is advertised and supported. |
| // The QuicStreamFactoy will pick up |version_|, which is verified as the |
| // PacketMakers are using |version_|. |
| |
| // Add support for another QUIC version besides |version_| on the client side. |
| // Also find a different version advertised by the server. |
| quic::QuicTransportVersion advertised_version_2 = |
| quic::QUIC_VERSION_UNSUPPORTED; |
| for (const quic::QuicTransportVersion& version : |
| quic::AllSupportedTransportVersions()) { |
| if (version == version_) |
| continue; |
| if (supported_versions_.size() != 2) { |
| supported_versions_.push_back(version); |
| continue; |
| } |
| advertised_version_2 = version; |
| break; |
| } |
| DCHECK_NE(advertised_version_2, quic::QUIC_VERSION_UNSUPPORTED); |
| |
| std::string QuicAltSvcWithVersionHeader = |
| base::StringPrintf("Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n", |
| advertised_version_2, version_); |
| |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n"), |
| MockRead(QuicAltSvcWithVersionHeader.c_str()), MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| AddCertificate(&ssl_data_); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); // EOF |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| AddHangingNonAlternateProtocolSocketData(); |
| CreateSession(supported_versions_); |
| |
| SendRequestAndExpectHttpResponse("hello world"); |
| SendRequestAndExpectQuicResponse("hello!"); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceWithVersionForQuic2) { |
| // Client and server mutually support more than one QUIC_VERSION. |
| // The QuicStreamFactoy will pick the preferred QUIC_VERSION: |version_|, |
| // which is verified as the PacketMakers are using |version_|. |
| |
| quic::QuicTransportVersion common_version_2 = quic::QUIC_VERSION_UNSUPPORTED; |
| for (const quic::QuicTransportVersion& version : |
| quic::AllSupportedTransportVersions()) { |
| if (version == version_) |
| continue; |
| common_version_2 = version; |
| break; |
| } |
| DCHECK_NE(common_version_2, quic::QUIC_VERSION_UNSUPPORTED); |
| |
| supported_versions_.push_back( |
| common_version_2); // Supported but unpreferred. |
| |
| std::string QuicAltSvcWithVersionHeader = base::StringPrintf( |
| "Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n", common_version_2, version_); |
| |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n"), |
| MockRead(QuicAltSvcWithVersionHeader.c_str()), MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| AddCertificate(&ssl_data_); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); // EOF |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| AddHangingNonAlternateProtocolSocketData(); |
| CreateSession(supported_versions_); |
| |
| SendRequestAndExpectHttpResponse("hello world"); |
| SendRequestAndExpectQuicResponse("hello!"); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, |
| UseAlternativeServiceWithProbabilityForQuic) { |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n"), |
| MockRead(kQuicAlternativeServiceWithProbabilityHeader), |
| MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| AddCertificate(&ssl_data_); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); // EOF |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| AddHangingNonAlternateProtocolSocketData(); |
| CreateSession(); |
| |
| SendRequestAndExpectHttpResponse("hello world"); |
| SendRequestAndExpectQuicResponse("hello!"); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, SetAlternativeServiceWithScheme) { |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n"), |
| MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"), |
| MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| AddCertificate(&ssl_data_); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| CreateSession(); |
| // Send https request, ignore alternative service advertising if response |
| // header advertises alternative service for mail.example.org. |
| request_.url = GURL("https://mail.example.org:443"); |
| SendRequestAndExpectHttpResponse("hello world"); |
| HttpServerProperties* http_server_properties = |
| session_->http_server_properties(); |
| url::SchemeHostPort http_server("http", "mail.example.org", 443); |
| url::SchemeHostPort https_server("https", "mail.example.org", 443); |
| // Check alternative service is set for the correct origin. |
| EXPECT_EQ( |
| 2u, |
| http_server_properties->GetAlternativeServiceInfos(https_server).size()); |
| EXPECT_TRUE( |
| http_server_properties->GetAlternativeServiceInfos(http_server).empty()); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, DoNotGetAltSvcForDifferentOrigin) { |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n"), |
| MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"), |
| MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| AddCertificate(&ssl_data_); |
| |
| socket_factory_.AddSocketDataProvider(&http_data); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| CreateSession(); |
| |
| // Send https request and set alternative services if response header |
| // advertises alternative service for mail.example.org. |
| SendRequestAndExpectHttpResponse("hello world"); |
| HttpServerProperties* http_server_properties = |
| session_->http_server_properties(); |
| |
| const url::SchemeHostPort https_server(request_.url); |
| // Check alternative service is set. |
| EXPECT_EQ( |
| 2u, |
| http_server_properties->GetAlternativeServiceInfos(https_server).size()); |
| |
| // Send http request to the same origin but with diffrent scheme, should not |
| // use QUIC. |
| request_.url = GURL("http://mail.example.org:443"); |
| SendRequestAndExpectHttpResponse("hello world"); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, |
| StoreMutuallySupportedVersionsWhenProcessAltSvc) { |
| // Add support for another QUIC version besides |version_|. |
| for (const quic::QuicTransportVersion& version : |
| quic::AllSupportedTransportVersions()) { |
| if (version == version_) |
| continue; |
| supported_versions_.push_back(version); |
| break; |
| } |
| |
| std::string advertised_versions_list_str = |
| GenerateQuicVersionsListForAltSvcHeader( |
| quic::AllSupportedTransportVersions()); |
| std::string altsvc_header = |
| base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%s\"\r\n\r\n", |
| advertised_versions_list_str.c_str()); |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| AddCertificate(&ssl_data_); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); // EOF |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| AddHangingNonAlternateProtocolSocketData(); |
| |
| CreateSession(supported_versions_); |
| |
| SendRequestAndExpectHttpResponse("hello world"); |
| SendRequestAndExpectQuicResponse("hello!"); |
| |
| // Check alternative service is set with only mutually supported versions. |
| const url::SchemeHostPort https_server(request_.url); |
| const AlternativeServiceInfoVector alt_svc_info_vector = |
| session_->http_server_properties()->GetAlternativeServiceInfos( |
| https_server); |
| EXPECT_EQ(1u, alt_svc_info_vector.size()); |
| EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); |
| EXPECT_EQ(2u, alt_svc_info_vector[0].advertised_versions().size()); |
| // Advertised versions will be lised in a sorted order. |
| std::sort(supported_versions_.begin(), supported_versions_.end()); |
| EXPECT_EQ(supported_versions_[0], |
| alt_svc_info_vector[0].advertised_versions()[0]); |
| EXPECT_EQ(supported_versions_[1], |
| alt_svc_info_vector[0].advertised_versions()[1]); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceAllSupportedVersion) { |
| std::string altsvc_header = |
| base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", version_); |
| MockRead http_reads[] = { |
| MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| MockRead("hello world"), |
| MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| MockRead(ASYNC, OK)}; |
| |
| StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| AddCertificate(&ssl_data_); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); // EOF |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| AddHangingNonAlternateProtocolSocketData(); |
| CreateSession(); |
| |
| SendRequestAndExpectHttpResponse("hello world"); |
| SendRequestAndExpectQuicResponse("hello!"); |
| } |
| |
| TEST_P(QuicNetworkTransactionTest, GoAwayWithConnectionMigrationOnPortsOnly) { |
| if (version_ == quic::QUIC_VERSION_99) { |
| // Not available under version 99 |
| return; |
| } |
| MockQuicData mock_quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| mock_quic_data.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| mock_quic_data.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| // Read a GoAway packet with |
| // quic::QuicErrorCode: quic::QUIC_ERROR_MIGRATING_PORT from the peer. |
| mock_quic_data.AddRead(SYNCHRONOUS, |
| ConstructServerGoAwayPacket( |
| 2, quic::QUIC_ERROR_MIGRATING_PORT, |
| "connection migration with port change only")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| quic::QuicString header = ConstructDataHeader(6); |
| mock_quic_data.AddRead( |
| SYNCHRONOUS, ConstructServerDataPacket( |
| 3, GetNthClientInitiatedBidirectionalStreamId(0), false, |
| true, 0, header + "hello!")); |
| mock_quic_data.AddWrite(SYNCHRONOUS, |
| ConstructClientAckAndRstPacket( |
| 4, GetNthClientInitiatedBidirectionalStreamId(0), |
| quic::QUIC_STREAM_CANCELLED, 3, 3, 1)); |
| mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| mock_quic_data.AddRead(ASYNC, 0); // EOF |
| |
| mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| // The non-alternate protocol job needs to hang in order to guarantee that |
| // the alternate-protocol job will "win". |
| AddHangingNonAlternateProtocolSocketData(); |
| |
| // In order for a new QUIC session to be established via alternate-protocol |
| // without racing an HTTP connection, we need the host resolution to happen |
| // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| // connection to the the server, in this test we require confirmation |
| // before encrypting so the HTTP job will still start. |
| host_resolver_.set_synchronous_mode(true); |
| host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| ""); |
| |
| CreateSession(); |
| session_->quic_stream_factory()->set_require_confirmation(true); |
| AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
| |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| |
| crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| quic::QuicSession::HANDSHAKE_CONFIRMED); |
| EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| |
| // Check whether this transaction is correctly marked as received a go-away |
| // because of migrating port. |
| NetErrorDetails details; |
| EXPECT_FALSE(details.quic_port_migration_detected); |
| trans.PopulateNetErrorDetails(&details); |
| EXPECT_TRUE(details.quic_port_migration_detected); |
| } |
| |
| // This test verifies that a new QUIC connection will be attempted on the |
| // alternate network if the original QUIC connection fails with idle timeout |
| // before handshake is confirmed. If TCP succeeds and QUIC fails on the |
| // alternate network as well, QUIC is marked as broken and the brokenness will |
| // not expire when default network changes. |
| TEST_P(QuicNetworkTransactionTest, QuicFailsOnBothNetworksWhileTCPSucceeds) { |
| if (version_ >= quic::QUIC_VERSION_47) { |
| // TODO(nharper): reenable once MakeDummyCHLOPacket() fixed |
| return; |
| } |
| SetUpTestForRetryConnectionOnAlternateNetwork(); |
| |
| std::string request_data; |
| client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
| |
| // The request will initially go out over QUIC. |
| MockQuicData quic_data; |
| quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read |
| int packet_num = 1; |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
| // Retranmit the handshake messages. |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| // TODO(zhongyi): remove condition check once b/115926584 is fixed. |
| if (version_ <= quic::QUIC_VERSION_39) { |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| } |
| // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT. |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeConnectionClosePacket( |
| packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| "No recent network activity.")); |
| quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| // Add successful TCP data so that TCP job will succeed. |
| MockWrite http_writes[] = { |
| MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| |
| MockRead http_reads[] = { |
| MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| MockRead(SYNCHRONOUS, 5, "TCP succeeds"), MockRead(SYNCHRONOUS, OK, 6)}; |
| SequencedSocketData http_data(http_reads, http_writes); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| // Add data for the second QUIC connection to fail. |
| MockQuicData quic_data2; |
| quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| quic_data2.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); // Write error. |
| quic_data2.AddSocketDataToFactory(&socket_factory_); |
| |
| // Resolve the host resolution synchronously. |
| host_resolver_.set_synchronous_mode(true); |
| host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| ""); |
| |
| CreateSession(); |
| session_->quic_stream_factory()->set_require_confirmation(true); |
| // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
| scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| QuicStreamFactoryPeer::SetAlarmFactory( |
| session_->quic_stream_factory(), |
| std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| &clock_)); |
| // Add alternate protocol mapping to race QUIC and TCP. |
| // QUIC connection requires handshake to be confirmed and sends CHLO to the |
| // peer. |
| AddQuicAlternateProtocolMapping( |
| MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
| |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| |
| // Pump the message loop to get the request started. |
| // Request will be served with TCP job. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| CheckResponseData(&trans, "TCP succeeds"); |
| |
| // Fire the retransmission alarm, from this point, connection will idle |
| // timeout after 4 seconds. |
| if (!GetQuicReloadableFlag( |
| quic_fix_time_of_first_packet_sent_after_receiving)) { |
| quic_task_runner_->RunNextTask(); |
| } |
| // Fast forward to idle timeout the original connection. A new connection will |
| // be kicked off on the alternate network. |
| quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4)); |
| ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| |
| // Run the message loop to execute posted tasks, which will report job status. |
| base::RunLoop().RunUntilIdle(); |
| |
| // Verify that QUIC is marked as broken. |
| ExpectBrokenAlternateProtocolMapping(); |
| |
| // Deliver a message to notify the new network becomes default, the brokenness |
| // will not expire as QUIC is broken on both networks. |
| scoped_mock_change_notifier_->mock_network_change_notifier() |
| ->NotifyNetworkMadeDefault(kNewNetworkForTests); |
| ExpectBrokenAlternateProtocolMapping(); |
| |
| ASSERT_TRUE(quic_data2.AllReadDataConsumed()); |
| ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); |
| } |
| |
| // This test verifies that a new QUIC connection will be attempted on the |
| // alternate network if the original QUIC connection fails with idle timeout |
| // before handshake is confirmed. If TCP succeeds and QUIC succeeds on the |
| // alternate network, QUIC is marked as broken. The brokenness will expire when |
| // the default network changes. |
| TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPSucceeds) { |
| if (version_ >= quic::QUIC_VERSION_47) { |
| // TODO(nharper): reenable once MakeDummyCHLOPacket() fixed |
| return; |
| } |
| SetUpTestForRetryConnectionOnAlternateNetwork(); |
| |
| std::string request_data; |
| client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
| |
| // The request will initially go out over QUIC. |
| MockQuicData quic_data; |
| quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read |
| int packet_num = 1; |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
| // Retranmit the handshake messages. |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| // TODO(zhongyi): remove condition check once b/115926584 is fixed. |
| if (version_ <= quic::QUIC_VERSION_39) { |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| } |
| // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT. |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeConnectionClosePacket( |
| packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| "No recent network activity.")); |
| quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| // Add successful TCP data so that TCP job will succeed. |
| MockWrite http_writes[] = { |
| MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| |
| MockRead http_reads[] = { |
| MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| MockRead(SYNCHRONOUS, 5, "TCP succeeds"), MockRead(SYNCHRONOUS, OK, 6)}; |
| SequencedSocketData http_data(http_reads, http_writes); |
| socket_factory_.AddSocketDataProvider(&http_data); |
| socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| |
| // Quic connection will be retried on the alternate network after the initial |
| // one fails on the default network. |
| MockQuicData quic_data2; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Handing read. |
| quic_data2.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(1)); // CHLO |
| |
| client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| quic_data2.AddWrite(SYNCHRONOUS, |
| ConstructInitialSettingsPacket(2, &header_stream_offset)); |
| quic_data2.AddSocketDataToFactory(&socket_factory_); |
| |
| // Resolve the host resolution synchronously. |
| host_resolver_.set_synchronous_mode(true); |
| host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| ""); |
| |
| CreateSession(); |
| session_->quic_stream_factory()->set_require_confirmation(true); |
| // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
| scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| QuicStreamFactoryPeer::SetAlarmFactory( |
| session_->quic_stream_factory(), |
| std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| &clock_)); |
| // Add alternate protocol mapping to race QUIC and TCP. |
| // QUIC connection requires handshake to be confirmed and sends CHLO to the |
| // peer. |
| AddQuicAlternateProtocolMapping( |
| MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
| |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| |
| // Pump the message loop to get the request started. |
| // Request will be served with TCP job. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| CheckResponseData(&trans, "TCP succeeds"); |
| |
| // Fire the retransmission alarm, after which connection will idle |
| // timeout after 4 seconds. |
| if (!GetQuicReloadableFlag( |
| quic_fix_time_of_first_packet_sent_after_receiving)) { |
| quic_task_runner_->RunNextTask(); |
| } |
| // Fast forward to idle timeout the original connection. A new connection will |
| // be kicked off on the alternate network. |
| quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4)); |
| ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| |
| // The second connection hasn't finish handshake, verify that QUIC is not |
| // marked as broken. |
| ExpectQuicAlternateProtocolMapping(); |
| // Explicitly confirm the handshake on the second connection. |
| crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| quic::QuicSession::HANDSHAKE_CONFIRMED); |
| // Run message loop to execute posted tasks, which will notify JoController |
| // about the orphaned job status. |
| base::RunLoop().RunUntilIdle(); |
| |
| // Verify that QUIC is marked as broken. |
| ExpectBrokenAlternateProtocolMapping(); |
| |
| // Deliver a message to notify the new network becomes default, the previous |
| // brokenness will be clear as the brokenness is bond with old default |
| // network. |
| scoped_mock_change_notifier_->mock_network_change_notifier() |
| ->NotifyNetworkMadeDefault(kNewNetworkForTests); |
| ExpectQuicAlternateProtocolMapping(); |
| |
| ASSERT_TRUE(quic_data2.AllReadDataConsumed()); |
| ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); |
| } |
| |
| // This test verifies that a new QUIC connection will be attempted on the |
| // alternate network if the original QUIC connection fails with idle timeout |
| // before handshake is confirmed. If TCP doesn't succeed but QUIC on the |
| // alternative network succeeds, QUIC is not marked as broken. |
| TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPHanging) { |
| if (version_ >= quic::QUIC_VERSION_47) { |
| // TODO(nharper): reenable once MakeDummyCHLOPacket() fixed |
| return; |
| } |
| SetUpTestForRetryConnectionOnAlternateNetwork(); |
| |
| std::string request_data; |
| client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
| |
| // The request will initially go out over QUIC. |
| MockQuicData quic_data; |
| quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read |
| int packet_num = 1; |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
| // Retranmit the handshake messages. |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| // TODO(zhongyi): remove condition check once b/115926584 is fixed, i.e., |
| // quic_fix_has_pending_crypto_data is introduced and enabled. |
| if (version_ <= quic::QUIC_VERSION_39) { |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| } |
| // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT. |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeConnectionClosePacket( |
| packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| "No recent network activity.")); |
| quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| // Add hanging TCP data so that TCP job will never succeeded. |
| AddHangingNonAlternateProtocolSocketData(); |
| |
| // Quic connection will then be retried on the alternate network. |
| MockQuicData quic_data2; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| quic_data2.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDummyCHLOPacket(1)); // CHLO |
| |
| const quic::QuicString body = "hello!"; |
| quic::QuicString header = ConstructDataHeader(body.length()); |
| |
| client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| quic_data2.AddWrite(SYNCHRONOUS, |
| ConstructInitialSettingsPacket(2, &header_stream_offset)); |
| quic_data2.AddWrite( |
| SYNCHRONOUS, |
| ConstructClientRequestHeadersPacket( |
| 3, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| quic_data2.AddRead( |
| ASYNC, ConstructServerResponseHeadersPacket( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| GetResponseHeaders("200 OK"))); |
| quic_data2.AddRead( |
| ASYNC, ConstructServerDataPacket( |
| 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 0, header + body)); |
| quic_data2.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(4, 2, 1, 1)); |
| quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| quic_data2.AddSocketDataToFactory(&socket_factory_); |
| |
| // Resolve the host resolution synchronously. |
| host_resolver_.set_synchronous_mode(true); |
| host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| ""); |
| |
| CreateSession(); |
| session_->quic_stream_factory()->set_require_confirmation(true); |
| // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
| scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| QuicStreamFactoryPeer::SetAlarmFactory( |
| session_->quic_stream_factory(), |
| std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| &clock_)); |
| // Add alternate protocol mapping to race QUIC and TCP. |
| // QUIC connection requires handshake to be confirmed and sends CHLO to the |
| // peer. |
| AddQuicAlternateProtocolMapping( |
| MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
| |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| |
| // Pump the message loop to get the request started. |
| base::RunLoop().RunUntilIdle(); |
| if (!GetQuicReloadableFlag( |
| quic_fix_time_of_first_packet_sent_after_receiving)) { |
| quic_task_runner_->RunNextTask(); |
| } |
| |
| // Fast forward to idle timeout the original connection. A new connection will |
| // be kicked off on the alternate network. |
| quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4)); |
| ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| |
| // Verify that QUIC is not marked as broken. |
| ExpectQuicAlternateProtocolMapping(); |
| // Explicitly confirm the handshake on the second connection. |
| crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| quic::QuicSession::HANDSHAKE_CONFIRMED); |
| |
| // Read the response. |
| EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| CheckResponseData(&trans, body); |
| // Verify that QUIC is not marked as broken. |
| ExpectQuicAlternateProtocolMapping(); |
| |
| // Deliver a message to notify the new network becomes default. |
| scoped_mock_change_notifier_->mock_network_change_notifier() |
| ->NotifyNetworkMadeDefault(kNewNetworkForTests); |
| ExpectQuicAlternateProtocolMapping(); |
| ASSERT_TRUE(quic_data2.AllReadDataConsumed()); |
| ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); |
| } |
| |
| // Verify that if a QUIC connection times out, the QuicHttpStream will |
| // return QUIC_PROTOCOL_ERROR. |
| TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmed) { |
| session_params_.retry_without_alt_svc_on_quic_errors = false; |
| session_params_.quic_idle_connection_timeout_seconds = 5; |
| |
| // The request will initially go out over QUIC. |
| MockQuicData quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| spdy::SpdyPriority priority = |
| ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| |
| std::string request_data; |
| client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| true, priority, GetRequestHeaders("GET", "https", "/"), |
| 0, nullptr, &header_stream_offset, &request_data)); |
| |
| std::string settings_data; |
| quic::QuicStreamOffset settings_offset = header_stream_offset; |
| client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 2, &header_stream_offset, &settings_data)); |
| // TLP 1 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 3, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, 0, request_data)); |
| // TLP 2 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 4, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, settings_offset, settings_data)); |
| // RTO 1 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 5, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, 0, request_data)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 6, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, settings_offset, settings_data)); |
| // RTO 2 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 7, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, 0, request_data)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 8, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, settings_offset, settings_data)); |
| // RTO 3 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 9, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, 0, request_data)); |
| quic_data.AddWrite( |
| SYNCHRONOUS, client_maker_.MakeDataPacket( |
| 10, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, settings_offset, settings_data)); |
| |
| quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
| 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| "No recent network activity.")); |
| |
| quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| quic_data.AddRead(ASYNC, OK); |
| quic_data.AddSocketDataToFactory(&socket_factory_); |
| |
| // In order for a new QUIC session to be established via alternate-protocol |
| // without racing an HTTP connection, we need the host resolution to happen |
| // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| // connection to the the server, in this test we require confirmation |
| // before encrypting so the HTTP job will still start. |
| host_resolver_.set_synchronous_mode(true); |
| host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| ""); |
| |
| CreateSession(); |
| // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
| scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| QuicStreamFactoryPeer::SetAlarmFactory( |
| session_->quic_stream_factory(), |
| std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| &clock_)); |
| |
| AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
| |
| HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| TestCompletionCallback callback; |
| int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| |
| // Pump the message loop to get the request started. |
| base::RunLoop().RunUntilIdle(); |
| // Explicitly confirm the handshake. |
| crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| quic::QuicSession::HANDSHAKE_CONFIRMED); |
| |
| // Run the QUIC session to completion. |
| quic_task_runner_->RunUntilIdle(); |
| |
| ExpectQuicAlternateProtocolMapping(); |
| ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| } |
| |
| // Verify that if a QUIC connection RTOs, the QuicHttpStream will |
| // return QUIC_PROTOCOL_ERROR. |
| TEST_P(QuicNetworkTransactionTest, TooManyRtosAfterHandshakeConfirmed) { |
| session_params_.retry_without_alt_svc_on_quic_errors = false; |
| session_params_.quic_connection_options.push_back(quic::k5RTO); |
| |
| // The request will initially go out over QUIC. |
| MockQuicData quic_data; |
| quic::QuicStreamOffset header_stream_offset = 0; |
| spdy::SpdyPriority priority = |
| ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| |
| std::string request_data; |
| client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 1, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| true, priority, GetRequestHeaders("GET", "https", "/"), |
| 0, nullptr, &header_stream_offset, &request_data)); |
| |
| std::string settings_data; |
| quic::QuicStreamOffset settings_offset = header_stream_offset; |
| client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 2, &header_stream_offset, &settings_data)); |
| // TLP 1 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 3, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, 0, request_data)); |
| // TLP 2 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 4, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, settings_offset, settings_data)); |
| // RTO 1 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 5, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, 0, request_data)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 6, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, settings_offset, settings_data)); |
| // RTO 2 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 7, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, 0, request_data)); |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 8, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, settings_offset, settings_data)); |
| // RTO 3 |
| quic_data.AddWrite(SYNCHRONOUS, |
| client_maker_.MakeDataPacket( |
| 9, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| false, 0, request_data)); |
| quic_data.AddWrite( |
| SYNCHRONOUS, client_maker_.MakeDataPacket( |
| 10, quic::QuicUtils::GetHeadersStreamId(version_), true, |
| |