mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Default enable WebRTC-IPv6NetworkResolutionFixes

Browse source 
Fully launched on mobile and approved for chrome launch.

Removed tests for feature enablement with field trial.

Bug: webrtc:14334
Change-Id: I7ca7183ff618835fef8c820cfd52863e1c7fa25e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/301163
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Jonas Oreland <jonaso@webrtc.org>
Commit-Queue: Sameer Vijaykar <samvi@google.com>
Cr-Commit-Position: refs/heads/main@{#39879}
This commit is contained in:
Sameer Vijaykar 2023-04-13 10:08:14 +02:00 committed by WebRTC LUCI CQ
parent 45eae34693
commit 1f251dd67e
10 changed files with 22 additions and 297 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
p2p/base/port_unittest.cc
View file

@ -545,12 +545,11 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
std::unique_ptr<UDPPort> CreateUdpPortMultipleAddrs(
const SocketAddress& global_addr,
const SocketAddress& link_local_addr,
PacketSocketFactory* socket_factory,
const webrtc::test::ScopedKeyValueConfig& field_trials) {
PacketSocketFactory* socket_factory) {
auto port = UDPPort::Create(
&main_, socket_factory,
MakeNetworkMultipleAddrs(global_addr, link_local_addr, &field_trials),
0, 0, username_, password_, true, absl::nullopt, &field_trials);
MakeNetworkMultipleAddrs(global_addr, link_local_addr, &field_trials_),
0, 0, username_, password_, true, absl::nullopt, &field_trials_);
port->SetIceTiebreaker(kTiebreakerDefault);
return port;
}
@ -1770,9 +1769,6 @@ TEST_F(PortTest, TestUdpSingleAddressV6CrossTypePorts) {
}
TEST_F(PortTest, TestUdpMultipleAddressesV6CrossTypePorts) {
webrtc::test::ScopedKeyValueConfig field_trials(
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,PreferGlobalIPv6Address:true/");
FakePacketSocketFactory factory;
std::unique_ptr<Port> ports[5];
SocketAddress addresses[5] = {
@ -1782,8 +1778,8 @@ TEST_F(PortTest, TestUdpMultipleAddressesV6CrossTypePorts) {
for (int i = 0; i < 5; i++) {
FakeAsyncPacketSocket* socket = new FakeAsyncPacketSocket();
factory.set_next_udp_socket(socket);
ports[i] = CreateUdpPortMultipleAddrs(addresses[i], kLinkLocalIPv6Addr,
&factory, field_trials);
ports[i] =
CreateUdpPortMultipleAddrs(addresses[i], kLinkLocalIPv6Addr, &factory);
ports[i]->SetIceTiebreaker(kTiebreakerDefault);
socket->set_state(AsyncPacketSocket::STATE_BINDING);
socket->SignalAddressReady(socket, addresses[i]);

15
p2p/base/stun_port.cc
View file

@ -32,19 +32,8 @@ namespace cricket {
namespace {
bool ResolveStunHostnameForFamily(const webrtc::FieldTrialsView& field_trials) {
// Bug fix for STUN hostname resolution on IPv6.
// Field trial key reserved in bugs.webrtc.org/14334
static constexpr char field_trial_name[] =
"WebRTC-IPv6NetworkResolutionFixes";
if (!field_trials.IsEnabled(field_trial_name)) {
return false;
}
webrtc::FieldTrialParameter<bool> resolve_stun_hostname_for_family(
"ResolveStunHostnameForFamily", /*default_value=*/false);
webrtc::ParseFieldTrial({&resolve_stun_hostname_for_family},
field_trials.Lookup(field_trial_name));
return resolve_stun_hostname_for_family;
// TODO(bugs.webrtc.org/14334) cleanup
return true;
}
} // namespace

88
p2p/base/stun_port_unittest.cc
View file

@ -317,8 +317,8 @@ TEST_F(StunPortWithMockDnsResolverTest, TestPrepareAddressHostname) {
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kValidHostnameAddr, _))
.WillOnce(InvokeArgument<1>());
EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _))
.WillOnce(InvokeArgument<2>());
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0));
@ -666,9 +666,9 @@ TEST_F(StunIPv6PortTestWithMockDnsResolver, TestPrepareAddressHostname) {
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
// Expect to call Resolver::Start without family arg.
EXPECT_CALL(*resolver, Start(kValidHostnameAddr, _))
.WillOnce(InvokeArgument<1>());
EXPECT_CALL(*resolver,
Start(kValidHostnameAddr, /*family=*/AF_INET6, _))
.WillOnce(InvokeArgument<2>());
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0));
@ -684,82 +684,4 @@ TEST_F(StunIPv6PortTestWithMockDnsResolver, TestPrepareAddressHostname) {
EXPECT_EQ(kIPv6StunCandidatePriority, port()->Candidates()[0].priority());
}
TEST_F(StunIPv6PortTestWithMockDnsResolver,
TestPrepareAddressHostnameFamilyFieldTrialDisabled) {
webrtc::test::ScopedKeyValueConfig field_trials(
"WebRTC-IPv6NetworkResolutionFixes/Disabled/");
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
// Expect to call Resolver::Start without family arg.
EXPECT_CALL(*resolver, Start(kValidHostnameAddr, _))
.WillOnce(InvokeArgument<1>());
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0));
EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _))
.WillOnce(DoAll(SetArgPointee<1>(SocketAddress("::1", 5000)),
Return(true)));
});
CreateStunPort(kValidHostnameAddr, &field_trials);
PrepareAddress();
EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kIPv6LocalAddr.EqualIPs(port()->Candidates()[0].address()));
EXPECT_EQ(kIPv6StunCandidatePriority, port()->Candidates()[0].priority());
}
TEST_F(StunIPv6PortTestWithMockDnsResolver,
TestPrepareAddressHostnameFamilyFieldTrialParamDisabled) {
webrtc::test::ScopedKeyValueConfig field_trials(
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,ResolveStunHostnameForFamily:false/");
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
// Expect to call Resolver::Start without family arg.
EXPECT_CALL(*resolver, Start(kValidHostnameAddr, _))
.WillOnce(InvokeArgument<1>());
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0));
EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _))
.WillOnce(DoAll(SetArgPointee<1>(SocketAddress("::1", 5000)),
Return(true)));
});
CreateStunPort(kValidHostnameAddr, &field_trials);
PrepareAddress();
EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kIPv6LocalAddr.EqualIPs(port()->Candidates()[0].address()));
EXPECT_EQ(kIPv6StunCandidatePriority, port()->Candidates()[0].priority());
}
TEST_F(StunIPv6PortTestWithMockDnsResolver,
TestPrepareAddressHostnameFamilyFieldTrialEnabled) {
webrtc::test::ScopedKeyValueConfig field_trials(
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,ResolveStunHostnameForFamily:true/");
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
// Expect to call Resolver::Start _with_ family arg.
EXPECT_CALL(*resolver,
Start(kValidHostnameAddr, /*family=*/AF_INET6, _))
.WillOnce(InvokeArgument<2>());
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0));
EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _))
.WillOnce(DoAll(SetArgPointee<1>(SocketAddress("::1", 5000)),
Return(true)));
});
CreateStunPort(kValidHostnameAddr, &field_trials);
PrepareAddress();
EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kIPv6LocalAddr.EqualIPs(port()->Candidates()[0].address()));
EXPECT_EQ(kIPv6StunCandidatePriority, port()->Candidates()[0].priority());
}
} // namespace

