From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- .../libwebrtc/p2p/base/basic_ice_controller.h | 165 +++++++++++++++++++++ 1 file changed, 165 insertions(+) create mode 100644 third_party/libwebrtc/p2p/base/basic_ice_controller.h (limited to 'third_party/libwebrtc/p2p/base/basic_ice_controller.h') diff --git a/third_party/libwebrtc/p2p/base/basic_ice_controller.h b/third_party/libwebrtc/p2p/base/basic_ice_controller.h new file mode 100644 index 0000000000..b941a0dd7e --- /dev/null +++ b/third_party/libwebrtc/p2p/base/basic_ice_controller.h @@ -0,0 +1,165 @@ +/* + * Copyright 2019 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef P2P_BASE_BASIC_ICE_CONTROLLER_H_ +#define P2P_BASE_BASIC_ICE_CONTROLLER_H_ + +#include +#include +#include +#include +#include + +#include "p2p/base/ice_controller_factory_interface.h" +#include "p2p/base/ice_controller_interface.h" +#include "p2p/base/p2p_transport_channel.h" + +namespace cricket { + +class BasicIceController : public IceControllerInterface { + public: + explicit BasicIceController(const IceControllerFactoryArgs& args); + virtual ~BasicIceController(); + + void SetIceConfig(const IceConfig& config) override; + void SetSelectedConnection(const Connection* selected_connection) override; + void AddConnection(const Connection* connection) override; + void OnConnectionDestroyed(const Connection* connection) override; + rtc::ArrayView connections() const override { + return rtc::ArrayView( + const_cast(connections_.data()), + connections_.size()); + } + + bool HasPingableConnection() const override; + + PingResult SelectConnectionToPing(int64_t last_ping_sent_ms) override; + + bool GetUseCandidateAttr(const Connection* conn, + NominationMode mode, + IceMode remote_ice_mode) const override; + + SwitchResult ShouldSwitchConnection(IceSwitchReason reason, + const Connection* connection) override; + SwitchResult SortAndSwitchConnection(IceSwitchReason reason) override; + + std::vector PruneConnections() override; + + // These methods are only for tests. + const Connection* FindNextPingableConnection() override; + void MarkConnectionPinged(const Connection* conn) override; + + private: + // A transport channel is weak if the current best connection is either + // not receiving or not writable, or if there is no best connection at all. + bool weak() const { + return !selected_connection_ || selected_connection_->weak(); + } + + int weak_ping_interval() const { + return std::max(config_.ice_check_interval_weak_connectivity_or_default(), + config_.ice_check_min_interval_or_default()); + } + + int strong_ping_interval() const { + return std::max(config_.ice_check_interval_strong_connectivity_or_default(), + config_.ice_check_min_interval_or_default()); + } + + int check_receiving_interval() const { + return std::max(MIN_CHECK_RECEIVING_INTERVAL, + config_.receiving_timeout_or_default() / 10); + } + + const Connection* FindOldestConnectionNeedingTriggeredCheck(int64_t now); + // Between `conn1` and `conn2`, this function returns the one which should + // be pinged first. + const Connection* MorePingable(const Connection* conn1, + const Connection* conn2); + // Select the connection which is Relay/Relay. If both of them are, + // UDP relay protocol takes precedence. + const Connection* MostLikelyToWork(const Connection* conn1, + const Connection* conn2); + // Compare the last_ping_sent time and return the one least recently pinged. + const Connection* LeastRecentlyPinged(const Connection* conn1, + const Connection* conn2); + + bool IsPingable(const Connection* conn, int64_t now) const; + bool IsBackupConnection(const Connection* conn) const; + // Whether a writable connection is past its ping interval and needs to be + // pinged again. + bool WritableConnectionPastPingInterval(const Connection* conn, + int64_t now) const; + int CalculateActiveWritablePingInterval(const Connection* conn, + int64_t now) const; + + std::map GetBestConnectionByNetwork() + const; + std::vector GetBestWritableConnectionPerNetwork() const; + + bool ReadyToSend(const Connection* connection) const; + bool PresumedWritable(const Connection* conn) const; + + int CompareCandidatePairNetworks( + const Connection* a, + const Connection* b, + absl::optional network_preference) const; + + // The methods below return a positive value if `a` is preferable to `b`, + // a negative value if `b` is preferable, and 0 if they're equally preferable. + // If `receiving_unchanged_threshold` is set, then when `b` is receiving and + // `a` is not, returns a negative value only if `b` has been in receiving + // state and `a` has been in not receiving state since + // `receiving_unchanged_threshold` and sets + // `missed_receiving_unchanged_threshold` to true otherwise. + int CompareConnectionStates( + const Connection* a, + const Connection* b, + absl::optional receiving_unchanged_threshold, + bool* missed_receiving_unchanged_threshold) const; + int CompareConnectionCandidates(const Connection* a, + const Connection* b) const; + // Compares two connections based on the connection states + // (writable/receiving/connected), nomination states, last data received time, + // and static preferences. Does not include latency. Used by both sorting + // and ShouldSwitchSelectedConnection(). + // Returns a positive value if `a` is better than `b`. + int CompareConnections(const Connection* a, + const Connection* b, + absl::optional receiving_unchanged_threshold, + bool* missed_receiving_unchanged_threshold) const; + + SwitchResult HandleInitialSelectDampening(IceSwitchReason reason, + const Connection* new_connection); + + std::function ice_transport_state_func_; + std::function ice_role_func_; + std::function is_connection_pruned_func_; + + IceConfig config_; + const IceFieldTrials* field_trials_; + + // `connections_` is a sorted list with the first one always be the + // `selected_connection_` when it's not nullptr. The combination of + // `pinged_connections_` and `unpinged_connections_` has the same + // connections as `connections_`. These 2 sets maintain whether a + // connection should be pinged next or not. + const Connection* selected_connection_ = nullptr; + std::vector connections_; + std::set pinged_connections_; + std::set unpinged_connections_; + + // Timestamp for when we got the first selectable connection. + int64_t initial_select_timestamp_ms_ = 0; +}; + +} // namespace cricket + +#endif // P2P_BASE_BASIC_ICE_CONTROLLER_H_ -- cgit v1.2.3