admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete old versions of GetNetworks and GetAnyAddressNetworks

Browse Source 
Bug: webrtc:13869
Change-Id: I8a54b875a06345ac6a762673aba9ca51d79f0a82
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/256967
Reviewed-by: Jonas Oreland <jonaso@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36479}
This commit is contained in:
Niels Möller 2022-04-07 11:43:28 +02:00 committed by WebRTC LUCI CQ
parent 5831afb832
commit 2221144d01
10 changed files with 100 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
examples/stunprober/main.cc
View File

@ -131,8 +131,7 @@ int main(int argc, char* argv[]) {
std::make_unique<rtc::BasicPacketSocketFactory>(&socket_server);
std::unique_ptr<rtc::BasicNetworkManager> network_manager(
new rtc::BasicNetworkManager(&socket_server, &field_trials));
rtc::NetworkManager::NetworkList networks;
network_manager->GetNetworks(&networks);
std::vector<const rtc::Network*> networks = network_manager->GetNetworks();
auto prober = std::make_unique<StunProber>(socket_factory.get(),
rtc::Thread::Current(), networks);
auto finish_callback = [&thread](StunProber* prober, int result) {

20
p2p/stunprober/stun_prober.cc
View File

@ -38,16 +38,6 @@ void IncrementCounterByAddress(std::map<T, int>* counter_per_ip, const T& ip) {
counter_per_ip->insert(std::make_pair(ip, 0)).first->second++;
}
std::vector<const rtc::Network*> NetworkListToConst(
const rtc::NetworkManager::NetworkList networks) {
std::vector<const rtc::Network*> result;
result.reserve(networks.size());
for (const rtc::Network* network : networks) {
result.push_back(network);
}
return result;
}
} // namespace
// A requester tracks the requests and responses from a single socket to many
@ -263,21 +253,13 @@ void StunProber::ObserverAdapter::OnFinished(StunProber* stunprober,
callback_(stunprober, status);
}
StunProber::StunProber(rtc::PacketSocketFactory* socket_factory,
rtc::Thread* thread,
const rtc::NetworkManager::NetworkList& networks)
: interval_ms_(0),
socket_factory_(socket_factory),
thread_(thread),
networks_(NetworkListToConst(networks)) {}
StunProber::StunProber(rtc::PacketSocketFactory* socket_factory,
rtc::Thread* thread,
std::vector<const rtc::Network*> networks)
: interval_ms_(0),
socket_factory_(socket_factory),
thread_(thread),
networks_(networks) {}
networks_(std::move(networks)) {}
StunProber::~StunProber() {
RTC_DCHECK(thread_checker_.IsCurrent());

6
p2p/stunprober/stun_prober.h
View File

@ -95,12 +95,6 @@ class RTC_EXPORT StunProber : public sigslot::has_slots<> {
std::set<std::string> srflx_addrs;
};
// TODO(bugs.webrtc.org/13869): Delete, use constructor with const
// rtc::Network*.
ABSL_DEPRECATED("bugs.webrtc.org/13869")
StunProber(rtc::PacketSocketFactory* socket_factory,
rtc::Thread* thread,
const rtc::NetworkManager::NetworkList& networks);
StunProber(rtc::PacketSocketFactory* socket_factory,
rtc::Thread* thread,
std::vector<const rtc::Network*> networks);

15
p2p/stunprober/stun_prober_unittest.cc
View File

@ -59,12 +59,13 @@ class StunProberTest : public ::testing::Test {
bool shared_socket,
uint16_t interval,
uint16_t pings_per_ip) {
prober = std::make_unique<StunProber>(
prober_ = std::make_unique<StunProber>(
socket_factory, rtc::Thread::Current(), std::move(networks));
prober->Start(addrs, shared_socket, interval, pings_per_ip,
100 /* timeout_ms */, [this](StunProber* prober, int result) {
this->StopCallback(prober, result);
});
prober_->Start(addrs, shared_socket, interval, pings_per_ip,
100 /* timeout_ms */,
[this](StunProber* prober, int result) {
StopCallback(prober, result);
});
}
void RunProber(bool shared_mode) {
@ -100,7 +101,7 @@ class StunProberTest : public ::testing::Test {
WAIT(stopped_, 1000);
StunProber::Stats stats;
EXPECT_TRUE(prober->GetStats(&stats));
EXPECT_TRUE(prober_->GetStats(&stats));
EXPECT_EQ(stats.success_percent, 100);
EXPECT_TRUE(stats.nat_type > stunprober::NATTYPE_NONE);
EXPECT_EQ(stats.srflx_addrs, srflx_addresses);
@ -118,7 +119,7 @@ class StunProberTest : public ::testing::Test {
std::unique_ptr<rtc::VirtualSocketServer> ss_;
rtc::AutoSocketServerThread main_;
std::unique_ptr<StunProber> prober;
std::unique_ptr<StunProber> prober_;
int result_ = 0;
bool stopped_ = false;
std::unique_ptr<cricket::TestStunServer> stun_server_1_;

3
pc/peer_connection_bundle_unittest.cc
View File

@ -92,13 +92,14 @@ constexpr int kDefaultTimeout = 10000;
class FakeNetworkManagerWithNoAnyNetwork : public rtc::FakeNetworkManager {
public:
void GetAnyAddressNetworks(NetworkList* networks) override {
std::vector<const rtc::Network*> GetAnyAddressNetworks() override {
// This function allocates networks that are owned by the
// NetworkManager. But some tests assume that they can release
// all networks independent of the network manager.
// In order to prevent use-after-free issues, don't allow this
// function to have any effect when run in tests.
RTC_LOG(LS_INFO) << "FakeNetworkManager::GetAnyAddressNetworks ignored";
return {};
}
};

6
rtc_base/nat_unittest.cc
View File

@ -227,8 +227,7 @@ void TestPhysicalInternal(const SocketAddress& int_addr) {
// Process pending messages so the network list is updated.
Thread::Current()->ProcessMessages(0);
std::vector<Network*> networks;
network_manager.GetNetworks(&networks);
std::vector<const Network*> networks = network_manager.GetNetworks();
networks.erase(std::remove_if(networks.begin(), networks.end(),
[](const rtc::Network* network) {
return rtc::kDefaultNetworkIgnoreMask &
@ -244,8 +243,7 @@ void TestPhysicalInternal(const SocketAddress& int_addr) {
SocketAddress ext_addr2;
// Find an available IP with matching family. The test breaks if int_addr
// can't talk to ip, so check for connectivity as well.
for (std::vector<Network*>::iterator it = networks.begin();
it != networks.end(); ++it) {
for (auto it = networks.begin(); it != networks.end(); ++it) {
const IPAddress& ip = (*it)->GetBestIP();
if (ip.family() == int_addr.family() && TestConnectivity(int_addr, ip)) {
ext_addr2.SetIP(ip);

26
rtc_base/network.cc
View File

@ -300,31 +300,34 @@ NetworkManagerBase::enumeration_permission() const {
return enumeration_permission_;
}
void NetworkManagerBase::GetAnyAddressNetworks(NetworkList* networks) {
std::vector<const Network*> NetworkManagerBase::GetAnyAddressNetworks() {
std::vector<const Network*> networks;
if (!ipv4_any_address_network_) {
const rtc::IPAddress ipv4_any_address(INADDR_ANY);
ipv4_any_address_network_.reset(
new rtc::Network("any", "any", ipv4_any_address, 0, ADAPTER_TYPE_ANY));
ipv4_any_address_network_ = std::make_unique<Network>(
"any", "any", ipv4_any_address, 0, ADAPTER_TYPE_ANY);
ipv4_any_address_network_->set_default_local_address_provider(this);
ipv4_any_address_network_->set_mdns_responder_provider(this);
ipv4_any_address_network_->AddIP(ipv4_any_address);
}
networks->push_back(ipv4_any_address_network_.get());
networks.push_back(ipv4_any_address_network_.get());
if (!ipv6_any_address_network_) {
const rtc::IPAddress ipv6_any_address(in6addr_any);
ipv6_any_address_network_.reset(
new rtc::Network("any", "any", ipv6_any_address, 0, ADAPTER_TYPE_ANY));
ipv6_any_address_network_ = std::make_unique<Network>(
"any", "any", ipv6_any_address, 0, ADAPTER_TYPE_ANY);
ipv6_any_address_network_->set_default_local_address_provider(this);
ipv6_any_address_network_->set_mdns_responder_provider(this);
ipv6_any_address_network_->AddIP(ipv6_any_address);
}
networks->push_back(ipv6_any_address_network_.get());
networks.push_back(ipv6_any_address_network_.get());
return networks;
}
void NetworkManagerBase::GetNetworks(NetworkList* result) const {
result->clear();
result->insert(result->begin(), networks_.begin(), networks_.end());
std::vector<const Network*> NetworkManagerBase::GetNetworks() const {
std::vector<const Network*> result;
result.insert(result.begin(), networks_.begin(), networks_.end());
return result;
}
void NetworkManagerBase::MergeNetworkList(const NetworkList& new_networks,
@ -1027,8 +1030,7 @@ void BasicNetworkManager::UpdateNetworksContinually() {
void BasicNetworkManager::DumpNetworks() {
RTC_DCHECK_RUN_ON(thread_);
NetworkList list;
GetNetworks(&list);
std::vector<const Network*> list = GetNetworks();
RTC_LOG(LS_INFO) << "NetworkManager detected " << list.size() << " networks:";
for (const Network* network : list) {
RTC_LOG(LS_INFO) << network->ToString() << ": " << network->description()

41
rtc_base/network.h
View File

@ -19,6 +19,7 @@
#include <string>
#include <vector>
#include "absl/base/attributes.h"
#include "absl/strings/string_view.h"
#include "api/array_view.h"
#include "api/field_trials_view.h"
@ -147,21 +148,17 @@ class RTC_EXPORT NetworkManager : public DefaultLocalAddressProvider,
virtual void StartUpdating() = 0;
virtual void StopUpdating() = 0;
// TODO(bugs.webrtc.org/13869): Delete after override in downstream subclasses
// is deleted.
ABSL_DEPRECATED("bugs.webrtc.org/13869")
virtual void GetNetworks(NetworkList* networks) const {}
// Returns the current list of networks available on this machine.
// StartUpdating() must be called before this method is called.
// It makes sure that repeated calls return the same object for a
// given network, so that quality is tracked appropriately. Does not
// include ignored networks.
virtual std::vector<const Network*> GetNetworks() const {
std::vector<Network*> networks;
std::vector<const Network*> const_networks;
GetNetworks(&networks);
const_networks.insert(const_networks.begin(), networks.begin(),
networks.end());
return const_networks;
}
// TODO(bugs.webrtc.org/13869): Delete this overload.
virtual void GetNetworks(NetworkList* networks) const = 0;
virtual std::vector<const Network*> GetNetworks() const = 0;
// Returns the current permission state of GetNetworks().
virtual EnumerationPermission enumeration_permission() const;
@ -173,18 +170,7 @@ class RTC_EXPORT NetworkManager : public DefaultLocalAddressProvider,
//
// This method appends the "any address" networks to the list, such that this
// can optionally be called after GetNetworks.
//
// TODO(guoweis): remove this body when chromium implements this.
virtual std::vector<const Network*> GetAnyAddressNetworks() {
std::vector<Network*> networks;
std::vector<const Network*> const_networks;
GetAnyAddressNetworks(&networks);
const_networks.insert(const_networks.begin(), networks.begin(),
networks.end());
return const_networks;
}
// TODO(bugs.webrtc.org/13869): Delete this overload.
virtual void GetAnyAddressNetworks(NetworkList* networks) {}
virtual std::vector<const Network*> GetAnyAddressNetworks() = 0;
// Dumps the current list of networks in the network manager.
virtual void DumpNetworks() {}
@ -211,13 +197,8 @@ class RTC_EXPORT NetworkManagerBase : public NetworkManager {
NetworkManagerBase(const webrtc::FieldTrialsView* field_trials = nullptr);
~NetworkManagerBase() override;
// The using declarations are needed to inherit new signature variant.
// TODO(bugs.webrtc.org/13869): Delete using declarations when old signature
// is replaced.
using NetworkManager::GetAnyAddressNetworks;
using NetworkManager::GetNetworks;
void GetNetworks(NetworkList* networks) const override;
void GetAnyAddressNetworks(NetworkList* networks) override;
std::vector<const Network*> GetNetworks() const override;
std::vector<const Network*> GetAnyAddressNetworks() override;
EnumerationPermission enumeration_permission() const override;
@ -230,7 +211,7 @@ class RTC_EXPORT NetworkManagerBase : public NetworkManager {
protected:
typedef std::map<std::string, Network*> NetworkMap;
// Updates `networks_` with the networks listed in `list`. If
// `network_map_` already has a Network object for a network listed
// `networks_map_` already has a Network object for a network listed
// in the `list` then it is reused. Accept ownership of the Network
// objects in the `list`. `changed` will be set to true if there is
// any change in the network list.

134
rtc_base/network_unittest.cc
View File

@ -192,8 +192,7 @@ class NetworkTest : public ::testing::Test, public sigslot::has_slots<> {
}
AdapterType GetAdapterType(BasicNetworkManager& network_manager) {
BasicNetworkManager::NetworkList list;
network_manager.GetNetworks(&list);
std::vector<const Network*> list = network_manager.GetNetworks();
RTC_CHECK_EQ(1, list.size());
return list[0]->type();
}
@ -462,13 +461,12 @@ TEST_F(NetworkTest, TestBasicMergeNetworkList) {
EXPECT_EQ(stats.ipv4_network_count, 1);
list.clear();
manager.GetNetworks(&list);
EXPECT_EQ(1U, list.size());
EXPECT_TRUE(SameNameAndPrefix(ipv4_network1, *list[0]));
Network* net1 = list[0];
std::vector<const rtc::Network*> current = manager.GetNetworks();
EXPECT_EQ(1U, current.size());
EXPECT_TRUE(SameNameAndPrefix(ipv4_network1, *current[0]));
const Network* net1 = current[0];
uint16_t net_id1 = net1->id();
EXPECT_EQ(1, net_id1);
list.clear();
// Replace ipv4_network1 with ipv4_network2.
list.push_back(new Network(ipv4_network2));
@ -478,14 +476,13 @@ TEST_F(NetworkTest, TestBasicMergeNetworkList) {
EXPECT_EQ(stats.ipv4_network_count, 1);
list.clear();
manager.GetNetworks(&list);
EXPECT_EQ(1U, list.size());
EXPECT_TRUE(SameNameAndPrefix(ipv4_network2, *list[0]));
Network* net2 = list[0];
current = manager.GetNetworks();
EXPECT_EQ(1U, current.size());
EXPECT_TRUE(SameNameAndPrefix(ipv4_network2, *current[0]));
const Network* net2 = current[0];
uint16_t net_id2 = net2->id();
// Network id will increase.
EXPECT_LT(net_id1, net_id2);
list.clear();
// Add Network2 back.
list.push_back(new Network(ipv4_network1));
@ -497,13 +494,12 @@ TEST_F(NetworkTest, TestBasicMergeNetworkList) {
list.clear();
// Verify that we get previous instances of Network objects.
manager.GetNetworks(&list);
EXPECT_EQ(2U, list.size());
EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
(net1 == list[1] && net2 == list[0]));
EXPECT_TRUE((net_id1 == list[0]->id() && net_id2 == list[1]->id()) ||
(net_id1 == list[1]->id() && net_id2 == list[0]->id()));
list.clear();
current = manager.GetNetworks();
EXPECT_EQ(2U, current.size());
EXPECT_TRUE((net1 == current[0] && net2 == current[1]) ||
(net1 == current[1] && net2 == current[0]));
EXPECT_TRUE((net_id1 == current[0]->id() && net_id2 == current[1]->id()) ||
(net_id1 == current[1]->id() && net_id2 == current[0]->id()));
// Call MergeNetworkList() again and verify that we don't get update
// notification.
@ -516,13 +512,12 @@ TEST_F(NetworkTest, TestBasicMergeNetworkList) {
list.clear();
// Verify that we get previous instances of Network objects.
manager.GetNetworks(&list);
EXPECT_EQ(2U, list.size());
EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
(net1 == list[1] && net2 == list[0]));
EXPECT_TRUE((net_id1 == list[0]->id() && net_id2 == list[1]->id()) ||
(net_id1 == list[1]->id() && net_id2 == list[0]->id()));
list.clear();
current = manager.GetNetworks();
EXPECT_EQ(2U, current.size());
EXPECT_TRUE((net1 == current[0] && net2 == current[1]) ||
(net1 == current[1] && net2 == current[0]));
EXPECT_TRUE((net_id1 == current[0]->id() && net_id2 == current[1]->id()) ||
(net_id1 == current[1]->id() && net_id2 == current[0]->id()));
}
// Sets up some test IPv6 networks and appends them to list.
@ -571,8 +566,7 @@ TEST_F(NetworkTest, TestIPv6MergeNetworkList) {
EXPECT_TRUE(changed);
EXPECT_EQ(stats.ipv6_network_count, 4);
EXPECT_EQ(stats.ipv4_network_count, 0);
NetworkManager::NetworkList list;
manager.GetNetworks(&list);
std::vector<const Network*> list = manager.GetNetworks();
// Verify that the original members are in the merged list.
EXPECT_THAT(list, UnorderedElementsAreArray(original_list));
}
@ -596,8 +590,7 @@ TEST_F(NetworkTest, TestNoChangeMerge) {
changed = false;
MergeNetworkList(manager, second_list, &changed);
EXPECT_FALSE(changed);
NetworkManager::NetworkList resulting_list;
manager.GetNetworks(&resulting_list);
std::vector<const Network*> resulting_list = manager.GetNetworks();
// Verify that the original members are in the merged list.
EXPECT_THAT(resulting_list, UnorderedElementsAreArray(original_list));
// Doublecheck that the new networks aren't in the list.
@ -636,8 +629,7 @@ TEST_F(NetworkTest, MergeWithChangedIP) {
changed = false;
MergeNetworkList(manager, second_list, &changed);
EXPECT_TRUE(changed);
NetworkManager::NetworkList list;
manager.GetNetworks(&list);
std::vector<const Network*> list = manager.GetNetworks();
EXPECT_EQ(original_list.size(), list.size());
// Make sure the original network is still in the merged list.
EXPECT_THAT(list, Contains(network_to_change));
@ -673,25 +665,23 @@ TEST_F(NetworkTest, DISABLED_TestMultipleIPMergeNetworkList) {
MergeNetworkList(manager, original_list, &changed);
EXPECT_TRUE(changed);
// There should still be four networks.
NetworkManager::NetworkList list;
manager.GetNetworks(&list);
std::vector<const Network*> list = manager.GetNetworks();
EXPECT_EQ(4U, list.size());
// Check the gathered IPs.
int matchcount = 0;
for (NetworkManager::NetworkList::iterator it = list.begin();
it != list.end(); ++it) {
if (SameNameAndPrefix(**it, *original_list[2])) {
for (const Network* network : list) {
if (SameNameAndPrefix(*network, *original_list[2])) {
++matchcount;
EXPECT_EQ(1, matchcount);
// This should be the same network object as before.
EXPECT_EQ((*it), original_list[2]);
EXPECT_EQ(network, original_list[2]);
// But with two addresses now.
EXPECT_THAT((*it)->GetIPs(),
EXPECT_THAT(network->GetIPs(),
UnorderedElementsAre(InterfaceAddress(check_ip),
InterfaceAddress(ip)));
} else {
// Check the IP didn't get added anywhere it wasn't supposed to.
EXPECT_THAT((*it)->GetIPs(), Not(Contains(InterfaceAddress(ip))));
EXPECT_THAT(network->GetIPs(), Not(Contains(InterfaceAddress(ip))));
}
}
}
@ -720,20 +710,18 @@ TEST_F(NetworkTest, TestMultiplePublicNetworksOnOneInterfaceMerge) {
MergeNetworkList(manager, original_list, &changed);
EXPECT_TRUE(changed);
// There should be five networks now.
NetworkManager::NetworkList list;
manager.GetNetworks(&list);
std::vector<const Network*> list = manager.GetNetworks();
EXPECT_EQ(5U, list.size());
// Check the resulting addresses.
for (NetworkManager::NetworkList::iterator it = list.begin();
it != list.end(); ++it) {
if ((*it)->prefix() == ipv6_eth0_publicnetwork2_ip1.prefix() &&
(*it)->name() == ipv6_eth0_publicnetwork2_ip1.name()) {
for (const Network* network : list) {
if (network->prefix() == ipv6_eth0_publicnetwork2_ip1.prefix() &&
network->name() == ipv6_eth0_publicnetwork2_ip1.name()) {
// Check the new network has 1 IP and that it's the correct one.
EXPECT_EQ(1U, (*it)->GetIPs().size());
EXPECT_EQ(ip, (*it)->GetIPs().at(0));
EXPECT_EQ(1U, network->GetIPs().size());
EXPECT_EQ(ip, network->GetIPs().at(0));
} else {
// Check the IP didn't get added anywhere it wasn't supposed to.
EXPECT_THAT((*it)->GetIPs(), Not(Contains(InterfaceAddress(ip))));
EXPECT_THAT(network->GetIPs(), Not(Contains(InterfaceAddress(ip))));
}
}
}
@ -1060,8 +1048,7 @@ TEST_F(NetworkTest, TestMergeNetworkList) {
MergeNetworkList(manager, list, &changed);
EXPECT_TRUE(changed);
NetworkManager::NetworkList list2;
manager.GetNetworks(&list2);
std::vector<const Network*> list2 = manager.GetNetworks();
// Make sure the resulted networklist has only 1 element and 2
// IPAddresses.
@ -1089,9 +1076,10 @@ TEST_F(NetworkTest, TestMergeNetworkListWithInactiveNetworks) {
MergeNetworkList(manager, list, &changed);
EXPECT_TRUE(changed);
list.clear();
manager.GetNetworks(&list);
ASSERT_EQ(1U, list.size());
EXPECT_EQ(net1, list[0]);
std::vector<const Network*> current = manager.GetNetworks();
ASSERT_EQ(1U, current.size());
EXPECT_EQ(net1, current[0]);
list.clear();
Network* net2 = new Network(network2);
@ -1099,9 +1087,10 @@ TEST_F(NetworkTest, TestMergeNetworkListWithInactiveNetworks) {
MergeNetworkList(manager, list, &changed);
EXPECT_TRUE(changed);
list.clear();
manager.GetNetworks(&list);
ASSERT_EQ(1U, list.size());
EXPECT_EQ(net2, list[0]);
current = manager.GetNetworks();
ASSERT_EQ(1U, current.size());
EXPECT_EQ(net2, current[0]);
// Now network1 is inactive. Try to merge it again.
list.clear();
@ -1109,10 +1098,10 @@ TEST_F(NetworkTest, TestMergeNetworkListWithInactiveNetworks) {
MergeNetworkList(manager, list, &changed);
EXPECT_TRUE(changed);
list.clear();
manager.GetNetworks(&list);
ASSERT_EQ(1U, list.size());
EXPECT_TRUE(list[0]->active());
EXPECT_EQ(net1, list[0]);
current = manager.GetNetworks();
ASSERT_EQ(1U, current.size());
EXPECT_TRUE(current[0]->active());
EXPECT_EQ(net1, current[0]);
}
// Test that the filtering logic follows the defined ruleset in network.h.
@ -1198,10 +1187,9 @@ TEST_F(NetworkTest, MAYBE_DefaultLocalAddress) {
// Make sure we can query default local address when an address for such
// address family exists.
std::vector<Network*> networks;
manager.GetNetworks(&networks);
std::vector<const Network*> networks = manager.GetNetworks();
EXPECT_TRUE(!networks.empty());
for (const auto* network : networks) {
for (const Network* network : networks) {
if (network->GetBestIP().family() == AF_INET) {
EXPECT_TRUE(QueryDefaultLocalAddress(manager, AF_INET) != IPAddress());
} else if (network->GetBestIP().family() == AF_INET6 &&
@ -1269,8 +1257,7 @@ TEST_F(NetworkTest, TestWhenNetworkListChangeReturnsChangedFlag) {
bool changed;
MergeNetworkList(manager, list, &changed);
EXPECT_TRUE(changed);
NetworkManager::NetworkList list2;
manager.GetNetworks(&list2);
std::vector<const Network*> list2 = manager.GetNetworks();
EXPECT_EQ(list2.size(), 1uL);
EXPECT_EQ(ADAPTER_TYPE_CELLULAR_3G, list2[0]->type());
}
@ -1288,8 +1275,7 @@ TEST_F(NetworkTest, TestWhenNetworkListChangeReturnsChangedFlag) {
// Change from 3G to 4G shall not trigger OnNetworksChanged,
// i.e changed = false.
EXPECT_FALSE(changed);
NetworkManager::NetworkList list2;
manager.GetNetworks(&list2);
std::vector<const Network*> list2 = manager.GetNetworks();
ASSERT_EQ(list2.size(), 1uL);
EXPECT_EQ(ADAPTER_TYPE_CELLULAR_4G, list2[0]->type());
}
@ -1306,8 +1292,7 @@ TEST_F(NetworkTest, TestWhenNetworkListChangeReturnsChangedFlag) {
// No change.
EXPECT_FALSE(changed);
NetworkManager::NetworkList list2;
manager.GetNetworks(&list2);
std::vector<const Network*> list2 = manager.GetNetworks();
ASSERT_EQ(list2.size(), 1uL);
EXPECT_EQ(ADAPTER_TYPE_CELLULAR_4G, list2[0]->type());
}
@ -1326,8 +1311,7 @@ TEST_F(NetworkTest, IgnoresMACBasedIPv6Address) {
ifaddrs* addr_list =
InstallIpv6Network(if_name, ipv6_address, ipv6_mask, manager);
BasicNetworkManager::NetworkList list;
manager.GetNetworks(&list);
std::vector<const Network*> list = manager.GetNetworks();
EXPECT_EQ(list.size(), 0u);
ReleaseIfAddrs(addr_list);
}
@ -1346,8 +1330,7 @@ TEST_F(NetworkTest, WebRTC_AllowMACBasedIPv6Address) {
ifaddrs* addr_list =
InstallIpv6Network(if_name, ipv6_address, ipv6_mask, manager);
BasicNetworkManager::NetworkList list;
manager.GetNetworks(&list);
std::vector<const Network*> list = manager.GetNetworks();
EXPECT_EQ(list.size(), 1u);
ReleaseIfAddrs(addr_list);
}
@ -1507,8 +1490,7 @@ TEST_F(NetworkTest, VpnListOverrideAdapterType) {
auto addr_list =
InstallIpv4Network(if_name, "192.168.1.23", "255.255.255.255", manager);
BasicNetworkManager::NetworkList list;
manager.GetNetworks(&list);
std::vector<const Network*> list = manager.GetNetworks();
ASSERT_EQ(1u, list.size());
EXPECT_EQ(ADAPTER_TYPE_VPN, list[0]->type());
EXPECT_EQ(ADAPTER_TYPE_ETHERNET, list[0]->underlying_type_for_vpn());

4
test/network/emulated_network_manager.h
View File

@ -45,7 +45,9 @@ class EmulatedNetworkManager : public rtc::NetworkManagerBase,
void StopUpdating() override;
// We don't support any address interfaces in the network emulation framework.
void GetAnyAddressNetworks(NetworkList* networks) override {}
std::vector<const rtc::Network*> GetAnyAddressNetworks() override {
return {};
}
// EmulatedNetworkManagerInterface API
rtc::Thread* network_thread() override { return network_thread_.get(); }