15
p2p/base/turn_port.cc
View file

@ -37,19 +37,8 @@ namespace cricket {
namespace {
bool ResolveTurnHostnameForFamily(const webrtc::FieldTrialsView& field_trials) {
// Bug fix for TURN hostname resolution on IPv6.
// Field trial key reserved in bugs.webrtc.org/14334
static constexpr char field_trial_name[] =
"WebRTC-IPv6NetworkResolutionFixes";
if (!field_trials.IsEnabled(field_trial_name)) {
return false;
}
webrtc::FieldTrialParameter<bool> resolve_turn_hostname_for_family(
"ResolveTurnHostnameForFamily", /*default_value=*/false);
webrtc::ParseFieldTrial({&resolve_turn_hostname_for_family},
field_trials.Lookup(field_trial_name));
return resolve_turn_hostname_for_family;
// TODO(bugs.webrtc.org/14334) cleanup
return true;
}
} // namespace

83
p2p/base/turn_port_unittest.cc
View file

@ -1912,8 +1912,8 @@ TEST_F(TurnPortWithMockDnsResolverTest, TestHostnameResolved) {
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kTurnValidAddr, _))
.WillOnce(InvokeArgument<1>());
EXPECT_CALL(*resolver, Start(kTurnValidAddr, /*family=*/AF_INET, _))
.WillOnce(InvokeArgument<2>());
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillRepeatedly(Return(0));
@ -1932,85 +1932,6 @@ TEST_F(TurnPortWithMockDnsResolverTest, TestHostnameResolvedIPv6Network) {
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kTurnValidAddr, _))
.WillOnce(InvokeArgument<1>());
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillRepeatedly(Return(0));
EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _))
.WillOnce(
DoAll(SetArgPointee<1>(kTurnUdpIPv6IntAddr), Return(true)));
});
TestTurnAllocateSucceeds(kSimulatedRtt * 2);
}
// Test an allocation from a TURN server specified by a hostname on an IPv6
// network, without network family-specific resolution.
TEST_F(TurnPortWithMockDnsResolverTest,
TestHostnameResolvedIPv6NetworkFamilyFieldTrialDisabled) {
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-IPv6NetworkResolutionFixes/Disabled/");
turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, PROTO_UDP);
CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
kTurnPortValidHostnameProtoAddr);
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
// Expect to call Resolver::Start without family arg.
EXPECT_CALL(*resolver, Start(kTurnValidAddr, _))
.WillOnce(InvokeArgument<1>());
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillRepeatedly(Return(0));
EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _))
.WillOnce(
DoAll(SetArgPointee<1>(kTurnUdpIPv6IntAddr), Return(true)));
});
TestTurnAllocateSucceeds(kSimulatedRtt * 2);
}
// Test an allocation from a TURN server specified by a hostname on an IPv6
// network, without network family-specific resolution.
TEST_F(TurnPortWithMockDnsResolverTest,
TestHostnameResolvedIPv6NetworkFamilyFieldTrialParamDisabled) {
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_,
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,ResolveTurnHostnameForFamily:false/");
turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, PROTO_UDP);
CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
kTurnPortValidHostnameProtoAddr);
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
// Expect to call Resolver::Start without family arg.
EXPECT_CALL(*resolver, Start(kTurnValidAddr, _))
.WillOnce(InvokeArgument<1>());
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillRepeatedly(Return(0));
EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _))
.WillOnce(
DoAll(SetArgPointee<1>(kTurnUdpIPv6IntAddr), Return(true)));
});
TestTurnAllocateSucceeds(kSimulatedRtt * 2);
}
// Test an allocation from a TURN server specified by a hostname on an IPv6
// network, with network family-specific resolution.
TEST_F(TurnPortWithMockDnsResolverTest,
TestHostnameResolvedIPv6NetworkFieldTrialEnabled) {
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_,
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,ResolveTurnHostnameForFamily:true/");
turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, PROTO_UDP);
CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
kTurnPortValidHostnameProtoAddr);
SetDnsResolverExpectations(
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
// Expect to call Resolver::Start _with_ family arg.
EXPECT_CALL(*resolver, Start(kTurnValidAddr, /*family=*/AF_INET6, _))
.WillOnce(InvokeArgument<2>());
EXPECT_CALL(*resolver, result)

13
p2p/client/basic_port_allocator.cc
View file

@ -156,17 +156,8 @@ std::string NetworksToString(const std::vector<const rtc::Network*>& networks) {
bool IsDiversifyIpv6InterfacesEnabled(
const webrtc::FieldTrialsView* field_trials) {
// webrtc:14334: Improve IPv6 network resolution and candidate creation
if (field_trials &&
field_trials->IsEnabled("WebRTC-IPv6NetworkResolutionFixes")) {
webrtc::FieldTrialParameter<bool> diversify_ipv6_interfaces(
"DiversifyIpv6Interfaces", false);
webrtc::ParseFieldTrial(
{&diversify_ipv6_interfaces},
field_trials->Lookup("WebRTC-IPv6NetworkResolutionFixes"));
return diversify_ipv6_interfaces;
}
return false;
// TODO(bugs.webrtc.org/14334) cleanup
return true;
}
} // namespace

69
p2p/client/basic_port_allocator_unittest.cc
View file

@ -2649,69 +2649,8 @@ TEST_F(BasicPortAllocatorTest, IPv6EtherAndWifiHaveHigherPriorityThanOthers) {
EXPECT_TRUE(HasNetwork(networks, ethe1));
}
// Do not change the default IPv6 selection behavior if
// IPv6NetworkResolutionFixes is disabled.
TEST_F(BasicPortAllocatorTest,
NotDiversifyIPv6NetworkTypesIfIPv6NetworkResolutionFixesDisabled) {
webrtc::test::ScopedKeyValueConfig field_trials(
field_trials_, "WebRTC-IPv6NetworkResolutionFixes/Disabled/");
// Add three IPv6 network interfaces, but tell the allocator to only use two.
allocator().set_max_ipv6_networks(2);
AddInterface(kClientIPv6Addr, "ethe1", rtc::ADAPTER_TYPE_ETHERNET);
AddInterface(kClientIPv6Addr2, "ethe2", rtc::ADAPTER_TYPE_ETHERNET);
AddInterface(kClientIPv6Addr3, "wifi1", rtc::ADAPTER_TYPE_WIFI);
// To simplify the test, only gather UDP host candidates.
allocator().set_flags(PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_DISABLE_TCP |
PORTALLOCATOR_DISABLE_STUN |
PORTALLOCATOR_DISABLE_RELAY |
PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(2U, candidates_.size());
// Wifi1 was not selected because it comes after ethe1 and ethe2.
EXPECT_FALSE(HasCandidate(candidates_, "local", "udp", kClientIPv6Addr3));
}
// Do not change the default IPv6 selection behavior if
// IPv6NetworkResolutionFixes is enabled but DiversifyIpv6Interfaces is not
// enabled.
TEST_F(BasicPortAllocatorTest,
NotDiversifyIPv6NetworkTypesIfDiversifyIpv6InterfacesDisabled) {
webrtc::test::ScopedKeyValueConfig field_trials(
field_trials_,
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,DiversifyIpv6Interfaces:false/");
// Add three IPv6 network interfaces, but tell the allocator to only use two.
allocator().set_max_ipv6_networks(2);
AddInterface(kClientIPv6Addr, "ethe1", rtc::ADAPTER_TYPE_ETHERNET);
AddInterface(kClientIPv6Addr2, "ethe2", rtc::ADAPTER_TYPE_ETHERNET);
AddInterface(kClientIPv6Addr3, "wifi1", rtc::ADAPTER_TYPE_WIFI);
// To simplify the test, only gather UDP host candidates.
allocator().set_flags(PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_DISABLE_TCP |
PORTALLOCATOR_DISABLE_STUN |
PORTALLOCATOR_DISABLE_RELAY |
PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(2U, candidates_.size());
// Wifi1 was not selected because it comes after ethe1 and ethe2.
EXPECT_FALSE(HasCandidate(candidates_, "local", "udp", kClientIPv6Addr3));
}
TEST_F(BasicPortAllocatorTest,
Select2DifferentIntefacesIfDiversifyIpv6InterfacesEnabled) {
webrtc::test::ScopedKeyValueConfig field_trials(
field_trials_,
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,DiversifyIpv6Interfaces:true/");
allocator().set_max_ipv6_networks(2);
AddInterface(kClientIPv6Addr, "ethe1", rtc::ADAPTER_TYPE_ETHERNET);
AddInterface(kClientIPv6Addr2, "ethe2", rtc::ADAPTER_TYPE_ETHERNET);
@ -2738,10 +2677,6 @@ TEST_F(BasicPortAllocatorTest,
TEST_F(BasicPortAllocatorTest,
Select3DifferentIntefacesIfDiversifyIpv6InterfacesEnabled) {
webrtc::test::ScopedKeyValueConfig field_trials(
field_trials_,
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,DiversifyIpv6Interfaces:true/");
allocator().set_max_ipv6_networks(3);
AddInterface(kClientIPv6Addr, "ethe1", rtc::ADAPTER_TYPE_ETHERNET);
AddInterface(kClientIPv6Addr2, "ethe2", rtc::ADAPTER_TYPE_ETHERNET);
@ -2769,10 +2704,6 @@ TEST_F(BasicPortAllocatorTest,
TEST_F(BasicPortAllocatorTest,
Select4DifferentIntefacesIfDiversifyIpv6InterfacesEnabled) {
webrtc::test::ScopedKeyValueConfig field_trials(
field_trials_,
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,DiversifyIpv6Interfaces:true/");
allocator().set_max_ipv6_networks(4);
AddInterface(kClientIPv6Addr, "ethe1", rtc::ADAPTER_TYPE_ETHERNET);
AddInterface(kClientIPv6Addr2, "ethe2", rtc::ADAPTER_TYPE_ETHERNET);

14
rtc_base/network.cc
View file

@ -187,18 +187,8 @@ bool ShouldAdapterChangeTriggerNetworkChange(rtc::AdapterType old_type,
}
bool PreferGlobalIPv6Address(const webrtc::FieldTrialsView* field_trials) {
// Bug fix to prefer global IPv6 address over link local.
// Field trial key reserved in bugs.webrtc.org/14334
if (field_trials &&
field_trials->IsEnabled("WebRTC-IPv6NetworkResolutionFixes")) {
webrtc::FieldTrialParameter<bool> prefer_global_ipv6_address_enabled(
"PreferGlobalIPv6Address", false);
webrtc::ParseFieldTrial(
{&prefer_global_ipv6_address_enabled},
field_trials->Lookup("WebRTC-IPv6NetworkResolutionFixes"));
return prefer_global_ipv6_address_enabled;
}
return false;
// TODO(bugs.webrtc.org/14334) cleanup
return true;
}
#if defined(WEBRTC_WIN)

3
rtc_base/network.h
View file

@ -445,8 +445,7 @@ class RTC_EXPORT Network {
// Here is the rule on how we mark the IPv6 address as ignorable for WebRTC.
// 1) return all global temporary dynamic and non-deprecated ones.
// 2) if #1 not available, return global ones.
// 3) if #2 not available and WebRTC-IPv6NetworkResolutionFixes enabled,
// return local link ones.
// 3) if #2 not available, return local link ones.
// 4) if #3 not available, use ULA ipv6 as last resort. (ULA stands for
// unique local address, which is not route-able in open internet but might
// be useful for a close WebRTC deployment.

5
rtc_base/network_unittest.cc
View file

@ -1159,9 +1159,6 @@ TEST_F(NetworkTest, TestIPv6Selection) {
// Test that the filtering logic follows the defined ruleset in network.h.
TEST_F(NetworkTest, TestGetBestIPWithPreferGlobalIPv6ToLinkLocalEnabled) {
webrtc::test::ScopedKeyValueConfig field_trials(
"WebRTC-IPv6NetworkResolutionFixes/"
"Enabled,PreferGlobalIPv6Address:true/");
InterfaceAddress ip, link_local;
std::string ipstr;
@ -1170,7 +1167,7 @@ TEST_F(NetworkTest, TestGetBestIPWithPreferGlobalIPv6ToLinkLocalEnabled) {
// Create a network with this prefix.
Network ipv6_network("test_eth0", "Test NetworkAdapter", TruncateIP(ip, 64),
64, ADAPTER_TYPE_UNKNOWN, &field_trials);
64, ADAPTER_TYPE_UNKNOWN, &field_trials_);
// When there is no address added, it should return an unspecified
// address.