blob: a5193fa796601d94b2d7ab59025dd9773f3f1132 [file] [log] [blame]
// 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/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/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/spdy/core/spdy_frame_builder.h"
#include "net/third_party/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 "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::IntToString(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_)),
client_maker_(version_,
0,
&clock_,
kDefaultServerHostName,
quic::Perspective::IS_CLIENT,
client_headers_include_h2_stream_dependency_),
server_maker_(version_,
0,
&clock_,
kDefaultServerHostName,
quic::Perspective::IS_SERVER,
false),
cert_transparency_verifier_(new MultiLogCTVerifier()),
ssl_config_service_(new SSLConfigServiceDefaults),
proxy_resolution_service_(ProxyResolutionService::CreateDirect()),
auth_handler_factory_(
HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
random_generator_(0),
ssl_data_(ASYNC, OK) {
request_.method = "GET";
std::string url("https://");
url.append(kDefaultServerHostName);
request_.url = GURL(url);
request_.load_flags = 0;
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(quic::QuicPacketNumber num) {
return client_maker_.MakeConnectionClosePacket(
num, false, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!");
}
std::unique_ptr<quic::QuicEncryptedPacket>
ConstructServerConnectionClosePacket(quic::QuicPacketNumber num) {
return server_maker_.MakeConnectionClosePacket(
num, false, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!");
}
std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerGoAwayPacket(
quic::QuicPacketNumber num,
quic::QuicErrorCode error_code,
std::string reason_phrase) {
return server_maker_.MakeGoAwayPacket(num, error_code, reason_phrase);
}
std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket(
quic::QuicPacketNumber packet_number,
quic::QuicPacketNumber largest_received,
quic::QuicPacketNumber smallest_received,
quic::QuicPacketNumber least_unacked) {
return client_maker_.MakeAckPacket(packet_number, largest_received,
smallest_received, least_unacked, true);
}
std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket(
quic::QuicPacketNumber packet_number,
quic::QuicPacketNumber largest_received,
quic::QuicPacketNumber smallest_received,
quic::QuicPacketNumber 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(
quic::QuicPacketNumber num,
quic::QuicStreamId stream_id,
quic::QuicRstStreamErrorCode error_code,
quic::QuicPacketNumber largest_received,
quic::QuicPacketNumber smallest_received,
quic::QuicPacketNumber 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(
quic::QuicPacketNumber 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);
}
std::unique_ptr<quic::QuicEncryptedPacket>
ConstructClientAckAndConnectionClosePacket(
quic::QuicPacketNumber packet_number,
quic::QuicPacketNumber largest_received,
quic::QuicPacketNumber smallest_received,
quic::QuicPacketNumber least_unacked) {
return client_maker_.MakeAckPacket(packet_number, largest_received,
smallest_received, least_unacked, true);
}
std::unique_ptr<quic::QuicEncryptedPacket>
ConstructClientAckAndConnectionClosePacket(
quic::QuicPacketNumber num,
quic::QuicTime::Delta delta_time_largest_observed,
quic::QuicPacketNumber largest_received,
quic::QuicPacketNumber smallest_received,
quic::QuicPacketNumber 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(
quic::QuicPacketNumber 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(
quic::QuicPacketNumber packet_number,
quic::QuicStreamOffset* offset) {
return client_maker_.MakeInitialSettingsPacket(packet_number, offset);
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructServerAckPacket(
quic::QuicPacketNumber packet_number,
quic::QuicPacketNumber largest_received,
quic::QuicPacketNumber smallest_received,
quic::QuicPacketNumber least_unacked) {
return server_maker_.MakeAckPacket(packet_number, largest_received,
smallest_received, least_unacked, false);
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructClientPriorityPacket(
quic::QuicPacketNumber 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(
quic::QuicPacketNumber packet_number,
bool should_include_version,
quic::QuicPacketNumber largest_received,
quic::QuicPacketNumber smallest_received,
quic::QuicPacketNumber 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(
quic::QuicPacketNumber 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(
quic::QuicPacketNumber 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> ConstructClientAckAndDataPacket(
quic::QuicPacketNumber packet_number,
bool include_version,
quic::QuicStreamId stream_id,
quic::QuicPacketNumber largest_received,
quic::QuicPacketNumber smallest_received,
quic::QuicPacketNumber 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> ConstructClientForceHolDataPacket(
quic::QuicPacketNumber 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(quic::QuicPacketNumber 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(quic::QuicPacketNumber 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(quic::QuicPacketNumber 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(quic::QuicPacketNumber 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(
quic::QuicPacketNumber 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(quic::QuicPacketNumber 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(
quic::QuicPacketNumber 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(quic::QuicPacketNumber 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(quic::QuicPacketNumber 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);
}
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);
EXPECT_EQ(port, response->socket_address.port());
}
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 GetNthClientInitiatedStreamId(int n) {
return quic::test::GetNthClientInitiatedStreamId(version_, n);
}
quic::QuicStreamId GetNthServerInitiatedStreamId(int n) {
return quic::test::GetNthServerInitiatedStreamId(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_;
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_;
quic::test::MockRandom random_generator_;
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_CASE_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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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);
std::string packet_number;
ASSERT_TRUE(entries[pos].GetStringValue("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(3, 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, GetNthClientInitiatedStreamId(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(GetNthClientInitiatedStreamId(0),
std::move(response_headers));
spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION);
spdy::SpdySerializedFrame spdy_frame =
response_framer.SerializeFrame(headers_frame);
quic::QuicPacketNumber 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)));
}
mock_quic_data.AddRead(
ASYNC,
ConstructServerDataPacket(packet_number, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(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(GetNthClientInitiatedStreamId(0),
std::move(response_headers));
spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION);
spdy::SpdySerializedFrame spdy_frame =
response_framer.SerializeFrame(headers_frame);
quic::QuicPacketNumber 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)));
}
mock_quic_data.AddRead(
ASYNC,
ConstructServerDataPacket(packet_number, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "http", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "http", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &request_header_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
mock_quic_data.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "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, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(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));
mock_quic_data.AddRead(SYNCHRONOUS, ConstructServerDataPacket(
3, GetNthClientInitiatedStreamId(0),
false, true, 0, "hello!"));
mock_quic_data.AddWrite(
SYNCHRONOUS,
ConstructClientAckAndRstPacket(4, GetNthClientInitiatedStreamId(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",
"");
HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
AddressList address;
std::unique_ptr<HostResolver::Request> request;
int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address,
CompletionOnceCallback(), &request,
net_log_.bound());
EXPECT_THAT(rv, IsOk());
CreateSession();
session_->quic_stream_factory()->set_require_confirmation(true);
AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get());
TestCompletionCallback callback;
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) {
SetUpTestForRetryConnectionOnAlternateNetwork();
std::string request_data;
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL);
client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED);
// 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",
"");
HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
AddressList address;
std::unique_ptr<HostResolver::Request> request;
int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address,
CompletionOnceCallback(), &request,
net_log_.bound());
EXPECT_THAT(rv, IsOk());
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;
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 (!quic::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) {
SetUpTestForRetryConnectionOnAlternateNetwork();
std::string request_data;
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL);
client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED);
// 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",
"");
HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
AddressList address;
std::unique_ptr<HostResolver::Request> request;
int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address,
CompletionOnceCallback(), &request,
net_log_.bound());
EXPECT_THAT(rv, IsOk());
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;
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 (!quic::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) {
SetUpTestForRetryConnectionOnAlternateNetwork();
std::string request_data;
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL);
client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED);
// 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
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
quic_data2.AddWrite(SYNCHRONOUS,
ConstructInitialSettingsPacket(2, &header_stream_offset));
quic_data2.AddWrite(
SYNCHRONOUS,
ConstructClientRequestHeadersPacket(
3, GetNthClientInitiatedStreamId(0), true, true,
GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
quic_data2.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedStreamId(0), false,
false, GetResponseHeaders("200 OK")));
quic_data2.AddRead(
ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
false, true, 0, "hello!"));
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",
"");
HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
AddressList address;
std::unique_ptr<HostResolver::Request> request;
int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address,
CompletionOnceCallback(), &request,
net_log_.bound());
EXPECT_THAT(rv, IsOk());
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;
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 (!quic::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.