commit c12d76104a631b4060a1038bba5b50c47a174963 parent af50d1bf5c69f586a4f210994e4e8322f5620d8d Author: Dan Baker <dbaker@mozilla.com> Date: Wed, 19 Nov 2025 21:43:17 -0700 Bug 2000941 - Vendor libwebrtc from 1de952a79d Upstream commit: https://webrtc.googlesource.com/src/+/1de952a79de780b2855991638e16d1e69e944b5e Use TimeDelta to represent p2p constants Rename them to follow constant name rule https://google.github.io/styleguide/cppguide.html#Constant_Names instead of of naming those constans like macros. Bug: webrtc:42223979 Change-Id: I5b8d41709cdc6092fa92276a6f5e15b27d9a14da Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/407541 Commit-Queue: Danil Chapovalov <danilchap@webrtc.org> Reviewed-by: Per Kjellander <perkj@webrtc.org> Cr-Commit-Position: refs/heads/main@{#45541} Diffstat:
15 files changed, 102 insertions(+), 119 deletions(-)
diff --git a/third_party/libwebrtc/README.mozilla.last-vendor b/third_party/libwebrtc/README.mozilla.last-vendor @@ -1,4 +1,4 @@ # ./mach python dom/media/webrtc/third_party_build/vendor-libwebrtc.py --from-local /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc --commit mozpatches libwebrtc -libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-11-20T04:40:41.912731+00:00. +libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-11-20T04:43:02.001877+00:00. # base of lastest vendoring -1a3b4f5c04 +1de952a79d diff --git a/third_party/libwebrtc/p2p/base/basic_ice_controller.cc b/third_party/libwebrtc/p2p/base/basic_ice_controller.cc @@ -130,7 +130,7 @@ IceControllerInterface::PingResult BasicIceController::SelectConnectionToPing( bool need_more_pings_at_weak_interval = absl::c_any_of(connections_, [](const Connection* conn) { return conn->active() && - conn->num_pings_sent() < MIN_PINGS_AT_WEAK_PING_INTERVAL; + conn->num_pings_sent() < kMinPingsAtWeakPingInterval; }); int ping_interval = (weak() || need_more_pings_at_weak_interval) ? weak_ping_interval() @@ -273,15 +273,15 @@ int BasicIceController::CalculateActiveWritablePingInterval( const Connection* conn, int64_t now) const { // Ping each connection at a higher rate at least - // MIN_PINGS_AT_WEAK_PING_INTERVAL times. - if (conn->num_pings_sent() < MIN_PINGS_AT_WEAK_PING_INTERVAL) { + // kMinPingsAtWeakPingInterval times. + if (conn->num_pings_sent() < kMinPingsAtWeakPingInterval) { return weak_ping_interval(); } int stable_interval = config_.stable_writable_connection_ping_interval_or_default(); - int weak_or_stablizing_interval = std::min( - stable_interval, WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL); + int weak_or_stablizing_interval = std::min<int>( + stable_interval, kWeakOrStabilizingWritableConnectionPingInterval.ms()); // If the channel is weak or the connection is not stable yet, use the // weak_or_stablizing_interval. return (!weak() && conn->stable(now)) ? stable_interval diff --git a/third_party/libwebrtc/p2p/base/basic_ice_controller.h b/third_party/libwebrtc/p2p/base/basic_ice_controller.h @@ -87,8 +87,8 @@ class BasicIceController : public IceControllerInterface { } int check_receiving_interval() const { - return std::max(MIN_CHECK_RECEIVING_INTERVAL, - config_.receiving_timeout_or_default() / 10); + return std::max<int>(kMinCheckReceivingInterval.ms(), + config_.receiving_timeout_or_default() / 10); } const Connection* FindOldestConnectionNeedingTriggeredCheck(int64_t now); diff --git a/third_party/libwebrtc/p2p/base/connection.cc b/third_party/libwebrtc/p2p/base/connection.cc @@ -225,7 +225,7 @@ void Connection::ConnectionRequest::OnSent() { } int Connection::ConnectionRequest::resend_delay() { - return CONNECTION_RESPONSE_TIMEOUT; + return kConnectionResponseTimeout.ms(); } Connection::Connection(const Environment& env, @@ -419,7 +419,7 @@ void Connection::SetUnwritableTimeout(std::optional<TimeDelta> value) { int Connection::unwritable_min_checks() const { RTC_DCHECK_RUN_ON(network_thread_); - return unwritable_min_checks_.value_or(CONNECTION_WRITE_CONNECT_FAILURES); + return unwritable_min_checks_.value_or(kConnectionWriteConnectFailures); } void Connection::set_unwritable_min_checks(const std::optional<int>& value) { @@ -795,7 +795,7 @@ void Connection::SendStunBindingResponse(const StunMessage* message) { response.AddAttribute(std::make_unique<StunUInt32Attribute>( STUN_ATTR_RETRANSMIT_COUNT, retransmit_attr->value())); - if (retransmit_attr->value() > CONNECTION_WRITE_CONNECT_FAILURES) { + if (retransmit_attr->value() > kConnectionWriteConnectFailures) { RTC_LOG(LS_INFO) << ToString() << ": Received a remote ping with high retransmit count: " diff --git a/third_party/libwebrtc/p2p/base/ice_transport_internal.cc b/third_party/libwebrtc/p2p/base/ice_transport_internal.cc @@ -145,48 +145,49 @@ IceConfig::IceConfig(const PeerConnectionInterface::RTCConfiguration& config) IceConfig::~IceConfig() = default; int IceConfig::receiving_timeout_or_default() const { - return receiving_timeout.value_or(RECEIVING_TIMEOUT); + return receiving_timeout.value_or(kReceivingTimeout.ms()); } int IceConfig::backup_connection_ping_interval_or_default() const { return backup_connection_ping_interval.value_or( - BACKUP_CONNECTION_PING_INTERVAL); + kBackupConnectionPingInterval.ms()); } int IceConfig::stable_writable_connection_ping_interval_or_default() const { return stable_writable_connection_ping_interval.value_or( - STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL); + kStrongAndStableWritableConnectionPingInterval.ms()); } int IceConfig::regather_on_failed_networks_interval_or_default() const { return regather_on_failed_networks_interval.value_or( - REGATHER_ON_FAILED_NETWORKS_INTERVAL); + kRegatherOnFailedNetworksInterval.ms()); } int IceConfig::receiving_switching_delay_or_default() const { - return receiving_switching_delay.value_or(RECEIVING_SWITCHING_DELAY); + return receiving_switching_delay.value_or(kReceivingSwitchingDelay.ms()); } int IceConfig::ice_check_interval_strong_connectivity_or_default() const { - return ice_check_interval_strong_connectivity.value_or(STRONG_PING_INTERVAL); + return ice_check_interval_strong_connectivity.value_or( + kStrongPingInterval.ms()); } int IceConfig::ice_check_interval_weak_connectivity_or_default() const { - return ice_check_interval_weak_connectivity.value_or(WEAK_PING_INTERVAL); + return ice_check_interval_weak_connectivity.value_or(kWeakPingInterval.ms()); } int IceConfig::ice_check_min_interval_or_default() const { return ice_check_min_interval.value_or(-1); } int IceConfig::ice_unwritable_timeout_or_default() const { - return ice_unwritable_timeout.value_or(CONNECTION_WRITE_CONNECT_TIMEOUT); + return ice_unwritable_timeout.value_or(kConnectionWriteConnectTimeout.ms()); } int IceConfig::ice_unwritable_min_checks_or_default() const { - return ice_unwritable_min_checks.value_or(CONNECTION_WRITE_CONNECT_FAILURES); + return ice_unwritable_min_checks.value_or(kConnectionWriteConnectFailures); } int IceConfig::ice_inactive_timeout_or_default() const { - return ice_inactive_timeout.value_or(CONNECTION_WRITE_TIMEOUT); + return ice_inactive_timeout.value_or(kConnectionWriteTimeout.ms()); } int IceConfig::stun_keepalive_interval_or_default() const { - return stun_keepalive_interval.value_or(STUN_KEEPALIVE_INTERVAL); + return stun_keepalive_interval.value_or(kStunKeepaliveInterval.ms()); } RTCError IceConfig::IsValid() const { if (ice_check_interval_strong_connectivity_or_default() < - ice_check_interval_weak_connectivity.value_or(WEAK_PING_INTERVAL)) { + ice_check_interval_weak_connectivity.value_or(kWeakPingInterval.ms())) { return RTCError(RTCErrorType::INVALID_PARAMETER, "Ping interval of candidate pairs is shorter when ICE is " "strongly connected than that when ICE is weakly " diff --git a/third_party/libwebrtc/p2p/base/ice_transport_internal.h b/third_party/libwebrtc/p2p/base/ice_transport_internal.h @@ -169,12 +169,12 @@ struct RTC_EXPORT IceConfig { // The interval in milliseconds at which ICE checks (STUN pings) will be sent // for a candidate pair when it is both writable and receiving (strong // connectivity). This parameter overrides the default value given by - // `STRONG_PING_INTERVAL` in p2ptransport.h if set. + // `kStrongPingInterval` in p2ptransport.h if set. std::optional<int> ice_check_interval_strong_connectivity; // The interval in milliseconds at which ICE checks (STUN pings) will be sent // for a candidate pair when it is either not writable or not receiving (weak // connectivity). This parameter overrides the default value given by - // `WEAK_PING_INTERVAL` in p2ptransport.h if set. + // `kWeakPingInterval` in p2ptransport.h if set. std::optional<int> ice_check_interval_weak_connectivity; // ICE checks (STUN pings) will not be sent at higher rate (lower interval) // than this, no matter what other settings there are. @@ -192,13 +192,13 @@ struct RTC_EXPORT IceConfig { // The min number of connectivity checks that a candidate pair must sent // without receiving response before it becomes unwritable. This parameter - // overrides the default value given by `CONNECTION_WRITE_CONNECT_FAILURES` in + // overrides the default value given by `kConnectionWriteConnectTimeout` in // port.h if set, when determining the writability of a candidate pair. std::optional<int> ice_unwritable_min_checks; // The min time period for which a candidate pair must wait for response to // connectivity checks it becomes inactive. This parameter overrides the - // default value given by `CONNECTION_WRITE_TIMEOUT` in port.h if set, when + // default value given by `kConnectionWriteTimeout` in port.h if set, when // determining the writability of a candidate pair. std::optional<int> ice_inactive_timeout; diff --git a/third_party/libwebrtc/p2p/base/p2p_constants.cc b/third_party/libwebrtc/p2p/base/p2p_constants.cc @@ -50,12 +50,6 @@ const char CONNECTIONROLE_HOLDCONN_STR[] = "holdconn"; const char LOCAL_TLD[] = ".local"; -const int MIN_CHECK_RECEIVING_INTERVAL = 50; -const int RECEIVING_TIMEOUT = MIN_CHECK_RECEIVING_INTERVAL * 50; -const int RECEIVING_SWITCHING_DELAY = 1000; -const int BACKUP_CONNECTION_PING_INTERVAL = 25 * 1000; -const int REGATHER_ON_FAILED_NETWORKS_INTERVAL = 5 * 60 * 1000; - // When the socket is unwritable, we will use 10 Kbps (ignoring IP+UDP headers) // for pinging. When the socket is writable, we will use only 1 Kbps because we // don't want to degrade the quality on a modem. These numbers should work well @@ -67,12 +61,4 @@ static_assert(kStrongPingInterval == static_assert(kWeakPingInterval == kStunPingPacketSize / DataRate::BitsPerSec(10'000)); -const uint32_t CONNECTION_WRITE_CONNECT_FAILURES = 5; // 5 pings - -const int STUN_KEEPALIVE_INTERVAL = 10 * 1000; // 10 seconds - -// There is no harm to keep this value high other than a small amount -// of increased memory, but in some networks (2G), we observe up to 60s RTTs. -const int CONNECTION_RESPONSE_TIMEOUT = 60 * 1000; // 60 seconds - } // namespace webrtc diff --git a/third_party/libwebrtc/p2p/base/p2p_constants.h b/third_party/libwebrtc/p2p/base/p2p_constants.h @@ -56,63 +56,54 @@ extern const char CONNECTIONROLE_HOLDCONN_STR[]; // RFC 6762, the .local pseudo-top-level domain used for mDNS names. extern const char LOCAL_TLD[]; -// Constants for time intervals are in milliseconds unless otherwise stated. -// // Most of the following constants are the default values of IceConfig // paramters. See IceConfig for detailed definition. // -// Default value of IceConfig.receiving_timeout. -extern const int RECEIVING_TIMEOUT; // Default value IceConfig.ice_check_min_interval. -extern const int MIN_CHECK_RECEIVING_INTERVAL; +inline constexpr TimeDelta kMinCheckReceivingInterval = TimeDelta::Millis(50); +// Default value of IceConfig.receiving_timeout. +inline constexpr TimeDelta kReceivingTimeout = kMinCheckReceivingInterval * 50; // The next two ping intervals are at the ICE transport level. // -// STRONG_PING_INTERVAL is applied when the selected connection is both +// kStrongPingInterval is applied when the selected connection is both // writable and receiving. // // Default value of IceConfig.ice_check_interval_strong_connectivity. inline constexpr TimeDelta kStrongPingInterval = TimeDelta::Millis(480); -inline constexpr int STRONG_PING_INTERVAL = kStrongPingInterval.ms(); -// WEAK_PING_INTERVAL is applied when the selected connection is either +// kWeakPingInterval is applied when the selected connection is either // not writable or not receiving. // // Defaul value of IceConfig.ice_check_interval_weak_connectivity. inline constexpr TimeDelta kWeakPingInterval = TimeDelta::Millis(48); -inline constexpr int WEAK_PING_INTERVAL = kWeakPingInterval.ms(); // The next two ping intervals are at the candidate pair level. // // Writable candidate pairs are pinged at a slower rate once they are stabilized // and the channel is strongly connected. inline constexpr TimeDelta kStrongAndStableWritableConnectionPingInterval = TimeDelta::Millis(2'500); -inline constexpr int STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL = - kStrongAndStableWritableConnectionPingInterval.ms(); // Writable candidate pairs are pinged at a faster rate while the connections // are stabilizing or the channel is weak. inline constexpr TimeDelta kWeakOrStabilizingWritableConnectionPingInterval = TimeDelta::Millis(900); -inline constexpr int WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL = - kWeakOrStabilizingWritableConnectionPingInterval.ms(); // Default value of IceConfig.backup_connection_ping_interval -extern const int BACKUP_CONNECTION_PING_INTERVAL; +inline constexpr TimeDelta kBackupConnectionPingInterval = + TimeDelta::Seconds(25); // Defualt value of IceConfig.receiving_switching_delay. -extern const int RECEIVING_SWITCHING_DELAY; +inline constexpr TimeDelta kReceivingSwitchingDelay = TimeDelta::Seconds(1); // Default value of IceConfig.regather_on_failed_networks_interval. -extern const int REGATHER_ON_FAILED_NETWORKS_INTERVAL; +inline constexpr TimeDelta kRegatherOnFailedNetworksInterval = + TimeDelta::Seconds(5 * 60); // Default vaule of IceConfig.ice_unwritable_timeout. inline constexpr TimeDelta kConnectionWriteConnectTimeout = TimeDelta::Seconds(5); -inline constexpr int CONNECTION_WRITE_CONNECT_TIMEOUT = - kConnectionWriteConnectTimeout.ms(); // Default vaule of IceConfig.ice_unwritable_min_checks. -extern const uint32_t CONNECTION_WRITE_CONNECT_FAILURES; +inline constexpr int kConnectionWriteConnectFailures = 5; // 5 pings // Default value of IceConfig.ice_inactive_timeout; inline constexpr TimeDelta kConnectionWriteTimeout = TimeDelta::Seconds(15); -inline constexpr int CONNECTION_WRITE_TIMEOUT = kConnectionWriteTimeout.ms(); // Default value of IceConfig.stun_keepalive_interval; -extern const int STUN_KEEPALIVE_INTERVAL; +inline constexpr TimeDelta kStunKeepaliveInterval = TimeDelta::Seconds(10); -inline constexpr int MIN_PINGS_AT_WEAK_PING_INTERVAL = 3; +inline constexpr int kMinPingsAtWeakPingInterval = 3; // The following constants are used at the candidate pair level to determine the // state of a candidate pair. @@ -124,14 +115,13 @@ inline constexpr TimeDelta kWeakConnectionReceiveTimeout = // long. inline constexpr TimeDelta kDeadConnectionReceiveTimeout = TimeDelta::Seconds(30); -inline constexpr int DEAD_CONNECTION_RECEIVE_TIMEOUT = - kDeadConnectionReceiveTimeout.ms(); // This is the length of time that we wait for a ping response to come back. -extern const int CONNECTION_RESPONSE_TIMEOUT; +// There is no harm to keep this value high other than a small amount +// of increased memory, but in some networks (2G), we observe up to 60s RTTs. +inline constexpr TimeDelta kConnectionResponseTimeout = TimeDelta::Seconds(60); // The minimum time we will wait before destroying a connection after creating // it. inline constexpr TimeDelta kMinConnectionLifetime = TimeDelta::Seconds(10); -inline constexpr int MIN_CONNECTION_LIFETIME = kMinConnectionLifetime.ms(); // The type preference MUST be an integer from 0 to 126 inclusive. // https://datatracker.ietf.org/doc/html/rfc5245#section-4.1.2.1 diff --git a/third_party/libwebrtc/p2p/base/p2p_transport_channel.cc b/third_party/libwebrtc/p2p/base/p2p_transport_channel.cc @@ -97,7 +97,7 @@ uint32_t GetWeakPingIntervalInFieldTrial(const FieldTrialsView& field_trials) { if (weak_ping_interval) { return static_cast<int>(weak_ping_interval); } - return WEAK_PING_INTERVAL; + return kWeakPingInterval.ms(); } RouteEndpoint CreateRouteEndpointFromCandidate(bool local, @@ -187,14 +187,14 @@ P2PTransportChannel::P2PTransportChannel( ice_role_(ICEROLE_UNKNOWN), gathering_state_(kIceGatheringNew), weak_ping_interval_(GetWeakPingIntervalInFieldTrial(env_.field_trials())), - config_(RECEIVING_TIMEOUT, - BACKUP_CONNECTION_PING_INTERVAL, + config_(kReceivingTimeout.ms(), + kBackupConnectionPingInterval.ms(), GATHER_ONCE /* continual_gathering_policy */, false /* prioritize_most_likely_candidate_pairs */, - STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL, + kStrongAndStableWritableConnectionPingInterval.ms(), true /* presume_writable_when_fully_relayed */, - REGATHER_ON_FAILED_NETWORKS_INTERVAL, - RECEIVING_SWITCHING_DELAY) { + kRegatherOnFailedNetworksInterval.ms(), + kReceivingSwitchingDelay.ms()) { TRACE_EVENT0("webrtc", "P2PTransportChannel::P2PTransportChannel"); RTC_DCHECK(allocator_ != nullptr); RTC_DCHECK(!transport_name_.empty()); @@ -828,8 +828,8 @@ const Connection* P2PTransportChannel::selected_connection() const { int P2PTransportChannel::check_receiving_interval() const { RTC_DCHECK_RUN_ON(network_thread_); - return std::max(MIN_CHECK_RECEIVING_INTERVAL, - config_.receiving_timeout_or_default() / 10); + return std::max<int>(kMinCheckReceivingInterval.ms(), + config_.receiving_timeout_or_default() / 10); } void P2PTransportChannel::MaybeStartGathering() { diff --git a/third_party/libwebrtc/p2p/base/p2p_transport_channel.h b/third_party/libwebrtc/p2p/base/p2p_transport_channel.h @@ -484,7 +484,8 @@ class RTC_EXPORT P2PTransportChannel : public IceTransportInternal, std::unique_ptr<BasicRegatheringController> regathering_controller_ RTC_GUARDED_BY(network_thread_); Timestamp last_ping_sent_ RTC_GUARDED_BY(network_thread_) = Timestamp::Zero(); - int weak_ping_interval_ RTC_GUARDED_BY(network_thread_) = WEAK_PING_INTERVAL; + int weak_ping_interval_ RTC_GUARDED_BY(network_thread_) = + kWeakPingInterval.ms(); // TODO(jonasolsson): Remove state_ and rename standardized_state_ once state_ // is no longer used to compute the ICE connection state. IceTransportStateInternal state_ RTC_GUARDED_BY(network_thread_) = diff --git a/third_party/libwebrtc/p2p/base/p2p_transport_channel_unittest.cc b/third_party/libwebrtc/p2p/base/p2p_transport_channel_unittest.cc @@ -2763,7 +2763,7 @@ TEST_F(P2PTransportChannelMultihomedTest, TestFailoverWithManyConnections) { constexpr int SCHEDULING_DELAY = 200; EXPECT_LT( ping_interval1, - WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL + SCHEDULING_DELAY); + kWeakOrStabilizingWritableConnectionPingInterval.ms() + SCHEDULING_DELAY); // It should switch over to use the cellular IPv6 addr on endpoint 1 before // it timed out on writing. @@ -3849,8 +3849,8 @@ TEST_F(P2PTransportChannelPingTest, TestAllConnectionsPingedSufficiently) { conn1->ReceivedPingResponse(LOW_RTT, "id"); EXPECT_TRUE(WaitUntil( [&] { - return conn1->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL && - conn2->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL; + return conn1->num_pings_sent() >= kMinPingsAtWeakPingInterval && + conn2->num_pings_sent() >= kMinPingsAtWeakPingInterval; }, {.timeout = kDefaultTimeout})); } @@ -3877,12 +3877,12 @@ TEST_F(P2PTransportChannelPingTest, TestStunPingIntervals) { // Initializing. int64_t start = clock.TimeNanos(); - SIMULATED_WAIT(conn->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL, + SIMULATED_WAIT(conn->num_pings_sent() >= kMinPingsAtWeakPingInterval, kDefaultTimeout.ms(), clock); int64_t ping_interval_ms = (clock.TimeNanos() - start) / kNumNanosecsPerMillisec / - (MIN_PINGS_AT_WEAK_PING_INTERVAL - 1); - EXPECT_EQ(ping_interval_ms, WEAK_PING_INTERVAL); + (kMinPingsAtWeakPingInterval - 1); + EXPECT_EQ(ping_interval_ms, kWeakPingInterval.ms()); // Stabilizing. @@ -3895,10 +3895,10 @@ TEST_F(P2PTransportChannelPingTest, TestStunPingIntervals) { kMediumTimeout.ms(), clock); ping_interval_ms = (clock.TimeNanos() - start) / kNumNanosecsPerMillisec; EXPECT_GE(ping_interval_ms, - WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL); + kWeakOrStabilizingWritableConnectionPingInterval.ms()); EXPECT_LE( ping_interval_ms, - WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL + SCHEDULING_RANGE); + kWeakOrStabilizingWritableConnectionPingInterval.ms() + SCHEDULING_RANGE); // Stabilized. @@ -3913,10 +3913,10 @@ TEST_F(P2PTransportChannelPingTest, TestStunPingIntervals) { kMediumTimeout.ms(), clock); ping_interval_ms = (clock.TimeNanos() - start) / kNumNanosecsPerMillisec; EXPECT_GE(ping_interval_ms, - STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL); + kStrongAndStableWritableConnectionPingInterval.ms()); EXPECT_LE( ping_interval_ms, - STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL + SCHEDULING_RANGE); + kStrongAndStableWritableConnectionPingInterval.ms() + SCHEDULING_RANGE); // Destabilized. @@ -3935,17 +3935,17 @@ TEST_F(P2PTransportChannelPingTest, TestStunPingIntervals) { SIMULATED_WAIT(conn->num_pings_sent() == ping_sent_before + 1, kMediumTimeout.ms(), clock); // The interval is expected to be - // WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL. + // kWeakOrStabilizingWritableConnectionPingInterval. start = clock.TimeNanos(); ping_sent_before = conn->num_pings_sent(); SIMULATED_WAIT(conn->num_pings_sent() == ping_sent_before + 1, kMediumTimeout.ms(), clock); ping_interval_ms = (clock.TimeNanos() - start) / kNumNanosecsPerMillisec; EXPECT_GE(ping_interval_ms, - WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL); + kWeakOrStabilizingWritableConnectionPingInterval.ms()); EXPECT_LE( ping_interval_ms, - WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL + SCHEDULING_RANGE); + kWeakOrStabilizingWritableConnectionPingInterval.ms() + SCHEDULING_RANGE); } // Test that we start pinging as soon as we have a connection and remote ICE diff --git a/third_party/libwebrtc/p2p/base/port_unittest.cc b/third_party/libwebrtc/p2p/base/port_unittest.cc @@ -1444,10 +1444,10 @@ TEST_F(PortTest, TestSslTcpToSslTcpRelay) { */ // Test that a connection will be dead and deleted if -// i) it has never received anything for MIN_CONNECTION_LIFETIME milliseconds -// since it was created, or -// ii) it has not received anything for DEAD_CONNECTION_RECEIVE_TIMEOUT -// milliseconds since last receiving. +// i) it has never received anything for kMinConnectionLifetime since +// it was created, or +// ii) it has not received anything for kDeadConnectionReceiveTimeout since +// last receiving. TEST_F(PortTest, TestConnectionDead) { TestChannel ch1(CreateUdpPort(kLocalAddr1)); TestChannel ch2(CreateUdpPort(kLocalAddr2)); @@ -1467,17 +1467,17 @@ TEST_F(PortTest, TestConnectionDead) { int64_t after_created = TimeMillis(); Connection* conn = ch1.conn(); ASSERT_NE(conn, nullptr); - // It is not dead if it is after MIN_CONNECTION_LIFETIME but not pruned. - conn->UpdateState(after_created + MIN_CONNECTION_LIFETIME + 1); + // It is not dead if it is after kMinConnectionLifetime but not pruned. + conn->UpdateState(after_created + kMinConnectionLifetime.ms() + 1); Thread::Current()->ProcessMessages(0); EXPECT_TRUE(ch1.conn() != nullptr); - // It is not dead if it is before MIN_CONNECTION_LIFETIME and pruned. - conn->UpdateState(before_created + MIN_CONNECTION_LIFETIME - 1); + // It is not dead if it is before kMinConnectionLifetime and pruned. + conn->UpdateState(before_created + kMinConnectionLifetime.ms() - 1); conn->Prune(); Thread::Current()->ProcessMessages(0); EXPECT_TRUE(ch1.conn() != nullptr); - // It will be dead after MIN_CONNECTION_LIFETIME and pruned. - conn->UpdateState(after_created + MIN_CONNECTION_LIFETIME + 1); + // It will be dead after kMinConnectionLifetime and pruned. + conn->UpdateState(after_created + kMinConnectionLifetime.ms() + 1); EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), {.timeout = TimeDelta::Millis(kDefaultTimeout)}), IsRtcOk()); @@ -1490,12 +1490,13 @@ TEST_F(PortTest, TestConnectionDead) { int64_t before_last_receiving = TimeMillis(); conn->ReceivedPing(); int64_t after_last_receiving = TimeMillis(); - // The connection will be dead after DEAD_CONNECTION_RECEIVE_TIMEOUT - conn->UpdateState(before_last_receiving + DEAD_CONNECTION_RECEIVE_TIMEOUT - + // The connection will be dead after kDeadConnectionReceiveTimeout + conn->UpdateState(before_last_receiving + kDeadConnectionReceiveTimeout.ms() - 1); Thread::Current()->ProcessMessages(100); EXPECT_TRUE(ch1.conn() != nullptr); - conn->UpdateState(after_last_receiving + DEAD_CONNECTION_RECEIVE_TIMEOUT + 1); + conn->UpdateState(after_last_receiving + kDeadConnectionReceiveTimeout.ms() + + 1); EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), {.timeout = TimeDelta::Millis(kDefaultTimeout)}), IsRtcOk()); @@ -1575,10 +1576,12 @@ TEST_F(PortTest, TestConnectionDeadOutstandingPing) { conn->Ping(send_ping_timestamp); // The connection will be dead 30s after the ping was sent. - conn->UpdateState(send_ping_timestamp + DEAD_CONNECTION_RECEIVE_TIMEOUT - 1); + conn->UpdateState(send_ping_timestamp + kDeadConnectionReceiveTimeout.ms() - + 1); Thread::Current()->ProcessMessages(100); EXPECT_TRUE(ch1.conn() != nullptr); - conn->UpdateState(send_ping_timestamp + DEAD_CONNECTION_RECEIVE_TIMEOUT + 1); + conn->UpdateState(send_ping_timestamp + kDeadConnectionReceiveTimeout.ms() + + 1); EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), {.timeout = TimeDelta::Millis(kDefaultTimeout)}), IsRtcOk()); @@ -3140,11 +3143,11 @@ TEST_F(PortTest, TestWritableState) { // Ask the connection to update state as if enough time has passed to lose // full writability and 5 pings went unresponded to. We'll accomplish the // latter by sending pings but not pumping messages. - for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) { + for (uint32_t i = 1; i <= kConnectionWriteConnectFailures; ++i) { ch1.Ping(i); } int unreliable_timeout_delay = - CONNECTION_WRITE_CONNECT_TIMEOUT + kMaxExpectedSimulatedRtt; + kConnectionWriteConnectTimeout.ms() + kMaxExpectedSimulatedRtt; ch1.conn()->UpdateState(unreliable_timeout_delay); EXPECT_EQ(Connection::STATE_WRITE_UNRELIABLE, ch1.conn()->write_state()); @@ -3160,10 +3163,11 @@ TEST_F(PortTest, TestWritableState) { IsRtcOk()); // Wait long enough for a full timeout (past however long we've already // waited). - for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) { + for (uint32_t i = 1; i <= kConnectionWriteConnectFailures; ++i) { ch1.Ping(unreliable_timeout_delay + i); } - ch1.conn()->UpdateState(unreliable_timeout_delay + CONNECTION_WRITE_TIMEOUT + + ch1.conn()->UpdateState(unreliable_timeout_delay + + kConnectionWriteTimeout.ms() + kMaxExpectedSimulatedRtt); EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state()); @@ -3176,8 +3180,8 @@ TEST_F(PortTest, TestWritableState) { } // Test writability states using the configured threshold value to replace -// the default value given by `CONNECTION_WRITE_CONNECT_TIMEOUT` and -// `CONNECTION_WRITE_CONNECT_FAILURES`. +// the default value given by `kConnectionWriteConnectTimeout` and +// `kConnectionWriteConnectFailures`. TEST_F(PortTest, TestWritableStateWithConfiguredThreshold) { ScopedFakeClock clock; auto port1 = CreateUdpPort(kLocalAddr1); @@ -3261,10 +3265,11 @@ TEST_F(PortTest, TestTimeoutForNeverWritable) { EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state()); // Attempt to go directly to write timeout. - for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) { + for (uint32_t i = 1; i <= kConnectionWriteConnectFailures; ++i) { ch1.Ping(i); } - ch1.conn()->UpdateState(CONNECTION_WRITE_TIMEOUT + kMaxExpectedSimulatedRtt); + ch1.conn()->UpdateState(kConnectionWriteTimeout.ms() + + kMaxExpectedSimulatedRtt); EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state()); } diff --git a/third_party/libwebrtc/p2p/base/regathering_controller.h b/third_party/libwebrtc/p2p/base/regathering_controller.h @@ -50,7 +50,7 @@ class BasicRegatheringController : public sigslot::has_slots<> { public: struct Config { int regather_on_failed_networks_interval = - REGATHER_ON_FAILED_NETWORKS_INTERVAL; + kRegatherOnFailedNetworksInterval.ms(); }; BasicRegatheringController() = delete; diff --git a/third_party/libwebrtc/p2p/base/stun_port.cc b/third_party/libwebrtc/p2p/base/stun_port.cc @@ -190,7 +190,7 @@ UDPPort::UDPPort(const PortParametersRef& args, socket_(socket), error_(0), ready_(false), - stun_keepalive_delay_(STUN_KEEPALIVE_INTERVAL), + stun_keepalive_delay_(kStunKeepaliveInterval.ms()), dscp_(DSCP_NO_CHANGE), emit_local_for_anyaddress_(emit_local_for_anyaddress) {} @@ -208,7 +208,7 @@ UDPPort::UDPPort(const PortParametersRef& args, socket_(nullptr), error_(0), ready_(false), - stun_keepalive_delay_(STUN_KEEPALIVE_INTERVAL), + stun_keepalive_delay_(kStunKeepaliveInterval.ms()), dscp_(DSCP_NO_CHANGE), emit_local_for_anyaddress_(emit_local_for_anyaddress) {} @@ -364,7 +364,7 @@ void UDPPort::GetStunStats(std::optional<StunStats>* stats) { } void UDPPort::set_stun_keepalive_delay(const std::optional<int>& delay) { - stun_keepalive_delay_ = delay.value_or(STUN_KEEPALIVE_INTERVAL); + stun_keepalive_delay_ = delay.value_or(kStunKeepaliveInterval.ms()); } void UDPPort::OnLocalAddressReady(AsyncPacketSocket* /* socket */, diff --git a/third_party/libwebrtc/p2p/base/tcp_port.cc b/third_party/libwebrtc/p2p/base/tcp_port.cc @@ -340,7 +340,7 @@ void TCPPort::OnReadyToSend(AsyncPacketSocket* socket) { Port::OnReadyToSend(); } -// TODO(qingsi): `CONNECTION_WRITE_CONNECT_TIMEOUT` is overriden by +// TODO(qingsi): `kConnectionWriteConnectTimeout` is overriden by // `ice_unwritable_timeout` in IceConfig when determining the writability state. // Replace this constant with the config parameter assuming the default value if // we decide it is also applicable here. @@ -354,7 +354,7 @@ TCPConnection::TCPConnection(const Environment& env, outgoing_(socket == nullptr), connection_pending_(false), pretending_to_be_writable_(false), - reconnection_timeout_(CONNECTION_WRITE_CONNECT_TIMEOUT) { + reconnection_timeout_(kConnectionWriteConnectTimeout.ms()) { RTC_DCHECK_RUN_ON(network_thread()); RTC_DCHECK_EQ(port()->GetProtocol(), PROTO_TCP); // Needs to be TCPPort.