zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Extend rtc::AdapterType with 2g, 3G, 4G & 5G enum values.

Browse Source 
This patch adds new enum values for different types of cellular
connections.

The new costs are currently blocked when sending to remote,
(so that arbitrary network switches does not starts occurring).

The end-game for this series to be able to distinguish between
different type of cellular connections in the ice-layer (e.g when
selecting/switching connections).

BUG: webrtc:11473
Change-Id: I587ac8fdff4f6cdd0f8905f327232f58818db4f6
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172582
Commit-Queue: Jonas Oreland <jonaso@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30970}
This commit is contained in:
Jonas Oreland
2020-04-02 07:19:12 +02:00
committed by Commit Bot
parent 01c107e37a
commit 08d1806e54
8 changed files with 79 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
p2p/base/connection.cc
View File

@ -106,18 +106,24 @@ webrtc::IceCandidatePairAddressFamily GetAddressFamilyByInt(
}
webrtc::IceCandidateNetworkType ConvertNetworkType(rtc::AdapterType type) {
if (type == rtc::ADAPTER_TYPE_ETHERNET) {
switch (type) {
case rtc::ADAPTER_TYPE_ETHERNET:
return webrtc::IceCandidateNetworkType::kEthernet;
} else if (type == rtc::ADAPTER_TYPE_LOOPBACK) {
case rtc::ADAPTER_TYPE_LOOPBACK:
return webrtc::IceCandidateNetworkType::kLoopback;
} else if (type == rtc::ADAPTER_TYPE_WIFI) {
case rtc::ADAPTER_TYPE_WIFI:
return webrtc::IceCandidateNetworkType::kWifi;
} else if (type == rtc::ADAPTER_TYPE_VPN) {
case rtc::ADAPTER_TYPE_VPN:
return webrtc::IceCandidateNetworkType::kVpn;
} else if (type == rtc::ADAPTER_TYPE_CELLULAR) {
case rtc::ADAPTER_TYPE_CELLULAR:
case rtc::ADAPTER_TYPE_CELLULAR_2G:
case rtc::ADAPTER_TYPE_CELLULAR_3G:
case rtc::ADAPTER_TYPE_CELLULAR_4G:
case rtc::ADAPTER_TYPE_CELLULAR_5G:
return webrtc::IceCandidateNetworkType::kCellular;
}
default:
return webrtc::IceCandidateNetworkType::kUnknown;
}
}
// When we don't have any RTT data, we have to pick something reasonable. We

10
p2p/base/p2p_transport_channel.cc
View File

