Make the QuicParams more self-documenting
With the introduction of QuicParams, it's now possible to
default-construct a QuicParams. However, it's not
self-documenting what those defaults are. As many of them
are actually constants from the header themselves, align
the class to initialize in-place, making it more obvious.
This also updates the various time-delta based parameters
of QuicParams to use base::TimeDelta, making it easier to
ensure safe math, while freeing callers from needing to
know about whether the units were _seconds or
_milliseconds. Several members of the class already
followed this pattern, this just aligns all of them.
Bug: None
Change-Id: Id1661af6736740dd470d713843d37b2af9b7134a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1707095
Reviewed-by: Ryan Hamilton <[email protected]>
Reviewed-by: Nick Harper <[email protected]>
Commit-Queue: Ryan Sleevi <[email protected]>
Cr-Commit-Position: refs/heads/master@{#678442}
diff --git a/components/cronet/url_request_context_config.cc b/components/cronet/url_request_context_config.cc
index be6390df..c27fa41 100644
--- a/components/cronet/url_request_context_config.cc
+++ b/components/cronet/url_request_context_config.cc
@@ -377,25 +377,26 @@
int quic_idle_connection_timeout_seconds = 0;
if (quic_args->GetInteger(kQuicIdleConnectionTimeoutSeconds,
&quic_idle_connection_timeout_seconds)) {
- session_params->quic_params.idle_connection_timeout_seconds =
- quic_idle_connection_timeout_seconds;
+ session_params->quic_params.idle_connection_timeout =
+ base::TimeDelta::FromSeconds(quic_idle_connection_timeout_seconds);
}
int quic_max_time_before_crypto_handshake_seconds = 0;
if (quic_args->GetInteger(
kQuicMaxTimeBeforeCryptoHandshakeSeconds,
&quic_max_time_before_crypto_handshake_seconds)) {
- session_params->quic_params.max_time_before_crypto_handshake_seconds =
- quic_max_time_before_crypto_handshake_seconds;
+ session_params->quic_params.max_time_before_crypto_handshake =
+ base::TimeDelta::FromSeconds(
+ quic_max_time_before_crypto_handshake_seconds);
}
int quic_max_idle_time_before_crypto_handshake_seconds = 0;
if (quic_args->GetInteger(
kQuicMaxIdleTimeBeforeCryptoHandshakeSeconds,
&quic_max_idle_time_before_crypto_handshake_seconds)) {
- session_params->quic_params
- .max_idle_time_before_crypto_handshake_seconds =
- quic_max_idle_time_before_crypto_handshake_seconds;
+ session_params->quic_params.max_idle_time_before_crypto_handshake =
+ base::TimeDelta::FromSeconds(
+ quic_max_idle_time_before_crypto_handshake_seconds);
}
bool quic_close_sessions_on_ip_change = false;
@@ -495,9 +496,9 @@
if (quic_args->GetInteger(
kQuicRetransmittableOnWireTimeoutMilliseconds,
&quic_retransmittable_on_wire_timeout_milliseconds)) {
- session_params->quic_params
- .retransmittable_on_wire_timeout_milliseconds =
- quic_retransmittable_on_wire_timeout_milliseconds;
+ session_params->quic_params.retransmittable_on_wire_timeout =
+ base::TimeDelta::FromMilliseconds(
+ quic_retransmittable_on_wire_timeout_milliseconds);
}
bool quic_retry_on_alternate_network_before_handshake = false;
diff --git a/components/cronet/url_request_context_config_unittest.cc b/components/cronet/url_request_context_config_unittest.cc
index 3478267..718b2f3 100644
--- a/components/cronet/url_request_context_config_unittest.cc
+++ b/components/cronet/url_request_context_config_unittest.cc
@@ -197,8 +197,8 @@
// Check max_server_configs_stored_in_properties.
EXPECT_EQ(2u, params->quic_params.max_server_configs_stored_in_properties);
- // Check idle_connection_timeout_seconds.
- EXPECT_EQ(300, params->quic_params.idle_connection_timeout_seconds);
+ // Check idle_connection_timeout.
+ EXPECT_EQ(300, params->quic_params.idle_connection_timeout.InSeconds());
EXPECT_TRUE(params->quic_params.close_sessions_on_ip_change);
EXPECT_FALSE(params->quic_params.goaway_sessions_on_ip_change);
@@ -691,8 +691,9 @@
EXPECT_TRUE(params->quic_params.migrate_sessions_on_network_change_v2);
EXPECT_TRUE(params->quic_params.migrate_sessions_early_v2);
EXPECT_TRUE(params->quic_params.retry_on_alternate_network_before_handshake);
- EXPECT_EQ(1000,
- params->quic_params.retransmittable_on_wire_timeout_milliseconds);
+ EXPECT_EQ(
+ 1000,
+ params->quic_params.retransmittable_on_wire_timeout.InMilliseconds());
EXPECT_TRUE(params->quic_params.migrate_idle_sessions);
EXPECT_EQ(base::TimeDelta::FromSeconds(15),
params->quic_params.idle_session_migration_period);
@@ -857,9 +858,11 @@
const net::HttpNetworkSession::Params* params =
context->GetNetworkSessionParams();
- EXPECT_EQ(7, params->quic_params.max_time_before_crypto_handshake_seconds);
- EXPECT_EQ(11,
- params->quic_params.max_idle_time_before_crypto_handshake_seconds);
+ EXPECT_EQ(7,
+ params->quic_params.max_time_before_crypto_handshake.InSeconds());
+ EXPECT_EQ(
+ 11,
+ params->quic_params.max_idle_time_before_crypto_handshake.InSeconds());
}
TEST(URLURLRequestContextConfigTest, SetQuicConnectionOptions) {
diff --git a/components/network_session_configurator/browser/network_session_configurator.cc b/components/network_session_configurator/browser/network_session_configurator.cc
index 409c0685..7979448 100644
--- a/components/network_session_configurator/browser/network_session_configurator.cc
+++ b/components/network_session_configurator/browser/network_session_configurator.cc
@@ -477,27 +477,29 @@
int idle_connection_timeout_seconds =
GetQuicIdleConnectionTimeoutSeconds(quic_trial_params);
if (idle_connection_timeout_seconds != 0) {
- params->quic_params.idle_connection_timeout_seconds =
- idle_connection_timeout_seconds;
+ params->quic_params.idle_connection_timeout =
+ base::TimeDelta::FromSeconds(idle_connection_timeout_seconds);
}
int reduced_ping_timeout_seconds =
GetQuicReducedPingTimeoutSeconds(quic_trial_params);
if (reduced_ping_timeout_seconds > 0 &&
reduced_ping_timeout_seconds < quic::kPingTimeoutSecs) {
- params->quic_params.reduced_ping_timeout_seconds =
- reduced_ping_timeout_seconds;
+ params->quic_params.reduced_ping_timeout =
+ base::TimeDelta::FromSeconds(reduced_ping_timeout_seconds);
}
int max_time_before_crypto_handshake_seconds =
GetQuicMaxTimeBeforeCryptoHandshakeSeconds(quic_trial_params);
if (max_time_before_crypto_handshake_seconds > 0) {
- params->quic_params.max_time_before_crypto_handshake_seconds =
- max_time_before_crypto_handshake_seconds;
+ params->quic_params.max_time_before_crypto_handshake =
+ base::TimeDelta::FromSeconds(
+ max_time_before_crypto_handshake_seconds);
}
int max_idle_time_before_crypto_handshake_seconds =
GetQuicMaxIdleTimeBeforeCryptoHandshakeSeconds(quic_trial_params);
if (max_idle_time_before_crypto_handshake_seconds > 0) {
- params->quic_params.max_idle_time_before_crypto_handshake_seconds =
- max_idle_time_before_crypto_handshake_seconds;
+ params->quic_params.max_idle_time_before_crypto_handshake =
+ base::TimeDelta::FromSeconds(
+ max_idle_time_before_crypto_handshake_seconds);
}
params->quic_params.race_cert_verification =
ShouldQuicRaceCertVerification(quic_trial_params);
@@ -516,14 +518,16 @@
int initial_rtt_for_handshake_milliseconds =
GetQuicInitialRttForHandshakeMilliseconds(quic_trial_params);
if (initial_rtt_for_handshake_milliseconds > 0) {
- params->quic_params.initial_rtt_for_handshake_milliseconds =
- initial_rtt_for_handshake_milliseconds;
+ params->quic_params.initial_rtt_for_handshake =
+ base::TimeDelta::FromMilliseconds(
+ initial_rtt_for_handshake_milliseconds);
}
int retransmittable_on_wire_timeout_milliseconds =
GetQuicRetransmittableOnWireTimeoutMilliseconds(quic_trial_params);
if (retransmittable_on_wire_timeout_milliseconds > 0) {
- params->quic_params.retransmittable_on_wire_timeout_milliseconds =
- retransmittable_on_wire_timeout_milliseconds;
+ params->quic_params.retransmittable_on_wire_timeout =
+ base::TimeDelta::FromMilliseconds(
+ retransmittable_on_wire_timeout_milliseconds);
}
params->quic_params.migrate_idle_sessions =
ShouldQuicMigrateIdleSessions(quic_trial_params);
diff --git a/components/network_session_configurator/browser/network_session_configurator_unittest.cc b/components/network_session_configurator/browser/network_session_configurator_unittest.cc
index d1f13354..4db23a0 100644
--- a/components/network_session_configurator/browser/network_session_configurator_unittest.cc
+++ b/components/network_session_configurator/browser/network_session_configurator_unittest.cc
@@ -112,14 +112,14 @@
EXPECT_FALSE(params_.enable_server_push_cancellation);
EXPECT_FALSE(params_.quic_params.close_sessions_on_ip_change);
EXPECT_FALSE(params_.quic_params.goaway_sessions_on_ip_change);
- EXPECT_EQ(net::kIdleConnectionTimeoutSeconds,
- params_.quic_params.idle_connection_timeout_seconds);
- EXPECT_EQ(quic::kPingTimeoutSecs,
- params_.quic_params.reduced_ping_timeout_seconds);
- EXPECT_EQ(quic::kMaxTimeForCryptoHandshakeSecs,
- params_.quic_params.max_time_before_crypto_handshake_seconds);
- EXPECT_EQ(quic::kInitialIdleTimeoutSecs,
- params_.quic_params.max_idle_time_before_crypto_handshake_seconds);
+ EXPECT_EQ(net::kIdleConnectionTimeout,
+ params_.quic_params.idle_connection_timeout);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(quic::kPingTimeoutSecs),
+ params_.quic_params.reduced_ping_timeout);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(quic::kMaxTimeForCryptoHandshakeSecs),
+ params_.quic_params.max_time_before_crypto_handshake);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(quic::kInitialIdleTimeoutSecs),
+ params_.quic_params.max_idle_time_before_crypto_handshake);
EXPECT_FALSE(params_.quic_params.race_cert_verification);
EXPECT_FALSE(params_.quic_params.estimate_initial_rtt);
EXPECT_FALSE(params_.quic_params.migrate_sessions_on_network_change_v2);
@@ -127,11 +127,10 @@
EXPECT_FALSE(params_.quic_params.retry_on_alternate_network_before_handshake);
EXPECT_FALSE(params_.quic_params.migrate_idle_sessions);
EXPECT_FALSE(params_.quic_params.go_away_on_path_degrading);
- EXPECT_EQ(0, params_.quic_params.initial_rtt_for_handshake_milliseconds);
+ EXPECT_TRUE(params_.quic_params.initial_rtt_for_handshake.is_zero());
EXPECT_FALSE(params_.quic_params.allow_server_migration);
EXPECT_TRUE(params_.quic_host_whitelist.empty());
- EXPECT_EQ(0,
- params_.quic_params.retransmittable_on_wire_timeout_milliseconds);
+ EXPECT_TRUE(params_.quic_params.retransmittable_on_wire_timeout.is_zero());
net::HttpNetworkSession::Params default_params;
EXPECT_EQ(default_params.quic_params.supported_versions,
@@ -237,8 +236,8 @@
ParseFieldTrials();
- EXPECT_EQ(1000,
- params_.quic_params.retransmittable_on_wire_timeout_milliseconds);
+ EXPECT_EQ(base::TimeDelta::FromMilliseconds(1000),
+ params_.quic_params.retransmittable_on_wire_timeout);
}
TEST_F(NetworkSessionConfiguratorTest,
@@ -250,7 +249,8 @@
ParseFieldTrials();
- EXPECT_EQ(300, params_.quic_params.idle_connection_timeout_seconds);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(300),
+ params_.quic_params.idle_connection_timeout);
}
TEST_F(NetworkSessionConfiguratorTest,
@@ -260,8 +260,8 @@
variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
ParseFieldTrials();
- EXPECT_EQ(quic::kPingTimeoutSecs,
- params_.quic_params.reduced_ping_timeout_seconds);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(quic::kPingTimeoutSecs),
+ params_.quic_params.reduced_ping_timeout);
}
TEST_F(NetworkSessionConfiguratorTest,
@@ -271,8 +271,8 @@
variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
ParseFieldTrials();
- EXPECT_EQ(quic::kPingTimeoutSecs,
- params_.quic_params.reduced_ping_timeout_seconds);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(quic::kPingTimeoutSecs),
+ params_.quic_params.reduced_ping_timeout);
}
TEST_F(NetworkSessionConfiguratorTest,
@@ -282,7 +282,8 @@
variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
ParseFieldTrials();
- EXPECT_EQ(10, params_.quic_params.reduced_ping_timeout_seconds);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(10),
+ params_.quic_params.reduced_ping_timeout);
}
TEST_F(NetworkSessionConfiguratorTest,
@@ -292,7 +293,8 @@
variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
ParseFieldTrials();
- EXPECT_EQ(7, params_.quic_params.max_time_before_crypto_handshake_seconds);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(7),
+ params_.quic_params.max_time_before_crypto_handshake);
}
TEST_F(NetworkSessionConfiguratorTest,
@@ -302,8 +304,8 @@
variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
ParseFieldTrials();
- EXPECT_EQ(quic::kMaxTimeForCryptoHandshakeSecs,
- params_.quic_params.max_time_before_crypto_handshake_seconds);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(quic::kMaxTimeForCryptoHandshakeSecs),
+ params_.quic_params.max_time_before_crypto_handshake);
}
TEST_F(NetworkSessionConfiguratorTest,
@@ -313,8 +315,8 @@
variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
ParseFieldTrials();
- EXPECT_EQ(11,
- params_.quic_params.max_idle_time_before_crypto_handshake_seconds);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(11),
+ params_.quic_params.max_idle_time_before_crypto_handshake);
}
TEST_F(NetworkSessionConfiguratorTest,
@@ -324,8 +326,8 @@
variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
ParseFieldTrials();
- EXPECT_EQ(quic::kInitialIdleTimeoutSecs,
- params_.quic_params.max_idle_time_before_crypto_handshake_seconds);
+ EXPECT_EQ(base::TimeDelta::FromSeconds(quic::kInitialIdleTimeoutSecs),
+ params_.quic_params.max_idle_time_before_crypto_handshake);
}
TEST_F(NetworkSessionConfiguratorTest, QuicRaceCertVerification) {
@@ -861,7 +863,8 @@
ParseFieldTrials();
- EXPECT_EQ(500, params_.quic_params.initial_rtt_for_handshake_milliseconds);
+ EXPECT_EQ(base::TimeDelta::FromMilliseconds(500),
+ params_.quic_params.initial_rtt_for_handshake);
}
} // namespace network_session_configurator
diff --git a/net/http/http_network_session.cc b/net/http/http_network_session.cc
index 88c1f52..e207a97 100644
--- a/net/http/http_network_session.cc
+++ b/net/http/http_network_session.cc
@@ -279,9 +279,9 @@
dict->SetInteger("max_server_configs_stored_in_properties",
params_.quic_params.max_server_configs_stored_in_properties);
dict->SetInteger("idle_connection_timeout_seconds",
- params_.quic_params.idle_connection_timeout_seconds);
+ params_.quic_params.idle_connection_timeout.InSeconds());
dict->SetInteger("reduced_ping_timeout_seconds",
- params_.quic_params.reduced_ping_timeout_seconds);
+ params_.quic_params.reduced_ping_timeout.InSeconds());
dict->SetBoolean(
"mark_quic_broken_when_network_blackholes",
params_.quic_params.mark_quic_broken_when_network_blackholes);
@@ -301,7 +301,7 @@
params_.quic_params.migrate_sessions_early_v2);
dict->SetInteger(
"retransmittable_on_wire_timeout_milliseconds",
- params_.quic_params.retransmittable_on_wire_timeout_milliseconds);
+ params_.quic_params.retransmittable_on_wire_timeout.InMilliseconds());
dict->SetBoolean(
"retry_on_alternate_network_before_handshake",
params_.quic_params.retry_on_alternate_network_before_handshake);
@@ -330,8 +330,9 @@
params_.quic_params.estimate_initial_rtt);
dict->SetBoolean("server_push_cancellation",
params_.enable_server_push_cancellation);
- dict->SetInteger("initial_rtt_for_handshake_milliseconds",
- params_.quic_params.initial_rtt_for_handshake_milliseconds);
+ dict->SetInteger(
+ "initial_rtt_for_handshake_milliseconds",
+ params_.quic_params.initial_rtt_for_handshake.InMilliseconds());
return std::move(dict);
}
diff --git a/net/quic/bidirectional_stream_quic_impl_unittest.cc b/net/quic/bidirectional_stream_quic_impl_unittest.cc
index 6143499..6a9e13d 100644
--- a/net/quic/bidirectional_stream_quic_impl_unittest.cc
+++ b/net/quic/bidirectional_stream_quic_impl_unittest.cc
@@ -522,10 +522,9 @@
/*migrate_session_on_network_change_v2=*/false,
/*default_network=*/NetworkChangeNotifier::kInvalidNetworkHandle,
quic::QuicTime::Delta::FromMilliseconds(
- kDefaultRetransmittableOnWireTimeoutMillisecs),
- /*migrate_idle_session=*/false,
- base::TimeDelta::FromSeconds(kDefaultIdleSessionMigrationPeriodSeconds),
- base::TimeDelta::FromSeconds(kMaxTimeOnNonDefaultNetworkSecs),
+ kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
+ /*migrate_idle_session=*/false, kDefaultIdleSessionMigrationPeriod,
+ kMaxTimeOnNonDefaultNetwork,
kMaxMigrationsToNonDefaultNetworkOnWriteError,
kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
kQuicYieldAfterPacketsRead,
diff --git a/net/quic/quic_chromium_client_session_test.cc b/net/quic/quic_chromium_client_session_test.cc
index f87bc19..3d0ac35 100644
--- a/net/quic/quic_chromium_client_session_test.cc
+++ b/net/quic/quic_chromium_client_session_test.cc
@@ -154,10 +154,9 @@
/*migrate_session_on_network_change_v2=*/false,
/*defaulet_network=*/NetworkChangeNotifier::kInvalidNetworkHandle,
quic::QuicTime::Delta::FromMilliseconds(
- kDefaultRetransmittableOnWireTimeoutMillisecs),
- /*migrate_idle_session=*/false,
- base::TimeDelta::FromSeconds(kDefaultIdleSessionMigrationPeriodSeconds),
- base::TimeDelta::FromSeconds(kMaxTimeOnNonDefaultNetworkSecs),
+ kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
+ /*migrate_idle_session=*/false, kDefaultIdleSessionMigrationPeriod,
+ kMaxTimeOnNonDefaultNetwork,
kMaxMigrationsToNonDefaultNetworkOnWriteError,
kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
kQuicYieldAfterPacketsRead,
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 0c0ba6c..298cae2 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -330,10 +330,9 @@
/*migrate_session_on_network_change_v2=*/false,
/*default_network=*/NetworkChangeNotifier::kInvalidNetworkHandle,
quic::QuicTime::Delta::FromMilliseconds(
- kDefaultRetransmittableOnWireTimeoutMillisecs),
- /*migrate_idle_session=*/false,
- base::TimeDelta::FromSeconds(kDefaultIdleSessionMigrationPeriodSeconds),
- base::TimeDelta::FromSeconds(kMaxTimeOnNonDefaultNetworkSecs),
+ kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
+ /*migrate_idle_session=*/false, kDefaultIdleSessionMigrationPeriod,
+ kMaxTimeOnNonDefaultNetwork,
kMaxMigrationsToNonDefaultNetworkOnWriteError,
kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
kQuicYieldAfterPacketsRead,
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index 04e3b04..7c27d08 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -2554,7 +2554,8 @@
// return QUIC_PROTOCOL_ERROR.
TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmed) {
session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false;
- session_params_.quic_params.idle_connection_timeout_seconds = 5;
+ session_params_.quic_params.idle_connection_timeout =
+ base::TimeDelta::FromSeconds(5);
// The request will initially go out over QUIC.
MockQuicData quic_data(version_);
@@ -3001,7 +3002,8 @@
// retried over TCP.
TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken) {
session_params_.quic_params.mark_quic_broken_when_network_blackholes = true;
- session_params_.quic_params.idle_connection_timeout_seconds = 5;
+ session_params_.quic_params.idle_connection_timeout =
+ base::TimeDelta::FromSeconds(5);
// The request will initially go out over QUIC.
MockQuicData quic_data(version_);
@@ -3139,7 +3141,8 @@
// connection times out, then QUIC will be marked as broken and the request
// retried over TCP.
TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken2) {
- session_params_.quic_params.idle_connection_timeout_seconds = 5;
+ session_params_.quic_params.idle_connection_timeout =
+ base::TimeDelta::FromSeconds(5);
// The request will initially go out over QUIC.
MockQuicData quic_data(version_);
@@ -3281,7 +3284,8 @@
TEST_P(QuicNetworkTransactionTest,
TimeoutAfterHandshakeConfirmedAndHeadersThenBrokenNotRetried) {
session_params_.quic_params.mark_quic_broken_when_network_blackholes = true;
- session_params_.quic_params.idle_connection_timeout_seconds = 5;
+ session_params_.quic_params.idle_connection_timeout =
+ base::TimeDelta::FromSeconds(5);
// The request will initially go out over QUIC.
MockQuicData quic_data(version_);
@@ -3721,7 +3725,8 @@
// retried over TCP and the QUIC will be marked as broken.
TEST_P(QuicNetworkTransactionTest,
ProtocolErrorAfterHandshakeConfirmedThenBroken) {
- session_params_.quic_params.idle_connection_timeout_seconds = 5;
+ session_params_.quic_params.idle_connection_timeout =
+ base::TimeDelta::FromSeconds(5);
// The request will initially go out over QUIC.
MockQuicData quic_data(version_);
diff --git a/net/quic/quic_proxy_client_socket_unittest.cc b/net/quic/quic_proxy_client_socket_unittest.cc
index c8d235fb..93bf9b3 100644
--- a/net/quic/quic_proxy_client_socket_unittest.cc
+++ b/net/quic/quic_proxy_client_socket_unittest.cc
@@ -224,10 +224,9 @@
/*migrate_session_on_network_change_v2=*/false,
/*default_network=*/NetworkChangeNotifier::kInvalidNetworkHandle,
quic::QuicTime::Delta::FromMilliseconds(
- kDefaultRetransmittableOnWireTimeoutMillisecs),
- /*migrate_idle_session=*/true,
- base::TimeDelta::FromSeconds(kDefaultIdleSessionMigrationPeriodSeconds),
- base::TimeDelta::FromSeconds(kMaxTimeOnNonDefaultNetworkSecs),
+ kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
+ /*migrate_idle_session=*/true, kDefaultIdleSessionMigrationPeriod,
+ kMaxTimeOnNonDefaultNetwork,
kMaxMigrationsToNonDefaultNetworkOnWriteError,
kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
kQuicYieldAfterPacketsRead,
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index 7be8413..633d3a30d 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -180,20 +180,21 @@
quic::QuicConfig InitializeQuicConfig(
const quic::QuicTagVector& connection_options,
const quic::QuicTagVector& client_connection_options,
- int idle_connection_timeout_seconds,
- int max_time_before_crypto_handshake_seconds,
- int max_idle_time_before_crypto_handshake_seconds) {
- DCHECK_GT(idle_connection_timeout_seconds, 0);
+ base::TimeDelta idle_connection_timeout,
+ base::TimeDelta max_time_before_crypto_handshake,
+ base::TimeDelta max_idle_time_before_crypto_handshake) {
+ DCHECK_GT(idle_connection_timeout, base::TimeDelta());
quic::QuicConfig config;
- config.SetIdleNetworkTimeout(
- quic::QuicTime::Delta::FromSeconds(idle_connection_timeout_seconds),
- quic::QuicTime::Delta::FromSeconds(idle_connection_timeout_seconds));
+ config.SetIdleNetworkTimeout(quic::QuicTime::Delta::FromMicroseconds(
+ idle_connection_timeout.InMicroseconds()),
+ quic::QuicTime::Delta::FromMicroseconds(
+ idle_connection_timeout.InMicroseconds()));
config.set_max_time_before_crypto_handshake(
- quic::QuicTime::Delta::FromSeconds(
- max_time_before_crypto_handshake_seconds));
+ quic::QuicTime::Delta::FromMicroseconds(
+ max_time_before_crypto_handshake.InMicroseconds()));
config.set_max_idle_time_before_crypto_handshake(
- quic::QuicTime::Delta::FromSeconds(
- max_idle_time_before_crypto_handshake_seconds));
+ quic::QuicTime::Delta::FromMicroseconds(
+ max_idle_time_before_crypto_handshake.InMicroseconds()));
config.SetConnectionOptionsToSend(connection_options);
config.SetClientConnectionOptions(client_connection_options);
return config;
@@ -227,41 +228,12 @@
QuicParams::QuicParams()
: max_packet_length(quic::kDefaultMaxPacketSize),
- max_server_configs_stored_in_properties(0u),
- enable_socket_recv_optimization(false),
- mark_quic_broken_when_network_blackholes(false),
- retry_without_alt_svc_on_quic_errors(true),
- support_ietf_format_quic_altsvc(false),
- close_sessions_on_ip_change(false),
- goaway_sessions_on_ip_change(false),
- idle_connection_timeout_seconds(kIdleConnectionTimeoutSeconds),
- reduced_ping_timeout_seconds(quic::kPingTimeoutSecs),
- retransmittable_on_wire_timeout_milliseconds(0),
- max_time_before_crypto_handshake_seconds(
- quic::kMaxTimeForCryptoHandshakeSecs),
- max_idle_time_before_crypto_handshake_seconds(
- quic::kInitialIdleTimeoutSecs),
- migrate_sessions_on_network_change_v2(false),
- migrate_sessions_early_v2(false),
- retry_on_alternate_network_before_handshake(false),
- migrate_idle_sessions(false),
- idle_session_migration_period(base::TimeDelta::FromSeconds(
- kDefaultIdleSessionMigrationPeriodSeconds)),
- max_time_on_non_default_network(
- base::TimeDelta::FromSeconds(kMaxTimeOnNonDefaultNetworkSecs)),
- max_migrations_to_non_default_network_on_write_error(
- kMaxMigrationsToNonDefaultNetworkOnWriteError),
- max_migrations_to_non_default_network_on_path_degrading(
- kMaxMigrationsToNonDefaultNetworkOnPathDegrading),
- allow_server_migration(false),
- allow_remote_alt_svc(true),
- race_stale_dns_on_connection(false),
- go_away_on_path_degrading(false),
- disable_bidirectional_streams(false),
- race_cert_verification(false),
- estimate_initial_rtt(false),
- headers_include_h2_stream_dependency(false),
- initial_rtt_for_handshake_milliseconds(0) {
+ reduced_ping_timeout(
+ base::TimeDelta::FromSeconds(quic::kPingTimeoutSecs)),
+ max_time_before_crypto_handshake(
+ base::TimeDelta::FromSeconds(quic::kMaxTimeForCryptoHandshakeSecs)),
+ max_idle_time_before_crypto_handshake(
+ base::TimeDelta::FromSeconds(quic::kInitialIdleTimeoutSecs)) {
supported_versions.push_back(quic::ParsedQuicVersion(
quic::PROTOCOL_QUIC_CRYPTO, quic::QUIC_VERSION_46));
}
@@ -1112,22 +1084,22 @@
params_(params),
clock_skew_detector_(base::TimeTicks::Now(), base::Time::Now()),
socket_performance_watcher_factory_(socket_performance_watcher_factory),
- config_(InitializeQuicConfig(
- params.connection_options,
- params.client_connection_options,
- params.idle_connection_timeout_seconds,
- params.max_time_before_crypto_handshake_seconds,
- params.max_idle_time_before_crypto_handshake_seconds)),
+ config_(
+ InitializeQuicConfig(params.connection_options,
+ params.client_connection_options,
+ params.idle_connection_timeout,
+ params.max_time_before_crypto_handshake,
+ params.max_idle_time_before_crypto_handshake)),
crypto_config_(
std::make_unique<ProofVerifierChromium>(cert_verifier,
ct_policy_enforcer,
transport_security_state,
cert_transparency_verifier)),
ping_timeout_(quic::QuicTime::Delta::FromSeconds(quic::kPingTimeoutSecs)),
- reduced_ping_timeout_(quic::QuicTime::Delta::FromSeconds(
- params.reduced_ping_timeout_seconds)),
- retransmittable_on_wire_timeout_(quic::QuicTime::Delta::FromMilliseconds(
- params.retransmittable_on_wire_timeout_milliseconds)),
+ reduced_ping_timeout_(quic::QuicTime::Delta::FromMicroseconds(
+ params.reduced_ping_timeout.InMicroseconds())),
+ retransmittable_on_wire_timeout_(quic::QuicTime::Delta::FromMicroseconds(
+ params.retransmittable_on_wire_timeout.InMicroseconds())),
yield_after_packets_(kQuicYieldAfterPacketsRead),
yield_after_duration_(quic::QuicTime::Delta::FromMilliseconds(
kQuicYieldAfterDurationMilliseconds)),
@@ -1162,10 +1134,10 @@
params.retry_on_alternate_network_before_handshake)
DCHECK(params.migrate_sessions_on_network_change_v2);
- if (params.retransmittable_on_wire_timeout_milliseconds == 0 &&
+ if (params.retransmittable_on_wire_timeout.is_zero() &&
params.migrate_sessions_early_v2) {
- retransmittable_on_wire_timeout_ = quic::QuicTime::Delta::FromMilliseconds(
- kDefaultRetransmittableOnWireTimeoutMillisecs);
+ retransmittable_on_wire_timeout_ = quic::QuicTime::Delta::FromMicroseconds(
+ kDefaultRetransmittableOnWireTimeout.InMicroseconds());
}
// goaway_sessions_on_ip_change and close_sessions_on_ip_change should never
@@ -1968,10 +1940,11 @@
return;
}
- if (params_.initial_rtt_for_handshake_milliseconds > 0) {
- SetInitialRttEstimate(base::TimeDelta::FromMilliseconds(
- params_.initial_rtt_for_handshake_milliseconds),
- INITIAL_RTT_DEFAULT, config);
+ if (params_.initial_rtt_for_handshake > base::TimeDelta()) {
+ SetInitialRttEstimate(
+ base::TimeDelta::FromMicroseconds(
+ params_.initial_rtt_for_handshake.InMicroseconds()),
+ INITIAL_RTT_DEFAULT, config);
return;
}
diff --git a/net/quic/quic_stream_factory.h b/net/quic/quic_stream_factory.h
index 55fca42..f725d49 100644
--- a/net/quic/quic_stream_factory.h
+++ b/net/quic/quic_stream_factory.h
@@ -79,20 +79,24 @@
} // namespace test
// When a connection is idle for 30 seconds it will be closed.
-const int kIdleConnectionTimeoutSeconds = 30;
+constexpr base::TimeDelta kIdleConnectionTimeout =
+ base::TimeDelta::FromSeconds(30);
// Sessions can migrate if they have been idle for less than this period.
-const int kDefaultIdleSessionMigrationPeriodSeconds = 30;
+constexpr base::TimeDelta kDefaultIdleSessionMigrationPeriod =
+ base::TimeDelta::FromSeconds(30);
// The default maximum time allowed to have no retransmittable packets on the
// wire (after sending the first retransmittable packet) if
// |migrate_session_early_v2_| is true. PING frames will be sent as needed to
// enforce this.
-const int64_t kDefaultRetransmittableOnWireTimeoutMillisecs = 100;
+constexpr base::TimeDelta kDefaultRetransmittableOnWireTimeout =
+ base::TimeDelta::FromMilliseconds(100);
// The default maximum time QUIC session could be on non-default network before
// migrate back to default network.
-const int64_t kMaxTimeOnNonDefaultNetworkSecs = 128;
+constexpr base::TimeDelta kMaxTimeOnNonDefaultNetwork =
+ base::TimeDelta::FromSeconds(128);
// The default maximum number of migrations to non default network on write
// error per network.
@@ -118,7 +122,7 @@
size_t max_packet_length;
// Maximum number of server configs that are to be stored in
// HttpServerProperties, instead of the disk cache.
- size_t max_server_configs_stored_in_properties;
+ size_t max_server_configs_stored_in_properties = 0u;
// QUIC will be used for all connections in this set.
std::set<HostPortPair> origins_to_force_quic_on;
// Set of QUIC tags to send in the handshake's connection options.
@@ -127,86 +131,89 @@
// affect the client.
quic::QuicTagVector client_connection_options;
// Enables experimental optimization for receiving data in UDPSocket.
- bool enable_socket_recv_optimization;
+ bool enable_socket_recv_optimization = false;
// Active QUIC experiments
// Marks a QUIC server broken when a connection blackholes after the
// handshake is confirmed.
- bool mark_quic_broken_when_network_blackholes;
+ bool mark_quic_broken_when_network_blackholes = false;
// Retry requests which fail with QUIC_PROTOCOL_ERROR, and mark QUIC
// broken if the retry succeeds.
- bool retry_without_alt_svc_on_quic_errors;
+ bool retry_without_alt_svc_on_quic_errors = true;
// If true, alt-svc headers advertising QUIC in IETF format will be
// supported.
- bool support_ietf_format_quic_altsvc;
+ bool support_ietf_format_quic_altsvc = false;
// If true, all QUIC sessions are closed when any local IP address changes.
- bool close_sessions_on_ip_change;
+ bool close_sessions_on_ip_change = false;
// If true, all QUIC sessions are marked as goaway when any local IP address
// changes.
- bool goaway_sessions_on_ip_change;
+ bool goaway_sessions_on_ip_change = false;
// Specifies QUIC idle connection state lifetime.
- int idle_connection_timeout_seconds;
+ base::TimeDelta idle_connection_timeout = kIdleConnectionTimeout;
// Specifies the reduced ping timeout subsequent connections should use when
// a connection was timed out with open streams.
- int reduced_ping_timeout_seconds;
+ base::TimeDelta reduced_ping_timeout;
// Maximum time that a session can have no retransmittable packets on the
// wire. Set to zero if not specified and no retransmittable PING will be
// sent to peer when the wire has no retransmittable packets.
- int retransmittable_on_wire_timeout_milliseconds;
+ base::TimeDelta retransmittable_on_wire_timeout;
// Maximum time the session can be alive before crypto handshake is
// finished.
- int max_time_before_crypto_handshake_seconds;
+ base::TimeDelta max_time_before_crypto_handshake;
// Maximum idle time before the crypto handshake has completed.
- int max_idle_time_before_crypto_handshake_seconds;
+ base::TimeDelta max_idle_time_before_crypto_handshake;
// If true, connection migration v2 will be used to migrate existing
// sessions to network when the platform indicates that the default network
// is changing.
- bool migrate_sessions_on_network_change_v2;
+ bool migrate_sessions_on_network_change_v2 = false;
// If true, connection migration v2 may be used to migrate active QUIC
// sessions to alternative network if current network connectivity is poor.
- bool migrate_sessions_early_v2;
+ bool migrate_sessions_early_v2 = false;
// If true, a new connection may be kicked off on an alternate network when
// a connection fails on the default network before handshake is confirmed.
- bool retry_on_alternate_network_before_handshake;
+ bool retry_on_alternate_network_before_handshake = false;
// If true, an idle session will be migrated within the idle migration
// period.
- bool migrate_idle_sessions;
+ bool migrate_idle_sessions = false;
// A session can be migrated if its idle time is within this period.
- base::TimeDelta idle_session_migration_period;
+ base::TimeDelta idle_session_migration_period =
+ kDefaultIdleSessionMigrationPeriod;
// Maximum time the session could be on the non-default network before
// migrates back to default network. Defaults to
// kMaxTimeOnNonDefaultNetwork.
- base::TimeDelta max_time_on_non_default_network;
+ base::TimeDelta max_time_on_non_default_network = kMaxTimeOnNonDefaultNetwork;
// Maximum number of migrations to the non-default network on write error
// per network for each session.
- int max_migrations_to_non_default_network_on_write_error;
+ int max_migrations_to_non_default_network_on_write_error =
+ kMaxMigrationsToNonDefaultNetworkOnWriteError;
// Maximum number of migrations to the non-default network on path
// degrading per network for each session.
- int max_migrations_to_non_default_network_on_path_degrading;
+ int max_migrations_to_non_default_network_on_path_degrading =
+ kMaxMigrationsToNonDefaultNetworkOnPathDegrading;
// If true, allows migration of QUIC connections to a server-specified
// alternate server address.
- bool allow_server_migration;
+ bool allow_server_migration = false;
// If true, allows QUIC to use alternative services with a different
// hostname from the origin.
- bool allow_remote_alt_svc;
+ bool allow_remote_alt_svc = true;
// If true, the quic stream factory may race connection from stale dns
// result with the original dns resolution
- bool race_stale_dns_on_connection;
+ bool race_stale_dns_on_connection = false;
// If true, the quic session may mark itself as GOAWAY on path degrading.
- bool go_away_on_path_degrading;
+ bool go_away_on_path_degrading = false;
// If true, bidirectional streams over QUIC will be disabled.
- bool disable_bidirectional_streams;
+ bool disable_bidirectional_streams = false;
// If true, race cert verification with host resolution.
- bool race_cert_verification;
+ bool race_cert_verification = false;
// If true, estimate the initial RTT for QUIC connections based on network.
- bool estimate_initial_rtt;
+ bool estimate_initial_rtt = false;
// If true, client headers will include HTTP/2 stream dependency info
// derived from the request priority.
- bool headers_include_h2_stream_dependency;
+ bool headers_include_h2_stream_dependency = false;
// The initial rtt that will be used in crypto handshake if no cached
// smoothed rtt is present.
- int initial_rtt_for_handshake_milliseconds;
+ base::TimeDelta initial_rtt_for_handshake;
};
enum QuicPlatformNotification {
diff --git a/net/quic/quic_stream_factory_test.cc b/net/quic/quic_stream_factory_test.cc
index 388e824..870cd39 100644
--- a/net/quic/quic_stream_factory_test.cc
+++ b/net/quic/quic_stream_factory_test.cc
@@ -559,7 +559,8 @@
// Verifies that the QUIC stream factory is initialized correctly.
void VerifyInitialization() {
test_params_.quic_params.max_server_configs_stored_in_properties = 1;
- test_params_.quic_params.idle_connection_timeout_seconds = 500;
+ test_params_.quic_params.idle_connection_timeout =
+ base::TimeDelta::FromSeconds(500);
Initialize();
factory_->set_require_confirmation(false);
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
@@ -7260,17 +7261,18 @@
base::RunLoop().RunUntilIdle();
// Ack delay time.
- int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
- EXPECT_GT(kDefaultRetransmittableOnWireTimeoutMillisecs, delay);
+ base::TimeDelta delay = task_runner->NextPendingTaskDelay();
+ EXPECT_GT(kDefaultRetransmittableOnWireTimeout, delay);
// Fire the ack alarm, since ack has been sent, no ack will be sent.
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
// Fire the ping alarm with retransmittable-on-wire timeout, send PING.
- delay = kDefaultRetransmittableOnWireTimeoutMillisecs - delay;
- EXPECT_EQ(base::TimeDelta::FromMilliseconds(delay),
- task_runner->NextPendingTaskDelay());
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ delay = kDefaultRetransmittableOnWireTimeout - delay;
+ EXPECT_EQ(delay, task_runner->NextPendingTaskDelay());
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
socket_data1.Resume();
@@ -7298,8 +7300,9 @@
// enabled, and a custom retransmittable on wire timeout is specified, the
// custom value is used.
TEST_P(QuicStreamFactoryTest, CustomRetransmittableOnWireTimeoutForMigration) {
- int custom_timeout_value = 200;
- test_params_.quic_params.retransmittable_on_wire_timeout_milliseconds =
+ constexpr base::TimeDelta custom_timeout_value =
+ base::TimeDelta::FromMilliseconds(200);
+ test_params_.quic_params.retransmittable_on_wire_timeout =
custom_timeout_value;
InitializeConnectionMigrationV2Test(
{kDefaultNetworkForTests, kNewNetworkForTests});
@@ -7405,17 +7408,18 @@
base::RunLoop().RunUntilIdle();
// Ack delay time.
- int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+ base::TimeDelta delay = task_runner->NextPendingTaskDelay();
EXPECT_GT(custom_timeout_value, delay);
// Fire the ack alarm, since ack has been sent, no ack will be sent.
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
// Fire the ping alarm with retransmittable-on-wire timeout, send PING.
delay = custom_timeout_value - delay;
- EXPECT_EQ(base::TimeDelta::FromMilliseconds(delay),
- task_runner->NextPendingTaskDelay());
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ EXPECT_EQ(delay, task_runner->NextPendingTaskDelay());
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
socket_data1.Resume();
@@ -7443,8 +7447,9 @@
// retransmittable-on-wire timeout is specified, the ping alarm is set up to
// send retransmittable pings with the custom value.
TEST_P(QuicStreamFactoryTest, CustomRetransmittableOnWireTimeout) {
- int custom_timeout_value = 200;
- test_params_.quic_params.retransmittable_on_wire_timeout_milliseconds =
+ constexpr base::TimeDelta custom_timeout_value =
+ base::TimeDelta::FromMilliseconds(200);
+ test_params_.quic_params.retransmittable_on_wire_timeout =
custom_timeout_value;
Initialize();
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
@@ -7534,17 +7539,18 @@
base::RunLoop().RunUntilIdle();
// Ack delay time.
- int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+ base::TimeDelta delay = task_runner->NextPendingTaskDelay();
EXPECT_GT(custom_timeout_value, delay);
// Fire the ack alarm, since ack has been sent, no ack will be sent.
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
// Fire the ping alarm with retransmittable-on-wire timeout, send PING.
delay = custom_timeout_value - delay;
- EXPECT_EQ(base::TimeDelta::FromMilliseconds(delay),
- task_runner->NextPendingTaskDelay());
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ EXPECT_EQ(delay, task_runner->NextPendingTaskDelay());
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
socket_data1.Resume();
@@ -7654,17 +7660,19 @@
base::RunLoop().RunUntilIdle();
// Ack delay time.
- int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
- EXPECT_GT(kDefaultRetransmittableOnWireTimeoutMillisecs, delay);
+ base::TimeDelta delay = task_runner->NextPendingTaskDelay();
+ EXPECT_GT(kDefaultRetransmittableOnWireTimeout, delay);
// Fire the ack alarm, since ack has been sent, no ack will be sent.
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
// Verify that the ping alarm is not set with any default value.
- int wrong_delay = kDefaultRetransmittableOnWireTimeoutMillisecs - delay;
- delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+ base::TimeDelta wrong_delay = kDefaultRetransmittableOnWireTimeout - delay;
+ delay = task_runner->NextPendingTaskDelay();
EXPECT_NE(wrong_delay, delay);
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
// Verify that response headers on the migrated socket were delivered to the
@@ -7688,8 +7696,9 @@
// send retransmittable pings to the peer with custom value.
TEST_P(QuicStreamFactoryTest,
CustomeRetransmittableOnWireTimeoutWithMigrationOnNetworkChangeOnly) {
- int custom_timeout_value = 200;
- test_params_.quic_params.retransmittable_on_wire_timeout_milliseconds =
+ constexpr base::TimeDelta custom_timeout_value =
+ base::TimeDelta::FromMilliseconds(200);
+ test_params_.quic_params.retransmittable_on_wire_timeout =
custom_timeout_value;
test_params_.quic_params.migrate_sessions_on_network_change_v2 = true;
Initialize();
@@ -7780,17 +7789,18 @@
base::RunLoop().RunUntilIdle();
// Ack delay time.
- int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+ base::TimeDelta delay = task_runner->NextPendingTaskDelay();
EXPECT_GT(custom_timeout_value, delay);
// Fire the ack alarm, since ack has been sent, no ack will be sent.
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
// Fire the ping alarm with retransmittable-on-wire timeout, send PING.
delay = custom_timeout_value - delay;
- EXPECT_EQ(base::TimeDelta::FromMilliseconds(delay),
- task_runner->NextPendingTaskDelay());
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ EXPECT_EQ(delay, task_runner->NextPendingTaskDelay());
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
socket_data1.Resume();
@@ -7902,17 +7912,19 @@
base::RunLoop().RunUntilIdle();
// Ack delay time.
- int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
- EXPECT_GT(kDefaultRetransmittableOnWireTimeoutMillisecs, delay);
+ base::TimeDelta delay = task_runner->NextPendingTaskDelay();
+ EXPECT_GT(kDefaultRetransmittableOnWireTimeout, delay);
// Fire the ack alarm, since ack has been sent, no ack will be sent.
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
// Verify ping alarm is not set with default value.
- int wrong_delay = kDefaultRetransmittableOnWireTimeoutMillisecs - delay;
- delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+ base::TimeDelta wrong_delay = kDefaultRetransmittableOnWireTimeout - delay;
+ delay = task_runner->NextPendingTaskDelay();
EXPECT_NE(wrong_delay, delay);
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+ clock_.AdvanceTime(
+ quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
// Verify that response headers on the migrated socket were delivered to the
@@ -8843,7 +8855,8 @@
}
TEST_P(QuicStreamFactoryTest, ReducePingTimeoutOnConnectionTimeOutOpenStreams) {
- test_params_.quic_params.reduced_ping_timeout_seconds = 10;
+ test_params_.quic_params.reduced_ping_timeout =
+ base::TimeDelta::FromSeconds(10);
Initialize();
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
@@ -9747,12 +9760,14 @@
EXPECT_EQ(DEFAULT_PRIORITY, host_resolver_->request_priority(2));
}
-// Passes |quic_max_time_before_crypto_handshake_seconds| and
-// |quic_max_idle_time_before_crypto_handshake_seconds| to QuicStreamFactory,
+// Passes |quic_max_time_before_crypto_handshake| and
+// |quic_max_idle_time_before_crypto_handshake| to QuicStreamFactory,
// checks that its internal quic::QuicConfig is correct.
TEST_P(QuicStreamFactoryTest, ConfigMaxTimeBeforeCryptoHandshake) {
- test_params_.quic_params.max_time_before_crypto_handshake_seconds = 11;
- test_params_.quic_params.max_idle_time_before_crypto_handshake_seconds = 13;
+ test_params_.quic_params.max_time_before_crypto_handshake =
+ base::TimeDelta::FromSeconds(11);
+ test_params_.quic_params.max_idle_time_before_crypto_handshake =
+ base::TimeDelta::FromSeconds(13);
Initialize();
const quic::QuicConfig* config =
@@ -11070,8 +11085,9 @@
}
TEST_P(QuicStreamFactoryTest, ConfigInitialRttForHandshake) {
- int kInitialRtt = 400;
- test_params_.quic_params.initial_rtt_for_handshake_milliseconds = kInitialRtt;
+ constexpr base::TimeDelta kInitialRtt =
+ base::TimeDelta::FromMilliseconds(400);
+ test_params_.quic_params.initial_rtt_for_handshake = kInitialRtt;
crypto_client_stream_factory_.set_handshake_mode(
MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
Initialize();
@@ -11110,19 +11126,17 @@
// The pending task is scheduled for handshake timeout retransmission,
// which is 2 * 400ms with crypto frames and 1.5 * 400ms otherwise.
- int handshake_timeout =
+ base::TimeDelta handshake_timeout =
QuicVersionUsesCryptoFrames(version_.transport_version)
? 2 * kInitialRtt
: 1.5 * kInitialRtt;
- EXPECT_EQ(base::TimeDelta::FromMilliseconds(handshake_timeout),
- task_runner->NextPendingTaskDelay());
+ EXPECT_EQ(handshake_timeout, task_runner->NextPendingTaskDelay());
// The alarm factory dependes on |clock_|, so clock is advanced to trigger
// retransmission alarm.
- clock_.AdvanceTime(
- quic::QuicTime::Delta::FromMilliseconds(handshake_timeout));
- task_runner->FastForwardBy(
- base::TimeDelta::FromMilliseconds(handshake_timeout));
+ clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(
+ handshake_timeout.InMilliseconds()));
+ task_runner->FastForwardBy(handshake_timeout);
crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
quic::QuicSession::HANDSHAKE_CONFIRMED);
