summaryrefslogtreecommitdiffstats
path: root/third_party/libwebrtc/p2p/base/basic_ice_controller.h
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/libwebrtc/p2p/base/basic_ice_controller.h')
-rw-r--r--third_party/libwebrtc/p2p/base/basic_ice_controller.h165
1 files changed, 165 insertions, 0 deletions
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 <algorithm>
+#include <map>
+#include <set>
+#include <utility>
+#include <vector>
+
+#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<const Connection*> connections() const override {
+ return rtc::ArrayView<const Connection*>(
+ const_cast<const Connection**>(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<const Connection*> 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<const rtc::Network*, const Connection*> GetBestConnectionByNetwork()
+ const;
+ std::vector<const Connection*> GetBestWritableConnectionPerNetwork() const;
+
+ bool ReadyToSend(const Connection* connection) const;
+ bool PresumedWritable(const Connection* conn) const;
+
+ int CompareCandidatePairNetworks(
+ const Connection* a,
+ const Connection* b,
+ absl::optional<rtc::AdapterType> 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<int64_t> 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<int64_t> receiving_unchanged_threshold,
+ bool* missed_receiving_unchanged_threshold) const;
+
+ SwitchResult HandleInitialSelectDampening(IceSwitchReason reason,
+ const Connection* new_connection);
+
+ std::function<IceTransportState()> ice_transport_state_func_;
+ std::function<IceRole()> ice_role_func_;
+ std::function<bool(const Connection*)> 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<const Connection*> connections_;
+ std::set<const Connection*> pinged_connections_;
+ std::set<const Connection*> 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_