@ -66,8 +66,16 @@ rtc::AdapterType GuessAdapterTypeFromNetworkCost(int network_cost) {
return rtc::ADAPTER_TYPE_ETHERNET;
case rtc::kNetworkCostLow:
return rtc::ADAPTER_TYPE_WIFI;
case rtc::kNetworkCostHigh:
case rtc::kNetworkCostCellular:
return rtc::ADAPTER_TYPE_CELLULAR;
case rtc::kNetworkCostCellular2G:
return rtc::ADAPTER_TYPE_CELLULAR_2G;
case rtc::kNetworkCostCellular3G:
return rtc::ADAPTER_TYPE_CELLULAR_3G;
case rtc::kNetworkCostCellular4G:
return rtc::ADAPTER_TYPE_CELLULAR_4G;
case rtc::kNetworkCostCellular5G:
return rtc::ADAPTER_TYPE_CELLULAR_5G;
case rtc::kNetworkCostUnknown:
return rtc::ADAPTER_TYPE_UNKNOWN;
case rtc::kNetworkCostMax:

4
pc/rtc_stats_collector.cc
View File

@ -184,6 +184,10 @@ const char* DtlsTransportStateToRTCDtlsTransportState(
const char* NetworkAdapterTypeToStatsType(rtc::AdapterType type) {
switch (type) {
case rtc::ADAPTER_TYPE_CELLULAR:
case rtc::ADAPTER_TYPE_CELLULAR_2G:
case rtc::ADAPTER_TYPE_CELLULAR_3G:
case rtc::ADAPTER_TYPE_CELLULAR_4G:
case rtc::ADAPTER_TYPE_CELLULAR_5G:
return RTCNetworkType::kCellular;
case rtc::ADAPTER_TYPE_ETHERNET:
return RTCNetworkType::kEthernet;

4
pc/stats_collector.cc
View File

@ -483,6 +483,10 @@ const char* AdapterTypeToStatsType(rtc::AdapterType type) {
case rtc::ADAPTER_TYPE_WIFI:
return STATSREPORT_ADAPTER_TYPE_WIFI;
case rtc::ADAPTER_TYPE_CELLULAR:
case rtc::ADAPTER_TYPE_CELLULAR_2G:
case rtc::ADAPTER_TYPE_CELLULAR_3G:
case rtc::ADAPTER_TYPE_CELLULAR_4G:
case rtc::ADAPTER_TYPE_CELLULAR_5G:
return STATSREPORT_ADAPTER_TYPE_WWAN;
case rtc::ADAPTER_TYPE_VPN:
return STATSREPORT_ADAPTER_TYPE_VPN;

8
rtc_base/network.cc
View File

@ -86,6 +86,8 @@ bool SortNetworks(const Network* a, const Network* b) {
}
uint16_t ComputeNetworkCostByType(int type) {
// TODO(jonaso) : Rollout support for cellular network cost using A/B
// experiment to make sure it does not introduce regressions.
switch (type) {
case rtc::ADAPTER_TYPE_ETHERNET:
case rtc::ADAPTER_TYPE_LOOPBACK:
@ -93,7 +95,11 @@ uint16_t ComputeNetworkCostByType(int type) {
case rtc::ADAPTER_TYPE_WIFI:
return kNetworkCostLow;
case rtc::ADAPTER_TYPE_CELLULAR:
return kNetworkCostHigh;
case rtc::ADAPTER_TYPE_CELLULAR_2G:
case rtc::ADAPTER_TYPE_CELLULAR_3G:
case rtc::ADAPTER_TYPE_CELLULAR_4G:
case rtc::ADAPTER_TYPE_CELLULAR_5G:
return kNetworkCostCellular;
case rtc::ADAPTER_TYPE_ANY:
// Candidates gathered from the any-address/wildcard ports, as backups,
// are given the maximum cost so that if there are other candidates with

13
rtc_base/network.h
View File

@ -409,6 +409,19 @@ class RTC_EXPORT Network {
bool IsVpn() const { return type_ == ADAPTER_TYPE_VPN; }
bool IsCellular() const {
switch (type_) {
case ADAPTER_TYPE_CELLULAR:
case ADAPTER_TYPE_CELLULAR_2G:
case ADAPTER_TYPE_CELLULAR_3G:
case ADAPTER_TYPE_CELLULAR_4G:
case ADAPTER_TYPE_CELLULAR_5G:
return true;
default:
return false;
}
}
uint16_t GetCost() const;
// A unique id assigned by the network manager, which may be signaled
// to the remote side in the candidate.

8
rtc_base/network_constants.cc
View File

@ -26,6 +26,14 @@ std::string AdapterTypeToString(AdapterType type) {
return "Wifi";
case ADAPTER_TYPE_CELLULAR:
return "Cellular";
case ADAPTER_TYPE_CELLULAR_2G:
return "Cellular2G";
case ADAPTER_TYPE_CELLULAR_3G:
return "Cellular3G";
case ADAPTER_TYPE_CELLULAR_4G:
return "Cellular4G";
case ADAPTER_TYPE_CELLULAR_5G:
return "Cellular5G";
case ADAPTER_TYPE_VPN:
return "VPN";
case ADAPTER_TYPE_LOOPBACK:

23
rtc_base/network_constants.h
View File

@ -17,18 +17,25 @@
namespace rtc {
static const uint16_t kNetworkCostMax = 999;
static const uint16_t kNetworkCostHigh = 900;
static const uint16_t kNetworkCostUnknown = 50;
static const uint16_t kNetworkCostLow = 10;
static const uint16_t kNetworkCostMin = 0;
constexpr uint16_t kNetworkCostMax = 999;
constexpr uint16_t kNetworkCostCellular2G = 980;
constexpr uint16_t kNetworkCostCellular3G = 910;
constexpr uint16_t kNetworkCostCellular = 900;
constexpr uint16_t kNetworkCostCellular4G = 500;
constexpr uint16_t kNetworkCostCellular5G = 250;
constexpr uint16_t kNetworkCostUnknown = 50;
constexpr uint16_t kNetworkCostLow = 10;
constexpr uint16_t kNetworkCostMin = 0;
// alias
constexpr uint16_t kNetworkCostHigh = kNetworkCostCellular;
enum AdapterType {
// This enum resembles the one in Chromium net::ConnectionType.
ADAPTER_TYPE_UNKNOWN = 0,
ADAPTER_TYPE_ETHERNET = 1 << 0,
ADAPTER_TYPE_WIFI = 1 << 1,
ADAPTER_TYPE_CELLULAR = 1 << 2,
ADAPTER_TYPE_CELLULAR = 1 << 2, // This is CELLULAR of unknown type.
ADAPTER_TYPE_VPN = 1 << 3,
ADAPTER_TYPE_LOOPBACK = 1 << 4,
// ADAPTER_TYPE_ANY is used for a network, which only contains a single "any
@ -37,6 +44,10 @@ enum AdapterType {
// when the network uses a specific interface/IP, but its interface type can
// not be determined or not fit in this enum.
ADAPTER_TYPE_ANY = 1 << 5,
ADAPTER_TYPE_CELLULAR_2G = 1 << 6,
ADAPTER_TYPE_CELLULAR_3G = 1 << 7,
ADAPTER_TYPE_CELLULAR_4G = 1 << 8,
ADAPTER_TYPE_CELLULAR_5G = 1 << 9
};
std::string AdapterTypeToString(AdapterType type);