diff options
Diffstat (limited to 'third_party/libwebrtc/p2p/base/ice_controller_interface.h')
-rw-r--r-- | third_party/libwebrtc/p2p/base/ice_controller_interface.h | 138 |
1 files changed, 138 insertions, 0 deletions
diff --git a/third_party/libwebrtc/p2p/base/ice_controller_interface.h b/third_party/libwebrtc/p2p/base/ice_controller_interface.h new file mode 100644 index 0000000000..482043ef35 --- /dev/null +++ b/third_party/libwebrtc/p2p/base/ice_controller_interface.h @@ -0,0 +1,138 @@ +/* + * 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_ICE_CONTROLLER_INTERFACE_H_ +#define P2P_BASE_ICE_CONTROLLER_INTERFACE_H_ + +#include <string> +#include <utility> +#include <vector> + +#include "absl/types/optional.h" +#include "p2p/base/connection.h" +#include "p2p/base/ice_switch_reason.h" +#include "p2p/base/ice_transport_internal.h" + +namespace cricket { + +struct IceFieldTrials; // Forward declaration to avoid circular dependency. + +struct IceRecheckEvent { + IceRecheckEvent(IceSwitchReason _reason, int _recheck_delay_ms) + : reason(_reason), recheck_delay_ms(_recheck_delay_ms) {} + + std::string ToString() const; + + IceSwitchReason reason; + int recheck_delay_ms; +}; + +// Defines the interface for a module that control +// - which connection to ping +// - which connection to use +// - which connection to prune +// - which connection to forget learned state on +// +// The P2PTransportChannel owns (creates and destroys) Connections, +// but P2PTransportChannel gives const pointers to the the IceController using +// `AddConnection`, i.e the IceController should not call any non-const methods +// on a Connection but signal back in the interface if any mutable function +// shall be called. +// +// Current these are limited to: +// Connection::Ping - returned in PingResult +// Connection::Prune - retuned in PruneConnections +// Connection::ForgetLearnedState - return in SwitchResult +// +// The IceController shall keep track of all connections added +// (and not destroyed) and give them back using the connections()-function- +// +// When a Connection gets destroyed +// - signals on Connection::SignalDestroyed +// - P2PTransportChannel calls IceController::OnConnectionDestroyed +class IceControllerInterface { + public: + // This represents the result of a switch call. + struct SwitchResult { + // Connection that we should (optionally) switch to. + absl::optional<const Connection*> connection; + + // An optional recheck event for when a Switch() should be attempted again. + absl::optional<IceRecheckEvent> recheck_event; + + // A vector with connection to run ForgetLearnedState on. + std::vector<const Connection*> connections_to_forget_state_on; + }; + + // This represents the result of a call to SelectConnectionToPing. + struct PingResult { + PingResult(const Connection* conn, int _recheck_delay_ms) + : connection(conn ? absl::optional<const Connection*>(conn) + : absl::nullopt), + recheck_delay_ms(_recheck_delay_ms) {} + + // Connection that we should (optionally) ping. + const absl::optional<const Connection*> connection; + + // The delay before P2PTransportChannel shall call SelectConnectionToPing() + // again. + // + // Since the IceController determines which connection to ping and + // only returns one connection at a time, the recheck_delay_ms does not have + // any obvious implication on bitrate for pings. E.g the recheck_delay_ms + // will be shorter if there are more connections available. + const int recheck_delay_ms = 0; + }; + + virtual ~IceControllerInterface() = default; + + // These setters are called when the state of P2PTransportChannel is mutated. + virtual void SetIceConfig(const IceConfig& config) = 0; + virtual void SetSelectedConnection(const Connection* selected_connection) = 0; + virtual void AddConnection(const Connection* connection) = 0; + virtual void OnConnectionDestroyed(const Connection* connection) = 0; + + // These are all connections that has been added and not destroyed. + virtual rtc::ArrayView<const Connection*> connections() const = 0; + + // Is there a pingable connection ? + // This function is used to boot-strap pinging, after this returns true + // SelectConnectionToPing() will be called periodically. + virtual bool HasPingableConnection() const = 0; + + // Select a connection to Ping, or nullptr if none. + virtual PingResult SelectConnectionToPing(int64_t last_ping_sent_ms) = 0; + + // Compute the "STUN_ATTR_USE_CANDIDATE" for `conn`. + virtual bool GetUseCandidateAttr(const Connection* conn, + NominationMode mode, + IceMode remote_ice_mode) const = 0; + + // These methods is only added to not have to change all unit tests + // that simulate pinging by marking a connection pinged. + virtual const Connection* FindNextPingableConnection() = 0; + virtual void MarkConnectionPinged(const Connection* con) = 0; + + // Check if we should switch to `connection`. + // This method is called for IceSwitchReasons that can switch directly + // i.e without resorting. + virtual SwitchResult ShouldSwitchConnection(IceSwitchReason reason, + const Connection* connection) = 0; + + // Sort connections and check if we should switch. + virtual SwitchResult SortAndSwitchConnection(IceSwitchReason reason) = 0; + + // Prune connections. + virtual std::vector<const Connection*> PruneConnections() = 0; +}; + +} // namespace cricket + +#endif // P2P_BASE_ICE_CONTROLLER_INTERFACE_H_ |