Remove redundant webrtc:: prefixes in ['modules/utility', 'p2p']
Created by
tools_webrtc/remove_extra_namespace.py --namespace webrtc
and manual adjustments.
This CL was uploaded by git cl split.
R=eshr@webrtc.org
No-IWYU: Refactoring
Bug: webrtc:42232595
Change-Id: Ib7ac05d58ad1a01008eae8706abaad55489da573
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/396200
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44890}
diff --git a/modules/utility/include/jvm_android.h b/modules/utility/include/jvm_android.h
index bafb8f2..5838aa2 100644
--- a/modules/utility/include/jvm_android.h
+++ b/modules/utility/include/jvm_android.h
@@ -123,7 +123,7 @@
// JNIEnv* jni = ::base::android::AttachCurrentThread();
// JavaVM* jvm = NULL;
// jni->GetJavaVM(&jvm);
-// webrtc::JVM::Initialize(jvm);
+// JVM::Initialize(jvm);
//
// // Header (.h) file of example class called User.
// std::unique_ptr<JNIEnvironment> env;
diff --git a/p2p/base/basic_async_resolver_factory.h b/p2p/base/basic_async_resolver_factory.h
index a553f90..9a0a4c8 100644
--- a/p2p/base/basic_async_resolver_factory.h
+++ b/p2p/base/basic_async_resolver_factory.h
@@ -25,16 +25,16 @@
public:
BasicAsyncDnsResolverFactory() = default;
- std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
+ std::unique_ptr<AsyncDnsResolverInterface> CreateAndResolve(
const SocketAddress& addr,
absl::AnyInvocable<void()> callback) override;
- std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
+ std::unique_ptr<AsyncDnsResolverInterface> CreateAndResolve(
const SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) override;
- std::unique_ptr<webrtc::AsyncDnsResolverInterface> Create() override;
+ std::unique_ptr<AsyncDnsResolverInterface> Create() override;
};
} // namespace webrtc
diff --git a/p2p/base/basic_ice_controller.cc b/p2p/base/basic_ice_controller.cc
index cea38d9..19360e8 100644
--- a/p2p/base/basic_ice_controller.cc
+++ b/p2p/base/basic_ice_controller.cc
@@ -128,7 +128,7 @@
// active connection has not been pinged enough times, use the weak ping
// interval.
bool need_more_pings_at_weak_interval =
- absl::c_any_of(connections_, [](const webrtc::Connection* conn) {
+ absl::c_any_of(connections_, [](const Connection* conn) {
return conn->active() &&
conn->num_pings_sent() < MIN_PINGS_AT_WEAK_PING_INTERVAL;
});
@@ -180,7 +180,7 @@
});
auto iter = absl::c_min_element(
pingable_selectable_connections,
- [](const webrtc::Connection* conn1, const webrtc::Connection* conn2) {
+ [](const Connection* conn1, const Connection* conn2) {
return conn1->last_ping_sent() < conn2->last_ping_sent();
});
if (iter != pingable_selectable_connections.end()) {
diff --git a/p2p/base/basic_ice_controller.h b/p2p/base/basic_ice_controller.h
index 70ebafc..e8593db 100644
--- a/p2p/base/basic_ice_controller.h
+++ b/p2p/base/basic_ice_controller.h
@@ -86,7 +86,7 @@
}
int check_receiving_interval() const {
- return std::max(webrtc::MIN_CHECK_RECEIVING_INTERVAL,
+ return std::max(MIN_CHECK_RECEIVING_INTERVAL,
config_.receiving_timeout_or_default() / 10);
}
diff --git a/p2p/base/connection.h b/p2p/base/connection.h
index e1b0bb8..79cb94a 100644
--- a/p2p/base/connection.h
+++ b/p2p/base/connection.h
@@ -151,8 +151,7 @@
// Register as a recipient of received packets. There can only be one.
void RegisterReceivedPacketCallback(
- absl::AnyInvocable<void(webrtc::Connection*,
- const webrtc::ReceivedIpPacket&)>
+ absl::AnyInvocable<void(Connection*, const ReceivedIpPacket&)>
received_packet_callback);
void DeregisterReceivedPacketCallback();
@@ -160,7 +159,7 @@
// Called when a packet is received on this connection.
void OnReadPacket(const ReceivedIpPacket& packet);
- [[deprecated("Pass a webrtc::ReceivedIpPacket")]] void
+ [[deprecated("Pass a ReceivedIpPacket")]] void
OnReadPacket(const char* data, size_t size, int64_t packet_time_us);
// Called when the socket is currently able to send.
@@ -350,8 +349,8 @@
void SetStunDictConsumer(
std::function<std::unique_ptr<StunAttribute>(
- const webrtc::StunByteStringAttribute*)> goog_delta_consumer,
- std::function<void(RTCErrorOr<const webrtc::StunUInt64Attribute*>)>
+ const StunByteStringAttribute*)> goog_delta_consumer,
+ std::function<void(RTCErrorOr<const StunUInt64Attribute*>)>
goog_delta_ack_consumer) {
goog_delta_consumer_ = std::move(goog_delta_consumer);
goog_delta_ack_consumer_ = std::move(goog_delta_ack_consumer);
@@ -513,12 +512,11 @@
RTC_GUARDED_BY(network_thread_);
std::optional<std::function<std::unique_ptr<StunAttribute>(
- const webrtc::StunByteStringAttribute*)>>
+ const StunByteStringAttribute*)>>
goog_delta_consumer_;
- std::optional<
- std::function<void(RTCErrorOr<const webrtc::StunUInt64Attribute*>)>>
+ std::optional<std::function<void(RTCErrorOr<const StunUInt64Attribute*>)>>
goog_delta_ack_consumer_;
- absl::AnyInvocable<void(webrtc::Connection*, const webrtc::ReceivedIpPacket&)>
+ absl::AnyInvocable<void(Connection*, const ReceivedIpPacket&)>
received_packet_callback_;
void MaybeAddDtlsPiggybackingAttributes(StunMessage* msg);
diff --git a/p2p/base/ice_controller_factory_interface.h b/p2p/base/ice_controller_factory_interface.h
index 958d322..bcf493d 100644
--- a/p2p/base/ice_controller_factory_interface.h
+++ b/p2p/base/ice_controller_factory_interface.h
@@ -26,7 +26,7 @@
struct IceControllerFactoryArgs {
std::function<IceTransportStateInternal()> ice_transport_state_func;
std::function<IceRole()> ice_role_func;
- std::function<bool(const webrtc::Connection*)> is_connection_pruned_func;
+ std::function<bool(const Connection*)> is_connection_pruned_func;
const IceFieldTrials* ice_field_trials;
std::string ice_controller_field_trials;
};
diff --git a/p2p/base/ice_transport_internal.h b/p2p/base/ice_transport_internal.h
index 5076605..ac63624 100644
--- a/p2p/base/ice_transport_internal.h
+++ b/p2p/base/ice_transport_internal.h
@@ -115,7 +115,7 @@
// is valid RTCError::OK() is returned.
RTCError VerifyCandidate(const Candidate& cand);
-// Runs through a list of webrtc::Candidate instances and calls VerifyCandidate
+// Runs through a list of Candidate instances and calls VerifyCandidate
// for each one, stopping on the first error encounted and returning that error
// value if so. On success returns RTCError::OK().
RTCError VerifyCandidates(const Candidates& candidates);
@@ -343,7 +343,7 @@
void AddGatheringStateCallback(
const void* removal_tag,
- absl::AnyInvocable<void(webrtc::IceTransportInternal*)> callback);
+ absl::AnyInvocable<void(IceTransportInternal*)> callback);
void RemoveGatheringStateCallback(const void* removal_tag);
// Handles sending and receiving of candidates.
@@ -351,15 +351,14 @@
SignalCandidateGathered;
void SetCandidateErrorCallback(
- absl::AnyInvocable<void(webrtc::IceTransportInternal*,
- const webrtc::IceCandidateErrorEvent&)>
- callback) {
+ absl::AnyInvocable<void(IceTransportInternal*,
+ const IceCandidateErrorEvent&)> callback) {
RTC_DCHECK(!candidate_error_callback_);
candidate_error_callback_ = std::move(callback);
}
void SetCandidatesRemovedCallback(
- absl::AnyInvocable<void(webrtc::IceTransportInternal*, const Candidates&)>
+ absl::AnyInvocable<void(IceTransportInternal*, const Candidates&)>
callback) {
RTC_DCHECK(!candidates_removed_callback_);
candidates_removed_callback_ = std::move(callback);
@@ -374,8 +373,7 @@
sigslot::signal2<IceTransportInternal*, const Candidate&> SignalRouteChange;
void SetCandidatePairChangeCallback(
- absl::AnyInvocable<void(const webrtc::CandidatePairChangeEvent&)>
- callback) {
+ absl::AnyInvocable<void(const CandidatePairChangeEvent&)> callback) {
RTC_DCHECK(!candidate_pair_change_callback_);
candidate_pair_change_callback_ = std::move(callback);
}
@@ -436,14 +434,13 @@
CallbackList<IceTransportInternal*> gathering_state_callback_list_;
- absl::AnyInvocable<void(webrtc::IceTransportInternal*,
- const webrtc::IceCandidateErrorEvent&)>
+ absl::AnyInvocable<void(IceTransportInternal*, const IceCandidateErrorEvent&)>
candidate_error_callback_;
- absl::AnyInvocable<void(webrtc::IceTransportInternal*, const Candidates&)>
+ absl::AnyInvocable<void(IceTransportInternal*, const Candidates&)>
candidates_removed_callback_;
- absl::AnyInvocable<void(const webrtc::CandidatePairChangeEvent&)>
+ absl::AnyInvocable<void(const CandidatePairChangeEvent&)>
candidate_pair_change_callback_;
};
diff --git a/p2p/base/p2p_transport_channel.h b/p2p/base/p2p_transport_channel.h
index d3c090d..960d0ff 100644
--- a/p2p/base/p2p_transport_channel.h
+++ b/p2p/base/p2p_transport_channel.h
@@ -504,7 +504,7 @@
uint32_t selected_candidate_pair_changes_ = 0;
// When was last data received on a existing connection,
- // from connection->last_data_received() that uses webrtc::TimeMillis().
+ // from connection->last_data_received() that uses TimeMillis().
int64_t last_data_received_ms_ = 0;
// Parsed field trials.
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index cceb4cc..6e9f8fc 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -324,10 +324,10 @@
stun_server_(TestStunServer::Create(ss_.get(), kStunAddr, main_)),
turn_server_(&main_, ss_.get(), kTurnUdpIntAddr, kTurnUdpExtAddr),
force_relay_(false) {
- ep1_.role_ = webrtc::ICEROLE_CONTROLLING;
- ep2_.role_ = webrtc::ICEROLE_CONTROLLED;
+ ep1_.role_ = ICEROLE_CONTROLLING;
+ ep2_.role_ = ICEROLE_CONTROLLED;
- webrtc::metrics::Reset();
+ metrics::Reset();
}
void CreatePortAllocators(const Environment& env) {
@@ -400,7 +400,7 @@
struct Endpoint : public sigslot::has_slots<> {
Endpoint()
- : role_(webrtc::ICEROLE_UNKNOWN),
+ : role_(ICEROLE_UNKNOWN),
tiebreaker_(0),
role_conflict_(false),
save_candidates_(false) {}
@@ -593,7 +593,7 @@
}
void RemoveAddress(int endpoint, const SocketAddress& addr) {
GetEndpoint(endpoint)->network_manager_.RemoveInterface(addr);
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, addr);
+ fw()->AddRule(false, FP_ANY, FD_ANY, addr);
}
void SetAllocatorFlags(int endpoint, int flags) {
GetAllocator(endpoint)->set_flags(flags);
@@ -710,19 +710,18 @@
void Test(const Environment& env, const Result& expected) {
ScopedFakeClock clock;
- int64_t connect_start = webrtc::TimeMillis();
+ int64_t connect_start = TimeMillis();
int64_t connect_time;
// Create the channels and wait for them to connect.
CreateChannels(env);
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
- {.timeout =
- TimeDelta::Millis(expected.connect_wait + kShortTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
- connect_time = webrtc::TimeMillis() - connect_start;
+ EXPECT_THAT(WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = TimeDelta::Millis(expected.connect_wait +
+ kShortTimeout),
+ .clock = &clock}),
+ IsRtcOk());
+ connect_time = TimeMillis() - connect_start;
if (connect_time < expected.connect_wait) {
RTC_LOG(LS_INFO) << "Connect time: " << connect_time << " ms";
} else {
@@ -733,25 +732,25 @@
// Allow a few turns of the crank for the selected connections to emerge.
// This may take up to 2 seconds.
if (ep1_ch1()->selected_connection() && ep2_ch1()->selected_connection()) {
- int64_t converge_start = webrtc::TimeMillis();
+ int64_t converge_start = TimeMillis();
int64_t converge_time;
// Verifying local and remote channel selected connection information.
// This is done only for the RFC 5245 as controlled agent will use
// USE-CANDIDATE from controlling (ep1) agent. We can easily predict from
// EP1 result matrix.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidate1(expected) && CheckCandidate2(expected);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Also do EXPECT_EQ on each part so that failures are more verbose.
ExpectCandidate1(expected);
ExpectCandidate2(expected);
- converge_time = webrtc::TimeMillis() - converge_start;
+ converge_time = TimeMillis() - converge_start;
int64_t converge_wait = 2000;
if (converge_time < converge_wait) {
RTC_LOG(LS_INFO) << "Converge time: " << converge_time << " ms";
@@ -773,27 +772,27 @@
int len = static_cast<int>(strlen(data));
// local_channel1 <==> remote_channel1
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return SendData(ep1_ch1(), data, len); }, Eq(len),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &*clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckDataOnChannel(ep2_ch1(), data, len); },
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &*clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return SendData(ep2_ch1(), data, len); }, Eq(len),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &*clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckDataOnChannel(ep1_ch1(), data, len); },
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &*clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
}
@@ -807,10 +806,10 @@
ep1_ch1()->SetRemoteIceParameters(kIceParams[1]);
ep2_ch1()->SetRemoteIceParameters(kIceParams[0]);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const Candidate* old_local_candidate1 = LocalCandidate(ep1_ch1());
const Candidate* old_local_candidate2 = LocalCandidate(ep2_ch1());
@@ -826,29 +825,29 @@
ep2_ch1()->MaybeStartGathering();
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return LocalCandidate(ep1_ch1())->generation(); },
Ne(old_local_candidate1->generation()),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return LocalCandidate(ep2_ch1())->generation(); },
Ne(old_local_candidate2->generation()),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return RemoteCandidate(ep1_ch1())->generation(); },
Ne(old_remote_candidate1->generation()),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return RemoteCandidate(ep2_ch1())->generation(); },
Ne(old_remote_candidate2->generation()),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(1u, RemoteCandidate(ep2_ch1())->generation());
EXPECT_EQ(1u, RemoteCandidate(ep1_ch1())->generation());
}
@@ -914,12 +913,12 @@
// Tcp candidate verification has to be done when they are generated.
void VerifySavedTcpCandidates(int endpoint, absl::string_view tcptype) {
for (auto& data : GetEndpoint(endpoint)->saved_candidates_) {
- EXPECT_EQ(data.candidate.protocol(), webrtc::TCP_PROTOCOL_NAME);
+ EXPECT_EQ(data.candidate.protocol(), TCP_PROTOCOL_NAME);
EXPECT_EQ(data.candidate.tcptype(), tcptype);
- if (data.candidate.tcptype() == webrtc::TCPTYPE_ACTIVE_STR) {
- EXPECT_EQ(data.candidate.address().port(), webrtc::DISCARD_PORT);
- } else if (data.candidate.tcptype() == webrtc::TCPTYPE_PASSIVE_STR) {
- EXPECT_NE(data.candidate.address().port(), webrtc::DISCARD_PORT);
+ if (data.candidate.tcptype() == TCPTYPE_ACTIVE_STR) {
+ EXPECT_EQ(data.candidate.address().port(), DISCARD_PORT);
+ } else if (data.candidate.tcptype() == TCPTYPE_PASSIVE_STR) {
+ EXPECT_NE(data.candidate.address().port(), DISCARD_PORT);
} else {
FAIL() << "Unknown tcptype: " << data.candidate.tcptype();
}
@@ -965,10 +964,9 @@
void OnRoleConflict(IceTransportInternal* channel) {
GetEndpoint(channel)->OnRoleConflict(true);
- IceRole new_role =
- GetEndpoint(channel)->ice_role() == webrtc::ICEROLE_CONTROLLING
- ? webrtc::ICEROLE_CONTROLLED
- : webrtc::ICEROLE_CONTROLLING;
+ IceRole new_role = GetEndpoint(channel)->ice_role() == ICEROLE_CONTROLLING
+ ? ICEROLE_CONTROLLED
+ : ICEROLE_CONTROLLING;
channel->SetIceRole(new_role);
}
@@ -1158,10 +1156,10 @@
CreatePortAllocators(env);
ConfigureEndpoint(0, config1);
SetAllocatorFlags(0, allocator_flags1);
- SetAllocationStepDelay(0, webrtc::kMinimumStepDelay);
+ SetAllocationStepDelay(0, kMinimumStepDelay);
ConfigureEndpoint(1, config2);
SetAllocatorFlags(1, allocator_flags2);
- SetAllocationStepDelay(1, webrtc::kMinimumStepDelay);
+ SetAllocationStepDelay(1, kMinimumStepDelay);
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
}
@@ -1187,10 +1185,11 @@
// Add a two cascaded NATs of the desired types
nat()
->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
- (config == NAT_DOUBLE_CONE) ? webrtc::NAT_OPEN_CONE
- : webrtc::NAT_SYMMETRIC)
+ (config == Config::NAT_DOUBLE_CONE)
+ ? NATType::NAT_OPEN_CONE
+ : NATType::NAT_SYMMETRIC)
->AddTranslator(kPrivateAddrs[endpoint],
- kCascadedNatAddrs[endpoint], webrtc::NAT_OPEN_CONE)
+ kCascadedNatAddrs[endpoint], NAT_OPEN_CONE)
->AddClient(kCascadedPrivateAddrs[endpoint]);
break;
case BLOCK_UDP:
@@ -1198,20 +1197,17 @@
case BLOCK_ALL_BUT_OUTGOING_HTTP:
AddAddress(endpoint, kPublicAddrs[endpoint]);
// Block all UDP
- fw()->AddRule(false, webrtc::FP_UDP, webrtc::FD_ANY,
- kPublicAddrs[endpoint]);
+ fw()->AddRule(false, FP_UDP, FD_ANY, kPublicAddrs[endpoint]);
if (config == BLOCK_UDP_AND_INCOMING_TCP) {
// Block TCP inbound to the endpoint
- fw()->AddRule(false, webrtc::FP_TCP, SocketAddress(),
- kPublicAddrs[endpoint]);
+ fw()->AddRule(false, FP_TCP, SocketAddress(), kPublicAddrs[endpoint]);
} else if (config == BLOCK_ALL_BUT_OUTGOING_HTTP) {
// Block all TCP to/from the endpoint except 80/443 out
- fw()->AddRule(true, webrtc::FP_TCP, kPublicAddrs[endpoint],
+ fw()->AddRule(true, FP_TCP, kPublicAddrs[endpoint],
SocketAddress(IPAddress(INADDR_ANY), 80));
- fw()->AddRule(true, webrtc::FP_TCP, kPublicAddrs[endpoint],
+ fw()->AddRule(true, FP_TCP, kPublicAddrs[endpoint],
SocketAddress(IPAddress(INADDR_ANY), 443));
- fw()->AddRule(false, webrtc::FP_TCP, webrtc::FD_ANY,
- kPublicAddrs[endpoint]);
+ fw()->AddRule(false, FP_TCP, FD_ANY, kPublicAddrs[endpoint]);
}
break;
default:
@@ -1326,8 +1322,8 @@
// Standard Ice protocol is used.
TEST_F(P2PTransportChannelTest, HandleUfragPwdChange) {
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
CreateChannels(env);
TestHandleIceUfragPasswordChanged();
DestroyChannels();
@@ -1338,8 +1334,7 @@
TEST_F(P2PTransportChannelTest, HandleUfragPwdChangeSymmetricNat) {
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, NAT_SYMMETRIC, NAT_SYMMETRIC,
- webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ kDefaultPortAllocatorFlags, kDefaultPortAllocatorFlags);
CreateChannels(env);
TestHandleIceUfragPasswordChanged();
DestroyChannels();
@@ -1349,18 +1344,18 @@
TEST_F(P2PTransportChannelTest, GetStats) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->receiving() && ep1_ch1()->writable() &&
ep2_ch1()->receiving() && ep2_ch1()->writable();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Sends and receives 10 packets.
TestSendRecv(&clock);
@@ -1405,23 +1400,23 @@
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
IceConfig continual_gathering_config =
- CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ CreateIceConfig(1000, GATHER_CONTINUALLY);
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
AddAddress(0, kAlternateAddrs[1], "rmnet0", ADAPTER_TYPE_CELLULAR);
CreateChannels(env, continual_gathering_config, continual_gathering_config);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->receiving() && ep1_ch1()->writable() &&
ep2_ch1()->receiving() && ep2_ch1()->writable();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Sends and receives 10 packets.
TestSendRecv(&clock);
@@ -1453,10 +1448,10 @@
const_cast<Connection*>(old_selected_connection));
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Sends and receives 10 packets.
TestSendRecv(&clock);
@@ -1490,27 +1485,27 @@
// ep1 gathers continually but ep2 does not.
IceConfig continual_gathering_config =
- CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ CreateIceConfig(1000, GATHER_CONTINUALLY);
IceConfig default_config;
CreateChannels(env, continual_gathering_config, default_config);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Adding address in ep1 will trigger continual gathering.
AddAddress(0, kAlternateAddrs[0]);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return GetEndpoint(0)->GetIceRegatheringCountForReason(
IceRegatheringReason::NETWORK_CHANGE);
},
Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ep2_ch1()->SetIceParameters(kIceParams[3]);
ep2_ch1()->SetRemoteIceParameters(kIceParams[2]);
@@ -1534,19 +1529,19 @@
ConfigureEndpoints(env, OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
// ep1 gathers continually but ep2 does not.
- IceConfig config1 = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig config1 = CreateIceConfig(1000, GATHER_CONTINUALLY);
config1.regather_on_failed_networks_interval = 2000;
IceConfig config2;
config2.regather_on_failed_networks_interval = 2000;
CreateChannels(env, config1, config2);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kPublicAddrs[0]);
// Timeout value such that all connections are deleted.
const int kNetworkFailureTimeout = 35000;
SIMULATED_WAIT(false, kNetworkFailureTimeout, clock);
@@ -1562,8 +1557,8 @@
// when the signaling is slow.
TEST_F(P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignaling) {
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
// Emulate no remote parameters coming in.
set_remote_ice_parameter_source(FROM_CANDIDATE);
CreateChannels(env);
@@ -1576,10 +1571,10 @@
// Wait until the callee becomes writable to make sure that a ping request is
// received by the caller before their remote ICE credentials are set.
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
// Add two sets of remote ICE credentials, so that the ones used by the
// candidate will be generation 1 instead of 0.
ep1_ch1()->SetRemoteIceParameters(kIceParams[3]);
@@ -1587,13 +1582,13 @@
// The caller should have the selected connection connected to the peer
// reflexive candidate.
const Connection* selected_connection = nullptr;
- ASSERT_THAT(webrtc::WaitUntil(
+ ASSERT_THAT(WaitUntil(
[&] {
return selected_connection =
ep1_ch1()->selected_connection();
},
Ne(nullptr), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(selected_connection->remote_candidate().is_prflx());
EXPECT_EQ(kIceUfrag[1], selected_connection->remote_candidate().username());
EXPECT_EQ(kIcePwd[1], selected_connection->remote_candidate().password());
@@ -1601,7 +1596,7 @@
ResumeCandidates(1);
// Verify ep1's selected connection is updated to use the 'local' candidate.
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return ep1_ch1()
->selected_connection()
@@ -1609,7 +1604,7 @@
.is_local();
},
IsTrue(), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(selected_connection, ep1_ch1()->selected_connection());
DestroyChannels();
}
@@ -1631,15 +1626,15 @@
// candidate.
PauseCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
ep1_ch1()->SetRemoteIceParameters(kIceParams[1]);
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
// Check the selected candidate pair.
auto pair_ep1 = ep1_ch1()->GetSelectedCandidatePair();
@@ -1660,7 +1655,7 @@
// Let ep1 receive the remote candidate to update its type from prflx to host.
ResumeCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil(
+ ASSERT_THAT(WaitUntil(
[&] {
return ep1_ch1()->selected_connection() != nullptr &&
ep1_ch1()
@@ -1669,7 +1664,7 @@
.is_local();
},
IsTrue(), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// We should be able to reveal the address after it is learnt via
// AddIceCandidate.
@@ -1696,9 +1691,8 @@
// when the signaling is slow and the end points are behind NAT.
TEST_F(P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignalingWithNAT) {
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, NAT_SYMMETRIC,
- webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, NAT_SYMMETRIC, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
// Emulate no remote parameters coming in.
set_remote_ice_parameter_source(FROM_CANDIDATE);
CreateChannels(env);
@@ -1710,10 +1704,10 @@
// Wait until the callee becomes writable to make sure that a ping request is
// received by the caller before their remote ICE credentials are set.
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
// Add two sets of remote ICE credentials, so that the ones used by the
// candidate will be generation 1 instead of 0.
ep1_ch1()->SetRemoteIceParameters(kIceParams[3]);
@@ -1722,13 +1716,13 @@
// The caller's selected connection should be connected to the peer reflexive
// candidate.
const Connection* selected_connection = nullptr;
- ASSERT_THAT(webrtc::WaitUntil(
+ ASSERT_THAT(WaitUntil(
[&] {
return selected_connection =
ep1_ch1()->selected_connection();
},
Ne(nullptr), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(selected_connection->remote_candidate().is_prflx());
EXPECT_EQ(kIceUfrag[1], selected_connection->remote_candidate().username());
EXPECT_EQ(kIcePwd[1], selected_connection->remote_candidate().password());
@@ -1736,7 +1730,7 @@
ResumeCandidates(1);
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return ep1_ch1()
->selected_connection()
@@ -1744,7 +1738,7 @@
.is_prflx();
},
IsTrue(), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(selected_connection, ep1_ch1()->selected_connection());
DestroyChannels();
}
@@ -1761,22 +1755,22 @@
TEST_F(P2PTransportChannelTest,
PeerReflexiveCandidateBeforeSignalingWithIceRestart) {
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
// Only gather relay candidates, so that when the prflx candidate arrives
// it's prioritized above the current candidate pair.
- GetEndpoint(0)->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
- GetEndpoint(1)->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
+ GetEndpoint(0)->allocator_->SetCandidateFilter(CF_RELAY);
+ GetEndpoint(1)->allocator_->SetCandidateFilter(CF_RELAY);
// Setting this allows us to control when SetRemoteIceParameters is called.
set_remote_ice_parameter_source(FROM_CANDIDATE);
CreateChannels(env);
// Wait for the initial connection to be made.
ep1_ch1()->SetRemoteIceParameters(kIceParams[1]);
ep2_ch1()->SetRemoteIceParameters(kIceParams[0]);
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
- IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
+ IsRtcOk());
// Simulate an ICE restart on ep2, but don't signal the candidate or new
// ICE parameters until after a prflx connection has been made.
@@ -1788,7 +1782,7 @@
// The caller should have the selected connection connected to the peer
// reflexive candidate.
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return ep1_ch1()
->selected_connection()
@@ -1796,7 +1790,7 @@
.is_prflx();
},
IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const Connection* prflx_selected_connection =
ep1_ch1()->selected_connection();
@@ -1810,7 +1804,7 @@
// their information to update the peer reflexive candidate.
ResumeCandidates(1);
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return ep1_ch1()
->selected_connection()
@@ -1818,7 +1812,7 @@
.is_relay();
},
IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(prflx_selected_connection, ep1_ch1()->selected_connection());
DestroyChannels();
}
@@ -1828,19 +1822,19 @@
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
CreateChannels(env);
const Connection* selected_connection = nullptr;
// Wait until the callee's connections are created.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return selected_connection = ep2_ch1()->selected_connection();
},
NotNull(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Wait to make sure the selected connection is not changed.
SIMULATED_WAIT(ep2_ch1()->selected_connection() != selected_connection,
kShortTimeout, clock);
@@ -1853,9 +1847,8 @@
TEST_F(P2PTransportChannelTest, IncomingOnlyBlocked) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, NAT_FULL_CONE, OPEN,
- webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, NAT_FULL_CONE, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
SetAllocatorFlags(0, kOnlyLocalPorts);
CreateChannels(env);
@@ -1877,19 +1870,18 @@
TEST_F(P2PTransportChannelTest, IncomingOnlyOpen) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, NAT_FULL_CONE,
- webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, NAT_FULL_CONE, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
SetAllocatorFlags(0, kOnlyLocalPorts);
CreateChannels(env);
ep1_ch1()->set_incoming_only(true);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -1905,15 +1897,15 @@
//
// TODO(deadbeef): Later, make this flag the default, and do more elegant
// things to ensure extra candidates don't waste resources?
- ConfigureEndpoints(env, OPEN, OPEN,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_ANY_ADDRESS_PORTS,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(
+ env, OPEN, OPEN,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_ANY_ADDRESS_PORTS,
+ kDefaultPortAllocatorFlags);
// In order to simulate nothing working but outgoing TCP connections, prevent
// the endpoint from binding to its interface's address as well as the
// "any" addresses. It can then only make a connection by using "Connect()".
- fw()->SetUnbindableIps({webrtc::GetAnyIP(AF_INET), webrtc::GetAnyIP(AF_INET6),
- kPublicAddrs[0].ipaddr()});
+ fw()->SetUnbindableIps(
+ {GetAnyIP(AF_INET), GetAnyIP(AF_INET6), kPublicAddrs[0].ipaddr()});
CreateChannels(env);
// Expect a IceCandidateType::kPrflx candidate on the side that can only make
// outgoing connections, endpoint 0.
@@ -1928,12 +1920,12 @@
AddAddress(0, kPublicAddrs[0]);
AddAddress(1, kPublicAddrs[1]);
- SetAllocationStepDelay(0, webrtc::kMinimumStepDelay);
- SetAllocationStepDelay(1, webrtc::kMinimumStepDelay);
+ SetAllocationStepDelay(0, kMinimumStepDelay);
+ SetAllocationStepDelay(1, kMinimumStepDelay);
- int kOnlyLocalTcpPorts = webrtc::PORTALLOCATOR_DISABLE_UDP |
- webrtc::PORTALLOCATOR_DISABLE_STUN |
- webrtc::PORTALLOCATOR_DISABLE_RELAY;
+ int kOnlyLocalTcpPorts = PORTALLOCATOR_DISABLE_UDP |
+ PORTALLOCATOR_DISABLE_STUN |
+ PORTALLOCATOR_DISABLE_RELAY;
// Disable all protocols except TCP.
SetAllocatorFlags(0, kOnlyLocalTcpPorts);
SetAllocatorFlags(1, kOnlyLocalTcpPorts);
@@ -1952,22 +1944,22 @@
CreateChannels(env);
// Verify tcp candidates.
- VerifySavedTcpCandidates(0, webrtc::TCPTYPE_PASSIVE_STR);
- VerifySavedTcpCandidates(1, webrtc::TCPTYPE_ACTIVE_STR);
+ VerifySavedTcpCandidates(0, TCPTYPE_PASSIVE_STR);
+ VerifySavedTcpCandidates(1, TCPTYPE_ACTIVE_STR);
// Resume candidates.
ResumeCandidates(0);
ResumeCandidates(1);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
TestSendRecv(&clock);
DestroyChannels();
@@ -1978,18 +1970,18 @@
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, BLOCK_UDP_AND_INCOMING_TCP, OPEN,
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+ PORTALLOCATOR_ENABLE_SHARED_SOCKET,
+ PORTALLOCATOR_ENABLE_SHARED_SOCKET);
SetAllowTcpListen(0, false); // active.
SetAllowTcpListen(1, true); // actpass.
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
SIMULATED_WAIT(false, kDefaultTimeout, clock);
EXPECT_EQ(RemoteCandidate(ep1_ch1())->tcptype(), "passive");
@@ -2008,8 +2000,8 @@
AddAddress(1, kPublicAddrs[1]);
// Creating channels with both channels role set to CONTROLLING.
- SetIceRole(0, webrtc::ICEROLE_CONTROLLING);
- SetIceRole(1, webrtc::ICEROLE_CONTROLLING);
+ SetIceRole(0, ICEROLE_CONTROLLING);
+ SetIceRole(1, ICEROLE_CONTROLLING);
CreateChannels(env);
bool first_endpoint_has_lower_tiebreaker =
@@ -2018,20 +2010,19 @@
// Since both the channels initiated with controlling state, the channel with
// the lower tiebreaker should receive SignalRoleConflict.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return GetRoleConflict(first_endpoint_has_lower_tiebreaker ? 0 : 1);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_FALSE(GetRoleConflict(first_endpoint_has_lower_tiebreaker ? 1 : 0));
EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection() &&
ep2_ch1()->selected_connection());
@@ -2050,34 +2041,32 @@
// Give the first connection the higher tiebreaker so its role won't
// change unless we tell it to.
- SetIceRole(0, webrtc::ICEROLE_CONTROLLING);
- SetIceRole(1, webrtc::ICEROLE_CONTROLLING);
+ SetIceRole(0, ICEROLE_CONTROLLING);
+ SetIceRole(1, ICEROLE_CONTROLLING);
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ep1_ch1()->ports().size(); }, Eq(2u),
- {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return ep1_ch1()->ports().size(); }, Eq(2u),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
const std::vector<PortInterface*> ports_before = ep1_ch1()->ports();
for (size_t i = 0; i < ports_before.size(); ++i) {
- EXPECT_EQ(webrtc::ICEROLE_CONTROLLING, ports_before[i]->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLING, ports_before[i]->GetIceRole());
}
- ep1_ch1()->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ep1_ch1()->SetIceRole(ICEROLE_CONTROLLED);
const std::vector<PortInterface*> ports_after = ep1_ch1()->ports();
for (size_t i = 0; i < ports_after.size(); ++i) {
- EXPECT_EQ(webrtc::ICEROLE_CONTROLLED, ports_before[i]->GetIceRole());
+ EXPECT_EQ(ICEROLE_CONTROLLED, ports_before[i]->GetIceRole());
}
EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection() &&
ep2_ch1()->selected_connection());
@@ -2117,26 +2106,26 @@
AddAddress(1, kIPv6PublicAddrs[1]);
AddAddress(1, kPublicAddrs[1]);
- SetAllocationStepDelay(0, webrtc::kMinimumStepDelay);
- SetAllocationStepDelay(1, webrtc::kMinimumStepDelay);
+ SetAllocationStepDelay(0, kMinimumStepDelay);
+ SetAllocationStepDelay(1, kMinimumStepDelay);
// Enable IPv6
- SetAllocatorFlags(0, webrtc::PORTALLOCATOR_ENABLE_IPV6 |
- webrtc::PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
- SetAllocatorFlags(1, webrtc::PORTALLOCATOR_ENABLE_IPV6 |
- webrtc::PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
+ SetAllocatorFlags(
+ 0, PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
+ SetAllocatorFlags(
+ 1, PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kIPv6PublicAddrs[0], kIPv6PublicAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
TestSendRecv(&clock);
DestroyChannels();
@@ -2146,23 +2135,22 @@
TEST_F(P2PTransportChannelTest, TestForceTurn) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, NAT_PORT_RESTRICTED, NAT_SYMMETRIC,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+ ConfigureEndpoints(
+ env, NAT_PORT_RESTRICTED, NAT_SYMMETRIC,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET);
set_force_relay(true);
- SetAllocationStepDelay(0, webrtc::kMinimumStepDelay);
- SetAllocationStepDelay(1, webrtc::kMinimumStepDelay);
+ SetAllocationStepDelay(0, kMinimumStepDelay);
+ SetAllocationStepDelay(1, kMinimumStepDelay);
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection() &&
ep2_ch1()->selected_connection());
@@ -2181,21 +2169,21 @@
TEST_F(P2PTransportChannelTest, TestContinualGathering) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
- SetAllocationStepDelay(0, webrtc::kDefaultStepDelay);
- SetAllocationStepDelay(1, webrtc::kDefaultStepDelay);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
+ SetAllocationStepDelay(0, kDefaultStepDelay);
+ SetAllocationStepDelay(1, kDefaultStepDelay);
IceConfig continual_gathering_config =
- CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ CreateIceConfig(1000, GATHER_CONTINUALLY);
// By default, ep2 does not gather continually.
IceConfig default_config;
CreateChannels(env, continual_gathering_config, default_config);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
SIMULATED_WAIT(
IceGatheringState::kIceGatheringComplete == ep1_ch1()->gathering_state(),
kShortTimeout, clock);
@@ -2213,18 +2201,18 @@
TEST_F(P2PTransportChannelTest, TestUsingPooledSessionBeforeDoneGathering) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
// First create a pooled session for each endpoint.
auto& allocator_1 = GetEndpoint(0)->allocator_;
auto& allocator_2 = GetEndpoint(1)->allocator_;
int pool_size = 1;
allocator_1->SetConfiguration(allocator_1->stun_servers(),
allocator_1->turn_servers(), pool_size,
- webrtc::NO_PRUNE);
+ NO_PRUNE);
allocator_2->SetConfiguration(allocator_2->stun_servers(),
allocator_2->turn_servers(), pool_size,
- webrtc::NO_PRUNE);
+ NO_PRUNE);
const PortAllocatorSession* pooled_session_1 =
allocator_1->GetPooledSession();
const PortAllocatorSession* pooled_session_2 =
@@ -2239,10 +2227,10 @@
// Now let the endpoints connect and try exchanging some data.
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
TestSendRecv(&clock);
// Make sure the P2PTransportChannels are actually using ports from the
// pooled sessions.
@@ -2260,18 +2248,18 @@
TEST_F(P2PTransportChannelTest, TestUsingPooledSessionAfterDoneGathering) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
// First create a pooled session for each endpoint.
auto& allocator_1 = GetEndpoint(0)->allocator_;
auto& allocator_2 = GetEndpoint(1)->allocator_;
int pool_size = 1;
allocator_1->SetConfiguration(allocator_1->stun_servers(),
allocator_1->turn_servers(), pool_size,
- webrtc::NO_PRUNE);
+ NO_PRUNE);
allocator_2->SetConfiguration(allocator_2->stun_servers(),
allocator_2->turn_servers(), pool_size,
- webrtc::NO_PRUNE);
+ NO_PRUNE);
const PortAllocatorSession* pooled_session_1 =
allocator_1->GetPooledSession();
const PortAllocatorSession* pooled_session_2 =
@@ -2281,21 +2269,21 @@
// Wait for the pooled sessions to finish gathering before the
// P2PTransportChannels try to use them.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return pooled_session_1->CandidatesAllocationDone() &&
pooled_session_2->CandidatesAllocationDone();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Now let the endpoints connect and try exchanging some data.
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
TestSendRecv(&clock);
// Make sure the P2PTransportChannels are actually using ports from the
// pooled sessions.
@@ -2316,8 +2304,8 @@
// (which supports TURN servers and TURN candidate gathering) is available.
TEST_F(P2PTransportChannelTest, TurnToTurnPresumedWritable) {
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
// Only configure one channel so we can control when the remote candidate
// is added.
GetEndpoint(0)->cd1_.ch_ = CreateChannel(
@@ -2326,11 +2314,10 @@
config.presume_writable_when_fully_relayed = true;
ep1_ch1()->SetIceConfig(config);
ep1_ch1()->MaybeStartGathering();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ep1_ch1()->gathering_state(); },
+ EXPECT_THAT(WaitUntil([&] { return ep1_ch1()->gathering_state(); },
Eq(IceGatheringState::kIceGatheringComplete),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Add two remote candidates; a host candidate (with higher priority)
// and TURN candidate.
ep1_ch1()->AddRemoteCandidate(
@@ -2339,10 +2326,10 @@
CreateUdpCandidate(IceCandidateType::kRelay, "2.2.2.2", 2, 0));
// Expect that the TURN-TURN candidate pair will be prioritized since it's
// "probably writable".
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kShortTimeout)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kShortTimeout)}),
+ IsRtcOk());
EXPECT_TRUE(LocalCandidate(ep1_ch1())->is_relay());
EXPECT_TRUE(RemoteCandidate(ep1_ch1())->is_relay());
// Also expect that the channel instantly indicates that it's writable since
@@ -2369,8 +2356,7 @@
virtual_socket_server()->UpdateDelayDistribution();
ConfigureEndpoints(env, NAT_SYMMETRIC, NAT_SYMMETRIC,
- webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ kDefaultPortAllocatorFlags, kDefaultPortAllocatorFlags);
// We want the remote TURN candidate to show up as prflx. To do this we need
// to configure the server to accept packets from an address we haven't
// explicitly installed permission for.
@@ -2391,11 +2377,11 @@
// Wait for the TURN<->prflx connection.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->receiving() && ep1_ch1()->writable(); },
IsTrue(),
{.timeout = TimeDelta::Millis(kShortTimeout), .clock = &fake_clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_NE(nullptr, ep1_ch1()->selected_connection());
EXPECT_TRUE(LocalCandidate(ep1_ch1())->is_relay());
EXPECT_TRUE(RemoteCandidate(ep1_ch1())->is_prflx());
@@ -2405,11 +2391,11 @@
// Now wait for it to actually become writable.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->selected_connection()->writable(); },
IsTrue(),
{.timeout = TimeDelta::Millis(kShortTimeout), .clock = &fake_clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Explitly destroy channels, before fake clock is destroyed.
DestroyChannels();
@@ -2422,8 +2408,7 @@
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, NAT_SYMMETRIC, NAT_SYMMETRIC,
- webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ kDefaultPortAllocatorFlags, kDefaultPortAllocatorFlags);
IceConfig config;
config.presume_writable_when_fully_relayed = true;
GetEndpoint(0)->cd1_.ch_ = CreateChannel(
@@ -2436,19 +2421,18 @@
ep2_ch1()->MaybeStartGathering();
// Wait for initial connection as usual.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kShortTimeout), .clock = &fake_clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const Connection* old_selected_connection = ep1_ch1()->selected_connection();
// Destroy the second channel and wait for the current connection on the
// first channel to become "unreliable", making it no longer writable.
GetEndpoint(1)->cd1_.ch_.reset();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return !ep1_ch1()->writable(); }, IsTrue(),
+ EXPECT_THAT(WaitUntil([&] { return !ep1_ch1()->writable(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout),
.clock = &fake_clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_NE(nullptr, ep1_ch1()->selected_connection());
// Add a remote TURN candidate. The first channel should still have a TURN
// port available to make a TURN<->TURN pair that's presumed writable.
@@ -2467,8 +2451,8 @@
// writable" connection. Previously this did not work.
TEST_F(P2PTransportChannelTest, SignalReadyToSendWithPresumedWritable) {
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
// Only test one endpoint, so we can ensure the connection doesn't receive a
// binding response and advance beyond being "presumed" writable.
GetEndpoint(0)->cd1_.ch_ = CreateChannel(
@@ -2477,18 +2461,17 @@
config.presume_writable_when_fully_relayed = true;
ep1_ch1()->SetIceConfig(config);
ep1_ch1()->MaybeStartGathering();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ep1_ch1()->gathering_state(); },
+ EXPECT_THAT(WaitUntil([&] { return ep1_ch1()->gathering_state(); },
Eq(IceGatheringState::kIceGatheringComplete),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ep1_ch1()->AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "1.1.1.1", 1, 0));
// Sanity checking the type of the connection.
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kShortTimeout)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kShortTimeout)}),
+ IsRtcOk());
EXPECT_TRUE(LocalCandidate(ep1_ch1())->is_relay());
EXPECT_TRUE(RemoteCandidate(ep1_ch1())->is_relay());
@@ -2515,18 +2498,16 @@
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
// Gather only relay candidates.
- ConfigureEndpoints(
- env, NAT_SYMMETRIC, NAT_SYMMETRIC,
- webrtc::kDefaultPortAllocatorFlags | webrtc::PORTALLOCATOR_DISABLE_UDP |
- webrtc::PORTALLOCATOR_DISABLE_STUN |
- webrtc::PORTALLOCATOR_DISABLE_TCP,
- webrtc::kDefaultPortAllocatorFlags | webrtc::PORTALLOCATOR_DISABLE_UDP |
- webrtc::PORTALLOCATOR_DISABLE_STUN |
- webrtc::PORTALLOCATOR_DISABLE_TCP);
+ ConfigureEndpoints(env, NAT_SYMMETRIC, NAT_SYMMETRIC,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_DISABLE_UDP |
+ PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_TCP,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_DISABLE_UDP |
+ PORTALLOCATOR_DISABLE_STUN |
+ PORTALLOCATOR_DISABLE_TCP);
// With conflicting ICE roles, endpoint 1 has the higher tie breaker and will
// send a binding error response.
- SetIceRole(0, webrtc::ICEROLE_CONTROLLING);
- SetIceRole(1, webrtc::ICEROLE_CONTROLLING);
+ SetIceRole(0, ICEROLE_CONTROLLING);
+ SetIceRole(1, ICEROLE_CONTROLLING);
// We want the remote TURN candidate to show up as prflx. To do this we need
// to configure the server to accept packets from an address we haven't
// explicitly installed permission for.
@@ -2542,11 +2523,11 @@
ep2_ch1()->MaybeStartGathering();
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->receiving() && ep1_ch1()->writable(); },
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_NE(nullptr, ep1_ch1()->selected_connection());
@@ -2565,7 +2546,7 @@
"WebRTC-PiggybackIceCheckAcknowledgement/Enabled/"));
ConfigureEndpoints(env, OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
IceConfig ep1_config;
- IceConfig ep2_config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig ep2_config = CreateIceConfig(1000, GATHER_CONTINUALLY);
// Let ep2 be tolerable of the loss of connectivity checks, so that it keeps
// sending pings even after ep1 becomes unwritable as we configure the
// firewall below.
@@ -2578,23 +2559,22 @@
// Wait until both sides become writable for the first time.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Block the ingress traffic to ep1 so that there is no check response from
// ep2.
ASSERT_NE(nullptr, LocalCandidate(ep1_ch1()));
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_IN,
- LocalCandidate(ep1_ch1())->address());
+ fw()->AddRule(false, FP_ANY, FD_IN, LocalCandidate(ep1_ch1())->address());
// Wait until ep1 becomes unwritable. At the same time ep2 should be still
// fine so that it will keep sending pings.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1() != nullptr && !ep1_ch1()->writable(); },
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(ep2_ch1() != nullptr && ep2_ch1()->writable());
// Now let the pings from ep2 to flow but block any pings from ep1, so that
// ep1 can only become writable again after receiving an incoming ping from
@@ -2602,14 +2582,13 @@
// though that ep1 should have stopped sending pings after becoming unwritable
// in the current design.
fw()->ClearRules();
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_OUT,
- LocalCandidate(ep1_ch1())->address());
+ fw()->AddRule(false, FP_ANY, FD_OUT, LocalCandidate(ep1_ch1())->address());
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1() != nullptr && ep1_ch1()->writable(); },
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -2752,43 +2731,43 @@
SetAllocatorFlags(1, kOnlyLocalPorts);
// Make the receiving timeout shorter for testing.
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_ONCE);
+ IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
// Create channels and let them go writable, as usual.
CreateChannels(env, config, config);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[1]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kPublicAddrs[1]);
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
// We should detect loss of receiving within 1 second or so.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return !selected_connection1->receiving(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// We should switch over to use the alternate addr on both sides
// when we are not receiving.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->selected_connection()->receiving() &&
ep2_ch1()->selected_connection()->receiving();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]));
EXPECT_TRUE(
RemoteCandidate(ep1_ch1())->address().EqualIPs(kAlternateAddrs[1]));
@@ -2814,35 +2793,35 @@
SetAllocatorFlags(1, kOnlyLocalPorts);
// Make the receiving timeout shorter for testing.
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_ONCE);
+ IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
// Create channels and let them go writable, as usual.
CreateChannels(env, config, config);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kPublicAddrs[0]);
// We should detect loss of receiving within 1 second or so.
// We should switch over to use the alternate addr on both sides
// when we are not receiving.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kAlternateAddrs[0], kPublicAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -2853,20 +2832,19 @@
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
- test_turn_server()->AddInternalSocket(kTurnTcpIntAddr, webrtc::PROTO_TCP);
+ test_turn_server()->AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
RelayServerConfig turn_server;
turn_server.credentials = kRelayCredentials;
- turn_server.ports.push_back(
- ProtocolAddress(kTurnTcpIntAddr, webrtc::PROTO_TCP));
+ turn_server.ports.push_back(ProtocolAddress(kTurnTcpIntAddr, PROTO_TCP));
GetAllocator(0)->AddTurnServerForTesting(turn_server);
GetAllocator(1)->AddTurnServerForTesting(turn_server);
// Enable IPv6
- SetAllocatorFlags(0, webrtc::PORTALLOCATOR_ENABLE_IPV6 |
- webrtc::PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
- SetAllocatorFlags(1, webrtc::PORTALLOCATOR_ENABLE_IPV6 |
- webrtc::PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
- SetAllocationStepDelay(0, webrtc::kMinimumStepDelay);
- SetAllocationStepDelay(1, webrtc::kMinimumStepDelay);
+ SetAllocatorFlags(
+ 0, PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
+ SetAllocatorFlags(
+ 1, PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
+ SetAllocationStepDelay(0, kMinimumStepDelay);
+ SetAllocationStepDelay(1, kMinimumStepDelay);
auto& wifi = kPublicAddrs;
auto& cellular = kAlternateAddrs;
@@ -2889,36 +2867,36 @@
virtual_socket_server()->UpdateDelayDistribution();
// Make the receiving timeout shorter for testing.
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig config = CreateIceConfig(1000, GATHER_CONTINUALLY);
// Create channels and let them go writable, as usual.
CreateChannels(env, config, config, true /* ice_renomination */);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
wifiIpv6[0], wifiIpv6[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Blackhole any traffic to or from the wifi on endpoint 1.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, wifi[0]);
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, wifiIpv6[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, wifi[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, wifiIpv6[0]);
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
const Connection* selected_connection2 = ep2_ch1()->selected_connection();
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return !selected_connection1->receiving() &&
!selected_connection2->receiving();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Per-network best connections will be pinged at relatively higher rate when
// the selected connection becomes not receiving.
@@ -2928,11 +2906,11 @@
int64_t last_ping_sent1 = per_network_best_connection1->last_ping_sent();
int num_pings_sent1 = per_network_best_connection1->num_pings_sent();
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return per_network_best_connection1->num_pings_sent(); },
Gt(num_pings_sent1),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(per_network_best_connection1->num_pings_sent() - num_pings_sent1,
0);
int64_t ping_interval1 =
@@ -2946,14 +2924,14 @@
// It should switch over to use the cellular IPv6 addr on endpoint 1 before
// it timed out on writing.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
cellularIpv6[0], wifiIpv6[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -2977,23 +2955,23 @@
// We want it to set the remote ICE parameters when creating channels.
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
// Make the receiving timeout shorter for testing.
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_ONCE);
+ IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
// Create channels with ICE renomination and let them go writable as usual.
CreateChannels(env, config, config, true);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep2_ch1()->selected_connection()->remote_nomination() > 0 &&
ep1_ch1()->selected_connection()->acked_nomination() > 0;
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
Connection* selected_connection2 =
const_cast<Connection*>(ep2_ch1()->selected_connection());
@@ -3006,23 +2984,22 @@
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kPublicAddrs[0]);
// The selected connection on the controlling side should switch.
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ep1_ch1()->selected_connection(); },
- Ne(selected_connection1),
- {.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ep1_ch1()->selected_connection(); },
+ Ne(selected_connection1),
+ {.timeout = TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ IsRtcOk());
// The connection on the controlled side should be nominated again
// and have an increased nomination.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep2_ch1()->selected_connection()->remote_nomination(); },
Gt(remote_nomination2),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -3050,33 +3027,33 @@
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Make the receiving timeout shorter for testing.
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_ONCE);
+ IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
ep1_ch1()->SetIceConfig(config);
ep2_ch1()->SetIceConfig(config);
reset_selected_candidate_pair_switches();
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[1]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kPublicAddrs[1]);
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
// We should detect loss of receiving within 1 second or so.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return !selected_connection1->receiving(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// After a short while, the link recovers itself.
SIMULATED_WAIT(false, 10, clock);
fw()->ClearRules();
@@ -3084,14 +3061,14 @@
// We should remain on the public address on both sides and no connection
// switches should have happened.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->selected_connection()->receiving() &&
ep2_ch1()->selected_connection()->receiving();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(RemoteCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[1]));
EXPECT_TRUE(LocalCandidate(ep2_ch1())->address().EqualIPs(kPublicAddrs[1]));
EXPECT_EQ(0, reset_selected_candidate_pair_switches());
@@ -3118,32 +3095,32 @@
// Create channels and let them go writable, as usual.
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Make the receiving timeout shorter for testing.
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_ONCE);
+ IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
ep1_ch1()->SetIceConfig(config);
ep2_ch1()->SetIceConfig(config);
reset_selected_candidate_pair_switches();
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kPublicAddrs[0]);
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
// We should detect loss of receiving within 1 second or so.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return !selected_connection1->receiving(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// The link recovers after a short while.
SIMULATED_WAIT(false, 10, clock);
fw()->ClearRules();
@@ -3151,14 +3128,14 @@
// We should not switch to the alternate addr on both sides because of the
// dampening.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(0, reset_selected_candidate_pair_switches());
DestroyChannels();
}
@@ -3184,36 +3161,36 @@
CreateChannels(env);
// Make the receiving timeout shorter for testing.
// Set the backup connection ping interval to 25s.
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_ONCE, 25000);
+ IceConfig config = CreateIceConfig(1000, GATHER_ONCE, 25000);
// Ping the best connection more frequently since we don't have traffic.
config.stable_writable_connection_ping_interval = 900;
ep1_ch1()->SetIceConfig(config);
ep2_ch1()->SetIceConfig(config);
// Need to wait to make sure the connections on both networks are writable.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), wifi[0],
wifi[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
Connection* backup_conn =
GetConnectionWithLocalAddress(ep1_ch1(), cellular[0]);
ASSERT_NE(nullptr, backup_conn);
// After a short while, the backup connection will be writable but not
// receiving because backup connection is pinged at a slower rate.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return backup_conn->writable() && !backup_conn->receiving(); },
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
reset_selected_candidate_pair_switches();
// Blackhole any traffic to or from the remote WiFi networks.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, wifi[1]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, wifi[1]);
int num_switches = 0;
SIMULATED_WAIT((num_switches = reset_selected_candidate_pair_switches()) > 0,
@@ -3242,18 +3219,17 @@
// Create channels and let them go writable, as usual.
CreateChannels(env);
- EXPECT_THAT(
- webrtc::WaitUntil([&]() { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ EXPECT_THAT(WaitUntil([&]() { return CheckConnected(ep1_ch1(), ep2_ch1()); },
IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Need to wait to make sure the connections on both networks are writable.
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
wifi[0], wifi[1]);
},
IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -3277,13 +3253,13 @@
// Create channels and let them go writable, as usual.
CreateChannels(env);
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&]() {
return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
cellular[0], wifi[1]);
},
IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -3305,30 +3281,28 @@
// Create channels and let them go writable, as usual.
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
- IsTrue()),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue()),
+ IsRtcOk());
int backup_ping_interval = 2000;
ep2_ch1()->SetIceConfig(
- CreateIceConfig(2000, webrtc::GATHER_ONCE, backup_ping_interval));
+ CreateIceConfig(2000, GATHER_ONCE, backup_ping_interval));
// After the state becomes COMPLETED, the backup connection will be pinged
// once every `backup_ping_interval` milliseconds.
- ASSERT_THAT(webrtc::WaitUntil([&] { return ep2_ch1()->GetState(); },
- Eq(IceTransportStateInternal::STATE_COMPLETED)),
- webrtc::IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ep2_ch1()->GetState(); },
+ Eq(IceTransportStateInternal::STATE_COMPLETED)),
+ IsRtcOk());
auto connections = ep2_ch1()->connections();
ASSERT_EQ(2U, connections.size());
Connection* backup_conn = GetBackupConnection(ep2_ch1());
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return backup_conn->writable(); }, IsTrue(),
+ EXPECT_THAT(WaitUntil([&] { return backup_conn->writable(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
int64_t last_ping_response_ms = backup_conn->last_ping_response_received();
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return backup_conn->last_ping_response_received(); },
- Gt(last_ping_response_ms),
- {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return backup_conn->last_ping_response_received(); },
+ Gt(last_ping_response_ms),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
+ IsRtcOk());
int time_elapsed =
backup_conn->last_ping_response_received() - last_ping_response_ms;
RTC_LOG(LS_INFO) << "Time elapsed: " << time_elapsed;
@@ -3355,35 +3329,33 @@
// Create channels and let them go writable, as usual.
CreateChannels(env);
EXPECT_THAT(
- webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
- IsTrue()),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue()),
+ IsRtcOk());
// Set a value larger than the default value of 2500 ms
int ping_interval_ms = 3456;
- IceConfig config = CreateIceConfig(2 * ping_interval_ms, webrtc::GATHER_ONCE);
+ IceConfig config = CreateIceConfig(2 * ping_interval_ms, GATHER_ONCE);
config.stable_writable_connection_ping_interval = ping_interval_ms;
ep2_ch1()->SetIceConfig(config);
// After the state becomes COMPLETED and is stable and writable, the
// connection will be pinged once every `ping_interval_ms` milliseconds.
- ASSERT_THAT(webrtc::WaitUntil([&] { return ep2_ch1()->GetState(); },
- Eq(IceTransportStateInternal::STATE_COMPLETED)),
- webrtc::IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ep2_ch1()->GetState(); },
+ Eq(IceTransportStateInternal::STATE_COMPLETED)),
+ IsRtcOk());
auto connections = ep2_ch1()->connections();
ASSERT_EQ(2U, connections.size());
Connection* conn = GetBestConnection(ep2_ch1());
- EXPECT_THAT(webrtc::WaitUntil([&] { return conn->writable(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return conn->writable(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
int64_t last_ping_response_ms;
// Burn through some pings so the connection is stable.
for (int i = 0; i < 5; i++) {
last_ping_response_ms = conn->last_ping_response_received();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return conn->last_ping_response_received(); },
+ EXPECT_THAT(WaitUntil([&] { return conn->last_ping_response_received(); },
Gt(last_ping_response_ms),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
EXPECT_TRUE(conn->stable(last_ping_response_ms)) << "Connection not stable";
int time_elapsed =
@@ -3405,16 +3377,16 @@
CreateChannels(env);
// Both transport channels will reach STATE_COMPLETED quickly.
- EXPECT_THAT(webrtc::WaitUntil([&] { return ep1_ch1()->GetState(); },
- Eq(IceTransportStateInternal::STATE_COMPLETED),
- {.timeout = TimeDelta::Millis(kShortTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
- EXPECT_THAT(webrtc::WaitUntil([&] { return ep2_ch1()->GetState(); },
- Eq(IceTransportStateInternal::STATE_COMPLETED),
- {.timeout = TimeDelta::Millis(kShortTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ep1_ch1()->GetState(); },
+ Eq(IceTransportStateInternal::STATE_COMPLETED),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ep2_ch1()->GetState(); },
+ Eq(IceTransportStateInternal::STATE_COMPLETED),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
DestroyChannels();
}
@@ -3429,17 +3401,17 @@
AddAddress(0, kPublicAddrs[0]);
AddAddress(1, kPublicAddrs[1]);
// Create channels and let them go writable, as usual.
- IceConfig ep1_config = CreateIceConfig(2000, webrtc::GATHER_CONTINUALLY);
- IceConfig ep2_config = CreateIceConfig(2000, webrtc::GATHER_ONCE);
+ IceConfig ep1_config = CreateIceConfig(2000, GATHER_CONTINUALLY);
+ IceConfig ep2_config = CreateIceConfig(2000, GATHER_ONCE);
CreateChannels(env, ep1_config, ep2_config);
SetAllocatorFlags(0, kOnlyLocalPorts);
SetAllocatorFlags(1, kOnlyLocalPorts);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// More than one port has been created.
EXPECT_LE(1U, ep1_ch1()->ports().size());
// Endpoint 1 enabled continual gathering; the port will be removed
@@ -3447,10 +3419,9 @@
RemoveAddress(0, kPublicAddrs[0]);
EXPECT_TRUE(ep1_ch1()->ports().empty());
// The remote candidates will be removed eventually.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ep2_ch1()->remote_candidates().empty(); },
+ EXPECT_THAT(WaitUntil([&] { return ep2_ch1()->remote_candidates().empty(); },
IsTrue(), {.clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
size_t num_ports = ep2_ch1()->ports().size();
EXPECT_LE(1U, num_ports);
@@ -3460,11 +3431,10 @@
// other participant will not be removed.
RemoveAddress(1, kPublicAddrs[1]);
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ep2_ch1()->ports().size(); }, Eq(0U),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ep2_ch1()->ports().size(); }, Eq(0U),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
SIMULATED_WAIT(ep1_ch1()->remote_candidates().empty(), 500, clock);
EXPECT_EQ(num_remote_candidates, ep1_ch1()->remote_candidates().size());
@@ -3483,40 +3453,40 @@
AddAddress(1, cellular[1], "test_cell1", ADAPTER_TYPE_CELLULAR);
// Set continual gathering policy.
IceConfig continual_gathering_config =
- CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ CreateIceConfig(1000, GATHER_CONTINUALLY);
CreateChannels(env, continual_gathering_config, continual_gathering_config);
SetAllocatorFlags(0, kOnlyLocalPorts);
SetAllocatorFlags(1, kOnlyLocalPorts);
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
- IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
+ IsRtcOk());
// Add a new wifi interface on end point 2. We should expect a new connection
// to be created and the new one will be the best connection.
AddAddress(1, wifi[1], "test_wifi1", ADAPTER_TYPE_WIFI);
const Connection* conn;
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return (conn = ep1_ch1()->selected_connection()) !=
nullptr &&
HasRemoteAddress(conn, wifi[1]);
},
IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- EXPECT_THAT(webrtc::WaitUntil(
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil(
[&] {
return (conn = ep2_ch1()->selected_connection()) !=
nullptr &&
HasLocalAddress(conn, wifi[1]);
},
IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Add a new cellular interface on end point 1, we should expect a new
// backup connection created using this new interface.
AddAddress(0, cellular[0], "test_cellular0", ADAPTER_TYPE_CELLULAR);
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return ep1_ch1()->GetState() ==
IceTransportStateInternal::STATE_COMPLETED &&
@@ -3531,8 +3501,8 @@
});
},
IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- EXPECT_THAT(webrtc::WaitUntil(
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil(
[&] {
return ep2_ch1()->GetState() ==
IceTransportStateInternal::STATE_COMPLETED &&
@@ -3547,7 +3517,7 @@
});
},
IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -3566,18 +3536,18 @@
// Set continual gathering policy.
IceConfig continual_gathering_config =
- CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ CreateIceConfig(1000, GATHER_CONTINUALLY);
// Create channels and let them go writable, as usual.
CreateChannels(env, continual_gathering_config, continual_gathering_config);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Add the new address first and then remove the other one.
RTC_LOG(LS_INFO) << "Draining...";
@@ -3585,28 +3555,28 @@
RemoveAddress(1, kPublicAddrs[1]);
// We should switch to use the alternate address after an exchange of pings.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kAlternateAddrs[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Remove one address first and then add another address.
RTC_LOG(LS_INFO) << "Draining again...";
RemoveAddress(1, kAlternateAddrs[1]);
AddAddress(1, kAlternateAddrs[0]);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(
ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kAlternateAddrs[0]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -3627,31 +3597,31 @@
SetAllocatorFlags(1, kOnlyLocalPorts);
// Create channels and let them go writable, as usual.
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig config = CreateIceConfig(1000, GATHER_CONTINUALLY);
config.regather_on_failed_networks_interval = 2000;
CreateChannels(env, config, config);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), wifi[0],
wifi[1]);
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Destroy all backup connections.
DestroyAllButBestConnection(ep1_ch1());
// Ensure the backup connection is removed first.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return GetConnectionWithLocalAddress(ep1_ch1(), cellular[0]); },
Eq(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const Connection* conn;
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return (conn = GetConnectionWithLocalAddress(
ep1_ch1(), cellular[0])) != nullptr &&
@@ -3659,7 +3629,7 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
@@ -3675,14 +3645,14 @@
IceConfig config;
CreateChannels(env, config, config, false);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckConnected(ep1_ch1(), ep2_ch1()) &&
!ep1_ch1()->selected_connection()->network()->IsVpn();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnPreferVpn) {
@@ -3699,28 +3669,28 @@
RTC_LOG(LS_INFO) << "KESO: config.vpn_preference: " << config.vpn_preference;
CreateChannels(env, config, config, false);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckConnected(ep1_ch1(), ep2_ch1()) &&
ep1_ch1()->selected_connection()->network()->IsVpn();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Block VPN.
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kAlternateAddrs[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kAlternateAddrs[0]);
// Check that it switches to non-VPN
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckConnected(ep1_ch1(), ep2_ch1()) &&
!ep1_ch1()->selected_connection()->network()->IsVpn();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnAvoidVpn) {
@@ -3736,28 +3706,28 @@
config.vpn_preference = VpnPreference::kAvoidVpn;
CreateChannels(env, config, config, false);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckConnected(ep1_ch1(), ep2_ch1()) &&
!ep1_ch1()->selected_connection()->network()->IsVpn();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Block non-VPN.
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kPublicAddrs[0]);
// Check that it switches to VPN
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckConnected(ep1_ch1(), ep2_ch1()) &&
ep1_ch1()->selected_connection()->network()->IsVpn();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnNeverVpn) {
@@ -3773,25 +3743,25 @@
config.vpn_preference = VpnPreference::kNeverUseVpn;
CreateChannels(env, config, config, false);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckConnected(ep1_ch1(), ep2_ch1()) &&
!ep1_ch1()->selected_connection()->network()->IsVpn();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Block non-VPN.
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kPublicAddrs[0]);
// Check that it does not switches to VPN
clock.AdvanceTime(TimeDelta::Millis(kDefaultTimeout));
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return !CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnOnlyVpn) {
@@ -3807,25 +3777,25 @@
config.vpn_preference = VpnPreference::kOnlyUseVpn;
CreateChannels(env, config, config, false);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return CheckConnected(ep1_ch1(), ep2_ch1()) &&
ep1_ch1()->selected_connection()->network()->IsVpn();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Block VPN.
- fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kAlternateAddrs[0]);
+ fw()->AddRule(false, FP_ANY, FD_ANY, kAlternateAddrs[0]);
// Check that it does not switch to non-VPN
clock.AdvanceTime(TimeDelta::Millis(kDefaultTimeout));
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return !CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, StunDictionaryPerformsSync) {
@@ -3841,7 +3811,7 @@
CreateChannels(env);
MockFunction<void(IceTransportInternal*, const StunDictionaryView&,
- webrtc::ArrayView<uint16_t>)>
+ ArrayView<uint16_t>)>
view_updated_func;
ep2_ch1()->AddDictionaryViewUpdatedCallback(
"tag", view_updated_func.AsStdFunction());
@@ -3859,10 +3829,10 @@
});
EXPECT_CALL(writer_synced_func, Call).Times(1);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
// A collection of tests which tests a single P2PTransportChannel by sending
@@ -3878,7 +3848,7 @@
protected:
void PrepareChannel(P2PTransportChannel* ch) {
- ch->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ ch->SetIceRole(ICEROLE_CONTROLLING);
ch->SetIceParameters(kIceParams[0]);
ch->SetRemoteIceParameters(kIceParams[1]);
ch->SignalNetworkRouteChanged.connect(
@@ -3898,17 +3868,16 @@
int port_num,
ThreadProcessingFakeClock* clock = nullptr) {
if (clock == nullptr) {
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return GetConnectionTo(ch, ip, port_num); },
+ EXPECT_THAT(WaitUntil([&] { return GetConnectionTo(ch, ip, port_num); },
Ne(nullptr),
{.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
} else {
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return GetConnectionTo(ch, ip, port_num); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &*clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
return GetConnectionTo(ch, ip, port_num);
}
@@ -3963,11 +3932,11 @@
channel->AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, ip_addr, port, priority));
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return GetConnectionTo(channel, ip_addr, port); },
Ne(nullptr),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &*clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
Connection* conn = GetConnectionTo(channel, ip_addr, port);
if (conn && writable) {
@@ -4014,8 +3983,7 @@
ByteBufferWriter buf;
msg.Write(&buf);
conn->OnReadPacket(ReceivedIpPacket::CreateFromLegacy(
- reinterpret_cast<const char*>(buf.Data()), buf.Length(),
- webrtc::TimeMicros()));
+ reinterpret_cast<const char*>(buf.Data()), buf.Length(), TimeMicros()));
}
void ReceivePingOnConnection(Connection* conn,
@@ -4149,13 +4117,13 @@
// is not pruned.
conn1->ReceivedPingResponse(LOW_RTT, "id");
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return conn1->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL &&
conn2->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL;
},
IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
// Verify that the connections are pinged at the right time.
@@ -4183,7 +4151,7 @@
SIMULATED_WAIT(conn->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL,
kDefaultTimeout, clock);
int64_t ping_interval_ms = (clock.TimeNanos() - start) /
- webrtc::kNumNanosecsPerMillisec /
+ kNumNanosecsPerMillisec /
(MIN_PINGS_AT_WEAK_PING_INTERVAL - 1);
EXPECT_EQ(ping_interval_ms, WEAK_PING_INTERVAL);
@@ -4196,8 +4164,7 @@
// to converge the RTT.
SIMULATED_WAIT(conn->num_pings_sent() == ping_sent_before + 1, kMediumTimeout,
clock);
- ping_interval_ms =
- (clock.TimeNanos() - start) / webrtc::kNumNanosecsPerMillisec;
+ ping_interval_ms = (clock.TimeNanos() - start) / kNumNanosecsPerMillisec;
EXPECT_GE(ping_interval_ms,
WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL);
EXPECT_LE(
@@ -4215,8 +4182,7 @@
start = clock.TimeNanos();
SIMULATED_WAIT(conn->num_pings_sent() == ping_sent_before + 1, kMediumTimeout,
clock);
- ping_interval_ms =
- (clock.TimeNanos() - start) / webrtc::kNumNanosecsPerMillisec;
+ ping_interval_ms = (clock.TimeNanos() - start) / kNumNanosecsPerMillisec;
EXPECT_GE(ping_interval_ms,
STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL);
EXPECT_LE(
@@ -4227,14 +4193,12 @@
conn->ReceivedPingResponse(LOW_RTT, "id");
// Create a in-flight ping.
- conn->Ping(clock.TimeNanos() / webrtc::kNumNanosecsPerMillisec);
+ conn->Ping(clock.TimeNanos() / kNumNanosecsPerMillisec);
start = clock.TimeNanos();
// In-flight ping timeout and the connection will be unstable.
- SIMULATED_WAIT(
- !conn->stable(clock.TimeNanos() / webrtc::kNumNanosecsPerMillisec),
- kMediumTimeout, clock);
- int64_t duration_ms =
- (clock.TimeNanos() - start) / webrtc::kNumNanosecsPerMillisec;
+ SIMULATED_WAIT(!conn->stable(clock.TimeNanos() / kNumNanosecsPerMillisec),
+ kMediumTimeout, clock);
+ int64_t duration_ms = (clock.TimeNanos() - start) / kNumNanosecsPerMillisec;
EXPECT_GE(duration_ms, 2 * conn->rtt() - RTT_RANGE);
EXPECT_LE(duration_ms, 2 * conn->rtt() + RTT_RANGE);
// The connection become unstable due to not receiving ping responses.
@@ -4247,8 +4211,7 @@
ping_sent_before = conn->num_pings_sent();
SIMULATED_WAIT(conn->num_pings_sent() == ping_sent_before + 1, kMediumTimeout,
clock);
- ping_interval_ms =
- (clock.TimeNanos() - start) / webrtc::kNumNanosecsPerMillisec;
+ ping_interval_ms = (clock.TimeNanos() - start) / kNumNanosecsPerMillisec;
EXPECT_GE(ping_interval_ms,
WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL);
EXPECT_LE(
@@ -4264,14 +4227,13 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("TestChannel", 1, &pa, &env.field_trials());
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ ch.SetIceRole(ICEROLE_CONTROLLING);
ch.SetIceParameters(kIceParams[0]);
ch.MaybeStartGathering();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.gathering_state(); },
+ EXPECT_THAT(WaitUntil([&] { return ch.gathering_state(); },
Eq(IceGatheringState::kIceGatheringComplete),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Simulate a binding request being received, creating a peer reflexive
// candidate pair while we still don't have remote ICE parameters.
@@ -4283,8 +4245,8 @@
prflx_priority));
Port* port = GetPort(&ch);
ASSERT_NE(nullptr, port);
- port->SignalUnknownAddress(port, SocketAddress("1.1.1.1", 1),
- webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
+ port->SignalUnknownAddress(port, SocketAddress("1.1.1.1", 1), PROTO_UDP,
+ &request, kIceUfrag[1], false);
Connection* conn = GetConnectionTo(&ch, "1.1.1.1", 1);
ASSERT_NE(nullptr, conn);
@@ -4297,9 +4259,9 @@
// the first ping is sent as soon as possible, within one simulated clock
// tick.
ch.SetRemoteIceParameters(kIceParams[1]);
- EXPECT_THAT(webrtc::WaitUntil([&] { return conn->num_pings_sent(); }, Gt(0),
- {.clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return conn->num_pings_sent(); }, Gt(0),
+ {.clock = &clock}),
+ IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestNoTriggeredChecksWhenWritable) {
@@ -4363,11 +4325,10 @@
// Pruning the connection reduces the set of active connections and changes
// the channel state.
conn1->Prune();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return channel_state(); },
+ EXPECT_THAT(WaitUntil([&] { return channel_state(); },
Eq(IceTransportStateInternal::STATE_FAILED),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
// Test adding remote candidates with different ufrags. If a remote candidate
@@ -4411,10 +4372,10 @@
ch.AddRemoteCandidate(CreateUdpCandidate(IceCandidateType::kHost, "3.3.3.3",
3, 0, kIceUfrag[2]));
Connection* conn3 = nullptr;
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return conn3 = GetConnectionTo(&ch, "3.3.3.3", 3); },
- Ne(nullptr), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return conn3 = GetConnectionTo(&ch, "3.3.3.3", 3); },
+ Ne(nullptr), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
const Candidate& new_candidate = conn3->remote_candidate();
EXPECT_EQ(kIcePwd[2], new_candidate.password());
EXPECT_EQ(1U, new_candidate.generation());
@@ -4456,16 +4417,15 @@
conn2->ReceivedPingResponse(LOW_RTT, "id");
// Wait for conn2 to be selected.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
{.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Destroy the connection to test SignalUnknownAddress.
ch.RemoveConnectionForTest(conn1);
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return GetConnectionTo(&ch, "1.1.1.1", 1); },
- Eq(nullptr), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return GetConnectionTo(&ch, "1.1.1.1", 1); }, Eq(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
// Create a minimal STUN message with prflx priority.
IceMessage request(STUN_BINDING_REQUEST);
@@ -4478,15 +4438,15 @@
Port* port = GetPort(&ch);
// conn1 should be resurrected with original priority.
- port->SignalUnknownAddress(port, SocketAddress("1.1.1.1", 1),
- webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
+ port->SignalUnknownAddress(port, SocketAddress("1.1.1.1", 1), PROTO_UDP,
+ &request, kIceUfrag[1], false);
conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
ASSERT_TRUE(conn1 != nullptr);
EXPECT_EQ(conn1->remote_candidate().priority(), remote_priority);
// conn3, a real prflx connection, should have prflx priority.
- port->SignalUnknownAddress(port, SocketAddress("3.3.3.3", 1),
- webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
+ port->SignalUnknownAddress(port, SocketAddress("3.3.3.3", 1), PROTO_UDP,
+ &request, kIceUfrag[1], false);
Connection* conn3 = WaitForConnectionTo(&ch, "3.3.3.3", 1);
ASSERT_TRUE(conn3 != nullptr);
EXPECT_EQ(conn3->remote_candidate().priority(), prflx_priority);
@@ -4502,7 +4462,7 @@
// small.
EXPECT_LE(1000, ch.config().receiving_timeout_or_default());
EXPECT_LE(200, ch.check_receiving_interval());
- ch.SetIceConfig(CreateIceConfig(500, webrtc::GATHER_ONCE));
+ ch.SetIceConfig(CreateIceConfig(500, GATHER_ONCE));
EXPECT_EQ(500, ch.config().receiving_timeout_or_default());
EXPECT_EQ(50, ch.check_receiving_interval());
ch.MaybeStartGathering();
@@ -4514,16 +4474,16 @@
clock.AdvanceTime(TimeDelta::Seconds(1));
conn1->ReceivedPing();
conn1->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("ABC", 3, webrtc::TimeMicros()));
+ ReceivedIpPacket::CreateFromLegacy("ABC", 3, TimeMicros()));
- EXPECT_THAT(webrtc::WaitUntil([&] { return ch.receiving(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kShortTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
- EXPECT_THAT(webrtc::WaitUntil([&] { return !ch.receiving(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kShortTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ch.receiving(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return !ch.receiving(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
}
// The controlled side will select a connection as the "selected connection"
@@ -4537,7 +4497,7 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("receiving state change", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 1));
@@ -4553,10 +4513,9 @@
// A connection needs to be writable before it is selected for transmission.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
EXPECT_TRUE(ConnectionMatchesChangeEvent(
conn1, "remote candidate generation maybe changed"));
@@ -4569,10 +4528,9 @@
Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
ASSERT_TRUE(conn2 != nullptr);
conn2->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
EXPECT_TRUE(
ConnectionMatchesChangeEvent(conn2, "candidate pair state changed"));
@@ -4618,10 +4576,9 @@
reset_channel_ready_to_send();
// The selected connection switches after conn4 becomes writable.
conn4->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn4),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn4),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn4));
EXPECT_TRUE(
ConnectionMatchesChangeEvent(conn4, "candidate pair state changed"));
@@ -4640,7 +4597,7 @@
P2PTransportChannel ch("receiving state change", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
ch.SetIceConfig(ch.config());
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 1));
@@ -4649,10 +4606,9 @@
// A connection needs to be writable before it is selected for transmission.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// When a higher priority candidate comes in, the new connection is chosen
@@ -4662,10 +4618,9 @@
Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
ASSERT_TRUE(conn2 != nullptr);
conn2->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
// Now nominate conn1 (low prio), it shall be choosen.
@@ -4688,7 +4643,7 @@
P2PTransportChannel ch("receiving state change", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
ch.SetIceConfig(ch.config());
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ ch.SetIceRole(ICEROLE_CONTROLLING);
ch.MaybeStartGathering();
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 1));
@@ -4697,10 +4652,9 @@
// A connection needs to be writable before it is selected for transmission.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// When a higher priority candidate comes in, the new connection is chosen
@@ -4713,10 +4667,9 @@
const int before = conn2->num_pings_sent();
conn2->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
// And the additional ping should have been sent directly.
@@ -4733,7 +4686,7 @@
P2PTransportChannel ch("receiving state change", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
ch.SetIceConfig(ch.config());
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ ch.SetIceRole(ICEROLE_CONTROLLING);
ch.MaybeStartGathering();
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 1));
@@ -4744,10 +4697,9 @@
// A connection needs to be writable before it is selected for transmission.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// And the additional ping should have been sent directly.
@@ -4765,7 +4717,7 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("receiving state change", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
// A minimal STUN message with prflx priority.
IceMessage request(STUN_BINDING_REQUEST);
@@ -4775,17 +4727,16 @@
request.AddAttribute(std::make_unique<StunUInt32Attribute>(STUN_ATTR_PRIORITY,
prflx_priority));
TestUDPPort* port = static_cast<TestUDPPort*>(GetPort(&ch));
- port->SignalUnknownAddress(port, SocketAddress("1.1.1.1", 1),
- webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
+ port->SignalUnknownAddress(port, SocketAddress("1.1.1.1", 1), PROTO_UDP,
+ &request, kIceUfrag[1], false);
Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
ASSERT_TRUE(conn1 != nullptr);
EXPECT_EQ(conn1->stats().sent_ping_responses, 1u);
EXPECT_NE(conn1, ch.selected_connection());
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Another connection is nominated via use_candidate.
ch.AddRemoteCandidate(
@@ -4803,8 +4754,8 @@
// Another request with unknown address, it will not be set as the selected
// connection because the selected connection was nominated by the controlling
// side.
- port->SignalUnknownAddress(port, SocketAddress("3.3.3.3", 3),
- webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
+ port->SignalUnknownAddress(port, SocketAddress("3.3.3.3", 3), PROTO_UDP,
+ &request, kIceUfrag[1], false);
Connection* conn3 = WaitForConnectionTo(&ch, "3.3.3.3", 3);
ASSERT_TRUE(conn3 != nullptr);
EXPECT_EQ(conn3->stats().sent_ping_responses, 1u);
@@ -4815,26 +4766,25 @@
// selected as the selected connection.
request.AddAttribute(
std::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
- port->SignalUnknownAddress(port, SocketAddress("4.4.4.4", 4),
- webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
+ port->SignalUnknownAddress(port, SocketAddress("4.4.4.4", 4), PROTO_UDP,
+ &request, kIceUfrag[1], false);
Connection* conn4 = WaitForConnectionTo(&ch, "4.4.4.4", 4);
ASSERT_TRUE(conn4 != nullptr);
EXPECT_EQ(conn4->stats().sent_ping_responses, 1u);
// conn4 is not the selected connection yet because it is not writable.
EXPECT_EQ(conn2, ch.selected_connection());
conn4->ReceivedPingResponse(LOW_RTT, "id"); // Become writable.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn4),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn4),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Test that the request from an unknown address contains a ufrag from an old
// generation.
// port->set_sent_binding_response(false);
ch.SetRemoteIceParameters(kIceParams[2]);
ch.SetRemoteIceParameters(kIceParams[3]);
- port->SignalUnknownAddress(port, SocketAddress("5.5.5.5", 5),
- webrtc::PROTO_UDP, &request, kIceUfrag[2], false);
+ port->SignalUnknownAddress(port, SocketAddress("5.5.5.5", 5), PROTO_UDP,
+ &request, kIceUfrag[2], false);
Connection* conn5 = WaitForConnectionTo(&ch, "5.5.5.5", 5);
ASSERT_TRUE(conn5 != nullptr);
EXPECT_EQ(conn5->stats().sent_ping_responses, 1u);
@@ -4850,17 +4800,16 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("receiving state change", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 10));
Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
ASSERT_TRUE(conn1 != nullptr);
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// If a data packet is received on conn2, the selected connection should
// switch to conn2 because the controlled side must mirror the media path
@@ -4871,7 +4820,7 @@
ASSERT_TRUE(conn2 != nullptr);
conn2->ReceivedPingResponse(LOW_RTT, "id"); // Become writable and receiving.
conn2->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("ABC", 3, webrtc::TimeMicros()));
+ ReceivedIpPacket::CreateFromLegacy("ABC", 3, TimeMicros()));
EXPECT_EQ(conn2, ch.selected_connection());
conn2->ReceivedPingResponse(LOW_RTT, "id"); // Become writable.
@@ -4886,27 +4835,25 @@
request.AddAttribute(
std::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
Port* port = GetPort(&ch);
- port->SignalUnknownAddress(port, SocketAddress("3.3.3.3", 3),
- webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
+ port->SignalUnknownAddress(port, SocketAddress("3.3.3.3", 3), PROTO_UDP,
+ &request, kIceUfrag[1], false);
Connection* conn3 = WaitForConnectionTo(&ch, "3.3.3.3", 3);
ASSERT_TRUE(conn3 != nullptr);
EXPECT_NE(conn3, ch.selected_connection()); // Not writable yet.
conn3->ReceivedPingResponse(LOW_RTT, "id"); // Become writable.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn3),
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn3),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Now another data packet will not switch the selected connection because the
// selected connection was nominated by the controlling side.
conn2->ReceivedPing();
conn2->ReceivedPingResponse(LOW_RTT, "id");
conn2->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("XYZ", 3, webrtc::TimeMicros()));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn3),
+ ReceivedIpPacket::CreateFromLegacy("XYZ", 3, TimeMicros()));
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn3),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest,
@@ -4918,7 +4865,7 @@
P2PTransportChannel ch("SwitchSelectedConnection", 1, &pa,
&env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
// The connections have decreasing priority.
Connection* conn1 =
@@ -4938,13 +4885,13 @@
SIMULATED_WAIT(false, 1, clock);
conn2->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("XYZ", 3, webrtc::TimeMicros()));
+ ReceivedIpPacket::CreateFromLegacy("XYZ", 3, TimeMicros()));
EXPECT_EQ(1, reset_selected_candidate_pair_switches());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
// conn1 also receives data; it becomes selected due to priority again.
conn1->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("ABC", 3, webrtc::TimeMicros()));
+ ReceivedIpPacket::CreateFromLegacy("ABC", 3, TimeMicros()));
EXPECT_EQ(1, reset_selected_candidate_pair_switches());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
@@ -4954,7 +4901,7 @@
// Need to become writable again because it was pruned.
conn2->ReceivedPingResponse(LOW_RTT, "id");
conn2->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("ABC", 3, webrtc::TimeMicros()));
+ ReceivedIpPacket::CreateFromLegacy("ABC", 3, TimeMicros()));
EXPECT_EQ(1, reset_selected_candidate_pair_switches());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
@@ -4973,7 +4920,7 @@
P2PTransportChannel ch("SwitchSelectedConnection", 1, &pa,
&env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
// The connections have decreasing priority.
Connection* conn1 =
@@ -4988,7 +4935,7 @@
SIMULATED_WAIT(false, 1, clock);
conn1->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("XYZ", 3, webrtc::TimeMicros()));
+ ReceivedIpPacket::CreateFromLegacy("XYZ", 3, TimeMicros()));
EXPECT_EQ(1, reset_selected_candidate_pair_switches());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
@@ -5016,7 +4963,7 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("test", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
// The connections have decreasing priority.
Connection* conn1 =
@@ -5027,11 +4974,10 @@
ASSERT_TRUE(conn2 != nullptr);
// conn1 is the selected connection because it has a higher priority,
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
reset_selected_candidate_pair_switches();
@@ -5066,7 +5012,7 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("test", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
// The connections have decreasing priority.
Connection* conn1 =
@@ -5079,11 +5025,10 @@
ASSERT_TRUE(conn2 != nullptr);
// conn1 is the selected connection because it has a higher priority,
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// No estimateded disconnect time at first connect <=> value is 0.
EXPECT_EQ(LastEstimatedDisconnectedTimeMs(), 0);
@@ -5095,7 +5040,7 @@
clock.AdvanceTime(TimeDelta::Seconds(1));
// This will not parse as STUN, and is considered data
conn1->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("XYZ", 3, webrtc::TimeMicros()));
+ ReceivedIpPacket::CreateFromLegacy("XYZ", 3, TimeMicros()));
clock.AdvanceTime(TimeDelta::Seconds(2));
// conn2 is nominated; it becomes selected.
@@ -5108,7 +5053,7 @@
{
clock.AdvanceTime(TimeDelta::Seconds(1));
conn2->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("XYZ", 3, webrtc::TimeMicros()));
+ ReceivedIpPacket::CreateFromLegacy("XYZ", 3, TimeMicros()));
clock.AdvanceTime(TimeDelta::Seconds(2));
ReceivePingOnConnection(conn2, kIceUfrag[1], 1, nomination++);
@@ -5130,7 +5075,7 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("test", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
Connection* conn =
CreateConnectionWithCandidate(&ch, &clock, "1.1.1.1", 1, 10, false);
@@ -5150,7 +5095,7 @@
P2PTransportChannel ch("SwitchSelectedConnection", 1, &pa,
&env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
// The connections have decreasing priority.
Connection* conn1 =
@@ -5167,29 +5112,27 @@
// conn2 becomes writable; it is selected even though it is not nominated.
conn2->ReceivedPingResponse(LOW_RTT, "id");
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return reset_selected_candidate_pair_switches(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn2),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
// If conn1 is also writable, it will become selected.
conn1->ReceivedPingResponse(LOW_RTT, "id");
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return reset_selected_candidate_pair_switches(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// Make sure sorting won't reselect candidate pair.
@@ -5245,7 +5188,7 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("test channel", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 1));
@@ -5262,17 +5205,17 @@
ASSERT_TRUE(conn2 != nullptr);
conn2->ReceivedPingResponse(LOW_RTT, "id"); // Becomes writable and receiving
NominateConnection(conn2);
- EXPECT_THAT(webrtc::WaitUntil([&] { return conn1->pruned(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kMediumTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return conn1->pruned(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ IsRtcOk());
- ch.SetIceConfig(CreateIceConfig(500, webrtc::GATHER_ONCE));
+ ch.SetIceConfig(CreateIceConfig(500, GATHER_ONCE));
// Wait until conn2 becomes not receiving.
- EXPECT_THAT(webrtc::WaitUntil([&] { return !conn2->receiving(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kMediumTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return !conn2->receiving(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ IsRtcOk());
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "3.3.3.3", 3, 1));
@@ -5291,7 +5234,7 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("test channel", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
Connection* conn1 =
CreateConnectionWithCandidate(&ch, &clock, "1.1.1.1", 1, 100, true);
@@ -5304,7 +5247,7 @@
NominateConnection(conn1);
SIMULATED_WAIT(false, 1, clock);
conn1->OnReadPacket(
- ReceivedIpPacket::CreateFromLegacy("XYZ", 3, webrtc::TimeMicros()));
+ ReceivedIpPacket::CreateFromLegacy("XYZ", 3, TimeMicros()));
SIMULATED_WAIT(conn2->pruned(), 100, clock);
EXPECT_FALSE(conn2->pruned());
}
@@ -5341,19 +5284,19 @@
EXPECT_EQ(IceTransportState::kChecking, ch.GetIceTransportState());
// `conn1` becomes writable and receiving; it then should prune `conn2`.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(webrtc::WaitUntil([&] { return conn2->pruned(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kShortTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return conn2->pruned(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
EXPECT_EQ(IceTransportStateInternal::STATE_COMPLETED, ch.GetState());
EXPECT_EQ(IceTransportState::kConnected, ch.GetIceTransportState());
conn1->Prune(); // All connections are pruned.
// Need to wait until the channel state is updated.
- EXPECT_THAT(webrtc::WaitUntil([&] { return ch.GetState(); },
- Eq(IceTransportStateInternal::STATE_FAILED),
- {.timeout = TimeDelta::Millis(kShortTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ch.GetState(); },
+ Eq(IceTransportStateInternal::STATE_FAILED),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
EXPECT_EQ(IceTransportState::kFailed, ch.GetIceTransportState());
}
@@ -5367,7 +5310,7 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("test channel", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_ONCE);
+ IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
config.receiving_switching_delay = 800;
ch.SetIceConfig(config);
ch.MaybeStartGathering();
@@ -5377,11 +5320,10 @@
ASSERT_TRUE(conn1 != nullptr);
EXPECT_EQ(nullptr, ch.selected_connection());
conn1->ReceivedPingResponse(LOW_RTT, "id"); // Becomes writable and receiving
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
// Add a low-priority connection `conn2`, which will be pruned, but it will
// not be deleted right away. Once the current selected connection becomes not
@@ -5391,45 +5333,43 @@
CreateUdpCandidate(IceCandidateType::kHost, "2.2.2.2", 2, 1));
Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2, &clock);
ASSERT_TRUE(conn2 != nullptr);
- EXPECT_THAT(webrtc::WaitUntil([&] { return !conn2->active(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return !conn2->active(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
// `conn2` should not send a ping yet.
EXPECT_EQ(IceCandidatePairState::WAITING, conn2->state());
EXPECT_EQ(IceTransportStateInternal::STATE_COMPLETED, ch.GetState());
// Wait for `conn1` becoming not receiving.
- EXPECT_THAT(webrtc::WaitUntil([&] { return !conn1->receiving(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kMediumTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return !conn1->receiving(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ IsRtcOk());
// Make sure conn2 is not deleted.
conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2, &clock);
ASSERT_TRUE(conn2 != nullptr);
- EXPECT_THAT(webrtc::WaitUntil([&] { return conn2->state(); },
- Eq(IceCandidatePairState::IN_PROGRESS),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return conn2->state(); },
+ Eq(IceCandidatePairState::IN_PROGRESS),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
conn2->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn2),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
EXPECT_EQ(IceTransportStateInternal::STATE_CONNECTING, ch.GetState());
// When `conn1` comes back again, `conn2` will be pruned again.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
- EXPECT_THAT(webrtc::WaitUntil([&] { return !conn2->active(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return !conn2->active(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
EXPECT_EQ(IceTransportStateInternal::STATE_COMPLETED, ch.GetState());
}
@@ -5450,10 +5390,9 @@
conn1->ReceivedPing(); // Becomes receiving
conn1->Prune();
EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch.connections().empty(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return ch.connections().empty(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
// Have two connections but both become write-time-out later.
ch.AddRemoteCandidate(
@@ -5470,10 +5409,9 @@
conn2->Prune();
conn3->Prune();
EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch.connections().empty(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return ch.connections().empty(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kShortTimeout), .clock = &clock}),
+ IsRtcOk());
}
// Tests that after a port allocator session is started, it will be stopped
@@ -5485,7 +5423,7 @@
FakePortAllocator pa(env, ss());
P2PTransportChannel ch("test channel", 1, &pa, &env.field_trials());
PrepareChannel(&ch);
- ch.SetIceConfig(CreateIceConfig(2000, webrtc::GATHER_ONCE));
+ ch.SetIceConfig(CreateIceConfig(2000, GATHER_ONCE));
ch.MaybeStartGathering();
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 100));
@@ -5523,7 +5461,7 @@
&env.field_trials());
// Starts with ICEROLE_CONTROLLING.
PrepareChannel(&ch);
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig config = CreateIceConfig(1000, GATHER_CONTINUALLY);
ch.SetIceConfig(config);
ch.MaybeStartGathering();
ch.AddRemoteCandidate(
@@ -5536,8 +5474,8 @@
// change the ICE role and expect it to be updated.
std::vector<PortInterface*> ports(1, conn->PortForTest());
ch.allocator_session()->SignalPortsPruned(ch.allocator_session(), ports);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
- EXPECT_EQ(webrtc::ICEROLE_CONTROLLED, conn->PortForTest()->GetIceRole());
+ ch.SetIceRole(ICEROLE_CONTROLLED);
+ EXPECT_EQ(ICEROLE_CONTROLLED, conn->PortForTest()->GetIceRole());
}
// Test that the ICE role is updated even on ports with inactive networks.
@@ -5562,8 +5500,8 @@
// role updated.
ch.SetIceParameters(kIceParams[1]);
ch.MaybeStartGathering();
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
- EXPECT_EQ(webrtc::ICEROLE_CONTROLLED, conn->PortForTest()->GetIceRole());
+ ch.SetIceRole(ICEROLE_CONTROLLED);
+ EXPECT_EQ(ICEROLE_CONTROLLED, conn->PortForTest()->GetIceRole());
}
// Test that after some amount of time without receiving data, the connection
@@ -5577,7 +5515,7 @@
P2PTransportChannel ch("test channel", ICE_CANDIDATE_COMPONENT_DEFAULT, &pa,
&env.field_trials());
PrepareChannel(&ch);
- ch.SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ ch.SetIceRole(ICEROLE_CONTROLLED);
ch.MaybeStartGathering();
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 1));
@@ -5597,12 +5535,12 @@
// If the session prunes all ports, the port will be destroyed.
ch.allocator_session()->PruneAllPorts();
- EXPECT_THAT(webrtc::WaitUntil([&] { return GetPort(&ch); }, Eq(nullptr),
- {.clock = &fake_clock}),
- webrtc::IsRtcOk());
- EXPECT_THAT(webrtc::WaitUntil([&] { return GetPrunedPort(&ch); }, Eq(nullptr),
- {.clock = &fake_clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return GetPort(&ch); }, Eq(nullptr),
+ {.clock = &fake_clock}),
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return GetPrunedPort(&ch); }, Eq(nullptr),
+ {.clock = &fake_clock}),
+ IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestMaxOutstandingPingsFieldTrial) {
@@ -5623,13 +5561,13 @@
ASSERT_TRUE(conn1 != nullptr);
ASSERT_TRUE(conn2 != nullptr);
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return conn1->num_pings_sent() == 3 &&
conn2->num_pings_sent() == 3;
},
IsTrue(), {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Check that these connections don't send any more pings.
EXPECT_EQ(nullptr, ch.FindNextPingableConnection());
@@ -5651,9 +5589,9 @@
env, &network_manager_, packet_socket_factory(), ServerAddresses(),
kTurnUdpIntAddr, SocketAddress());
port_allocator_->set_flags(port_allocator_->flags() |
- webrtc::PORTALLOCATOR_DISABLE_STUN |
- webrtc::PORTALLOCATOR_DISABLE_TCP);
- port_allocator_->set_step_delay(webrtc::kMinimumStepDelay);
+ PORTALLOCATOR_DISABLE_STUN |
+ PORTALLOCATOR_DISABLE_TCP);
+ port_allocator_->set_step_delay(kMinimumStepDelay);
return *port_allocator_;
}
@@ -5682,7 +5620,7 @@
void VerifyNextPingableConnection(
IceCandidateType local_candidate_type,
IceCandidateType remote_candidate_type,
- absl::string_view relay_protocol_type = webrtc::UDP_PROTOCOL_NAME) {
+ absl::string_view relay_protocol_type = UDP_PROTOCOL_NAME) {
Connection* conn = FindNextPingableConnectionAndPingIt(channel_.get());
ASSERT_TRUE(conn != nullptr);
EXPECT_EQ(conn->local_candidate().type(), local_candidate_type);
@@ -5709,10 +5647,9 @@
CreatePortAllocator(env);
P2PTransportChannel& ch =
StartTransportChannel(env, true, max_strong_interval);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.ports().size(); }, Eq(2),
+ EXPECT_THAT(WaitUntil([&] { return ch.ports().size(); }, Eq(2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
@@ -5721,10 +5658,9 @@
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "2.2.2.2", 2, 2));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.connections().size(); }, Eq(4),
+ EXPECT_THAT(WaitUntil([&] { return ch.connections().size(); }, Eq(4),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Relay/Relay should be the first pingable connection.
Connection* conn = FindNextPingableConnectionAndPingIt(&ch);
@@ -5778,19 +5714,17 @@
const Environment env = CreateEnvironment();
CreatePortAllocator(env);
P2PTransportChannel& ch = StartTransportChannel(env, true, 500);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.ports().size(); }, Eq(2),
+ EXPECT_THAT(WaitUntil([&] { return ch.ports().size(); }, Eq(2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 1));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.connections().size(); }, Eq(2),
+ EXPECT_THAT(WaitUntil([&] { return ch.connections().size(); }, Eq(2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Initially, only have Local/Local and Local/Relay.
VerifyNextPingableConnection(IceCandidateType::kHost,
@@ -5801,10 +5735,9 @@
// Remote Relay candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "2.2.2.2", 2, 2));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.connections().size(); }, Eq(4),
+ EXPECT_THAT(WaitUntil([&] { return ch.connections().size(); }, Eq(4),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Relay/Relay should be the first since it hasn't been pinged before.
VerifyNextPingableConnection(IceCandidateType::kRelay,
@@ -5827,19 +5760,17 @@
const Environment env = CreateEnvironment();
CreatePortAllocator(env);
P2PTransportChannel& ch = StartTransportChannel(env, true, 500);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.ports().size(); }, Eq(2),
+ EXPECT_THAT(WaitUntil([&] { return ch.ports().size(); }, Eq(2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "1.1.1.1", 1, 1));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.connections().size(); }, Eq(2),
+ EXPECT_THAT(WaitUntil([&] { return ch.connections().size(); }, Eq(2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Initially, only have Relay/Relay and Local/Relay. Ping Relay/Relay first.
VerifyNextPingableConnection(IceCandidateType::kRelay,
@@ -5852,10 +5783,9 @@
// Remote Local candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "2.2.2.2", 2, 2));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.connections().size(); }, Eq(4),
+ EXPECT_THAT(WaitUntil([&] { return ch.connections().size(); }, Eq(4),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Local/Local should be the first since it hasn't been pinged before.
VerifyNextPingableConnection(IceCandidateType::kHost,
@@ -5879,28 +5809,25 @@
"WebRTC-IceFieldTrials/skip_relay_to_non_relay_connections:true/"));
CreatePortAllocator(env);
P2PTransportChannel& ch = StartTransportChannel(env, true, 500);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.ports().size(); }, Eq(2),
+ EXPECT_THAT(WaitUntil([&] { return ch.ports().size(); }, Eq(2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
// Remote Relay candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "1.1.1.1", 1, 1));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.connections().size(); }, Eq(1),
+ EXPECT_THAT(WaitUntil([&] { return ch.connections().size(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Remote Local candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "2.2.2.2", 2, 2));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.connections().size(); }, Eq(2),
+ EXPECT_THAT(WaitUntil([&] { return ch.connections().size(); }, Eq(2),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
// Test the ping sequence is UDP Relay/Relay followed by TCP Relay/Relay,
@@ -5908,17 +5835,16 @@
TEST_F(P2PTransportChannelMostLikelyToWorkFirstTest, TestTcpTurn) {
const Environment env = CreateEnvironment();
// Add a Tcp Turn server.
- turn_server()->AddInternalSocket(kTurnTcpIntAddr, webrtc::PROTO_TCP);
+ turn_server()->AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
RelayServerConfig config;
config.credentials = kRelayCredentials;
- config.ports.push_back(ProtocolAddress(kTurnTcpIntAddr, webrtc::PROTO_TCP));
+ config.ports.push_back(ProtocolAddress(kTurnTcpIntAddr, PROTO_TCP));
CreatePortAllocator(env).AddTurnServerForTesting(config);
P2PTransportChannel& ch = StartTransportChannel(env, true, 500);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.ports().size(); }, Eq(3),
+ EXPECT_THAT(WaitUntil([&] { return ch.ports().size(); }, Eq(3),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
EXPECT_EQ(ch.ports()[2]->Type(), IceCandidateType::kRelay);
@@ -5926,10 +5852,9 @@
// Remote Relay candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "1.1.1.1", 1, 1));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch.connections().size(); }, Eq(3),
+ EXPECT_THAT(WaitUntil([&] { return ch.connections().size(); }, Eq(3),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// UDP Relay/Relay should be pinged first.
VerifyNextPingableConnection(IceCandidateType::kRelay,
@@ -5937,8 +5862,7 @@
// TCP Relay/Relay is the next.
VerifyNextPingableConnection(IceCandidateType::kRelay,
- IceCandidateType::kRelay,
- webrtc::TCP_PROTOCOL_NAME);
+ IceCandidateType::kRelay, TCP_PROTOCOL_NAME);
// Finally, Local/Relay will be pinged.
VerifyNextPingableConnection(IceCandidateType::kHost,
@@ -5951,8 +5875,7 @@
TEST(P2PTransportChannelResolverTest, HostnameCandidateIsResolved) {
const Environment env = CreateEnvironment();
ResolverFactoryFixture resolver_fixture;
- std::unique_ptr<SocketServer> socket_server =
- webrtc::CreateDefaultSocketServer();
+ std::unique_ptr<SocketServer> socket_server = CreateDefaultSocketServer();
AutoSocketServerThread main_thread(socket_server.get());
FakePortAllocator allocator(env, socket_server.get());
IceTransportInit init;
@@ -5965,10 +5888,10 @@
hostname_candidate.set_address(hostname_address);
channel->AddRemoteCandidate(hostname_candidate);
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return channel->remote_candidates().size(); }, Eq(1u),
- {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return channel->remote_candidates().size(); }, Eq(1u),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
+ IsRtcOk());
const RemoteCandidate& candidate = channel->remote_candidates()[0];
EXPECT_FALSE(candidate.address().IsUnresolvedIP());
}
@@ -5995,10 +5918,10 @@
// number is assgined to ep1's host candidate.
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return GetEndpoint(0)->saved_candidates_.size(); },
- Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return GetEndpoint(0)->saved_candidates_.size(); },
+ Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
const auto& local_candidate = GetEndpoint(0)->saved_candidates_[0].candidate;
// The IP address of ep1's host candidate should be obfuscated.
EXPECT_TRUE(local_candidate.address().IsUnresolvedIP());
@@ -6010,20 +5933,20 @@
// pair and start to ping. After receiving the ping, ep2 discovers a prflx
// remote candidate and form a candidate pair as well.
ResumeCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
// ep2 should have the selected connection connected to the prflx remote
// candidate.
const Connection* selected_connection = nullptr;
- ASSERT_THAT(webrtc::WaitUntil(
+ ASSERT_THAT(WaitUntil(
[&] {
return selected_connection =
ep2_ch1()->selected_connection();
},
Ne(nullptr), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(selected_connection->remote_candidate().is_prflx());
EXPECT_EQ(kIceUfrag[0], selected_connection->remote_candidate().username());
EXPECT_EQ(kIcePwd[0], selected_connection->remote_candidate().password());
@@ -6031,7 +5954,7 @@
resolver_fixture.SetAddressToReturn(local_address);
ResumeCandidates(0);
// Verify ep2's selected connection is updated to use the 'local' candidate.
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return ep2_ch1()
->selected_connection()
@@ -6039,7 +5962,7 @@
.is_local();
},
IsTrue(), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(selected_connection, ep2_ch1()->selected_connection());
DestroyChannels();
@@ -6070,10 +5993,10 @@
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return GetEndpoint(0)->saved_candidates_.size(); },
- Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return GetEndpoint(0)->saved_candidates_.size(); },
+ Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
const auto& local_candidate = GetEndpoint(0)->saved_candidates_[0].candidate;
// The IP address of ep1's host candidate should be obfuscated.
ASSERT_TRUE(local_candidate.address().IsUnresolvedIP());
@@ -6086,10 +6009,10 @@
// by ep1. Let ep2 signal its host candidate with an IP address to ep1, so
// that ep1 can form a candidate pair, select it and start to ping ep2.
ResumeCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
// Let the mock resolver of ep2 receives the correct resolution.
resolver_fixture.SetAddressToReturn(local_address);
@@ -6098,17 +6021,17 @@
//
// There is a caveat in our implementation associated with this expectation.
// See the big comment in P2PTransportChannel::OnUnknownAddress.
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
EXPECT_TRUE(ep2_ch1()->selected_connection()->remote_candidate().is_prflx());
// ep2 should also be able resolve the hostname candidate. The resolved remote
// host candidate should be merged with the prflx remote candidate.
resolver_fixture.FireDelayedResolution();
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return ep2_ch1()
->selected_connection()
@@ -6116,7 +6039,7 @@
.is_local();
},
IsTrue(), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(1u, ep2_ch1()->remote_candidates().size());
DestroyChannels();
@@ -6142,10 +6065,10 @@
// number is assgined to ep1's host candidate.
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return GetEndpoint(0)->saved_candidates_.size(); },
- Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return GetEndpoint(0)->saved_candidates_.size(); },
+ Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
const auto& local_candidate_ep1 =
GetEndpoint(0)->saved_candidates_[0].candidate;
// The IP address of ep1's host candidate should be obfuscated.
@@ -6161,10 +6084,10 @@
// We should be able to receive a ping from ep2 and establish a connection
// with a peer reflexive candidate from ep2.
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->local_candidate().is_local());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_prflx());
@@ -6185,10 +6108,9 @@
// ep1 and ep2 will gather host candidates with addresses
// kPublicAddrs[0] and kPublicAddrs[1], respectively. ep1 also gathers a srflx
// and a relay candidates.
- ConfigureEndpoints(
- env, OPEN, OPEN,
- webrtc::kDefaultPortAllocatorFlags | webrtc::PORTALLOCATOR_DISABLE_TCP,
- kOnlyLocalPorts);
+ ConfigureEndpoints(env, OPEN, OPEN,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_DISABLE_TCP,
+ kOnlyLocalPorts);
// ICE parameter will be set up when creating the channels.
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
GetEndpoint(0)->network_manager_.set_mdns_responder(
@@ -6200,14 +6122,14 @@
PauseCandidates(0);
PauseCandidates(1);
// Ep1 has a UDP host, a srflx and a relay candidates.
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return GetEndpoint(0)->saved_candidates_.size(); },
- Eq(3u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return GetEndpoint(1)->saved_candidates_.size(); },
- Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return GetEndpoint(0)->saved_candidates_.size(); },
+ Eq(3u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return GetEndpoint(1)->saved_candidates_.size(); },
+ Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
for (const auto& candidates_data : GetEndpoint(0)->saved_candidates_) {
const auto& local_candidate_ep1 = candidates_data.candidate;
@@ -6223,20 +6145,18 @@
ResumeCandidates(0);
ResumeCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil([&] { return ep1_ch1()->gathering_state(); },
- Eq(webrtc::kIceGatheringComplete),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ep1_ch1()->gathering_state(); },
+ Eq(kIceGatheringComplete),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
// We should have the following candidate pairs on both endpoints:
// ep1_host <-> ep2_host, ep1_srflx <-> ep2_host, ep1_relay <-> ep2_host
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ep1_ch1()->connections().size(); }, Eq(3u),
+ ASSERT_THAT(WaitUntil([&] { return ep1_ch1()->connections().size(); }, Eq(3u),
{.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ep2_ch1()->connections().size(); }, Eq(3u),
+ IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ep2_ch1()->connections().size(); }, Eq(3u),
{.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
IceTransportStats ice_transport_stats1;
IceTransportStats ice_transport_stats2;
@@ -6283,8 +6203,8 @@
ConnectingIncreasesSelectedCandidatePairChanges) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
CreateChannels(env);
IceTransportStats ice_transport_stats;
@@ -6293,10 +6213,10 @@
// Let the channels connect.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_EQ(1u, ice_transport_stats.selected_candidate_pair_changes);
@@ -6308,8 +6228,8 @@
DisconnectedIncreasesSelectedCandidatePairChanges) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
CreateChannels(env);
IceTransportStats ice_transport_stats;
@@ -6318,10 +6238,10 @@
// Let the channels connect.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_EQ(1u, ice_transport_stats.selected_candidate_pair_changes);
@@ -6331,10 +6251,10 @@
con->Prune();
}
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->selected_connection(); }, Eq(nullptr),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_EQ(2u, ice_transport_stats.selected_candidate_pair_changes);
@@ -6346,8 +6266,8 @@
NewSelectionIncreasesSelectedCandidatePairChanges) {
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
CreateChannels(env);
IceTransportStats ice_transport_stats;
@@ -6356,10 +6276,10 @@
// Let the channels connect.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_EQ(1u, ice_transport_stats.selected_candidate_pair_changes);
@@ -6373,7 +6293,7 @@
}
}
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->selected_connection() != nullptr &&
(ep1_ch1()->GetStats(&ice_transport_stats),
@@ -6381,7 +6301,7 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kMediumTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_GE(ice_transport_stats.selected_candidate_pair_changes, 2u);
@@ -6409,10 +6329,10 @@
// number is assigned to ep1's host candidate.
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return GetEndpoint(0)->saved_candidates_.size(); },
- Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return GetEndpoint(0)->saved_candidates_.size(); },
+ Eq(1u), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
const auto& candidates_data = GetEndpoint(0)->saved_candidates_[0];
const auto& local_candidate_ep1 = candidates_data.candidate;
ASSERT_TRUE(local_candidate_ep1.is_local());
@@ -6425,13 +6345,13 @@
ResumeCandidates(0);
ResumeCandidates(1);
- ASSERT_THAT(webrtc::WaitUntil(
+ ASSERT_THAT(WaitUntil(
[&] {
return ep1_ch1()->selected_connection() != nullptr &&
ep2_ch1()->selected_connection() != nullptr;
},
IsTrue(), {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const auto pair_ep1 = ep1_ch1()->GetSelectedCandidatePair();
ASSERT_TRUE(pair_ep1.has_value());
@@ -6449,24 +6369,23 @@
TEST_F(P2PTransportChannelTest,
NoPairOfLocalRelayCandidateWithRemoteMdnsCandidate) {
const Environment env = CreateEnvironment();
- const int kOnlyRelayPorts = webrtc::PORTALLOCATOR_DISABLE_UDP |
- webrtc::PORTALLOCATOR_DISABLE_STUN |
- webrtc::PORTALLOCATOR_DISABLE_TCP;
+ const int kOnlyRelayPorts = PORTALLOCATOR_DISABLE_UDP |
+ PORTALLOCATOR_DISABLE_STUN |
+ PORTALLOCATOR_DISABLE_TCP;
// We use one endpoint to test the behavior of adding remote candidates, and
// this endpoint only gathers relay candidates.
ConfigureEndpoints(env, OPEN, OPEN, kOnlyRelayPorts,
- webrtc::kDefaultPortAllocatorFlags);
+ kDefaultPortAllocatorFlags);
GetEndpoint(0)->cd1_.ch_ = CreateChannel(
env, 0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]);
IceConfig config;
// Start gathering and we should have only a single relay port.
ep1_ch1()->SetIceConfig(config);
ep1_ch1()->MaybeStartGathering();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ep1_ch1()->gathering_state(); },
+ EXPECT_THAT(WaitUntil([&] { return ep1_ch1()->gathering_state(); },
Eq(IceGatheringState::kIceGatheringComplete),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(1u, ep1_ch1()->ports().size());
// Add a plain remote host candidate and three remote mDNS candidates with the
// host, srflx and relay types. Note that the candidates differ in their
@@ -6526,9 +6445,9 @@
// ep1 and ep2 will only gather host and srflx candidates with base addresses
// kPublicAddrs[0] and kPublicAddrs[1], respectively, and we use a shared
// socket in gathering.
- const auto kOnlyLocalAndStunPorts =
- webrtc::PORTALLOCATOR_DISABLE_RELAY | webrtc::PORTALLOCATOR_DISABLE_TCP |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET;
+ const auto kOnlyLocalAndStunPorts = PORTALLOCATOR_DISABLE_RELAY |
+ PORTALLOCATOR_DISABLE_TCP |
+ PORTALLOCATOR_ENABLE_SHARED_SOCKET;
// ep1 is configured with a NAT so that we do gather a srflx candidate.
ConfigureEndpoints(env, NAT_FULL_CONE, OPEN, kOnlyLocalAndStunPorts,
kOnlyLocalAndStunPorts);
@@ -6546,10 +6465,10 @@
CreateChannels(env);
// We should be able to form a srflx-host connection to ep2.
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->local_candidate().is_stun());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_local());
@@ -6566,37 +6485,36 @@
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+ ConfigureEndpoints(
+ env, OPEN, OPEN,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET);
auto* ep1 = GetEndpoint(0);
auto* ep2 = GetEndpoint(1);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
- ep2->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
+ ep1->allocator_->SetCandidateFilter(CF_RELAY);
+ ep2->allocator_->SetCandidateFilter(CF_RELAY);
// Enable continual gathering and also resurfacing gathered candidates upon
// the candidate filter changed in the ICE configuration.
- IceConfig ice_config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig ice_config = CreateIceConfig(1000, GATHER_CONTINUALLY);
ice_config.surface_ice_candidates_on_ice_transport_type_changed = true;
CreateChannels(env, ice_config, ice_config);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->local_candidate().is_relay());
EXPECT_TRUE(ep2_ch1()->selected_connection()->local_candidate().is_relay());
// Loosen the candidate filter at ep1.
- ep1->allocator_->SetCandidateFilter(webrtc::CF_ALL);
+ ep1->allocator_->SetCandidateFilter(CF_ALL);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->selected_connection() != nullptr &&
ep1_ch1()
@@ -6606,13 +6524,13 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_relay());
// Loosen the candidate filter at ep2.
- ep2->allocator_->SetCandidateFilter(webrtc::CF_ALL);
+ ep2->allocator_->SetCandidateFilter(CF_ALL);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep2_ch1()->selected_connection() != nullptr &&
ep2_ch1()
@@ -6622,19 +6540,19 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// We have migrated to a host-host candidate pair.
EXPECT_TRUE(ep2_ch1()->selected_connection()->remote_candidate().is_local());
// Block the traffic over non-relay-to-relay routes and expect a route change.
- fw()->AddRule(false, webrtc::FP_ANY, kPublicAddrs[0], kPublicAddrs[1]);
- fw()->AddRule(false, webrtc::FP_ANY, kPublicAddrs[1], kPublicAddrs[0]);
- fw()->AddRule(false, webrtc::FP_ANY, kPublicAddrs[0], kTurnUdpExtAddr);
- fw()->AddRule(false, webrtc::FP_ANY, kPublicAddrs[1], kTurnUdpExtAddr);
+ fw()->AddRule(false, FP_ANY, kPublicAddrs[0], kPublicAddrs[1]);
+ fw()->AddRule(false, FP_ANY, kPublicAddrs[1], kPublicAddrs[0]);
+ fw()->AddRule(false, FP_ANY, kPublicAddrs[0], kTurnUdpExtAddr);
+ fw()->AddRule(false, FP_ANY, kPublicAddrs[1], kTurnUdpExtAddr);
// We should be able to reuse the previously gathered relay candidates.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()
->selected_connection()
@@ -6643,7 +6561,7 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_relay());
DestroyChannels();
}
@@ -6662,35 +6580,34 @@
// 1. We don't generate the srflx candidate when we have public IP.
// 2. We keep the host candidate in this case in CheckCandidateFilter even
// though we intend to filter them.
- ConfigureEndpoints(env, NAT_FULL_CONE, NAT_FULL_CONE,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+ ConfigureEndpoints(
+ env, NAT_FULL_CONE, NAT_FULL_CONE,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET);
auto* ep1 = GetEndpoint(0);
auto* ep2 = GetEndpoint(1);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
- ep2->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
+ ep1->allocator_->SetCandidateFilter(CF_RELAY);
+ ep2->allocator_->SetCandidateFilter(CF_RELAY);
// Enable continual gathering and also resurfacing gathered candidates upon
// the candidate filter changed in the ICE configuration.
- IceConfig ice_config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig ice_config = CreateIceConfig(1000, GATHER_CONTINUALLY);
ice_config.surface_ice_candidates_on_ice_transport_type_changed = true;
CreateChannels(env, ice_config, ice_config);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
- const uint32_t kCandidateFilterNoHost = webrtc::CF_ALL & ~webrtc::CF_HOST;
+ IsRtcOk());
+ const uint32_t kCandidateFilterNoHost = CF_ALL & ~CF_HOST;
// Loosen the candidate filter at ep1.
ep1->allocator_->SetCandidateFilter(kCandidateFilterNoHost);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->selected_connection() != nullptr &&
ep1_ch1()
@@ -6700,13 +6617,13 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_relay());
// Loosen the candidate filter at ep2.
ep2->allocator_->SetCandidateFilter(kCandidateFilterNoHost);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep2_ch1()->selected_connection() != nullptr &&
ep2_ch1()
@@ -6716,18 +6633,18 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// We have migrated to a srflx-srflx candidate pair.
EXPECT_TRUE(ep2_ch1()->selected_connection()->remote_candidate().is_stun());
// Block the traffic over non-relay-to-relay routes and expect a route change.
- fw()->AddRule(false, webrtc::FP_ANY, kPrivateAddrs[0], kPublicAddrs[1]);
- fw()->AddRule(false, webrtc::FP_ANY, kPrivateAddrs[1], kPublicAddrs[0]);
- fw()->AddRule(false, webrtc::FP_ANY, kPrivateAddrs[0], kTurnUdpExtAddr);
- fw()->AddRule(false, webrtc::FP_ANY, kPrivateAddrs[1], kTurnUdpExtAddr);
+ fw()->AddRule(false, FP_ANY, kPrivateAddrs[0], kPublicAddrs[1]);
+ fw()->AddRule(false, FP_ANY, kPrivateAddrs[1], kPublicAddrs[0]);
+ fw()->AddRule(false, FP_ANY, kPrivateAddrs[0], kTurnUdpExtAddr);
+ fw()->AddRule(false, FP_ANY, kPrivateAddrs[1], kTurnUdpExtAddr);
// We should be able to reuse the previously gathered relay candidates.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()
->selected_connection()
@@ -6736,7 +6653,7 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_relay());
DestroyChannels();
}
@@ -6751,37 +6668,36 @@
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+ ConfigureEndpoints(
+ env, OPEN, OPEN,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET);
auto* ep1 = GetEndpoint(0);
auto* ep2 = GetEndpoint(1);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
- ep2->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
+ ep1->allocator_->SetCandidateFilter(CF_RELAY);
+ ep2->allocator_->SetCandidateFilter(CF_RELAY);
// Only gather once.
- IceConfig ice_config = CreateIceConfig(1000, webrtc::GATHER_ONCE);
+ IceConfig ice_config = CreateIceConfig(1000, GATHER_ONCE);
ice_config.surface_ice_candidates_on_ice_transport_type_changed = true;
CreateChannels(env, ice_config, ice_config);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Loosen the candidate filter at ep1.
- ep1->allocator_->SetCandidateFilter(webrtc::CF_ALL);
+ ep1->allocator_->SetCandidateFilter(CF_ALL);
// Wait for a period for any potential surfacing of new candidates.
SIMULATED_WAIT(false, kDefaultTimeout, clock);
EXPECT_TRUE(ep1_ch1()->selected_connection()->local_candidate().is_relay());
// Loosen the candidate filter at ep2.
- ep2->allocator_->SetCandidateFilter(webrtc::CF_ALL);
+ ep2->allocator_->SetCandidateFilter(CF_ALL);
EXPECT_TRUE(ep2_ch1()->selected_connection()->local_candidate().is_relay());
DestroyChannels();
}
@@ -6794,18 +6710,17 @@
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+ ConfigureEndpoints(
+ env, OPEN, OPEN,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET);
auto* ep1 = GetEndpoint(0);
auto* ep2 = GetEndpoint(1);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_ALL);
- ep2->allocator_->SetCandidateFilter(webrtc::CF_ALL);
+ ep1->allocator_->SetCandidateFilter(CF_ALL);
+ ep2->allocator_->SetCandidateFilter(CF_ALL);
// Enable continual gathering and also resurfacing gathered candidates upon
// the candidate filter changed in the ICE configuration.
- IceConfig ice_config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig ice_config = CreateIceConfig(1000, GATHER_CONTINUALLY);
ice_config.surface_ice_candidates_on_ice_transport_type_changed = true;
// Pause candidates so we can gather all types of candidates. See
// P2PTransportChannel::OnConnectionStateChange, where we would stop the
@@ -6815,15 +6730,14 @@
CreateChannels(env, ice_config, ice_config);
// We have gathered host, srflx and relay candidates.
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ep1->saved_candidates_.size(); }, Eq(3u),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ep1->saved_candidates_.size(); }, Eq(3u),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
ResumeCandidates(0);
ResumeCandidates(1);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->selected_connection() != nullptr &&
ep1_ch1()
@@ -6838,12 +6752,12 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Test that we have a host-host candidate pair selected and the number of
// candidates signaled to the remote peer stays the same.
auto test_invariants = [this]() {
@@ -6856,15 +6770,15 @@
test_invariants();
// Set a more restrictive candidate filter at ep1.
- ep1->allocator_->SetCandidateFilter(webrtc::CF_HOST | webrtc::CF_REFLEXIVE);
+ ep1->allocator_->SetCandidateFilter(CF_HOST | CF_REFLEXIVE);
SIMULATED_WAIT(false, kDefaultTimeout, clock);
test_invariants();
- ep1->allocator_->SetCandidateFilter(webrtc::CF_HOST);
+ ep1->allocator_->SetCandidateFilter(CF_HOST);
SIMULATED_WAIT(false, kDefaultTimeout, clock);
test_invariants();
- ep1->allocator_->SetCandidateFilter(webrtc::CF_NONE);
+ ep1->allocator_->SetCandidateFilter(CF_NONE);
SIMULATED_WAIT(false, kDefaultTimeout, clock);
test_invariants();
DestroyChannels();
@@ -6881,18 +6795,17 @@
const Environment env = CreateEnvironment(FieldTrials::CreateNoGlobal(
"WebRTC-IceFieldTrials/skip_relay_to_non_relay_connections:true/"));
- ConfigureEndpoints(env, OPEN, OPEN,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
- webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
+ ConfigureEndpoints(
+ env, OPEN, OPEN,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET,
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET);
auto* ep1 = GetEndpoint(0);
auto* ep2 = GetEndpoint(1);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
- ep2->allocator_->SetCandidateFilter(webrtc::CF_ALL);
+ ep1->allocator_->SetCandidateFilter(CF_RELAY);
+ ep2->allocator_->SetCandidateFilter(CF_ALL);
// Enable continual gathering and also resurfacing gathered candidates upon
// the candidate filter changed in the ICE configuration.
- IceConfig ice_config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig ice_config = CreateIceConfig(1000, GATHER_CONTINUALLY);
ice_config.surface_ice_candidates_on_ice_transport_type_changed = true;
// Pause candidates gathering so we can gather all types of candidates. See
// P2PTransportChannel::OnConnectionStateChange, where we would stop the
@@ -6903,21 +6816,19 @@
// On the caller we only have relay,
// on the callee we have host, srflx and relay.
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ep1->saved_candidates_.size(); }, Eq(1u),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ep2->saved_candidates_.size(); }, Eq(3u),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ep1->saved_candidates_.size(); }, Eq(1u),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ep2->saved_candidates_.size(); }, Eq(3u),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
ResumeCandidates(0);
ResumeCandidates(1);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->selected_connection() != nullptr &&
ep1_ch1()
@@ -6932,19 +6843,19 @@
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Wait until the callee discards it's candidates
// since they don't manage to connect.
SIMULATED_WAIT(false, 300000, clock);
// And then loosen caller candidate filter.
- ep1->allocator_->SetCandidateFilter(webrtc::CF_ALL);
+ ep1->allocator_->SetCandidateFilter(CF_ALL);
SIMULATED_WAIT(false, kDefaultTimeout, clock);
@@ -6978,10 +6889,10 @@
conn1->ReceivedPingResponse(LOW_RTT, "id"); // Becomes writable and receiving
// It shall not be selected until 0ms has passed....i.e it should be connected
// directly.
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn1),
- {.timeout = TimeDelta::Millis(kMargin), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = TimeDelta::Millis(kMargin), .clock = &clock}),
+ IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampening) {
@@ -7005,10 +6916,10 @@
conn1->ReceivedPingResponse(LOW_RTT, "id"); // Becomes writable and receiving
// It shall not be selected until 100ms has passed.
SIMULATED_WAIT(conn1 == ch.selected_connection(), 100 - kMargin, clock);
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn1),
- {.timeout = TimeDelta::Millis(2 * kMargin), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = TimeDelta::Millis(2 * kMargin), .clock = &clock}),
+ IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampeningPingReceived) {
@@ -7033,10 +6944,10 @@
conn1->ReceivedPing("id1"); //
// It shall not be selected until 100ms has passed.
SIMULATED_WAIT(conn1 == ch.selected_connection(), 100 - kMargin, clock);
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn1),
- {.timeout = TimeDelta::Millis(2 * kMargin), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = TimeDelta::Millis(2 * kMargin), .clock = &clock}),
+ IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampeningBoth) {
@@ -7064,16 +6975,15 @@
SIMULATED_WAIT(conn1 == ch.selected_connection(), 50 - kMargin, clock);
// Now receiving ping and new timeout should kick in.
conn1->ReceivedPing("id1"); //
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return ch.selected_connection(); }, Eq(conn1),
- {.timeout = TimeDelta::Millis(2 * kMargin), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = TimeDelta::Millis(2 * kMargin), .clock = &clock}),
+ IsRtcOk());
}
TEST(P2PTransportChannelIceControllerTest, InjectIceController) {
const Environment env = CreateEnvironment();
- std::unique_ptr<SocketServer> socket_server =
- webrtc::CreateDefaultSocketServer();
+ std::unique_ptr<SocketServer> socket_server = CreateDefaultSocketServer();
AutoSocketServerThread main_thread(socket_server.get());
MockIceControllerFactory factory;
FakePortAllocator pa(env, socket_server.get());
@@ -7089,8 +6999,7 @@
TEST(P2PTransportChannel, InjectActiveIceController) {
const Environment env = CreateEnvironment();
- std::unique_ptr<SocketServer> socket_server =
- webrtc::CreateDefaultSocketServer();
+ std::unique_ptr<SocketServer> socket_server = CreateDefaultSocketServer();
AutoSocketServerThread main_thread(socket_server.get());
MockActiveIceControllerFactory factory;
FakePortAllocator pa(env, socket_server.get());
@@ -7169,10 +7078,9 @@
// Wait for conn1 to be selected.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch->selected_connection(); }, Eq(conn1),
+ EXPECT_THAT(WaitUntil([&] { return ch->selected_connection(); }, Eq(conn1),
{.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
conn2->ReceivedPingResponse(LOW_RTT, "id");
EXPECT_TRUE(conn2->writable());
@@ -7184,17 +7092,17 @@
// We don't have a mock Connection, so verify this by checking that it
// is no longer writable.
- EXPECT_THAT(webrtc::WaitUntil([&] { return conn2->writable(); }, IsFalse(),
- {.timeout = TimeDelta::Millis(kMediumTimeout)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return conn2->writable(); }, IsFalse(),
+ {.timeout = TimeDelta::Millis(kMediumTimeout)}),
+ IsRtcOk());
}
TEST_F(P2PTransportChannelTest, DisableDnsLookupsWithTransportPolicyRelay) {
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
auto* ep1 = GetEndpoint(0);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_RELAY);
+ ep1->allocator_->SetCandidateFilter(CF_RELAY);
std::unique_ptr<MockAsyncDnsResolver> mock_async_resolver =
std::make_unique<MockAsyncDnsResolver>();
@@ -7218,10 +7126,10 @@
TEST_F(P2PTransportChannelTest, DisableDnsLookupsWithTransportPolicyNone) {
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
auto* ep1 = GetEndpoint(0);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_NONE);
+ ep1->allocator_->SetCandidateFilter(CF_NONE);
std::unique_ptr<MockAsyncDnsResolver> mock_async_resolver =
std::make_unique<MockAsyncDnsResolver>();
@@ -7245,10 +7153,10 @@
TEST_F(P2PTransportChannelTest, EnableDnsLookupsWithTransportPolicyNoHost) {
const Environment env = CreateEnvironment();
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
auto* ep1 = GetEndpoint(0);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_ALL & ~webrtc::CF_HOST);
+ ep1->allocator_->SetCandidateFilter(CF_ALL & ~CF_HOST);
std::unique_ptr<MockAsyncDnsResolver> mock_async_resolver =
std::make_unique<MockAsyncDnsResolver>();
@@ -7288,22 +7196,21 @@
const Environment env =
CreateEnvironment(FieldTrials::CreateNoGlobal(field_trial));
// Use local + relay
- constexpr uint32_t flags = webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET |
- webrtc::PORTALLOCATOR_DISABLE_STUN |
- webrtc::PORTALLOCATOR_DISABLE_TCP;
+ constexpr uint32_t flags =
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET |
+ PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_TCP;
ConfigureEndpoints(env, OPEN, OPEN, flags, flags);
auto* ep1 = GetEndpoint(0);
auto* ep2 = GetEndpoint(1);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_ALL);
- ep2->allocator_->SetCandidateFilter(webrtc::CF_ALL);
+ ep1->allocator_->SetCandidateFilter(CF_ALL);
+ ep2->allocator_->SetCandidateFilter(CF_ALL);
// Use step delay 3s which is long enough for
// connection to be established before managing to gather relay candidates.
int delay = 3000;
SetAllocationStepDelay(0, delay);
SetAllocationStepDelay(1, delay);
- IceConfig ice_config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig ice_config = CreateIceConfig(1000, GATHER_CONTINUALLY);
CreateChannels(env, ice_config, ice_config);
PauseCandidates(0);
@@ -7311,14 +7218,14 @@
// We have gathered host candidates but not relay.
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1->saved_candidates_.size() == 1u &&
ep2->saved_candidates_.size() == 1u;
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ResumeCandidates(0);
ResumeCandidates(1);
@@ -7327,24 +7234,24 @@
PauseCandidates(1);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->remote_candidates().size() == 1 &&
ep2_ch1()->remote_candidates().size() == 1;
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->selected_connection() &&
ep2_ch1()->selected_connection();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
clock.AdvanceTime(TimeDelta::Millis(10 * delay));
@@ -7370,23 +7277,22 @@
CreateEnvironment(FieldTrials::CreateNoGlobal(field_trial));
// Use local + relay
- constexpr uint32_t flags = webrtc::kDefaultPortAllocatorFlags |
- webrtc::PORTALLOCATOR_ENABLE_SHARED_SOCKET |
- webrtc::PORTALLOCATOR_DISABLE_STUN |
- webrtc::PORTALLOCATOR_DISABLE_TCP;
+ constexpr uint32_t flags =
+ kDefaultPortAllocatorFlags | PORTALLOCATOR_ENABLE_SHARED_SOCKET |
+ PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_TCP;
AddAddress(0, kAlternateAddrs[0]);
ConfigureEndpoints(env, OPEN, OPEN, flags, flags);
auto* ep1 = GetEndpoint(0);
auto* ep2 = GetEndpoint(1);
- ep1->allocator_->SetCandidateFilter(webrtc::CF_ALL);
- ep2->allocator_->SetCandidateFilter(webrtc::CF_ALL);
+ ep1->allocator_->SetCandidateFilter(CF_ALL);
+ ep2->allocator_->SetCandidateFilter(CF_ALL);
// Use step delay 3s which is long enough for
// connection to be established before managing to gather relay candidates.
int delay = 3000;
SetAllocationStepDelay(0, delay);
SetAllocationStepDelay(1, delay);
- IceConfig ice_config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig ice_config = CreateIceConfig(1000, GATHER_CONTINUALLY);
CreateChannels(env, ice_config, ice_config);
PauseCandidates(0);
@@ -7394,14 +7300,14 @@
// We have gathered host candidates but not relay.
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1->saved_candidates_.size() == 2u &&
ep2->saved_candidates_.size() == 1u;
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ResumeCandidates(0);
ResumeCandidates(1);
@@ -7410,24 +7316,24 @@
PauseCandidates(1);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->remote_candidates().size() == 1 &&
ep2_ch1()->remote_candidates().size() == 2;
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] {
return ep1_ch1()->selected_connection() &&
ep2_ch1()->selected_connection();
},
IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
clock.AdvanceTime(TimeDelta::Millis(10 * delay));
@@ -7448,18 +7354,18 @@
ScopedFakeClock clock;
const Environment env = CreateEnvironment();
AddAddress(0, kAlternateAddrs[0]);
- ConfigureEndpoints(env, OPEN, OPEN, webrtc::kDefaultPortAllocatorFlags,
- webrtc::kDefaultPortAllocatorFlags);
+ ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
+ kDefaultPortAllocatorFlags);
// gathers continually.
- IceConfig config = CreateIceConfig(1000, webrtc::GATHER_CONTINUALLY);
+ IceConfig config = CreateIceConfig(1000, GATHER_CONTINUALLY);
CreateChannels(env, config, config);
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
PauseCandidates(0);
@@ -7467,10 +7373,10 @@
ep1_ch1()->MaybeStartGathering();
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return GetEndpoint(0)->saved_candidates_.size(); }, Gt(0),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
for (const auto& cd : GetEndpoint(0)->saved_candidates_) {
EXPECT_EQ(cd.candidate.username(), kIceUfrag[3]);
@@ -7511,10 +7417,10 @@
[&](auto data, auto ack) { piggyback_data_received(data, ack); }));
}
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock_}),
- webrtc::IsRtcOk());
+ IsRtcOk());
DestroyChannels();
}
diff --git a/p2p/base/packet_transport_internal.h b/p2p/base/packet_transport_internal.h
index a326ce7..2418cf4 100644
--- a/p2p/base/packet_transport_internal.h
+++ b/p2p/base/packet_transport_internal.h
@@ -83,8 +83,8 @@
// Callback is invoked each time a packet is received on this channel.
void RegisterReceivedPacketCallback(
void* id,
- absl::AnyInvocable<void(webrtc::PacketTransportInternal*,
- const webrtc::ReceivedIpPacket&)> callback);
+ absl::AnyInvocable<void(PacketTransportInternal*,
+ const ReceivedIpPacket&)> callback);
void DeregisterReceivedPacketCallback(void* id);
diff --git a/p2p/base/port.h b/p2p/base/port.h
index 522fc93..b7dbe49 100644
--- a/p2p/base/port.h
+++ b/p2p/base/port.h
@@ -386,7 +386,7 @@
void OnReadPacket(const ReceivedIpPacket& packet, ProtocolType proto);
[[deprecated(
- "Use OnReadPacket(const webrtc::ReceivedIpPacket& packet, ProtocolType "
+ "Use OnReadPacket(const ReceivedIpPacket& packet, ProtocolType "
"proto)")]] void
OnReadPacket(const char* data,
size_t size,
diff --git a/p2p/base/port_allocator.h b/p2p/base/port_allocator.h
index 3b95772..997ddfb 100644
--- a/p2p/base/port_allocator.h
+++ b/p2p/base/port_allocator.h
@@ -548,7 +548,7 @@
// Deprecated (by the next method).
bool prune_turn_ports() const {
CheckRunOnValidThreadIfInitialized();
- return turn_port_prune_policy_ == webrtc::PRUNE_BASED_ON_PRIORITY;
+ return turn_port_prune_policy_ == PRUNE_BASED_ON_PRIORITY;
}
PortPrunePolicy turn_port_prune_policy() const {
@@ -619,7 +619,7 @@
std::vector<RelayServerConfig> turn_servers_;
int candidate_pool_size_ = 0; // Last value passed into SetConfiguration.
std::vector<std::unique_ptr<PortAllocatorSession>> pooled_sessions_;
- PortPrunePolicy turn_port_prune_policy_ = webrtc::NO_PRUNE;
+ PortPrunePolicy turn_port_prune_policy_ = NO_PRUNE;
// Customizer for TURN messages.
// The instance is owned by application and will be shared among
diff --git a/p2p/base/port_interface.h b/p2p/base/port_interface.h
index 93a3a25..3d0b014 100644
--- a/p2p/base/port_interface.h
+++ b/p2p/base/port_interface.h
@@ -121,7 +121,7 @@
// Signaled when this port decides to delete itself because it no longer has
// any usefulness.
virtual void SubscribePortDestroyed(
- std::function<void(webrtc::PortInterface*)> callback) = 0;
+ std::function<void(PortInterface*)> callback) = 0;
// Signaled when Port discovers ice role conflict with the peer.
sigslot::signal1<PortInterface*> SignalRoleConflict;
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index 5bf4b43..a0b982d 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -105,10 +105,10 @@
const SocketAddress kLocalAddr1("192.168.1.2", 0);
const SocketAddress kLocalAddr2("192.168.1.3", 0);
const SocketAddress kLinkLocalIPv6Addr("fe80::aabb:ccff:fedd:eeff", 0);
-const SocketAddress kNatAddr1("77.77.77.77", webrtc::NAT_SERVER_UDP_PORT);
-const SocketAddress kNatAddr2("88.88.88.88", webrtc::NAT_SERVER_UDP_PORT);
-const SocketAddress kStunAddr("99.99.99.1", webrtc::STUN_SERVER_PORT);
-const SocketAddress kTurnUdpIntAddr("99.99.99.4", webrtc::STUN_SERVER_PORT);
+const SocketAddress kNatAddr1("77.77.77.77", NAT_SERVER_UDP_PORT);
+const SocketAddress kNatAddr2("88.88.88.88", NAT_SERVER_UDP_PORT);
+const SocketAddress kStunAddr("99.99.99.1", STUN_SERVER_PORT);
+const SocketAddress kTurnUdpIntAddr("99.99.99.4", STUN_SERVER_PORT);
const SocketAddress kTurnTcpIntAddr("99.99.99.4", 5010);
const SocketAddress kTurnUdpExtAddr("99.99.99.5", 0);
const RelayCredentials kRelayCredentials("test", "test");
@@ -190,7 +190,7 @@
return true;
}
- virtual ProtocolType GetProtocol() const { return webrtc::PROTO_UDP; }
+ virtual ProtocolType GetProtocol() const { return PROTO_UDP; }
// Exposed for testing candidate building.
void AddCandidateAddress(const SocketAddress& addr) {
@@ -269,20 +269,18 @@
TestPort* rport,
ScopedFakeClock* clock,
int64_t ms) {
- lconn->Ping(webrtc::TimeMillis());
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
+ lconn->Ping(TimeMillis());
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(lport->last_stun_buf().size(), 0u);
rconn->OnReadPacket(
ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
clock->AdvanceTime(TimeDelta::Millis(ms));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
+ ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(rport->last_stun_buf().size(), 0u);
lconn->OnReadPacket(
ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt));
@@ -309,10 +307,9 @@
void CreateConnection(const Candidate& remote_candidate) {
RTC_DCHECK(!conn_);
conn_ = port_->CreateConnection(remote_candidate, Port::ORIGIN_MESSAGE);
- IceMode remote_ice_mode = (ice_mode_ == webrtc::ICEMODE_FULL)
- ? webrtc::ICEMODE_LITE
- : webrtc::ICEMODE_FULL;
- conn_->set_use_candidate_attr(remote_ice_mode == webrtc::ICEMODE_FULL);
+ IceMode remote_ice_mode =
+ (ice_mode_ == ICEMODE_FULL) ? ICEMODE_LITE : ICEMODE_FULL;
+ conn_->set_use_candidate_attr(remote_ice_mode == ICEMODE_FULL);
conn_->SignalStateChange.connect(this,
&TestChannel::OnConnectionStateChange);
conn_->SignalDestroyed.connect(this, &TestChannel::OnDestroyed);
@@ -412,7 +409,7 @@
connection_ready_to_send_ = true;
}
- IceMode ice_mode_ = webrtc::ICEMODE_FULL;
+ IceMode ice_mode_ = ICEMODE_FULL;
std::unique_ptr<Port> port_;
int complete_count_ = 0;
@@ -436,8 +433,8 @@
nat_socket_factory2_(&nat_factory2_),
stun_server_(TestStunServer::Create(ss_.get(), kStunAddr, main_)),
turn_server_(&main_, ss_.get(), kTurnUdpIntAddr, kTurnUdpExtAddr),
- username_(webrtc::CreateRandomString(ICE_UFRAG_LENGTH)),
- password_(webrtc::CreateRandomString(ICE_PWD_LENGTH)),
+ username_(CreateRandomString(ICE_UFRAG_LENGTH)),
+ password_(CreateRandomString(ICE_PWD_LENGTH)),
role_conflict_(false),
ports_destroyed_(0) {}
@@ -453,84 +450,82 @@
void TestLocalToLocal() {
auto port1 = CreateUdpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
auto port2 = CreateUdpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
TestConnectivity("udp", std::move(port1), "udp", std::move(port2), true,
true, true, true);
}
void TestLocalToStun(NATType ntype) {
auto port1 = CreateUdpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
nat_server2_ = CreateNatServer(kNatAddr2, ntype);
auto port2 = CreateStunPort(kLocalAddr2, &nat_socket_factory2_);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
TestConnectivity("udp", std::move(port1), StunName(ntype), std::move(port2),
- ntype == webrtc::NAT_OPEN_CONE, true,
- ntype != webrtc::NAT_SYMMETRIC, true);
+ ntype == NAT_OPEN_CONE, true, ntype != NAT_SYMMETRIC,
+ true);
}
void TestLocalToRelay(ProtocolType proto) {
auto port1 = CreateUdpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
- auto port2 = CreateRelayPort(kLocalAddr2, proto, webrtc::PROTO_UDP);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
+ auto port2 = CreateRelayPort(kLocalAddr2, proto, PROTO_UDP);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
TestConnectivity("udp", std::move(port1), RelayName(proto),
std::move(port2), false, true, true, true);
}
void TestStunToLocal(NATType ntype) {
nat_server1_ = CreateNatServer(kNatAddr1, ntype);
auto port1 = CreateStunPort(kLocalAddr1, &nat_socket_factory1_);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
auto port2 = CreateUdpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
TestConnectivity(StunName(ntype), std::move(port1), "udp", std::move(port2),
- true, ntype != webrtc::NAT_SYMMETRIC, true, true);
+ true, ntype != NAT_SYMMETRIC, true, true);
}
void TestStunToStun(NATType ntype1, NATType ntype2) {
nat_server1_ = CreateNatServer(kNatAddr1, ntype1);
auto port1 = CreateStunPort(kLocalAddr1, &nat_socket_factory1_);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
nat_server2_ = CreateNatServer(kNatAddr2, ntype2);
auto port2 = CreateStunPort(kLocalAddr2, &nat_socket_factory2_);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
TestConnectivity(StunName(ntype1), std::move(port1), StunName(ntype2),
- std::move(port2), ntype2 == webrtc::NAT_OPEN_CONE,
- ntype1 != webrtc::NAT_SYMMETRIC,
- ntype2 != webrtc::NAT_SYMMETRIC,
- ntype1 + ntype2 <
- (webrtc::NAT_PORT_RESTRICTED + webrtc::NAT_SYMMETRIC));
+ std::move(port2), ntype2 == NAT_OPEN_CONE,
+ ntype1 != NAT_SYMMETRIC, ntype2 != NAT_SYMMETRIC,
+ ntype1 + ntype2 < (NAT_PORT_RESTRICTED + NAT_SYMMETRIC));
}
void TestStunToRelay(NATType ntype, ProtocolType proto) {
nat_server1_ = CreateNatServer(kNatAddr1, ntype);
auto port1 = CreateStunPort(kLocalAddr1, &nat_socket_factory1_);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
- auto port2 = CreateRelayPort(kLocalAddr2, proto, webrtc::PROTO_UDP);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
+ auto port2 = CreateRelayPort(kLocalAddr2, proto, PROTO_UDP);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
TestConnectivity(StunName(ntype), std::move(port1), RelayName(proto),
- std::move(port2), false, ntype != webrtc::NAT_SYMMETRIC,
- true, true);
+ std::move(port2), false, ntype != NAT_SYMMETRIC, true,
+ true);
}
void TestTcpToTcp() {
auto port1 = CreateTcpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
auto port2 = CreateTcpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
TestConnectivity("tcp", std::move(port1), "tcp", std::move(port2), true,
false, true, true);
}
void TestTcpToRelay(ProtocolType proto) {
auto port1 = CreateTcpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
- auto port2 = CreateRelayPort(kLocalAddr2, proto, webrtc::PROTO_TCP);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
+ auto port2 = CreateRelayPort(kLocalAddr2, proto, PROTO_TCP);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
TestConnectivity("tcp", std::move(port1), RelayName(proto),
std::move(port2), false, false, true, true);
}
void TestSslTcpToRelay(ProtocolType proto) {
auto port1 = CreateTcpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
- auto port2 = CreateRelayPort(kLocalAddr2, proto, webrtc::PROTO_SSLTCP);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
+ auto port2 = CreateRelayPort(kLocalAddr2, proto, PROTO_SSLTCP);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
TestConnectivity("ssltcp", std::move(port1), RelayName(proto),
std::move(port2), false, false, true, true);
}
@@ -544,7 +539,7 @@
Network* MakeNetworkMultipleAddrs(const SocketAddress& global_addr,
const SocketAddress& link_local_addr) {
networks_.emplace_back("unittest", "unittest", global_addr.ipaddr(), 32,
- webrtc::ADAPTER_TYPE_UNKNOWN);
+ ADAPTER_TYPE_UNKNOWN);
networks_.back().AddIP(link_local_addr.ipaddr());
networks_.back().AddIP(global_addr.ipaddr());
networks_.back().AddIP(link_local_addr.ipaddr());
@@ -623,7 +618,7 @@
ProtocolType int_proto,
ProtocolType ext_proto) {
SocketAddress server_addr =
- int_proto == webrtc::PROTO_TCP ? kTurnTcpIntAddr : kTurnUdpIntAddr;
+ int_proto == PROTO_TCP ? kTurnTcpIntAddr : kTurnUdpIntAddr;
return CreateTurnPort(addr, socket_factory, int_proto, ext_proto,
server_addr);
}
@@ -656,13 +651,13 @@
}
static const char* StunName(NATType type) {
switch (type) {
- case webrtc::NAT_OPEN_CONE:
+ case NAT_OPEN_CONE:
return "stun(open cone)";
- case webrtc::NAT_ADDR_RESTRICTED:
+ case NAT_ADDR_RESTRICTED:
return "stun(addr restricted)";
- case webrtc::NAT_PORT_RESTRICTED:
+ case NAT_PORT_RESTRICTED:
return "stun(port restricted)";
- case webrtc::NAT_SYMMETRIC:
+ case NAT_SYMMETRIC:
return "stun(symmetric)";
default:
return "stun(?)";
@@ -670,13 +665,13 @@
}
static const char* RelayName(ProtocolType proto) {
switch (proto) {
- case webrtc::PROTO_UDP:
+ case PROTO_UDP:
return "turn(udp)";
- case webrtc::PROTO_TCP:
+ case PROTO_TCP:
return "turn(tcp)";
- case webrtc::PROTO_SSLTCP:
+ case PROTO_SSLTCP:
return "turn(ssltcp)";
- case webrtc::PROTO_TLS:
+ case PROTO_TLS:
return "turn(tls)";
default:
return "turn(?)";
@@ -702,21 +697,19 @@
// TCP reconnecting mechanism before entering this function.
void ConnectStartedChannels(TestChannel* ch1, TestChannel* ch2) {
ASSERT_TRUE(ch1->conn());
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1->conn()->connected(); }, IsTrue(),
+ EXPECT_THAT(WaitUntil([&] { return ch1->conn()->connected(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk()); // for TCP connect
+ IsRtcOk()); // for TCP connect
ch1->Ping();
WAIT(!ch2->remote_address().IsNil(), kShortTimeout);
// Send a ping from dst to src.
ch2->AcceptConnection(GetCandidate(ch1->port()));
ch2->Ping();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch2->conn()->write_state(); },
+ EXPECT_THAT(WaitUntil([&] { return ch2->conn()->write_state(); },
Eq(Connection::STATE_WRITABLE),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
// This connects and disconnects the provided channels in the same sequence as
@@ -745,14 +738,12 @@
tcp_conn2->socket()->GetLocalAddress()));
// Wait for both OnClose are delivered.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return !ch1->conn()->connected(); }, IsTrue(),
+ EXPECT_THAT(WaitUntil([&] { return !ch1->conn()->connected(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return !ch2->conn()->connected(); }, IsTrue(),
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return !ch2->conn()->connected(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Ensure redundant SignalClose events on TcpConnection won't break tcp
// reconnection. Chromium will fire SignalClose for all outstanding IPC
@@ -763,18 +754,17 @@
// Speed up destroying ch2's connection such that the test is ready to
// accept a new connection from ch1 before ch1's connection destroys itself.
ch2->Stop();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch2->conn(); }, IsNull(),
+ EXPECT_THAT(WaitUntil([&] { return ch2->conn(); }, IsNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
void TestTcpReconnect(bool ping_after_disconnected,
bool send_after_disconnected) {
auto port1 = CreateTcpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
auto port2 = CreateTcpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
port1->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT);
port2->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT);
@@ -787,14 +777,12 @@
ch1.Start();
ch2.Start();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Initial connecting the channel, create connection on channel1.
ch1.CreateConnection(GetCandidate(ch2.port()));
@@ -827,17 +815,16 @@
}
// Wait for channel's outgoing TCPConnection connected.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Verify that we could still connect channels.
ConnectStartedChannels(&ch1, &ch2);
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return ch1.connection_ready_to_send(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kTcpReconnectTimeout)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ch1.connection_ready_to_send(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kTcpReconnectTimeout)}),
+ IsRtcOk());
// Channel2 is the passive one so a new connection is created during
// reconnect. This new connection should never have issued ENOTCONN
// hence the connection_ready_to_send() should be false.
@@ -846,25 +833,22 @@
EXPECT_EQ(ch1.conn()->write_state(), Connection::STATE_WRITABLE);
// Since the reconnection never happens, the connections should have been
// destroyed after the timeout.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return !ch1.conn(); }, IsTrue(),
+ EXPECT_THAT(WaitUntil([&] { return !ch1.conn(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kTcpReconnectTimeout +
kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(!ch2.conn());
}
// Tear down and ensure that goes smoothly.
ch1.Stop();
ch2.Stop();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1.conn(); }, IsNull(),
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, IsNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch2.conn(); }, IsNull(),
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch2.conn(); }, IsNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
std::unique_ptr<IceMessage> CreateStunMessage(StunMessageType type) {
@@ -904,7 +888,7 @@
port->SetIceTiebreaker(tiebreaker);
return port;
}
- // Overload to create a test port given an webrtc::Network directly.
+ // Overload to create a test port given an Network directly.
std::unique_ptr<TestPort> CreateTestPort(const Network* network,
absl::string_view username,
absl::string_view password) {
@@ -981,23 +965,22 @@
// Acquire addresses.
ch1.Start();
ch2.Start();
- ASSERT_THAT(webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
- ASSERT_THAT(webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
// Send a ping from src to dst. This may or may not make it.
ch1.CreateConnection(GetCandidate(ch2.port()));
ASSERT_TRUE(ch1.conn() != nullptr);
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch1.conn()->connected(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk()); // for TCP connect
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk()); // for TCP connect
ch1.Ping();
SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
@@ -1017,12 +1000,11 @@
ch2.AcceptConnection(GetCandidate(ch1.port()));
ASSERT_TRUE(ch2.conn() != nullptr);
ch2.Ping();
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch2.conn()->write_state(); },
- Eq(Connection::STATE_WRITABLE),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch2.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
} else {
// We can't send a ping from src to dst, so flip it around. This will happen
// when the destination NAT is addr/port restricted or symmetric.
@@ -1045,12 +1027,11 @@
// through. So we will have to do another.
if (ch1.conn()->write_state() == Connection::STATE_WRITE_INIT) {
ch1.Ping();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1.conn()->write_state(); },
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
Eq(Connection::STATE_WRITABLE),
{.timeout = TimeDelta::Millis(kDefaultTimeout),
.clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
} else if (!same_addr1 && possible) {
// The new ping went to the candidate address, but that address was bad.
@@ -1062,10 +1043,10 @@
// able to get a ping from it. This gives us the real source address.
ch1.Ping();
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return !ch2.remote_address().IsNil(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_FALSE(ch2.conn()->receiving());
EXPECT_TRUE(ch1.remote_address().IsNil());
@@ -1073,12 +1054,11 @@
ch2.AcceptConnection(GetCandidate(ch1.port()));
ASSERT_TRUE(ch2.conn() != nullptr);
ch2.Ping();
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch2.conn()->write_state(); },
- Eq(Connection::STATE_WRITABLE),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch2.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
} else if (!same_addr2 && possible) {
// The new ping came in, but from an unexpected address. This will happen
// when the destination NAT is symmetric.
@@ -1088,12 +1068,11 @@
// Update our address and complete the connection.
ch1.AcceptConnection(GetCandidate(ch2.port()));
ch1.Ping();
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch1.conn()->write_state(); },
- Eq(Connection::STATE_WRITABLE),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
} else { // (!possible)
// There should be s no way for the pings to reach each other. Check it.
EXPECT_TRUE(ch1.remote_address().IsNil());
@@ -1123,14 +1102,14 @@
// Tear down and ensure that goes smoothly.
ch1.Stop();
ch2.Stop();
- EXPECT_THAT(webrtc::WaitUntil([&] { return ch1.conn(); }, IsNull(),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
- EXPECT_THAT(webrtc::WaitUntil([&] { return ch2.conn(); }, IsNull(),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, IsNull(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch2.conn(); }, IsNull(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
}
class FakePacketSocketFactory : public PacketSocketFactory {
@@ -1258,127 +1237,127 @@
}
TEST_F(PortTest, TestLocalToConeNat) {
- TestLocalToStun(webrtc::NAT_OPEN_CONE);
+ TestLocalToStun(NAT_OPEN_CONE);
}
TEST_F(PortTest, TestLocalToARNat) {
- TestLocalToStun(webrtc::NAT_ADDR_RESTRICTED);
+ TestLocalToStun(NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestLocalToPRNat) {
- TestLocalToStun(webrtc::NAT_PORT_RESTRICTED);
+ TestLocalToStun(NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestLocalToSymNat) {
- TestLocalToStun(webrtc::NAT_SYMMETRIC);
+ TestLocalToStun(NAT_SYMMETRIC);
}
// Flaky: https://code.google.com/p/webrtc/issues/detail?id=3316.
TEST_F(PortTest, DISABLED_TestLocalToTurn) {
- TestLocalToRelay(webrtc::PROTO_UDP);
+ TestLocalToRelay(PROTO_UDP);
}
// Cone NAT -> XXXX
TEST_F(PortTest, TestConeNatToLocal) {
- TestStunToLocal(webrtc::NAT_OPEN_CONE);
+ TestStunToLocal(NAT_OPEN_CONE);
}
TEST_F(PortTest, TestConeNatToConeNat) {
- TestStunToStun(webrtc::NAT_OPEN_CONE, webrtc::NAT_OPEN_CONE);
+ TestStunToStun(NAT_OPEN_CONE, NAT_OPEN_CONE);
}
TEST_F(PortTest, TestConeNatToARNat) {
- TestStunToStun(webrtc::NAT_OPEN_CONE, webrtc::NAT_ADDR_RESTRICTED);
+ TestStunToStun(NAT_OPEN_CONE, NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestConeNatToPRNat) {
- TestStunToStun(webrtc::NAT_OPEN_CONE, webrtc::NAT_PORT_RESTRICTED);
+ TestStunToStun(NAT_OPEN_CONE, NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestConeNatToSymNat) {
- TestStunToStun(webrtc::NAT_OPEN_CONE, webrtc::NAT_SYMMETRIC);
+ TestStunToStun(NAT_OPEN_CONE, NAT_SYMMETRIC);
}
TEST_F(PortTest, TestConeNatToTurn) {
- TestStunToRelay(webrtc::NAT_OPEN_CONE, webrtc::PROTO_UDP);
+ TestStunToRelay(NAT_OPEN_CONE, PROTO_UDP);
}
// Address-restricted NAT -> XXXX
TEST_F(PortTest, TestARNatToLocal) {
- TestStunToLocal(webrtc::NAT_ADDR_RESTRICTED);
+ TestStunToLocal(NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestARNatToConeNat) {
- TestStunToStun(webrtc::NAT_ADDR_RESTRICTED, webrtc::NAT_OPEN_CONE);
+ TestStunToStun(NAT_ADDR_RESTRICTED, NAT_OPEN_CONE);
}
TEST_F(PortTest, TestARNatToARNat) {
- TestStunToStun(webrtc::NAT_ADDR_RESTRICTED, webrtc::NAT_ADDR_RESTRICTED);
+ TestStunToStun(NAT_ADDR_RESTRICTED, NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestARNatToPRNat) {
- TestStunToStun(webrtc::NAT_ADDR_RESTRICTED, webrtc::NAT_PORT_RESTRICTED);
+ TestStunToStun(NAT_ADDR_RESTRICTED, NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestARNatToSymNat) {
- TestStunToStun(webrtc::NAT_ADDR_RESTRICTED, webrtc::NAT_SYMMETRIC);
+ TestStunToStun(NAT_ADDR_RESTRICTED, NAT_SYMMETRIC);
}
TEST_F(PortTest, TestARNatToTurn) {
- TestStunToRelay(webrtc::NAT_ADDR_RESTRICTED, webrtc::PROTO_UDP);
+ TestStunToRelay(NAT_ADDR_RESTRICTED, PROTO_UDP);
}
// Port-restricted NAT -> XXXX
TEST_F(PortTest, TestPRNatToLocal) {
- TestStunToLocal(webrtc::NAT_PORT_RESTRICTED);
+ TestStunToLocal(NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestPRNatToConeNat) {
- TestStunToStun(webrtc::NAT_PORT_RESTRICTED, webrtc::NAT_OPEN_CONE);
+ TestStunToStun(NAT_PORT_RESTRICTED, NAT_OPEN_CONE);
}
TEST_F(PortTest, TestPRNatToARNat) {
- TestStunToStun(webrtc::NAT_PORT_RESTRICTED, webrtc::NAT_ADDR_RESTRICTED);
+ TestStunToStun(NAT_PORT_RESTRICTED, NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestPRNatToPRNat) {
- TestStunToStun(webrtc::NAT_PORT_RESTRICTED, webrtc::NAT_PORT_RESTRICTED);
+ TestStunToStun(NAT_PORT_RESTRICTED, NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestPRNatToSymNat) {
// Will "fail"
- TestStunToStun(webrtc::NAT_PORT_RESTRICTED, webrtc::NAT_SYMMETRIC);
+ TestStunToStun(NAT_PORT_RESTRICTED, NAT_SYMMETRIC);
}
TEST_F(PortTest, TestPRNatToTurn) {
- TestStunToRelay(webrtc::NAT_PORT_RESTRICTED, webrtc::PROTO_UDP);
+ TestStunToRelay(NAT_PORT_RESTRICTED, PROTO_UDP);
}
// Symmetric NAT -> XXXX
TEST_F(PortTest, TestSymNatToLocal) {
- TestStunToLocal(webrtc::NAT_SYMMETRIC);
+ TestStunToLocal(NAT_SYMMETRIC);
}
TEST_F(PortTest, TestSymNatToConeNat) {
- TestStunToStun(webrtc::NAT_SYMMETRIC, webrtc::NAT_OPEN_CONE);
+ TestStunToStun(NAT_SYMMETRIC, NAT_OPEN_CONE);
}
TEST_F(PortTest, TestSymNatToARNat) {
- TestStunToStun(webrtc::NAT_SYMMETRIC, webrtc::NAT_ADDR_RESTRICTED);
+ TestStunToStun(NAT_SYMMETRIC, NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestSymNatToPRNat) {
// Will "fail"
- TestStunToStun(webrtc::NAT_SYMMETRIC, webrtc::NAT_PORT_RESTRICTED);
+ TestStunToStun(NAT_SYMMETRIC, NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestSymNatToSymNat) {
// Will "fail"
- TestStunToStun(webrtc::NAT_SYMMETRIC, webrtc::NAT_SYMMETRIC);
+ TestStunToStun(NAT_SYMMETRIC, NAT_SYMMETRIC);
}
TEST_F(PortTest, TestSymNatToTurn) {
- TestStunToRelay(webrtc::NAT_SYMMETRIC, webrtc::PROTO_UDP);
+ TestStunToRelay(NAT_SYMMETRIC, PROTO_UDP);
}
// Outbound TCP -> XXXX
@@ -1402,7 +1381,7 @@
// destroy the connection.
TEST_F(PortTest, TestTcpNeverConnect) {
auto port1 = CreateTcpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
port1->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT);
// Set up a channel and ensure the port will be deleted.
@@ -1410,10 +1389,9 @@
EXPECT_EQ(0, ch1.complete_count());
ch1.Start();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
std::unique_ptr<Socket> server(
vss()->CreateSocket(kLocalAddr2.family(), SOCK_STREAM));
@@ -1425,10 +1403,9 @@
ch1.CreateConnection(c);
EXPECT_TRUE(ch1.conn());
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return !ch1.conn(); }, IsTrue(),
+ EXPECT_THAT(WaitUntil([&] { return !ch1.conn(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk()); // for TCP connect
+ IsRtcOk()); // for TCP connect
}
/* TODO(?): Enable these once testrelayserver can accept external TCP.
@@ -1463,19 +1440,17 @@
// Acquire address.
ch1.Start();
ch2.Start();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Test case that the connection has never received anything.
- int64_t before_created = webrtc::TimeMillis();
+ int64_t before_created = TimeMillis();
ch1.CreateConnection(GetCandidate(ch2.port()));
- int64_t after_created = webrtc::TimeMillis();
+ int64_t after_created = TimeMillis();
Connection* conn = ch1.conn();
ASSERT_NE(conn, nullptr);
// It is not dead if it is after MIN_CONNECTION_LIFETIME but not pruned.
@@ -1489,29 +1464,27 @@
EXPECT_TRUE(ch1.conn() != nullptr);
// It will be dead after MIN_CONNECTION_LIFETIME and pruned.
conn->UpdateState(after_created + MIN_CONNECTION_LIFETIME + 1);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Test case that the connection has received something.
// Create a connection again and receive a ping.
ch1.CreateConnection(GetCandidate(ch2.port()));
conn = ch1.conn();
ASSERT_NE(conn, nullptr);
- int64_t before_last_receiving = webrtc::TimeMillis();
+ int64_t before_last_receiving = TimeMillis();
conn->ReceivedPing();
- int64_t after_last_receiving = webrtc::TimeMillis();
+ int64_t after_last_receiving = TimeMillis();
// The connection will be dead after DEAD_CONNECTION_RECEIVE_TIMEOUT
conn->UpdateState(before_last_receiving + DEAD_CONNECTION_RECEIVE_TIMEOUT -
1);
Thread::Current()->ProcessMessages(100);
EXPECT_TRUE(ch1.conn() != nullptr);
conn->UpdateState(after_last_receiving + DEAD_CONNECTION_RECEIVE_TIMEOUT + 1);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
TEST_F(PortTest, TestConnectionDeadWithDeadConnectionTimeout) {
@@ -1520,14 +1493,12 @@
// Acquire address.
ch1.Start();
ch2.Start();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Note: set field trials manually since they are parsed by
// P2PTransportChannel but P2PTransportChannel is not used in this test.
@@ -1540,26 +1511,25 @@
conn->SetIceFieldTrials(&field_trials);
ASSERT_NE(conn, nullptr);
- int64_t before_last_receiving = webrtc::TimeMillis();
+ int64_t before_last_receiving = TimeMillis();
conn->ReceivedPing();
- int64_t after_last_receiving = webrtc::TimeMillis();
+ int64_t after_last_receiving = TimeMillis();
// The connection will be dead after 90s
conn->UpdateState(before_last_receiving + 90000 - 1);
Thread::Current()->ProcessMessages(100);
EXPECT_TRUE(ch1.conn() != nullptr);
conn->UpdateState(after_last_receiving + 90000 + 1);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
TEST_F(PortTest, TestConnectionDeadOutstandingPing) {
auto port1 = CreateUdpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
port1->SetIceTiebreaker(kTiebreaker1);
auto port2 = CreateUdpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
port2->SetIceTiebreaker(kTiebreaker2);
TestChannel ch1(std::move(port1));
@@ -1567,14 +1537,12 @@
// Acquire address.
ch1.Start();
ch2.Start();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Note: set field trials manually since they are parsed by
// P2PTransportChannel but P2PTransportChannel is not used in this test.
@@ -1589,7 +1557,7 @@
ASSERT_NE(conn, nullptr);
conn->ReceivedPing();
- int64_t send_ping_timestamp = webrtc::TimeMillis();
+ int64_t send_ping_timestamp = TimeMillis();
conn->Ping(send_ping_timestamp);
// The connection will be dead 30s after the ping was sent.
@@ -1597,10 +1565,9 @@
Thread::Current()->ProcessMessages(100);
EXPECT_TRUE(ch1.conn() != nullptr);
conn->UpdateState(send_ping_timestamp + DEAD_CONNECTION_RECEIVE_TIMEOUT + 1);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
// This test case verifies standard ICE features in STUN messages. Currently it
@@ -1608,10 +1575,10 @@
// binding request will have colon (":") between remote and local username.
TEST_F(PortTest, TestLocalToLocalStandard) {
auto port1 = CreateUdpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
port1->SetIceTiebreaker(kTiebreaker1);
auto port2 = CreateUdpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
port2->SetIceTiebreaker(kTiebreaker2);
// Same parameters as TestLocalToLocal above.
TestConnectivity("udp", std::move(port1), "udp", std::move(port2), true, true,
@@ -1624,7 +1591,7 @@
// must be in controlling.
TEST_F(PortTest, TestLoopbackCall) {
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
lport->PrepareAddress();
ASSERT_FALSE(lport->Candidates().empty());
@@ -1632,18 +1599,16 @@
lport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
conn->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
conn->OnReadPacket(
ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
@@ -1656,10 +1621,9 @@
lport->CreateConnection(lport->Candidates()[1], Port::ORIGIN_MESSAGE);
conn1->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
std::unique_ptr<IceMessage> modified_req(
@@ -1681,10 +1645,9 @@
conn1->OnReadPacket(ReceivedIpPacket::CreateFromLegacy(
reinterpret_cast<const char*>(buf->Data()), buf->Length(),
/*packet_time_us=*/-1));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
}
@@ -1696,10 +1659,10 @@
// send role conflict signal.
TEST_F(PortTest, TestIceRoleConflict) {
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ rport->SetIceRole(ICEROLE_CONTROLLING);
rport->SetIceTiebreaker(kTiebreaker2);
lport->PrepareAddress();
@@ -1712,20 +1675,18 @@
rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
rconn->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
IceMessage* msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Send rport binding request to lport.
lconn->OnReadPacket(
ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
EXPECT_TRUE(role_conflict());
}
@@ -1733,14 +1694,14 @@
TEST_F(PortTest, TestTcpNoDelay) {
ScopedFakeClock clock;
auto port1 = CreateTcpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
int option_value = -1;
int success = port1->GetOption(Socket::OPT_NODELAY, &option_value);
ASSERT_EQ(0, success); // GetOption() should complete successfully w/ 0
EXPECT_EQ(1, option_value);
auto port2 = CreateTcpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
// Set up a connection, and verify that option is set on connected sockets at
// both ends.
@@ -1749,22 +1710,21 @@
// Acquire addresses.
ch1.Start();
ch2.Start();
- ASSERT_THAT(webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
- ASSERT_THAT(webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
// Connect and send a ping from src to dst.
ch1.CreateConnection(GetCandidate(ch2.port()));
ASSERT_TRUE(ch1.conn() != nullptr);
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch1.conn()->connected(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk()); // for TCP connect
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk()); // for TCP connect
ch1.Ping();
SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
@@ -1817,9 +1777,9 @@
lsocket->Bind(kLocalAddr1);
rsocket->Bind(kLocalAddr2);
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
rport->SetIceTiebreaker(kTiebreaker2);
lport->PrepareAddress();
@@ -1997,16 +1957,16 @@
EXPECT_EQ(0, stunport->SetOption(Socket::OPT_DSCP, DSCP_AF41));
EXPECT_EQ(0, stunport->GetOption(Socket::OPT_DSCP, &dscp));
EXPECT_EQ(DSCP_AF41, dscp);
- auto turnport1 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
- webrtc::PROTO_UDP, webrtc::PROTO_UDP);
+ auto turnport1 =
+ CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
// Socket is created in PrepareAddress.
turnport1->PrepareAddress();
EXPECT_EQ(0, turnport1->SetOption(Socket::OPT_DSCP, DSCP_CS7));
EXPECT_EQ(0, turnport1->GetOption(Socket::OPT_DSCP, &dscp));
EXPECT_EQ(DSCP_CS7, dscp);
// This will verify correct value returned without the socket.
- auto turnport2 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
- webrtc::PROTO_UDP, webrtc::PROTO_UDP);
+ auto turnport2 =
+ CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
EXPECT_EQ(0, turnport2->SetOption(Socket::OPT_DSCP, DSCP_CS6));
EXPECT_EQ(0, turnport2->GetOption(Socket::OPT_DSCP, &dscp));
EXPECT_EQ(DSCP_CS6, dscp);
@@ -2016,9 +1976,9 @@
TEST_F(PortTest, TestSendStunMessage) {
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
rport->SetIceTiebreaker(kTiebreaker2);
// Send a fake ping from lport to rport.
@@ -2032,10 +1992,9 @@
lconn->Ping(0);
// Check that it's a proper BINDING-REQUEST.
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
EXPECT_FALSE(msg->IsLegacy());
@@ -2137,10 +2096,9 @@
rconn->Ping(0);
rconn->Ping(0);
rconn->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
const StunUInt64Attribute* ice_controlled_attr =
@@ -2185,9 +2143,9 @@
TEST_F(PortTest, TestNomination) {
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
rport->SetIceTiebreaker(kTiebreaker2);
lport->PrepareAddress();
@@ -2211,10 +2169,9 @@
// Send ping (including the nomination value) from `lconn` to `rconn`. This
// should set the remote nomination of `rconn`.
lconn->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(lport->last_stun_buf().size(), 0u);
rconn->OnReadPacket(
ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
@@ -2227,10 +2184,9 @@
// This should result in an acknowledgment sent back from `rconn` to `lconn`,
// updating the acknowledged nomination of `lconn`.
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
+ ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(rport->last_stun_buf().size(), 0u);
lconn->OnReadPacket(
ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt));
@@ -2247,9 +2203,9 @@
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
rport->SetIceTiebreaker(kTiebreaker2);
lport->PrepareAddress();
@@ -2286,9 +2242,9 @@
TEST_F(PortTest, TestUseCandidateAttribute) {
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
rport->SetIceTiebreaker(kTiebreaker2);
// Send a fake ping from lport to rport.
@@ -2298,10 +2254,9 @@
Connection* lconn =
lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
lconn->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
const StunUInt64Attribute* ice_controlling_attr =
msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
@@ -2318,51 +2273,50 @@
Network* test_network = MakeNetwork(kLocalAddr1);
auto lport = CreateTestPort(test_network, "lfrag", "lpass");
auto rport = CreateTestPort(test_network, "rfrag", "rpass");
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
rport->SetIceTiebreaker(kTiebreaker2);
lport->PrepareAddress();
rport->PrepareAddress();
- // Default local port cost is webrtc::kNetworkCostUnknown.
- EXPECT_EQ(webrtc::kNetworkCostUnknown, lport->network_cost());
+ // Default local port cost is kNetworkCostUnknown.
+ EXPECT_EQ(kNetworkCostUnknown, lport->network_cost());
ASSERT_TRUE(!lport->Candidates().empty());
for (const Candidate& candidate : lport->Candidates()) {
- EXPECT_EQ(webrtc::kNetworkCostUnknown, candidate.network_cost());
+ EXPECT_EQ(kNetworkCostUnknown, candidate.network_cost());
}
// Change the network type to wifi.
- test_network->set_type(webrtc::ADAPTER_TYPE_WIFI);
- EXPECT_EQ(webrtc::kNetworkCostLow, lport->network_cost());
+ test_network->set_type(ADAPTER_TYPE_WIFI);
+ EXPECT_EQ(kNetworkCostLow, lport->network_cost());
for (const Candidate& candidate : lport->Candidates()) {
- EXPECT_EQ(webrtc::kNetworkCostLow, candidate.network_cost());
+ EXPECT_EQ(kNetworkCostLow, candidate.network_cost());
}
// Add a connection and then change the network type.
Connection* lconn =
lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
// Change the network type to cellular.
- test_network->set_type(webrtc::ADAPTER_TYPE_CELLULAR);
- EXPECT_EQ(webrtc::kNetworkCostHigh, lport->network_cost());
+ test_network->set_type(ADAPTER_TYPE_CELLULAR);
+ EXPECT_EQ(kNetworkCostHigh, lport->network_cost());
for (const Candidate& candidate : lport->Candidates()) {
- EXPECT_EQ(webrtc::kNetworkCostHigh, candidate.network_cost());
+ EXPECT_EQ(kNetworkCostHigh, candidate.network_cost());
}
- test_network->set_type(webrtc::ADAPTER_TYPE_WIFI);
+ test_network->set_type(ADAPTER_TYPE_WIFI);
Connection* rconn =
rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
- test_network->set_type(webrtc::ADAPTER_TYPE_CELLULAR);
+ test_network->set_type(ADAPTER_TYPE_CELLULAR);
lconn->Ping(0);
- // The rconn's remote candidate cost is webrtc::kNetworkCostLow, but the ping
- // contains an attribute of network cost of webrtc::kNetworkCostHigh. Once the
+ // The rconn's remote candidate cost is kNetworkCostLow, but the ping
+ // contains an attribute of network cost of kNetworkCostHigh. Once the
// message is handled in rconn, The rconn's remote candidate will have cost
- // webrtc::kNetworkCostHigh;
- EXPECT_EQ(webrtc::kNetworkCostLow, rconn->remote_candidate().network_cost());
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ // kNetworkCostHigh;
+ EXPECT_EQ(kNetworkCostLow, rconn->remote_candidate().network_cost());
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Pass the binding request to rport.
@@ -2370,20 +2324,19 @@
ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
// Wait until rport sends the response and then check the remote network cost.
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- EXPECT_EQ(webrtc::kNetworkCostHigh, rconn->remote_candidate().network_cost());
+ IsRtcOk());
+ EXPECT_EQ(kNetworkCostHigh, rconn->remote_candidate().network_cost());
}
TEST_F(PortTest, TestNetworkInfoAttribute) {
Network* test_network = MakeNetwork(kLocalAddr1);
auto lport = CreateTestPort(test_network, "lfrag", "lpass");
auto rport = CreateTestPort(test_network, "rfrag", "rpass");
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
rport->SetIceTiebreaker(kTiebreaker2);
uint16_t lnetwork_id = 9;
@@ -2394,10 +2347,9 @@
Connection* lconn =
lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
lconn->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
const StunUInt32Attribute* network_info_attr =
msg->GetUInt32(STUN_ATTR_GOOG_NETWORK_INFO);
@@ -2405,26 +2357,25 @@
uint32_t network_info = network_info_attr->value();
EXPECT_EQ(lnetwork_id, network_info >> 16);
// Default network has unknown type and cost kNetworkCostUnknown.
- EXPECT_EQ(webrtc::kNetworkCostUnknown, network_info & 0xFFFF);
+ EXPECT_EQ(kNetworkCostUnknown, network_info & 0xFFFF);
// Set the network type to be cellular so its cost will be kNetworkCostHigh.
// Send a fake ping from rport to lport.
- test_network->set_type(webrtc::ADAPTER_TYPE_CELLULAR);
+ test_network->set_type(ADAPTER_TYPE_CELLULAR);
uint16_t rnetwork_id = 8;
test_network->set_id(rnetwork_id);
Connection* rconn =
rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
rconn->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
msg = rport->last_stun_msg();
network_info_attr = msg->GetUInt32(STUN_ATTR_GOOG_NETWORK_INFO);
ASSERT_TRUE(network_info_attr != nullptr);
network_info = network_info_attr->value();
EXPECT_EQ(rnetwork_id, network_info >> 16);
- EXPECT_EQ(webrtc::kNetworkCostHigh, network_info & 0xFFFF);
+ EXPECT_EQ(kNetworkCostHigh, network_info & 0xFFFF);
}
// Test handling STUN messages.
@@ -2691,9 +2642,9 @@
TestHandleStunResponseWithUnknownComprehensionRequiredAttribute) {
// Generic setup.
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass",
- webrtc::ICEROLE_CONTROLLING, kTiebreakerDefault);
- auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
- webrtc::ICEROLE_CONTROLLED, kTiebreakerDefault);
+ ICEROLE_CONTROLLING, kTiebreakerDefault);
+ auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
+ kTiebreakerDefault);
lport->PrepareAddress();
rport->PrepareAddress();
ASSERT_FALSE(lport->Candidates().empty());
@@ -2705,18 +2656,16 @@
// Send request.
lconn->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
rconn->OnReadPacket(
ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
// Intercept request and add comprehension required attribute.
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
auto modified_response = rport->last_stun_msg()->Clone();
modified_response->AddAttribute(StunAttribute::CreateUInt32(0x7777));
modified_response->RemoveAttribute(STUN_ATTR_FINGERPRINT);
@@ -2736,9 +2685,9 @@
TestHandleStunIndicationWithUnknownComprehensionRequiredAttribute) {
// Generic set up.
auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass",
- webrtc::ICEROLE_CONTROLLING, kTiebreakerDefault);
- auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
- webrtc::ICEROLE_CONTROLLED, kTiebreakerDefault);
+ ICEROLE_CONTROLLING, kTiebreakerDefault);
+ auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
+ kTiebreakerDefault);
lport->PrepareAddress();
rport->PrepareAddress();
ASSERT_FALSE(lport->Candidates().empty());
@@ -2762,7 +2711,7 @@
// indications are allowed only to the connection which is in read mode.
TEST_F(PortTest, TestHandleStunBindingIndication) {
auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass",
- webrtc::ICEROLE_CONTROLLING, kTiebreaker1);
+ ICEROLE_CONTROLLING, kTiebreaker1);
// Verifying encoding and decoding STUN indication message.
std::unique_ptr<IceMessage> in_msg, out_msg;
@@ -2782,7 +2731,7 @@
// Verify connection can handle STUN indication and updates
// last_ping_received.
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
rport->SetIceTiebreaker(kTiebreaker2);
lport->PrepareAddress();
@@ -2796,20 +2745,18 @@
rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
rconn->Ping(0);
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
IceMessage* msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Send rport binding request to lport.
lconn->OnReadPacket(
ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
int64_t last_ping_received1 = lconn->last_ping_received();
@@ -2876,20 +2823,15 @@
port->AddCandidateAddress(SocketAddress("3ffe::1234:5678", 1234));
// These should all be:
// (90 << 24) | (([rfc3484 pref value] << 8) + kMaxTurnServers) | (256 - 177)
- uint32_t expected_priority_v4 = 1509957199U + (webrtc::kMaxTurnServers << 8);
- uint32_t expected_priority_v6 = 1509959759U + (webrtc::kMaxTurnServers << 8);
- uint32_t expected_priority_ula = 1509962319U + (webrtc::kMaxTurnServers << 8);
+ uint32_t expected_priority_v4 = 1509957199U + (kMaxTurnServers << 8);
+ uint32_t expected_priority_v6 = 1509959759U + (kMaxTurnServers << 8);
+ uint32_t expected_priority_ula = 1509962319U + (kMaxTurnServers << 8);
uint32_t expected_priority_v4mapped = expected_priority_v4;
- uint32_t expected_priority_v4compat =
- 1509949775U + (webrtc::kMaxTurnServers << 8);
- uint32_t expected_priority_6to4 =
- 1509954639U + (webrtc::kMaxTurnServers << 8);
- uint32_t expected_priority_teredo =
- 1509952079U + (webrtc::kMaxTurnServers << 8);
- uint32_t expected_priority_sitelocal =
- 1509949775U + (webrtc::kMaxTurnServers << 8);
- uint32_t expected_priority_6bone =
- 1509949775U + (webrtc::kMaxTurnServers << 8);
+ uint32_t expected_priority_v4compat = 1509949775U + (kMaxTurnServers << 8);
+ uint32_t expected_priority_6to4 = 1509954639U + (kMaxTurnServers << 8);
+ uint32_t expected_priority_teredo = 1509952079U + (kMaxTurnServers << 8);
+ uint32_t expected_priority_sitelocal = 1509949775U + (kMaxTurnServers << 8);
+ uint32_t expected_priority_6bone = 1509949775U + (kMaxTurnServers << 8);
ASSERT_EQ(expected_priority_v4, port->Candidates()[0].priority());
ASSERT_EQ(expected_priority_v6, port->Candidates()[1].priority());
ASSERT_EQ(expected_priority_ula, port->Candidates()[2].priority());
@@ -2919,7 +2861,7 @@
// This test verifies the foundation of different types of ICE candidates.
TEST_F(PortTest, TestCandidateFoundation) {
std::unique_ptr<NATServer> nat_server(
- CreateNatServer(kNatAddr1, webrtc::NAT_OPEN_CONE));
+ CreateNatServer(kNatAddr1, NAT_OPEN_CONE));
auto udpport1 = CreateUdpPort(kLocalAddr1);
udpport1->PrepareAddress();
auto udpport2 = CreateUdpPort(kLocalAddr1);
@@ -2934,10 +2876,9 @@
tcpport2->Candidates()[0].foundation());
auto stunport = CreateStunPort(kLocalAddr1, nat_socket_factory1());
stunport->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U),
+ ASSERT_THAT(WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_NE(tcpport1->Candidates()[0].foundation(),
stunport->Candidates()[0].foundation());
EXPECT_NE(tcpport2->Candidates()[0].foundation(),
@@ -2947,56 +2888,51 @@
EXPECT_NE(udpport2->Candidates()[0].foundation(),
stunport->Candidates()[0].foundation());
// Verifying TURN candidate foundation.
- auto turnport1 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
- webrtc::PROTO_UDP, webrtc::PROTO_UDP);
+ auto turnport1 =
+ CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
turnport1->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return turnport1->Candidates().size(); }, Eq(1U),
+ ASSERT_THAT(WaitUntil([&] { return turnport1->Candidates().size(); }, Eq(1U),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_NE(udpport1->Candidates()[0].foundation(),
turnport1->Candidates()[0].foundation());
EXPECT_NE(udpport2->Candidates()[0].foundation(),
turnport1->Candidates()[0].foundation());
EXPECT_NE(stunport->Candidates()[0].foundation(),
turnport1->Candidates()[0].foundation());
- auto turnport2 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
- webrtc::PROTO_UDP, webrtc::PROTO_UDP);
+ auto turnport2 =
+ CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
turnport2->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return turnport2->Candidates().size(); }, Eq(1U),
+ ASSERT_THAT(WaitUntil([&] { return turnport2->Candidates().size(); }, Eq(1U),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(turnport1->Candidates()[0].foundation(),
turnport2->Candidates()[0].foundation());
// Running a second turn server, to get different base IP address.
- SocketAddress kTurnUdpIntAddr2("99.99.98.4", webrtc::STUN_SERVER_PORT);
+ SocketAddress kTurnUdpIntAddr2("99.99.98.4", STUN_SERVER_PORT);
SocketAddress kTurnUdpExtAddr2("99.99.98.5", 0);
TestTurnServer turn_server2(Thread::Current(), vss(), kTurnUdpIntAddr2,
kTurnUdpExtAddr2);
- auto turnport3 =
- CreateTurnPort(kLocalAddr1, nat_socket_factory1(), webrtc::PROTO_UDP,
- webrtc::PROTO_UDP, kTurnUdpIntAddr2);
+ auto turnport3 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP,
+ PROTO_UDP, kTurnUdpIntAddr2);
turnport3->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return turnport3->Candidates().size(); }, Eq(1U),
+ ASSERT_THAT(WaitUntil([&] { return turnport3->Candidates().size(); }, Eq(1U),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_NE(turnport3->Candidates()[0].foundation(),
turnport2->Candidates()[0].foundation());
// Start a TCP turn server, and check that two turn candidates have
// different foundations if their relay protocols are different.
TestTurnServer turn_server3(Thread::Current(), vss(), kTurnTcpIntAddr,
- kTurnUdpExtAddr, webrtc::PROTO_TCP);
- auto turnport4 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
- webrtc::PROTO_TCP, webrtc::PROTO_UDP);
+ kTurnUdpExtAddr, PROTO_TCP);
+ auto turnport4 =
+ CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_TCP, PROTO_UDP);
turnport4->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return turnport4->Candidates().size(); }, Eq(1U),
+ ASSERT_THAT(WaitUntil([&] { return turnport4->Candidates().size(); }, Eq(1U),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_NE(turnport2->Candidates()[0].foundation(),
turnport4->Candidates()[0].foundation());
}
@@ -3004,7 +2940,7 @@
// This test verifies the related addresses of different types of
// ICE candidates.
TEST_F(PortTest, TestCandidateRelatedAddress) {
- auto nat_server = CreateNatServer(kNatAddr1, webrtc::NAT_OPEN_CONE);
+ auto nat_server = CreateNatServer(kNatAddr1, NAT_OPEN_CONE);
auto udpport = CreateUdpPort(kLocalAddr1);
udpport->PrepareAddress();
// For UDPPort, related address will be empty.
@@ -3014,10 +2950,9 @@
// socket address.
auto stunport = CreateStunPort(kLocalAddr1, nat_socket_factory1());
stunport->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U),
+ ASSERT_THAT(WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Check STUN candidate address.
EXPECT_EQ(stunport->Candidates()[0].address().ipaddr(), kNatAddr1.ipaddr());
// Check STUN candidate related address.
@@ -3025,13 +2960,12 @@
stunport->GetLocalAddress());
// Verifying the related address for TURN candidate.
// For TURN related address must be equal to the mapped address.
- auto turnport = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
- webrtc::PROTO_UDP, webrtc::PROTO_UDP);
+ auto turnport =
+ CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
turnport->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return turnport->Candidates().size(); }, Eq(1U),
+ ASSERT_THAT(WaitUntil([&] { return turnport->Candidates().size(); }, Eq(1U),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
turnport->Candidates()[0].address().ipaddr());
EXPECT_EQ(kNatAddr1.ipaddr(),
@@ -3066,8 +3000,8 @@
// RFC 5245
// pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
Connection* lconn =
lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
#if defined(WEBRTC_WIN)
@@ -3076,8 +3010,8 @@
EXPECT_EQ(0x2001EE9FC003D0BLLU, lconn->priority());
#endif
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLING);
Connection* rconn =
rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
#if defined(WEBRTC_WIN)
@@ -3103,15 +3037,15 @@
rport->set_component(23);
rport->AddCandidateAddress(SocketAddress("10.1.1.100", 1234));
- EXPECT_EQ(0x7E001E85U + (webrtc::kMaxTurnServers << 8),
+ EXPECT_EQ(0x7E001E85U + (kMaxTurnServers << 8),
lport->Candidates()[0].priority());
- EXPECT_EQ(0x2001EE9U + (webrtc::kMaxTurnServers << 8),
+ EXPECT_EQ(0x2001EE9U + (kMaxTurnServers << 8),
rport->Candidates()[0].priority());
// RFC 5245
// pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ lport->SetIceRole(ICEROLE_CONTROLLING);
+ rport->SetIceRole(ICEROLE_CONTROLLED);
Connection* lconn =
lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
#if defined(WEBRTC_WIN)
@@ -3120,8 +3054,8 @@
EXPECT_EQ(0x2003EE9FC007D0BLLU, lconn->priority());
#endif
- lport->SetIceRole(webrtc::ICEROLE_CONTROLLED);
- rport->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport->SetIceRole(ICEROLE_CONTROLLED);
+ rport->SetIceRole(ICEROLE_CONTROLLING);
Connection* rconn =
rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
RTC_LOG(LS_ERROR) << "RCONN " << rconn->priority();
@@ -3141,9 +3075,9 @@
TEST_F(PortTest, TestWritableState) {
ScopedFakeClock clock;
auto port1 = CreateUdpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
auto port2 = CreateUdpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
// Set up channels.
TestChannel ch1(std::move(port1));
@@ -3152,25 +3086,24 @@
// Acquire addresses.
ch1.Start();
ch2.Start();
- ASSERT_THAT(webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
- ASSERT_THAT(webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
// Send a ping from src to dst.
ch1.CreateConnection(GetCandidate(ch2.port()));
ASSERT_TRUE(ch1.conn() != nullptr);
EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
// for TCP connect
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ch1.conn()->connected(); }, IsTrue(),
- {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
ch1.Ping();
SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
@@ -3183,11 +3116,11 @@
// Accept the connection to return the binding response, transition to
// writable, and allow data to be sent.
ch2.AcceptConnection(GetCandidate(ch1.port()));
- EXPECT_THAT(webrtc::WaitUntil([&] { return ch1.conn()->write_state(); },
- Eq(Connection::STATE_WRITABLE),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
EXPECT_EQ(data_size, ch1.conn()->Send(data, data_size, options));
// Ask the connection to update state as if enough time has passed to lose
@@ -3206,11 +3139,11 @@
// And now allow the other side to process the pings and send binding
// responses.
- EXPECT_THAT(webrtc::WaitUntil([&] { return ch1.conn()->write_state(); },
- Eq(Connection::STATE_WRITABLE),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
// Wait long enough for a full timeout (past however long we've already
// waited).
for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
@@ -3234,9 +3167,9 @@
TEST_F(PortTest, TestWritableStateWithConfiguredThreshold) {
ScopedFakeClock clock;
auto port1 = CreateUdpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
auto port2 = CreateUdpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
// Set up channels.
TestChannel ch1(std::move(port1));
@@ -3245,14 +3178,14 @@
// Acquire addresses.
ch1.Start();
ch2.Start();
- ASSERT_THAT(webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
- ASSERT_THAT(webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
+ ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
// Send a ping from src to dst.
ch1.CreateConnection(GetCandidate(ch2.port()));
@@ -3263,11 +3196,11 @@
// Accept the connection to return the binding response, transition to
// writable, and allow data to be sent.
ch2.AcceptConnection(GetCandidate(ch1.port()));
- EXPECT_THAT(webrtc::WaitUntil([&] { return ch1.conn()->write_state(); },
- Eq(Connection::STATE_WRITABLE),
- {.timeout = TimeDelta::Millis(kDefaultTimeout),
- .clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ IsRtcOk());
ch1.conn()->set_unwritable_timeout(1000);
ch1.conn()->set_unwritable_min_checks(3);
@@ -3297,9 +3230,9 @@
TEST_F(PortTest, TestTimeoutForNeverWritable) {
auto port1 = CreateUdpPort(kLocalAddr1);
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
auto port2 = CreateUdpPort(kLocalAddr2);
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
// Set up channels.
TestChannel ch1(std::move(port1));
@@ -3326,24 +3259,23 @@
// In this test `ch1` behaves like FULL mode client and we have created
// port which responds to the ping message just like LITE client.
TEST_F(PortTest, TestIceLiteConnectivity) {
- auto ice_full_port = CreateTestPort(
- kLocalAddr1, "lfrag", "lpass", webrtc::ICEROLE_CONTROLLING, kTiebreaker1);
+ auto ice_full_port = CreateTestPort(kLocalAddr1, "lfrag", "lpass",
+ ICEROLE_CONTROLLING, kTiebreaker1);
auto* ice_full_port_ptr = ice_full_port.get();
auto ice_lite_port = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
- webrtc::ICEROLE_CONTROLLED, kTiebreaker2);
+ ICEROLE_CONTROLLED, kTiebreaker2);
// Setup TestChannel. This behaves like FULL mode client.
TestChannel ch1(std::move(ice_full_port));
- ch1.SetIceMode(webrtc::ICEMODE_FULL);
+ ch1.SetIceMode(ICEMODE_FULL);
// Start gathering candidates.
ch1.Start();
ice_lite_port->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_FALSE(ice_lite_port->Candidates().empty());
ch1.CreateConnection(GetCandidate(ice_lite_port.get()));
@@ -3356,10 +3288,10 @@
// Verify stun ping is without USE_CANDIDATE_ATTR. Getting message directly
// from port.
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(),
- {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
+ IsRtcOk());
IceMessage* msg = ice_full_port_ptr->last_stun_msg();
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == nullptr);
@@ -3377,25 +3309,23 @@
SocketAddress(), std::nullopt));
// Verifying full mode connection becomes writable from the response.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1.conn()->write_state(); },
+ EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
Eq(Connection::STATE_WRITABLE),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return ch1.nominated(); }, IsTrue(),
+ IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return ch1.nominated(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Clear existing stun messsages. Otherwise we will process old stun
// message right after we send ping.
ice_full_port_ptr->Reset();
// Send ping. This must have USE_CANDIDATE_ATTR.
ch1.Ping();
- ASSERT_THAT(webrtc::WaitUntil(
- [&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(),
- {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ ASSERT_THAT(
+ WaitUntil([&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(),
+ {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
+ IsRtcOk());
msg = ice_full_port_ptr->last_stun_msg();
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != nullptr);
ch1.Stop();
@@ -3453,24 +3383,23 @@
<< " enable:" << trials.enable_goog_ping;
auto port1_unique = CreateTestPort(kLocalAddr1, "lfrag", "lpass",
- webrtc::ICEROLE_CONTROLLING, kTiebreaker1);
+ ICEROLE_CONTROLLING, kTiebreaker1);
auto* port1 = port1_unique.get();
- auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
- webrtc::ICEROLE_CONTROLLED, kTiebreaker2);
+ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
+ kTiebreaker2);
TestChannel ch1(std::move(port1_unique));
// Block usage of STUN_ATTR_USE_CANDIDATE so that
// ch1.conn() will sent GOOG_PING_REQUEST directly.
// This only makes test a bit shorter...
- ch1.SetIceMode(webrtc::ICEMODE_LITE);
+ ch1.SetIceMode(ICEMODE_LITE);
// Start gathering candidates.
ch1.Start();
port2->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3481,10 +3410,9 @@
// Send ping.
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* request1 = port1->last_stun_msg();
ASSERT_EQ(trials.enable_goog_ping,
@@ -3512,10 +3440,9 @@
port2->Reset();
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* request2 = port1->last_stun_msg();
// It should be a GOOG_PING if both of these are TRUE
@@ -3552,24 +3479,23 @@
trials.enable_goog_ping = true;
auto port1_unique = CreateTestPort(kLocalAddr1, "lfrag", "lpass",
- webrtc::ICEROLE_CONTROLLING, kTiebreaker1);
+ ICEROLE_CONTROLLING, kTiebreaker1);
auto* port1 = port1_unique.get();
- auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
- webrtc::ICEROLE_CONTROLLED, kTiebreaker2);
+ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
+ kTiebreaker2);
TestChannel ch1(std::move(port1_unique));
// Block usage of STUN_ATTR_USE_CANDIDATE so that
// ch1.conn() will sent GOOG_PING_REQUEST directly.
// This only makes test a bit shorter...
- ch1.SetIceMode(webrtc::ICEMODE_LITE);
+ ch1.SetIceMode(ICEMODE_LITE);
// Start gathering candidates.
ch1.Start();
port2->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3580,10 +3506,9 @@
// Send ping.
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* request1 = port1->last_stun_msg();
ASSERT_TRUE(GetSupportedGoogPingVersion(request1) &&
@@ -3627,24 +3552,23 @@
trials.enable_goog_ping = true;
auto port1_unique = CreateTestPort(kLocalAddr1, "lfrag", "lpass",
- webrtc::ICEROLE_CONTROLLING, kTiebreaker1);
+ ICEROLE_CONTROLLING, kTiebreaker1);
auto* port1 = port1_unique.get();
- auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
- webrtc::ICEROLE_CONTROLLED, kTiebreaker2);
+ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
+ kTiebreaker2);
TestChannel ch1(std::move(port1_unique));
// Block usage of STUN_ATTR_USE_CANDIDATE so that
// ch1.conn() will sent GOOG_PING_REQUEST directly.
// This only makes test a bit shorter...
- ch1.SetIceMode(webrtc::ICEMODE_LITE);
+ ch1.SetIceMode(ICEMODE_LITE);
// Start gathering candidates.
ch1.Start();
port2->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3655,10 +3579,9 @@
// Send ping.
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* request1 = port1->last_stun_msg();
ASSERT_TRUE(GetSupportedGoogPingVersion(request1) &&
@@ -3707,10 +3630,9 @@
port2->Reset();
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// This should now be a STUN_BINDING...without a kGoogPingVersion
const IceMessage* request2 = port1->last_stun_msg();
@@ -3735,24 +3657,23 @@
trials.enable_goog_ping = true;
auto port1_unique = CreateTestPort(kLocalAddr1, "lfrag", "lpass",
- webrtc::ICEROLE_CONTROLLING, kTiebreaker1);
+ ICEROLE_CONTROLLING, kTiebreaker1);
auto* port1 = port1_unique.get();
- auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
- webrtc::ICEROLE_CONTROLLED, kTiebreaker2);
+ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
+ kTiebreaker2);
TestChannel ch1(std::move(port1_unique));
// Block usage of STUN_ATTR_USE_CANDIDATE so that
// ch1.conn() will sent GOOG_PING_REQUEST directly.
// This only makes test a bit shorter...
- ch1.SetIceMode(webrtc::ICEMODE_LITE);
+ ch1.SetIceMode(ICEMODE_LITE);
// Start gathering candidates.
ch1.Start();
port2->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3763,10 +3684,9 @@
// Send ping.
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* msg = port1->last_stun_msg();
auto* con =
port2->CreateConnection(port1->Candidates()[0], Port::ORIGIN_MESSAGE);
@@ -3788,10 +3708,9 @@
port2->Reset();
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* msg2 = port1->last_stun_msg();
// It should be a GOOG_PING if both of these are TRUE
@@ -3812,10 +3731,9 @@
ch1.conn()->set_use_candidate_attr(!ch1.conn()->use_candidate_attr());
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* msg3 = port1->last_stun_msg();
// It should be a STUN_BINDING_REQUEST
@@ -3831,24 +3749,23 @@
trials.enable_goog_ping = true;
auto port1_unique = CreateTestPort(kLocalAddr1, "lfrag", "lpass",
- webrtc::ICEROLE_CONTROLLING, kTiebreaker1);
+ ICEROLE_CONTROLLING, kTiebreaker1);
auto* port1 = port1_unique.get();
- auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
- webrtc::ICEROLE_CONTROLLED, kTiebreaker2);
+ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
+ kTiebreaker2);
TestChannel ch1(std::move(port1_unique));
// Block usage of STUN_ATTR_USE_CANDIDATE so that
// ch1.conn() will sent GOOG_PING_REQUEST directly.
// This only makes test a bit shorter...
- ch1.SetIceMode(webrtc::ICEMODE_LITE);
+ ch1.SetIceMode(ICEMODE_LITE);
// Start gathering candidates.
ch1.Start();
port2->PrepareAddress();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3859,10 +3776,9 @@
// Send ping.
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* msg = port1->last_stun_msg();
auto* con =
port2->CreateConnection(port1->Candidates()[0], Port::ORIGIN_MESSAGE);
@@ -3884,10 +3800,9 @@
port2->Reset();
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* msg2 = port1->last_stun_msg();
// It should be a GOOG_PING.
@@ -3915,10 +3830,9 @@
port2->Reset();
ch1.Ping();
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+ ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
const IceMessage* msg3 = port1->last_stun_msg();
// It should be a STUN_BINDING_REQUEST
@@ -3936,13 +3850,13 @@
auto port1 = CreateUdpPort(kLocalAddr1);
ConnectToSignalDestroyed(port1.get());
port1->set_timeout_delay(timeout_delay); // milliseconds
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
port1->SetIceTiebreaker(kTiebreaker1);
auto port2 = CreateUdpPort(kLocalAddr2);
ConnectToSignalDestroyed(port2.get());
port2->set_timeout_delay(timeout_delay); // milliseconds
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
port2->SetIceTiebreaker(kTiebreaker2);
// Set up channels and ensure both ports will be deleted.
@@ -3953,9 +3867,9 @@
StartConnectAndStopChannels(&ch1, &ch2);
// After the connection is destroyed, the port will be destroyed because
// none of them is marked as "keep alive until pruned.
- EXPECT_THAT(webrtc::WaitUntil([&] { return ports_destroyed(); }, Eq(2),
- {.clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ports_destroyed(); }, Eq(2), {.clock = &clock}),
+ IsRtcOk());
}
// Test that if after all connection are destroyed, new connections are created
@@ -3967,14 +3881,14 @@
auto port1 = CreateUdpPort(kLocalAddr1);
ConnectToSignalDestroyed(port1.get());
port1->set_timeout_delay(timeout_delay); // milliseconds
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
port1->SetIceTiebreaker(kTiebreaker1);
auto port2 = CreateUdpPort(kLocalAddr2);
ConnectToSignalDestroyed(port2.get());
port2->set_timeout_delay(timeout_delay); // milliseconds
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
port2->SetIceTiebreaker(kTiebreaker2);
// Set up channels and ensure both ports will be deleted.
@@ -3996,9 +3910,9 @@
EXPECT_EQ(0, ports_destroyed());
// The ports on both sides should be destroyed after timeout.
- EXPECT_THAT(webrtc::WaitUntil([&] { return ports_destroyed(); }, Eq(2),
- {.clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ports_destroyed(); }, Eq(2), {.clock = &clock}),
+ IsRtcOk());
}
// This test case verifies that neither the controlling port nor the controlled
@@ -4010,13 +3924,13 @@
auto port1 = CreateUdpPort(kLocalAddr1);
ConnectToSignalDestroyed(port1.get());
port1->set_timeout_delay(timeout_delay); // milliseconds
- port1->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ port1->SetIceRole(ICEROLE_CONTROLLING);
port1->SetIceTiebreaker(kTiebreaker1);
auto port2 = CreateUdpPort(kLocalAddr2);
ConnectToSignalDestroyed(port2.get());
port2->set_timeout_delay(timeout_delay); // milliseconds
- port2->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ port2->SetIceRole(ICEROLE_CONTROLLED);
port2->SetIceTiebreaker(kTiebreaker2);
// The connection must not be destroyed before a connection is attempted.
EXPECT_EQ(0, ports_destroyed());
@@ -4039,29 +3953,29 @@
ch1.port()->Prune();
ch2.port()->Prune();
// The ports on both sides should be destroyed after timeout.
- EXPECT_THAT(webrtc::WaitUntil([&] { return ports_destroyed(); }, Eq(2),
- {.clock = &clock}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ports_destroyed(); }, Eq(2), {.clock = &clock}),
+ IsRtcOk());
}
TEST_F(PortTest, TestSupportsProtocol) {
auto udp_port = CreateUdpPort(kLocalAddr1);
- EXPECT_TRUE(udp_port->SupportsProtocol(webrtc::UDP_PROTOCOL_NAME));
- EXPECT_FALSE(udp_port->SupportsProtocol(webrtc::TCP_PROTOCOL_NAME));
+ EXPECT_TRUE(udp_port->SupportsProtocol(UDP_PROTOCOL_NAME));
+ EXPECT_FALSE(udp_port->SupportsProtocol(TCP_PROTOCOL_NAME));
auto stun_port = CreateStunPort(kLocalAddr1, nat_socket_factory1());
- EXPECT_TRUE(stun_port->SupportsProtocol(webrtc::UDP_PROTOCOL_NAME));
- EXPECT_FALSE(stun_port->SupportsProtocol(webrtc::TCP_PROTOCOL_NAME));
+ EXPECT_TRUE(stun_port->SupportsProtocol(UDP_PROTOCOL_NAME));
+ EXPECT_FALSE(stun_port->SupportsProtocol(TCP_PROTOCOL_NAME));
auto tcp_port = CreateTcpPort(kLocalAddr1);
- EXPECT_TRUE(tcp_port->SupportsProtocol(webrtc::TCP_PROTOCOL_NAME));
- EXPECT_TRUE(tcp_port->SupportsProtocol(webrtc::SSLTCP_PROTOCOL_NAME));
- EXPECT_FALSE(tcp_port->SupportsProtocol(webrtc::UDP_PROTOCOL_NAME));
+ EXPECT_TRUE(tcp_port->SupportsProtocol(TCP_PROTOCOL_NAME));
+ EXPECT_TRUE(tcp_port->SupportsProtocol(SSLTCP_PROTOCOL_NAME));
+ EXPECT_FALSE(tcp_port->SupportsProtocol(UDP_PROTOCOL_NAME));
- auto turn_port = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
- webrtc::PROTO_UDP, webrtc::PROTO_UDP);
- EXPECT_TRUE(turn_port->SupportsProtocol(webrtc::UDP_PROTOCOL_NAME));
- EXPECT_FALSE(turn_port->SupportsProtocol(webrtc::TCP_PROTOCOL_NAME));
+ auto turn_port =
+ CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
+ EXPECT_TRUE(turn_port->SupportsProtocol(UDP_PROTOCOL_NAME));
+ EXPECT_FALSE(turn_port->SupportsProtocol(TCP_PROTOCOL_NAME));
}
// Test that SetIceParameters updates the component, ufrag and password
@@ -4116,9 +4030,9 @@
ConnectionTest() {
lport_ = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
rport_ = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
- lport_->SetIceRole(webrtc::ICEROLE_CONTROLLING);
+ lport_->SetIceRole(ICEROLE_CONTROLLING);
lport_->SetIceTiebreaker(kTiebreaker1);
- rport_->SetIceRole(webrtc::ICEROLE_CONTROLLED);
+ rport_->SetIceRole(ICEROLE_CONTROLLED);
rport_->SetIceTiebreaker(kTiebreaker2);
lport_->PrepareAddress();
@@ -4130,7 +4044,7 @@
Connection* CreateConnection(IceRole role) {
Connection* conn;
- if (role == webrtc::ICEROLE_CONTROLLING) {
+ if (role == ICEROLE_CONTROLLING) {
conn = lport_->CreateConnection(rport_->Candidates()[0],
Port::ORIGIN_MESSAGE);
} else {
@@ -4150,20 +4064,18 @@
lconn->PortForTest() == lport_.get() ? lport_.get() : rport_.get();
TestPort* rport =
rconn->PortForTest() == rport_.get() ? rport_.get() : lport_.get();
- lconn->Ping(webrtc::TimeMillis());
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
+ lconn->Ping(TimeMillis());
+ ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(lport->last_stun_buf().size(), 0u);
rconn->OnReadPacket(ReceivedIpPacket(lport->last_stun_buf(),
SocketAddress(), std::nullopt));
clock_.AdvanceTime(TimeDelta::Millis(ms));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
+ ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(rport->last_stun_buf().size(), 0u);
reply->SetData(rport->last_stun_buf());
}
@@ -4184,8 +4096,8 @@
};
TEST_F(ConnectionTest, ConnectionForgetLearnedState) {
- Connection* lconn = CreateConnection(webrtc::ICEROLE_CONTROLLING);
- Connection* rconn = CreateConnection(webrtc::ICEROLE_CONTROLLED);
+ Connection* lconn = CreateConnection(ICEROLE_CONTROLLING);
+ Connection* rconn = CreateConnection(ICEROLE_CONTROLLED);
EXPECT_FALSE(lconn->writable());
EXPECT_FALSE(lconn->receiving());
@@ -4219,8 +4131,8 @@
}
TEST_F(ConnectionTest, ConnectionForgetLearnedStateDiscardsPendingPings) {
- Connection* lconn = CreateConnection(webrtc::ICEROLE_CONTROLLING);
- Connection* rconn = CreateConnection(webrtc::ICEROLE_CONTROLLED);
+ Connection* lconn = CreateConnection(ICEROLE_CONTROLLING);
+ Connection* rconn = CreateConnection(ICEROLE_CONTROLLED);
SendPingAndReceiveResponse(lconn, rconn, 10);
@@ -4249,8 +4161,8 @@
}
TEST_F(ConnectionTest, ConnectionForgetLearnedStateDoesNotTriggerStateChange) {
- Connection* lconn = CreateConnection(webrtc::ICEROLE_CONTROLLING);
- Connection* rconn = CreateConnection(webrtc::ICEROLE_CONTROLLED);
+ Connection* lconn = CreateConnection(ICEROLE_CONTROLLING);
+ Connection* rconn = CreateConnection(ICEROLE_CONTROLLED);
EXPECT_EQ(num_state_changes_, 0);
SendPingAndReceiveResponse(lconn, rconn, 10);
@@ -4270,8 +4182,8 @@
// Sending a delta and getting a delta ack in response.
TEST_F(ConnectionTest, SendReceiveGoogDelta) {
constexpr int64_t ms = 10;
- Connection* lconn = CreateConnection(webrtc::ICEROLE_CONTROLLING);
- Connection* rconn = CreateConnection(webrtc::ICEROLE_CONTROLLED);
+ Connection* lconn = CreateConnection(ICEROLE_CONTROLLING);
+ Connection* rconn = CreateConnection(ICEROLE_CONTROLLED);
std::unique_ptr<StunByteStringAttribute> delta =
absl::WrapUnique(new StunByteStringAttribute(STUN_ATTR_GOOG_DELTA));
@@ -4285,9 +4197,9 @@
lconn->SetStunDictConsumer(
// DeltaReceived
[](const StunByteStringAttribute* delta)
- -> std::unique_ptr<webrtc::StunAttribute> { return nullptr; },
+ -> std::unique_ptr<StunAttribute> { return nullptr; },
// DeltaAckReceived
- [&](webrtc::RTCErrorOr<const StunUInt64Attribute*> error_or_ack) {
+ [&](RTCErrorOr<const StunUInt64Attribute*> error_or_ack) {
received_goog_delta_ack = true;
EXPECT_TRUE(error_or_ack.ok());
EXPECT_EQ(error_or_ack.value()->value(), 133ull);
@@ -4302,24 +4214,21 @@
return std::move(delta_ack);
},
// DeltaAckReceived
- [](webrtc::RTCErrorOr<const webrtc::StunUInt64Attribute*> error_or__ack) {
- });
+ [](RTCErrorOr<const StunUInt64Attribute*> error_or__ack) {});
- lconn->Ping(webrtc::TimeMillis(), std::move(delta));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport_->last_stun_msg(); }, IsTrue(),
+ lconn->Ping(TimeMillis(), std::move(delta));
+ ASSERT_THAT(WaitUntil([&] { return lport_->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(lport_->last_stun_buf().size(), 0u);
rconn->OnReadPacket(
ReceivedIpPacket(lport_->last_stun_buf(), SocketAddress(), std::nullopt));
EXPECT_TRUE(received_goog_delta);
clock_.AdvanceTime(TimeDelta::Millis(ms));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport_->last_stun_msg(); }, IsTrue(),
+ ASSERT_THAT(WaitUntil([&] { return rport_->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(rport_->last_stun_buf().size(), 0u);
lconn->OnReadPacket(
ReceivedIpPacket(rport_->last_stun_buf(), SocketAddress(), std::nullopt));
@@ -4331,8 +4240,8 @@
// a delta ack in reply gives an error callback.
TEST_F(ConnectionTest, SendGoogDeltaNoReply) {
constexpr int64_t ms = 10;
- Connection* lconn = CreateConnection(webrtc::ICEROLE_CONTROLLING);
- Connection* rconn = CreateConnection(webrtc::ICEROLE_CONTROLLED);
+ Connection* lconn = CreateConnection(ICEROLE_CONTROLLING);
+ Connection* rconn = CreateConnection(ICEROLE_CONTROLLED);
std::unique_ptr<StunByteStringAttribute> delta =
absl::WrapUnique(new StunByteStringAttribute(STUN_ATTR_GOOG_DELTA));
@@ -4342,27 +4251,25 @@
lconn->SetStunDictConsumer(
// DeltaReceived
[](const StunByteStringAttribute* delta)
- -> std::unique_ptr<webrtc::StunAttribute> { return nullptr; },
+ -> std::unique_ptr<StunAttribute> { return nullptr; },
// DeltaAckReceived
- [&](webrtc::RTCErrorOr<const StunUInt64Attribute*> error_or_ack) {
+ [&](RTCErrorOr<const StunUInt64Attribute*> error_or_ack) {
received_goog_delta_ack_error = true;
EXPECT_FALSE(error_or_ack.ok());
});
- lconn->Ping(webrtc::TimeMillis(), std::move(delta));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return lport_->last_stun_msg(); }, IsTrue(),
+ lconn->Ping(TimeMillis(), std::move(delta));
+ ASSERT_THAT(WaitUntil([&] { return lport_->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(lport_->last_stun_buf().size(), 0u);
rconn->OnReadPacket(
ReceivedIpPacket(lport_->last_stun_buf(), SocketAddress(), std::nullopt));
clock_.AdvanceTime(TimeDelta::Millis(ms));
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return rport_->last_stun_msg(); }, IsTrue(),
+ ASSERT_THAT(WaitUntil([&] { return rport_->last_stun_msg(); }, IsTrue(),
{.timeout = TimeDelta::Millis(kDefaultTimeout)}),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(rport_->last_stun_buf().size(), 0u);
lconn->OnReadPacket(
ReceivedIpPacket(rport_->last_stun_buf(), SocketAddress(), std::nullopt));
diff --git a/p2p/base/pseudo_tcp.cc b/p2p/base/pseudo_tcp.cc
index 8564afe..a3e336e 100644
--- a/p2p/base/pseudo_tcp.cc
+++ b/p2p/base/pseudo_tcp.cc
@@ -203,7 +203,7 @@
uint32_t PseudoTcp::Now() {
#if 0 // Use this to synchronize timers with logging timestamps (easier debug)
- return static_cast<uint32_t>(webrtc::TimeSince(StartTime()));
+ return static_cast<uint32_t>(TimeSince(StartTime()));
#else
return Time32();
#endif
@@ -625,10 +625,9 @@
#if PSEUDO_KEEPALIVE
if (m_state == TCP_ESTABLISHED) {
nTimeout = std::min<int32_t>(
- nTimeout,
- webrtc::TimeDiff32(
- m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3 / 2 : IDLE_PING),
- now));
+ nTimeout, TimeDiff32(m_lasttraffic +
+ (m_bOutgoing ? IDLE_PING * 3 / 2 : IDLE_PING),
+ now));
}
#endif // PSEUDO_KEEPALIVE
return true;
diff --git a/p2p/base/stun_port.h b/p2p/base/stun_port.h
index 612ee0f..c04e9a1 100644
--- a/p2p/base/stun_port.h
+++ b/p2p/base/stun_port.h
@@ -162,7 +162,7 @@
private:
// A helper class which can be called repeatedly to resolve multiple
- // addresses, as opposed to webrtc::AsyncDnsResolverInterface, which can only
+ // addresses, as opposed to AsyncDnsResolverInterface, which can only
// resolve one address per instance.
class AddressResolver {
public:
@@ -212,7 +212,7 @@
// Sends STUN requests to the server.
void OnSendPacket(const void* data, size_t size, StunRequest* req);
- // TODO(mallinaht): Move this up to webrtc::Port when SignalAddressReady is
+ // TODO(mallinaht): Move this up to Port when SignalAddressReady is
// changed to SignalPortReady.
void MaybeSetPortCompleteOrError();
@@ -222,7 +222,7 @@
// requests indefinitely to keep the NAT binding alive. Otherwise, stop
// sending STUN binding requests after HIGH_COST_PORT_KEEPALIVE_LIFETIME.
int GetStunKeepaliveLifetime() {
- return (network_cost() >= webrtc::kNetworkCostHigh)
+ return (network_cost() >= kNetworkCostHigh)
? HIGH_COST_PORT_KEEPALIVE_LIFETIME
: INFINITE_LIFETIME;
}
diff --git a/p2p/base/stun_request.h b/p2p/base/stun_request.h
index 9c10e40..22a252e 100644
--- a/p2p/base/stun_request.h
+++ b/p2p/base/stun_request.h
@@ -42,8 +42,7 @@
public:
StunRequestManager(
TaskQueueBase* thread,
- std::function<void(const void*, size_t, webrtc::StunRequest*)>
- send_packet);
+ std::function<void(const void*, size_t, StunRequest*)> send_packet);
~StunRequestManager();
// Starts sending the given request (perhaps after a delay).
@@ -85,8 +84,7 @@
TaskQueueBase* const thread_;
RequestMap requests_ RTC_GUARDED_BY(thread_);
- const std::function<void(const void*, size_t, webrtc::StunRequest*)>
- send_packet_;
+ const std::function<void(const void*, size_t, StunRequest*)> send_packet_;
};
// Represents an individual request to be sent. The STUN message can either be
diff --git a/p2p/base/tcp_port.h b/p2p/base/tcp_port.h
index 3f82c9d..6ea517a 100644
--- a/p2p/base/tcp_port.h
+++ b/p2p/base/tcp_port.h
@@ -174,7 +174,7 @@
void OnDestroyed(Connection* c);
TCPPort* tcp_port() {
- RTC_DCHECK_EQ(port()->GetProtocol(), webrtc::PROTO_TCP);
+ RTC_DCHECK_EQ(port()->GetProtocol(), PROTO_TCP);
return static_cast<TCPPort*>(port());
}
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index dc20bdc..2e96fe3 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -1188,7 +1188,7 @@
}
// Regression test for crbug.com/webrtc/8972, caused by buggy comparison
-// between webrtc::IPAddress and webrtc::InterfaceAddress.
+// between IPAddress and InterfaceAddress.
TEST_F(TurnPortTest, TCPPortNotDiscardedIfBoundToTemporaryIP) {
networks_.emplace_back("unittest", "unittest", kLocalIPv6Addr.ipaddr(), 32);
networks_.back().AddIP(
@@ -2147,10 +2147,10 @@
TEST_F(TurnPortWithMockDnsResolverTest, TestHostnameResolved) {
CreateTurnPort(kTurnUsername, kTurnPassword, kTurnPortValidHostnameProtoAddr);
SetDnsResolverExpectations(
- [](webrtc::MockAsyncDnsResolver* resolver,
- webrtc::MockAsyncDnsResolverResult* resolver_result) {
+ [](MockAsyncDnsResolver* resolver,
+ MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kTurnValidAddr, /*family=*/AF_INET, _))
- .WillOnce([](const webrtc::SocketAddress& addr, int family,
+ .WillOnce([](const SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
@@ -2168,10 +2168,10 @@
CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
kTurnPortValidHostnameProtoAddr);
SetDnsResolverExpectations(
- [](webrtc::MockAsyncDnsResolver* resolver,
- webrtc::MockAsyncDnsResolverResult* resolver_result) {
+ [](MockAsyncDnsResolver* resolver,
+ MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kTurnValidAddr, /*family=*/AF_INET6, _))
- .WillOnce([](const webrtc::SocketAddress& addr, int family,
+ .WillOnce([](const SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
diff --git a/p2p/client/basic_port_allocator.cc b/p2p/client/basic_port_allocator.cc
index fa12319..cf370d9 100644
--- a/p2p/client/basic_port_allocator.cc
+++ b/p2p/client/basic_port_allocator.cc
@@ -704,9 +704,7 @@
// Filter out link-local networks if needed.
if (flags() & PORTALLOCATOR_DISABLE_LINK_LOCAL_NETWORKS) {
NetworkFilter link_local_filter(
- [](const webrtc::Network* network) {
- return IPIsLinkLocal(network->prefix());
- },
+ [](const Network* network) { return IPIsLinkLocal(network->prefix()); },
"link-local");
FilterNetworks(&networks, link_local_filter);
}
diff --git a/p2p/client/basic_port_allocator.h b/p2p/client/basic_port_allocator.h
index 3af4d1b..01d118a 100644
--- a/p2p/client/basic_port_allocator.h
+++ b/p2p/client/basic_port_allocator.h
@@ -103,7 +103,7 @@
NetworkManager* network_manager_;
// Always externally-owned pointer to a socket factory.
PacketSocketFactory* const socket_factory_;
- int network_ignore_mask_ = webrtc::kDefaultNetworkIgnoreMask;
+ int network_ignore_mask_ = kDefaultNetworkIgnoreMask;
AlwaysValidPointer<RelayPortFactoryInterface, TurnPortFactory>
relay_port_factory_;
@@ -143,7 +143,7 @@
// the type of candidates to gather and the candidate filter only controls the
// signaling of candidates. As a result, with the candidate filter changed
// alone, all newly allowed candidates for signaling should already be
- // gathered by the respective webrtc::Port.
+ // gathered by the respective Port.
void SetCandidateFilter(uint32_t filter) override;
void StartGettingPorts() override;
void StopGettingPorts() override;
@@ -151,7 +151,7 @@
bool IsGettingPorts() override;
bool IsCleared() const override;
bool IsStopped() const override;
- // These will all be webrtc::Ports.
+ // These will all be Ports.
std::vector<PortInterface*> ReadyPorts() const override;
std::vector<Candidate> ReadyCandidates() const override;
bool CandidatesAllocationDone() const override;
@@ -286,7 +286,7 @@
std::vector<AllocationSequence*> sequences_;
std::vector<PortData> ports_;
std::vector<IceCandidateErrorEvent> candidate_error_events_;
- uint32_t candidate_filter_ = webrtc::CF_ALL;
+ uint32_t candidate_filter_ = CF_ALL;
// Policy on how to prune turn ports, taken from the port allocator.
PortPrunePolicy turn_port_prune_policy_;
SessionState state_ = SessionState::CLEARED;
diff --git a/p2p/client/basic_port_allocator_unittest.cc b/p2p/client/basic_port_allocator_unittest.cc
index c022efe..c8e5464 100644
--- a/p2p/client/basic_port_allocator_unittest.cc
+++ b/p2p/client/basic_port_allocator_unittest.cc
@@ -1597,7 +1597,7 @@
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "tcp", kClientAddr));
// We wait at least for a full STUN timeout, which
- // webrtc::STUN_TOTAL_TIMEOUT seconds.
+ // STUN_TOTAL_TIMEOUT seconds.
EXPECT_THAT(WaitUntil([&] { return candidate_allocation_done_; }, IsTrue(),
{.timeout = TimeDelta::Millis(STUN_TOTAL_TIMEOUT),
.clock = &fake_clock}),
@@ -2524,7 +2524,7 @@
.clock = &fake_clock}),
IsRtcOk());
EXPECT_TRUE(candidates_.back().is_local());
- // We use a shared socket and webrtc::UDPPort handles the srflx candidate.
+ // We use a shared socket and UDPPort handles the srflx candidate.
EXPECT_EQ(2u, ports_.size());
}
diff --git a/p2p/dtls/dtls_ice_integrationtest.cc b/p2p/dtls/dtls_ice_integrationtest.cc
index 240c147..4f692b9 100644
--- a/p2p/dtls/dtls_ice_integrationtest.cc
+++ b/p2p/dtls/dtls_ice_integrationtest.cc
@@ -63,17 +63,17 @@
class DtlsIceIntegrationTest : public ::testing::TestWithParam<std::tuple<
/* 0 client_piggyback= */ bool,
/* 1 server_piggyback= */ bool,
- webrtc::SSLProtocolVersion,
+ SSLProtocolVersion,
/* 3 client_dtls_is_ice_controlling= */ bool,
/* 4 client_pqc= */ bool,
/* 5 server_pqc= */ bool>>,
public sigslot::has_slots<> {
public:
- void CandidateC2S(webrtc::IceTransportInternal*, const webrtc::Candidate& c) {
+ void CandidateC2S(IceTransportInternal*, const Candidate& c) {
server_thread()->PostTask(
[this, c = c]() { server_.ice->AddRemoteCandidate(c); });
}
- void CandidateS2C(webrtc::IceTransportInternal*, const webrtc::Candidate& c) {
+ void CandidateS2C(IceTransportInternal*, const Candidate& c) {
client_thread()->PostTask(
[this, c = c]() { client_.ice->AddRemoteCandidate(c); });
}
@@ -86,17 +86,17 @@
dtls_stun_piggyback(dtls_in_stun),
pqc(pqc_) {}
- webrtc::EmulatedNetworkManagerInterface* emulated_network_manager = nullptr;
- std::unique_ptr<webrtc::NetworkManager> network_manager;
- std::unique_ptr<webrtc::BasicPacketSocketFactory> packet_socket_factory;
- std::unique_ptr<webrtc::PortAllocator> allocator;
- std::unique_ptr<webrtc::IceTransportInternal> ice;
+ EmulatedNetworkManagerInterface* emulated_network_manager = nullptr;
+ std::unique_ptr<NetworkManager> network_manager;
+ std::unique_ptr<BasicPacketSocketFactory> packet_socket_factory;
+ std::unique_ptr<PortAllocator> allocator;
+ std::unique_ptr<IceTransportInternal> ice;
std::unique_ptr<DtlsTransportInternalImpl> dtls;
// SetRemoteFingerprintFromCert does not actually set the fingerprint,
// but only store it for setting later.
bool store_but_dont_set_remote_fingerprint = false;
- std::unique_ptr<webrtc::SSLFingerprint> remote_fingerprint;
+ std::unique_ptr<SSLFingerprint> remote_fingerprint;
Environment env;
bool dtls_stun_piggyback;
@@ -105,14 +105,13 @@
protected:
DtlsIceIntegrationTest()
- : ss_(std::make_unique<webrtc::VirtualSocketServer>()),
- socket_factory_(
- std::make_unique<webrtc::BasicPacketSocketFactory>(ss_.get())),
+ : ss_(std::make_unique<VirtualSocketServer>()),
+ socket_factory_(std::make_unique<BasicPacketSocketFactory>(ss_.get())),
client_(std::get<0>(GetParam()),
- std::get<2>(GetParam()) == webrtc::SSL_PROTOCOL_DTLS_13 &&
+ std::get<2>(GetParam()) == SSL_PROTOCOL_DTLS_13 &&
std::get<4>(GetParam())),
server_(std::get<1>(GetParam()),
- std::get<2>(GetParam()) == webrtc::SSL_PROTOCOL_DTLS_13 &&
+ std::get<2>(GetParam()) == SSL_PROTOCOL_DTLS_13 &&
std::get<5>(GetParam())),
client_ice_parameters_("c_ufrag",
"c_icepwd_something_something",
@@ -122,11 +121,11 @@
false) {}
void ConfigureEmulatedNetwork() {
- network_emulation_manager_ = webrtc::CreateNetworkEmulationManager(
- {.time_mode = webrtc::TimeMode::kSimulated});
+ network_emulation_manager_ =
+ CreateNetworkEmulationManager({.time_mode = TimeMode::kSimulated});
BuiltInNetworkBehaviorConfig networkBehavior;
- networkBehavior.link_capacity = webrtc::DataRate::KilobitsPerSec(220);
+ networkBehavior.link_capacity = DataRate::KilobitsPerSec(220);
// TODO (webrtc:383141571) : Investigate why this testcase fails for
// DTLS 1.3 delay if networkBehavior.queue_delay_ms = 100ms.
// - unless both peers support dtls in stun, in which case it passes.
@@ -142,31 +141,29 @@
server_.emulated_network_manager = pair.second;
}
- void SetupEndpoint(
- Endpoint& ep,
- bool client,
- const scoped_refptr<webrtc::RTCCertificate> client_certificate,
- const scoped_refptr<webrtc::RTCCertificate> server_certificate) {
+ void SetupEndpoint(Endpoint& ep,
+ bool client,
+ const scoped_refptr<RTCCertificate> client_certificate,
+ const scoped_refptr<RTCCertificate> server_certificate) {
thread(ep)->BlockingCall([&]() {
if (!network_manager_) {
network_manager_ =
std::make_unique<FakeNetworkManager>(Thread::Current());
}
if (network_emulation_manager_ == nullptr) {
- ep.allocator = std::make_unique<webrtc::BasicPortAllocator>(
+ ep.allocator = std::make_unique<BasicPortAllocator>(
ep.env, network_manager_.get(), socket_factory_.get());
} else {
ep.network_manager =
ep.emulated_network_manager->ReleaseNetworkManager();
- ep.packet_socket_factory =
- std::make_unique<webrtc::BasicPacketSocketFactory>(
- ep.emulated_network_manager->socket_factory());
- ep.allocator = std::make_unique<webrtc::BasicPortAllocator>(
+ ep.packet_socket_factory = std::make_unique<BasicPacketSocketFactory>(
+ ep.emulated_network_manager->socket_factory());
+ ep.allocator = std::make_unique<BasicPortAllocator>(
ep.env, ep.network_manager.get(), ep.packet_socket_factory.get());
}
ep.allocator->set_flags(ep.allocator->flags() |
- webrtc::PORTALLOCATOR_DISABLE_TCP);
- ep.ice = std::make_unique<webrtc::P2PTransportChannel>(
+ PORTALLOCATOR_DISABLE_TCP);
+ ep.ice = std::make_unique<P2PTransportChannel>(
client ? "client_transport" : "server_transport", 0,
ep.allocator.get(), &ep.env.field_trials());
CryptoOptions crypto_options;
@@ -181,8 +178,8 @@
// Enable(or disable) the dtls_in_stun parameter before
// DTLS is negotiated.
- webrtc::IceConfig config;
- config.continual_gathering_policy = webrtc::GATHER_CONTINUALLY;
+ IceConfig config;
+ config.continual_gathering_policy = GATHER_CONTINUALLY;
config.dtls_handshake_in_stun = ep.dtls_stun_piggyback;
ep.ice->SetIceConfig(config);
@@ -192,13 +189,11 @@
ep.ice->SetRemoteIceParameters(client ? server_ice_parameters_
: client_ice_parameters_);
if (client) {
- ep.ice->SetIceRole(std::get<3>(GetParam())
- ? webrtc::ICEROLE_CONTROLLED
- : webrtc::ICEROLE_CONTROLLING);
+ ep.ice->SetIceRole(std::get<3>(GetParam()) ? ICEROLE_CONTROLLED
+ : ICEROLE_CONTROLLING);
} else {
- ep.ice->SetIceRole(std::get<3>(GetParam())
- ? webrtc::ICEROLE_CONTROLLING
- : webrtc::ICEROLE_CONTROLLED);
+ ep.ice->SetIceRole(std::get<3>(GetParam()) ? ICEROLE_CONTROLLING
+ : ICEROLE_CONTROLLED);
}
if (client) {
ep.ice->SignalCandidateGathered.connect(
@@ -209,7 +204,7 @@
}
// Setup DTLS.
- ep.dtls->SetDtlsRole(client ? webrtc::SSL_SERVER : webrtc::SSL_CLIENT);
+ ep.dtls->SetDtlsRole(client ? SSL_SERVER : SSL_CLIENT);
SetLocalCertificate(ep, client ? client_certificate : server_certificate);
SetRemoteFingerprintFromCert(
ep, client ? server_certificate : client_certificate);
@@ -217,13 +212,13 @@
}
void Prepare() {
- auto client_certificate = webrtc::RTCCertificate::Create(
- webrtc::SSLIdentity::Create("test", webrtc::KT_DEFAULT));
- auto server_certificate = webrtc::RTCCertificate::Create(
- webrtc::SSLIdentity::Create("test", webrtc::KT_DEFAULT));
+ auto client_certificate =
+ RTCCertificate::Create(SSLIdentity::Create("test", KT_DEFAULT));
+ auto server_certificate =
+ RTCCertificate::Create(SSLIdentity::Create("test", KT_DEFAULT));
if (network_emulation_manager_ == nullptr) {
- thread_ = std::make_unique<webrtc::AutoSocketServerThread>(ss_.get());
+ thread_ = std::make_unique<AutoSocketServerThread>(ss_.get());
}
client_thread()->BlockingCall([&]() {
@@ -238,7 +233,7 @@
// Setup the network.
if (network_emulation_manager_ == nullptr) {
- network_manager_->AddInterface(webrtc::SocketAddress("192.168.1.1", 0));
+ network_manager_->AddInterface(SocketAddress("192.168.1.1", 0));
}
client_thread()->BlockingCall([&]() { client_.allocator->Initialize(); });
@@ -262,9 +257,9 @@
~DtlsIceIntegrationTest() = default;
static int CountConnectionsWithFilter(
- webrtc::IceTransportInternal* ice,
- std::function<bool(const webrtc::ConnectionInfo&)> filter) {
- webrtc::IceTransportStats stats;
+ IceTransportInternal* ice,
+ std::function<bool(const ConnectionInfo&)> filter) {
+ IceTransportStats stats;
ice->GetStats(&stats);
int count = 0;
for (const auto& con : stats.connection_infos) {
@@ -275,30 +270,30 @@
return count;
}
- static int CountConnections(webrtc::IceTransportInternal* ice) {
+ static int CountConnections(IceTransportInternal* ice) {
return CountConnectionsWithFilter(ice, [](auto con) { return true; });
}
- static int CountWritableConnections(webrtc::IceTransportInternal* ice) {
+ static int CountWritableConnections(IceTransportInternal* ice) {
return CountConnectionsWithFilter(ice,
[](auto con) { return con.writable; });
}
- webrtc::WaitUntilSettings wait_until_settings() {
+ WaitUntilSettings wait_until_settings() {
if (network_emulation_manager_ == nullptr) {
return {
- .timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .timeout = TimeDelta::Millis(kDefaultTimeout),
.clock = &fake_clock_,
};
} else {
return {
- .timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .timeout = TimeDelta::Millis(kDefaultTimeout),
.clock = network_emulation_manager_->time_controller(),
};
}
}
- webrtc::Thread* thread(Endpoint& ep) {
+ Thread* thread(Endpoint& ep) {
if (ep.emulated_network_manager == nullptr) {
return thread_.get();
} else {
@@ -306,14 +301,13 @@
}
}
- webrtc::Thread* client_thread() { return thread(client_); }
+ Thread* client_thread() { return thread(client_); }
- webrtc::Thread* server_thread() { return thread(server_); }
+ Thread* server_thread() { return thread(server_); }
void SetRemoteFingerprintFromCert(Endpoint& ep,
const scoped_refptr<RTCCertificate>& cert) {
- ep.remote_fingerprint =
- webrtc::SSLFingerprint::CreateFromCertificate(*cert);
+ ep.remote_fingerprint = SSLFingerprint::CreateFromCertificate(*cert);
if (ep.store_but_dont_set_remote_fingerprint) {
return;
}
@@ -338,18 +332,18 @@
ep.dtls->SetLocalCertificate(certificate);
}
- webrtc::ScopedFakeClock fake_clock_;
- std::unique_ptr<webrtc::VirtualSocketServer> ss_;
- std::unique_ptr<webrtc::BasicPacketSocketFactory> socket_factory_;
- std::unique_ptr<webrtc::NetworkEmulationManager> network_emulation_manager_;
- std::unique_ptr<webrtc::AutoSocketServerThread> thread_;
- std::unique_ptr<webrtc::FakeNetworkManager> network_manager_;
+ ScopedFakeClock fake_clock_;
+ std::unique_ptr<VirtualSocketServer> ss_;
+ std::unique_ptr<BasicPacketSocketFactory> socket_factory_;
+ std::unique_ptr<NetworkEmulationManager> network_emulation_manager_;
+ std::unique_ptr<AutoSocketServerThread> thread_;
+ std::unique_ptr<FakeNetworkManager> network_manager_;
Endpoint client_;
Endpoint server_;
- webrtc::IceParameters client_ice_parameters_;
- webrtc::IceParameters server_ice_parameters_;
+ IceParameters client_ice_parameters_;
+ IceParameters server_ice_parameters_;
};
TEST_P(DtlsIceIntegrationTest, SmokeTest) {
@@ -359,10 +353,10 @@
// Note: this only reaches the pending piggybacking state.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return client_.dtls->writable() && server_.dtls->writable(); },
IsTrue(), wait_until_settings()),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(client_.dtls->IsDtlsPiggybackSupportedByPeer(),
client_.dtls_stun_piggyback && server_.dtls_stun_piggyback);
EXPECT_EQ(server_.dtls->IsDtlsPiggybackSupportedByPeer(),
@@ -390,14 +384,14 @@
}
// Validate that we can add new Connections (that become writable).
- network_manager_->AddInterface(webrtc::SocketAddress("192.168.2.1", 0));
- EXPECT_THAT(webrtc::WaitUntil(
+ network_manager_->AddInterface(SocketAddress("192.168.2.1", 0));
+ EXPECT_THAT(WaitUntil(
[&] {
return CountWritableConnections(client_.ice.get()) > 1 &&
CountWritableConnections(server_.ice.get()) > 1;
},
IsTrue(), wait_until_settings()),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
// Check that DtlsInStun still works even if SetRemoteFingerprint is called
@@ -410,17 +404,16 @@
server_.ice->MaybeStartGathering();
ASSERT_THAT(
- webrtc::WaitUntil(
- [&] { return CountWritableConnections(client_.ice.get()) > 0; },
- IsTrue(), wait_until_settings()),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return CountWritableConnections(client_.ice.get()) > 0; },
+ IsTrue(), wait_until_settings()),
+ IsRtcOk());
SetRemoteFingerprint(client_);
ASSERT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return client_.dtls->writable() && server_.dtls->writable(); },
IsTrue(), wait_until_settings()),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(client_.dtls->IsDtlsPiggybackSupportedByPeer(),
client_.dtls_stun_piggyback && server_.dtls_stun_piggyback);
@@ -451,7 +444,7 @@
server_thread()->PostTask([&]() { server_.ice->MaybeStartGathering(); });
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return client_thread()->BlockingCall([&]() {
return client_.dtls->writable();
@@ -460,7 +453,7 @@
});
},
IsTrue(), wait_until_settings()),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(client_thread()->BlockingCall([&]() {
return client_.dtls->IsDtlsPiggybackSupportedByPeer();
@@ -488,10 +481,10 @@
// Note: this only reaches the pending piggybacking state.
EXPECT_THAT(
- webrtc::WaitUntil(
+ WaitUntil(
[&] { return client_.dtls->writable() && server_.dtls->writable(); },
IsTrue(), wait_until_settings()),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_EQ(client_.dtls->IsDtlsPiggybackSupportedByPeer(),
client_.dtls_stun_piggyback && server_.dtls_stun_piggyback);
EXPECT_EQ(server_.dtls->IsDtlsPiggybackSupportedByPeer(),
@@ -528,8 +521,8 @@
DtlsIceIntegrationTest,
::testing::Combine(testing::Bool(),
testing::Bool(),
- testing::Values(webrtc::SSL_PROTOCOL_DTLS_12,
- webrtc::SSL_PROTOCOL_DTLS_13),
+ testing::Values(SSL_PROTOCOL_DTLS_12,
+ SSL_PROTOCOL_DTLS_13),
testing::Bool(),
testing::Bool(),
testing::Bool()));
diff --git a/p2p/dtls/dtls_stun_piggyback_callbacks.h b/p2p/dtls/dtls_stun_piggyback_callbacks.h
index 4c8b226..e9c176c 100644
--- a/p2p/dtls/dtls_stun_piggyback_callbacks.h
+++ b/p2p/dtls/dtls_stun_piggyback_callbacks.h
@@ -32,14 +32,13 @@
// - an optional DTLS_IN_STUN_ACK attribute
absl::AnyInvocable<std::pair<std::optional<absl::string_view>,
std::optional<absl::string_view>>(
- /* request-type */ webrtc::StunMessageType)>&& send_data,
+ /* request-type */ StunMessageType)>&& send_data,
// Function invoked when receiving a STUN_BINDING { REQUEST / RESPONSE }
// contains the (nullable) DTLS_IN_STUN and DTLS_IN_STUN_ACK attributes.
- absl::AnyInvocable<
- void(const webrtc::StunByteStringAttribute* /* DTLS_IN_STUN */,
- const webrtc::StunByteStringAttribute* /* DTLS_IN_STUN_ACK */)>&&
- recv_data)
+ absl::AnyInvocable<void(
+ const StunByteStringAttribute* /* DTLS_IN_STUN */,
+ const StunByteStringAttribute* /* DTLS_IN_STUN_ACK */)>&& recv_data)
: send_data_(std::move(send_data)), recv_data_(std::move(recv_data)) {
RTC_DCHECK(
// either all set
@@ -69,11 +68,11 @@
private:
absl::AnyInvocable<std::pair<std::optional<absl::string_view>,
std::optional<absl::string_view>>(
- /* request-type */ webrtc::StunMessageType)>
+ /* request-type */ StunMessageType)>
send_data_;
absl::AnyInvocable<void(
- const webrtc::StunByteStringAttribute* /* DTLS_IN_STUN */,
- const webrtc::StunByteStringAttribute* /* DTLS_IN_STUN_ACK */)>
+ const StunByteStringAttribute* /* DTLS_IN_STUN */,
+ const StunByteStringAttribute* /* DTLS_IN_STUN_ACK */)>
recv_data_;
};
diff --git a/p2p/dtls/dtls_stun_piggyback_controller.h b/p2p/dtls/dtls_stun_piggyback_controller.h
index 9f9c3e9..ad9b97a 100644
--- a/p2p/dtls/dtls_stun_piggyback_controller.h
+++ b/p2p/dtls/dtls_stun_piggyback_controller.h
@@ -37,8 +37,7 @@
// dtls_data_callback will be called with any DTLS packets received
// piggybacked.
DtlsStunPiggybackController(
- absl::AnyInvocable<void(webrtc::ArrayView<const uint8_t>)>
- dtls_data_callback);
+ absl::AnyInvocable<void(ArrayView<const uint8_t>)> dtls_data_callback);
~DtlsStunPiggybackController();
enum class State {
diff --git a/p2p/dtls/dtls_transport.cc b/p2p/dtls/dtls_transport.cc
index 85c27d2..0d2dbc8 100644
--- a/p2p/dtls/dtls_transport.cc
+++ b/p2p/dtls/dtls_transport.cc
@@ -571,13 +571,13 @@
// Can't send anything when we're failed.
RTC_LOG(LS_ERROR) << ToString()
<< ": Couldn't send packet due to "
- "webrtc::DtlsTransportState::kFailed.";
+ "DtlsTransportState::kFailed.";
return -1;
case DtlsTransportState::kClosed:
// Can't send anything when we're closed.
RTC_LOG(LS_ERROR) << ToString()
<< ": Couldn't send packet due to "
- "webrtc::DtlsTransportState::kClosed.";
+ "DtlsTransportState::kClosed.";
return -1;
default:
RTC_DCHECK_NOTREACHED();
@@ -729,13 +729,13 @@
// Should not happen. Do nothing.
RTC_LOG(LS_ERROR) << ToString()
<< ": OnWritableState() called in state "
- "webrtc::DtlsTransportState::kFailed.";
+ "DtlsTransportState::kFailed.";
break;
case DtlsTransportState::kClosed:
// Should not happen. Do nothing.
RTC_LOG(LS_ERROR) << ToString()
<< ": OnWritableState() called in state "
- "webrtc::DtlsTransportState::kClosed.";
+ "DtlsTransportState::kClosed.";
break;
case DtlsTransportState::kNumValues:
RTC_DCHECK_NOTREACHED();
diff --git a/p2p/dtls/dtls_transport.h b/p2p/dtls/dtls_transport.h
index a7fb055..edf0635 100644
--- a/p2p/dtls/dtls_transport.h
+++ b/p2p/dtls/dtls_transport.h
@@ -54,10 +54,10 @@
// the bottom and a StreamInterface on the top.
class StreamInterfaceChannel : public StreamInterface {
public:
- explicit StreamInterfaceChannel(webrtc::IceTransportInternal* ice_transport);
+ explicit StreamInterfaceChannel(IceTransportInternal* ice_transport);
void SetDtlsStunPiggybackController(
- webrtc::DtlsStunPiggybackController* dtls_stun_piggyback_controller);
+ DtlsStunPiggybackController* dtls_stun_piggyback_controller);
StreamInterfaceChannel(const StreamInterfaceChannel&) = delete;
StreamInterfaceChannel& operator=(const StreamInterfaceChannel&) = delete;
@@ -78,11 +78,11 @@
bool Flush() override;
private:
- webrtc::IceTransportInternal* const ice_transport_; // owned by DtlsTransport
- webrtc::DtlsStunPiggybackController* dtls_stun_piggyback_controller_ =
+ IceTransportInternal* const ice_transport_; // owned by DtlsTransport
+ DtlsStunPiggybackController* dtls_stun_piggyback_controller_ =
nullptr; // owned by DtlsTransport
StreamState state_ RTC_GUARDED_BY(callback_sequence_);
- webrtc::BufferQueue packets_ RTC_GUARDED_BY(callback_sequence_);
+ BufferQueue packets_ RTC_GUARDED_BY(callback_sequence_);
};
// This class provides a DTLS SSLStreamAdapter inside a TransportChannel-style
@@ -113,7 +113,7 @@
//
// This class is not thread safe; all methods must be called on the same thread
// as the constructor.
-class DtlsTransportInternalImpl : public webrtc::DtlsTransportInternal {
+class DtlsTransportInternalImpl : public DtlsTransportInternal {
public:
// `ice_transport` is the ICE transport this DTLS transport is wrapping. It
// must outlive this DTLS transport.
@@ -124,10 +124,10 @@
// `event_log` is an optional RtcEventLog for logging state changes. It should
// outlive the DtlsTransport.
DtlsTransportInternalImpl(
- webrtc::IceTransportInternal* ice_transport,
- const webrtc::CryptoOptions& crypto_options,
- webrtc::RtcEventLog* event_log,
- webrtc::SSLProtocolVersion max_version = webrtc::SSL_PROTOCOL_DTLS_12);
+ IceTransportInternal* ice_transport,
+ const CryptoOptions& crypto_options,
+ RtcEventLog* event_log,
+ SSLProtocolVersion max_version = SSL_PROTOCOL_DTLS_12);
~DtlsTransportInternalImpl() override;
@@ -135,7 +135,7 @@
DtlsTransportInternalImpl& operator=(const DtlsTransportInternalImpl&) =
delete;
- webrtc::DtlsTransportState dtls_state() const override;
+ DtlsTransportState dtls_state() const override;
const std::string& transport_name() const override;
int component() const override;
@@ -151,8 +151,8 @@
// being "active" or not (acting as a passthrough if not active), just require
// this certificate on construction or "Start".
bool SetLocalCertificate(
- const scoped_refptr<webrtc::RTCCertificate>& certificate) override;
- scoped_refptr<webrtc::RTCCertificate> GetLocalCertificate() const override;
+ const scoped_refptr<RTCCertificate>& certificate) override;
+ scoped_refptr<RTCCertificate> GetLocalCertificate() const override;
// SetRemoteFingerprint must be called after SetLocalCertificate, and any
// other methods like SetDtlsRole. It's what triggers the actual DTLS setup.
@@ -162,11 +162,10 @@
size_t digest_len) override;
// SetRemoteParameters must be called after SetLocalCertificate.
- webrtc::RTCError SetRemoteParameters(
- absl::string_view digest_alg,
- const uint8_t* digest,
- size_t digest_len,
- std::optional<webrtc::SSLRole> role) override;
+ RTCError SetRemoteParameters(absl::string_view digest_alg,
+ const uint8_t* digest,
+ size_t digest_len,
+ std::optional<SSLRole> role) override;
// Called to send a packet (via DTLS, if turned on).
int SendPacket(const char* data,
@@ -174,7 +173,7 @@
const AsyncSocketPacketOptions& options,
int flags) override;
- bool GetOption(webrtc::Socket::Option opt, int* value) override;
+ bool GetOption(Socket::Option opt, int* value) override;
// Find out which TLS version was negotiated
bool GetSslVersionBytes(int* version) const override;
@@ -190,8 +189,8 @@
// If not applicable, it returns zero.
uint16_t GetSslPeerSignatureAlgorithm() const override;
- bool GetDtlsRole(webrtc::SSLRole* role) const override;
- bool SetDtlsRole(webrtc::SSLRole role) override;
+ bool GetDtlsRole(SSLRole* role) const override;
+ bool SetDtlsRole(SSLRole role) override;
// Find out which DTLS cipher was negotiated
bool GetSslCipherSuite(int* cipher) const override;
@@ -200,7 +199,7 @@
// Once DTLS has been established, this method retrieves the certificate
// chain in use by the remote peer, for use in external identity
// verification.
- std::unique_ptr<webrtc::SSLCertChain> GetRemoteSSLCertChain() const override;
+ std::unique_ptr<SSLCertChain> GetRemoteSSLCertChain() const override;
// Once DTLS has established (i.e., this ice_transport is writable), this
// method extracts the keys negotiated during the DTLS handshake, for use in
@@ -208,7 +207,7 @@
bool ExportSrtpKeyingMaterial(
ZeroOnFreeBuffer<uint8_t>& keying_material) override;
- webrtc::IceTransportInternal* ice_transport() override;
+ IceTransportInternal* ice_transport() override;
// For informational purposes. Tells if the DTLS handshake has finished.
// This may be true even if writable() is false, if the remote fingerprint
@@ -220,9 +219,9 @@
int GetError() override;
- std::optional<webrtc::NetworkRoute> network_route() const override;
+ std::optional<NetworkRoute> network_route() const override;
- int SetOption(webrtc::Socket::Option opt, int value) override;
+ int SetOption(Socket::Option opt, int value) override;
std::string ToString() const {
const absl::string_view RECEIVING_ABBREV[2] = {"_", "R"};
@@ -247,48 +246,47 @@
private:
void ConnectToIceTransport();
- void OnWritableState(webrtc::PacketTransportInternal* transport);
- void OnReadPacket(webrtc::PacketTransportInternal* transport,
+ void OnWritableState(PacketTransportInternal* transport);
+ void OnReadPacket(PacketTransportInternal* transport,
const ReceivedIpPacket& packet,
bool piggybacked);
- void OnSentPacket(webrtc::PacketTransportInternal* transport,
+ void OnSentPacket(PacketTransportInternal* transport,
const SentPacketInfo& sent_packet);
- void OnReadyToSend(webrtc::PacketTransportInternal* transport);
- void OnReceivingState(webrtc::PacketTransportInternal* transport);
+ void OnReadyToSend(PacketTransportInternal* transport);
+ void OnReceivingState(PacketTransportInternal* transport);
void OnDtlsEvent(int sig, int err);
- void OnNetworkRouteChanged(std::optional<webrtc::NetworkRoute> network_route);
+ void OnNetworkRouteChanged(std::optional<NetworkRoute> network_route);
bool SetupDtls();
void MaybeStartDtls();
bool HandleDtlsPacket(ArrayView<const uint8_t> payload);
- void OnDtlsHandshakeError(webrtc::SSLHandshakeError error);
+ void OnDtlsHandshakeError(SSLHandshakeError error);
void ConfigureHandshakeTimeout();
void set_receiving(bool receiving);
void set_writable(bool writable);
// Sets the DTLS state, signaling if necessary.
- void set_dtls_state(webrtc::DtlsTransportState state);
+ void set_dtls_state(DtlsTransportState state);
void SetPiggybackDtlsDataCallback(
- absl::AnyInvocable<void(webrtc::PacketTransportInternal* transport,
- const webrtc::ReceivedIpPacket& packet)>
- callback);
+ absl::AnyInvocable<void(PacketTransportInternal* transport,
+ const ReceivedIpPacket& packet)> callback);
void PeriodicRetransmitDtlsPacketUntilDtlsConnected();
- RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker thread_checker_;
+ RTC_NO_UNIQUE_ADDRESS SequenceChecker thread_checker_;
const int component_;
- webrtc::DtlsTransportState dtls_state_ = webrtc::DtlsTransportState::kNew;
+ DtlsTransportState dtls_state_ = DtlsTransportState::kNew;
// Underlying ice_transport, not owned by this class.
- webrtc::IceTransportInternal* const ice_transport_;
- std::unique_ptr<webrtc::SSLStreamAdapter> dtls_; // The DTLS stream
+ IceTransportInternal* const ice_transport_;
+ std::unique_ptr<SSLStreamAdapter> dtls_; // The DTLS stream
StreamInterfaceChannel*
downward_; // Wrapper for ice_transport_, owned by dtls_.
const std::vector<int> srtp_ciphers_; // SRTP ciphers to use with DTLS.
// Cipher groups used for DTLS handshake to establish ephemeral key.
const std::vector<uint16_t> ephemeral_key_exchange_cipher_groups_;
bool dtls_active_ = false;
- scoped_refptr<webrtc::RTCCertificate> local_certificate_;
- std::optional<webrtc::SSLRole> dtls_role_;
- const webrtc::SSLProtocolVersion ssl_max_version_;
+ scoped_refptr<RTCCertificate> local_certificate_;
+ std::optional<SSLRole> dtls_role_;
+ const SSLProtocolVersion ssl_max_version_;
Buffer remote_fingerprint_value_;
std::string remote_fingerprint_algorithm_;
@@ -306,7 +304,7 @@
// of the stack.
bool ice_has_been_writable_ = false;
- webrtc::RtcEventLog* const event_log_;
+ RtcEventLog* const event_log_;
// Initialized in constructor based on WebRTC-IceHandshakeDtls,
// (so that we return PIGGYBACK_ACK to client if we get STUN_BINDING_REQUEST
@@ -314,10 +312,9 @@
bool dtls_in_stun_ = false;
// A controller for piggybacking DTLS in STUN.
- webrtc::DtlsStunPiggybackController dtls_stun_piggyback_controller_;
+ DtlsStunPiggybackController dtls_stun_piggyback_controller_;
- absl::AnyInvocable<void(webrtc::PacketTransportInternal*,
- const webrtc::ReceivedIpPacket&)>
+ absl::AnyInvocable<void(PacketTransportInternal*, const ReceivedIpPacket&)>
piggybacked_dtls_callback_;
// When ICE get writable during dtls piggybacked handshake
@@ -325,7 +322,7 @@
// in boringssl (that is work in progress). Therefore
// DtlsTransportInternalImpl has a "hack" to periodically retransmit.
bool pending_periodic_retransmit_dtls_packet_ = false;
- webrtc::ScopedTaskSafetyDetached safety_flag_;
+ ScopedTaskSafetyDetached safety_flag_;
};
} // namespace webrtc
diff --git a/p2p/dtls/dtls_transport_internal.h b/p2p/dtls/dtls_transport_internal.h
index c5df3c5..c54d567 100644
--- a/p2p/dtls/dtls_transport_internal.h
+++ b/p2p/dtls/dtls_transport_internal.h
@@ -115,7 +115,7 @@
// Expose the underneath IceTransport.
virtual IceTransportInternal* ice_transport() = 0;
- // F: void(DtlsTransportInternal*, const webrtc::DtlsTransportState)
+ // F: void(DtlsTransportInternal*, const DtlsTransportState)
template <typename F>
void SubscribeDtlsTransportState(F&& callback) {
dtls_transport_state_callback_list_.AddReceiver(std::forward<F>(callback));
@@ -137,7 +137,7 @@
}
// Emitted whenever the Dtls handshake failed on some transport channel.
- // F: void(webrtc::SSLHandshakeError)
+ // F: void(SSLHandshakeError)
template <typename F>
void SubscribeDtlsHandshakeError(F&& callback) {
dtls_handshake_error_callback_list_.AddReceiver(std::forward<F>(callback));
diff --git a/p2p/dtls/dtls_transport_unittest.cc b/p2p/dtls/dtls_transport_unittest.cc
index 0fc2814..1e7067d 100644
--- a/p2p/dtls/dtls_transport_unittest.cc
+++ b/p2p/dtls/dtls_transport_unittest.cc
@@ -112,7 +112,7 @@
dtls_transport_ = nullptr;
fake_ice_transport_ = nullptr;
- webrtc::CryptoOptions crypto_options;
+ CryptoOptions crypto_options;
if (pqc_) {
FieldTrials field_trials("WebRTC-EnableDtlsPqc/Enabled/");
crypto_options.ephemeral_key_exchange_cipher_groups.Update(&field_trials);
diff --git a/p2p/dtls/fake_dtls_transport.h b/p2p/dtls/fake_dtls_transport.h
index a0f7596..dc99ed5 100644
--- a/p2p/dtls/fake_dtls_transport.h
+++ b/p2p/dtls/fake_dtls_transport.h
@@ -145,7 +145,7 @@
}
// If the `dtls_role_` is unset, set it to SSL_CLIENT by default.
if (!dtls_role_) {
- dtls_role_ = std::move(webrtc::SSL_CLIENT);
+ dtls_role_ = std::move(SSL_CLIENT);
}
SetDtlsState(DtlsTransportState::kConnected);
ice_transport_->SetDestination(
@@ -320,10 +320,10 @@
scoped_refptr<RTCCertificate> local_cert_;
FakeSSLCertificate* remote_cert_ = nullptr;
bool do_dtls_ = false;
- SSLProtocolVersion ssl_max_version_ = webrtc::SSL_PROTOCOL_DTLS_12;
+ SSLProtocolVersion ssl_max_version_ = SSL_PROTOCOL_DTLS_12;
SSLFingerprint dtls_fingerprint_;
std::optional<SSLRole> dtls_role_;
- int crypto_suite_ = webrtc::kSrtpAes128CmSha1_80;
+ int crypto_suite_ = kSrtpAes128CmSha1_80;
std::optional<int> ssl_cipher_suite_;
DtlsTransportState dtls_state_ = DtlsTransportState::kNew;
diff --git a/p2p/test/fake_ice_transport.h b/p2p/test/fake_ice_transport.h
index 3e51459..ef4a90c 100644
--- a/p2p/test/fake_ice_transport.h
+++ b/p2p/test/fake_ice_transport.h
@@ -168,8 +168,8 @@
void SetCandidatesGatheringComplete() {
RTC_DCHECK_RUN_ON(network_thread_);
- if (gathering_state_ != webrtc::kIceGatheringComplete) {
- gathering_state_ = webrtc::kIceGatheringComplete;
+ if (gathering_state_ != kIceGatheringComplete) {
+ gathering_state_ = kIceGatheringComplete;
SendGatheringStateEvent();
}
}
@@ -264,8 +264,8 @@
void MaybeStartGathering() override {
RTC_DCHECK_RUN_ON(network_thread_);
- if (gathering_state_ == webrtc::kIceGatheringNew) {
- gathering_state_ = webrtc::kIceGatheringGathering;
+ if (gathering_state_ == kIceGatheringNew) {
+ gathering_state_ = kIceGatheringGathering;
SendGatheringStateEvent();
}
}
@@ -353,7 +353,7 @@
}
}
- SentPacketInfo sent_packet(options.packet_id, webrtc::TimeMillis());
+ SentPacketInfo sent_packet(options.packet_id, TimeMillis());
SignalSentPacket(this, sent_packet);
return static_cast<int>(len);
}
@@ -398,7 +398,7 @@
void set_packet_send_filter(
absl::AnyInvocable<bool(const char* data,
size_t len,
- const webrtc::AsyncSocketPacketOptions& options,
+ const AsyncSocketPacketOptions& options,
int /* flags */)> func) {
RTC_DCHECK_RUN_ON(network_thread_);
packet_send_filter_func_ = std::move(func);
@@ -436,7 +436,7 @@
bool SendIcePing() {
RTC_DCHECK_RUN_ON(network_thread_);
RTC_DLOG(LS_INFO) << name_ << ": SendIcePing()";
- last_sent_ping_timestamp_ = webrtc::TimeMicros();
+ last_sent_ping_timestamp_ = TimeMicros();
auto msg = std::make_unique<IceMessage>(STUN_BINDING_REQUEST);
MaybeAddDtlsPiggybackingAttributes(msg.get());
msg->AddFingerprint();
@@ -564,7 +564,7 @@
void ReceivePacketInternal(const CopyOnWriteBuffer& packet) {
RTC_DCHECK_RUN_ON(network_thread_);
- auto now = webrtc::TimeMicros();
+ auto now = TimeMicros();
if (auto msg = GetStunMessage(packet)) {
RTC_LOG(LS_INFO) << name_ << ": RECV STUN message: "
<< ", data[0]: "
@@ -634,7 +634,7 @@
std::optional<IceTransportStateInternal> legacy_transport_state_
RTC_GUARDED_BY(network_thread_);
IceGatheringState gathering_state_ RTC_GUARDED_BY(network_thread_) =
- webrtc::kIceGatheringNew;
+ kIceGatheringNew;
bool had_connection_ RTC_GUARDED_BY(network_thread_) = false;
bool writable_ RTC_GUARDED_BY(network_thread_) = false;
bool receiving_ RTC_GUARDED_BY(network_thread_) = false;
diff --git a/p2p/test/fake_port_allocator.h b/p2p/test/fake_port_allocator.h
index bce0834..3853b21 100644
--- a/p2p/test/fake_port_allocator.h
+++ b/p2p/test/fake_port_allocator.h
@@ -122,10 +122,10 @@
void StartGettingPorts() override {
if (!port_) {
- Network& network = (webrtc::HasIPv6Enabled() &&
- (flags() & webrtc::PORTALLOCATOR_ENABLE_IPV6))
- ? ipv6_network_
- : ipv4_network_;
+ Network& network =
+ (HasIPv6Enabled() && (flags() & PORTALLOCATOR_ENABLE_IPV6))
+ ? ipv6_network_
+ : ipv4_network_;
port_.reset(TestUDPPort::Create({.env = env_,
.network_thread = network_thread_,
.socket_factory = factory_,
@@ -220,7 +220,7 @@
bool is_cleared = false;
ServerAddresses stun_servers_;
std::vector<RelayServerConfig> turn_servers_;
- uint32_t candidate_filter_ = webrtc::CF_ALL;
+ uint32_t candidate_filter_ = CF_ALL;
int transport_info_update_count_ = 0;
bool running_ = false;
};
diff --git a/p2p/test/mock_active_ice_controller.h b/p2p/test/mock_active_ice_controller.h
index df18a44..98d6cb9 100644
--- a/p2p/test/mock_active_ice_controller.h
+++ b/p2p/test/mock_active_ice_controller.h
@@ -29,41 +29,24 @@
const ActiveIceControllerFactoryArgs& /* args */) {}
~MockActiveIceController() override = default;
- MOCK_METHOD(void, SetIceConfig, (const webrtc::IceConfig&), (override));
- MOCK_METHOD(void, OnConnectionAdded, (const webrtc::Connection*), (override));
- MOCK_METHOD(void,
- OnConnectionSwitched,
- (const webrtc::Connection*),
- (override));
- MOCK_METHOD(void,
- OnConnectionDestroyed,
- (const webrtc::Connection*),
- (override));
- MOCK_METHOD(void,
- OnConnectionPinged,
- (const webrtc::Connection*),
- (override));
- MOCK_METHOD(void,
- OnConnectionUpdated,
- (const webrtc::Connection*),
- (override));
+ MOCK_METHOD(void, SetIceConfig, (const IceConfig&), (override));
+ MOCK_METHOD(void, OnConnectionAdded, (const Connection*), (override));
+ MOCK_METHOD(void, OnConnectionSwitched, (const Connection*), (override));
+ MOCK_METHOD(void, OnConnectionDestroyed, (const Connection*), (override));
+ MOCK_METHOD(void, OnConnectionPinged, (const Connection*), (override));
+ MOCK_METHOD(void, OnConnectionUpdated, (const Connection*), (override));
MOCK_METHOD(bool,
GetUseCandidateAttribute,
- (const webrtc::Connection*,
- webrtc::NominationMode,
- webrtc::IceMode),
+ (const Connection*, NominationMode, IceMode),
(const, override));
- MOCK_METHOD(void,
- OnSortAndSwitchRequest,
- (webrtc::IceSwitchReason),
- (override));
+ MOCK_METHOD(void, OnSortAndSwitchRequest, (IceSwitchReason), (override));
MOCK_METHOD(void,
OnImmediateSortAndSwitchRequest,
- (webrtc::IceSwitchReason),
+ (IceSwitchReason),
(override));
MOCK_METHOD(bool,
OnImmediateSwitchRequest,
- (webrtc::IceSwitchReason, const webrtc::Connection*),
+ (IceSwitchReason, const Connection*),
(override));
MOCK_METHOD(const Connection*, FindNextPingableConnection, (), (override));
};
diff --git a/p2p/test/mock_ice_agent.h b/p2p/test/mock_ice_agent.h
index 113ddf4..3ae3f75 100644
--- a/p2p/test/mock_ice_agent.h
+++ b/p2p/test/mock_ice_agent.h
@@ -33,16 +33,16 @@
MOCK_METHOD(void, UpdateState, (), (override));
MOCK_METHOD(void,
ForgetLearnedStateForConnections,
- (webrtc::ArrayView<const webrtc::Connection* const>),
+ (ArrayView<const Connection* const>),
(override));
- MOCK_METHOD(void, SendPingRequest, (const webrtc::Connection*), (override));
+ MOCK_METHOD(void, SendPingRequest, (const Connection*), (override));
MOCK_METHOD(void,
SwitchSelectedConnection,
- (const webrtc::Connection*, webrtc::IceSwitchReason),
+ (const Connection*, IceSwitchReason),
(override));
MOCK_METHOD(bool,
PruneConnections,
- (webrtc::ArrayView<const webrtc::Connection* const>),
+ (ArrayView<const Connection* const>),
(override));
};
diff --git a/p2p/test/mock_ice_controller.h b/p2p/test/mock_ice_controller.h
index 5b92dde..5cc4f31 100644
--- a/p2p/test/mock_ice_controller.h
+++ b/p2p/test/mock_ice_controller.h
@@ -31,16 +31,10 @@
explicit MockIceController(const IceControllerFactoryArgs& /* args */) {}
~MockIceController() override = default;
- MOCK_METHOD(void, SetIceConfig, (const webrtc::IceConfig&), (override));
- MOCK_METHOD(void,
- SetSelectedConnection,
- (const webrtc::Connection*),
- (override));
- MOCK_METHOD(void, AddConnection, (const webrtc::Connection*), (override));
- MOCK_METHOD(void,
- OnConnectionDestroyed,
- (const webrtc::Connection*),
- (override));
+ MOCK_METHOD(void, SetIceConfig, (const IceConfig&), (override));
+ MOCK_METHOD(void, SetSelectedConnection, (const Connection*), (override));
+ MOCK_METHOD(void, AddConnection, (const Connection*), (override));
+ MOCK_METHOD(void, OnConnectionDestroyed, (const Connection*), (override));
MOCK_METHOD(ArrayView<const Connection* const>,
GetConnections,
(),
@@ -53,22 +47,17 @@
(override));
MOCK_METHOD(bool,
GetUseCandidateAttr,
- (const webrtc::Connection*,
- webrtc::NominationMode,
- webrtc::IceMode),
+ (const Connection*, NominationMode, IceMode),
(const, override));
MOCK_METHOD(const Connection*, FindNextPingableConnection, (), (override));
- MOCK_METHOD(void,
- MarkConnectionPinged,
- (const webrtc::Connection*),
- (override));
+ MOCK_METHOD(void, MarkConnectionPinged, (const Connection*), (override));
MOCK_METHOD(IceControllerInterface::SwitchResult,
ShouldSwitchConnection,
- (webrtc::IceSwitchReason, const webrtc::Connection*),
+ (IceSwitchReason, const Connection*),
(override));
MOCK_METHOD(IceControllerInterface::SwitchResult,
SortAndSwitchConnection,
- (webrtc::IceSwitchReason),
+ (IceSwitchReason),
(override));
MOCK_METHOD(std::vector<const Connection*>, PruneConnections, (), (override));
};
diff --git a/p2p/test/nat_unittest.cc b/p2p/test/nat_unittest.cc
index b9dddc1..e98bd17 100644
--- a/p2p/test/nat_unittest.cc
+++ b/p2p/test/nat_unittest.cc
@@ -45,7 +45,7 @@
namespace webrtc {
namespace {
-bool CheckReceive(webrtc::TestClient* client,
+bool CheckReceive(TestClient* client,
bool should_receive,
const char* buf,
size_t size) {
@@ -53,44 +53,43 @@
: client->CheckNoPacket();
}
-webrtc::TestClient* CreateTestClient(webrtc::SocketFactory* factory,
- const webrtc::SocketAddress& local_addr) {
- return new webrtc::TestClient(
- absl::WrapUnique(webrtc::AsyncUDPSocket::Create(factory, local_addr)));
+webrtc::TestClient* CreateTestClient(SocketFactory* factory,
+ const SocketAddress& local_addr) {
+ return new TestClient(
+ absl::WrapUnique(AsyncUDPSocket::Create(factory, local_addr)));
}
-webrtc::TestClient* CreateTCPTestClient(webrtc::Socket* socket) {
- return new webrtc::TestClient(
- std::make_unique<webrtc::AsyncTCPSocket>(socket));
+webrtc::TestClient* CreateTCPTestClient(Socket* socket) {
+ return new TestClient(std::make_unique<AsyncTCPSocket>(socket));
}
// Tests that when sending from internal_addr to external_addrs through the
// NAT type specified by nat_type, all external addrs receive the sent packet
// and, if exp_same is true, all use the same mapped-address on the NAT.
-void TestSend(webrtc::SocketServer* internal,
- const webrtc::SocketAddress& internal_addr,
- webrtc::SocketServer* external,
- const webrtc::SocketAddress external_addrs[4],
- webrtc::NATType nat_type,
+void TestSend(SocketServer* internal,
+ const SocketAddress& internal_addr,
+ SocketServer* external,
+ const SocketAddress external_addrs[4],
+ NATType nat_type,
bool exp_same) {
- webrtc::Thread th_int(internal);
- webrtc::Thread th_ext(external);
+ Thread th_int(internal);
+ Thread th_ext(external);
th_int.Start();
th_ext.Start();
- webrtc::SocketAddress server_addr = internal_addr;
+ SocketAddress server_addr = internal_addr;
server_addr.SetPort(0); // Auto-select a port
- webrtc::NATServer* nat =
- new webrtc::NATServer(nat_type, th_int, internal, server_addr,
- server_addr, th_ext, external, external_addrs[0]);
- webrtc::NATSocketFactory* natsf = new webrtc::NATSocketFactory(
+ NATServer* nat =
+ new NATServer(nat_type, th_int, internal, server_addr, server_addr,
+ th_ext, external, external_addrs[0]);
+ NATSocketFactory* natsf = new NATSocketFactory(
internal, nat->internal_udp_address(), nat->internal_tcp_address());
- webrtc::TestClient* in;
+ TestClient* in;
th_int.BlockingCall([&] { in = CreateTestClient(natsf, internal_addr); });
- webrtc::TestClient* out[4];
+ TestClient* out[4];
th_ext.BlockingCall([&] {
for (int i = 0; i < 4; i++)
out[i] = CreateTestClient(external, external_addrs[i]);
@@ -100,13 +99,13 @@
size_t len = strlen(buf);
th_int.BlockingCall([&] { in->SendTo(buf, len, out[0]->address()); });
- webrtc::SocketAddress trans_addr;
+ SocketAddress trans_addr;
th_ext.BlockingCall(
[&] { EXPECT_TRUE(out[0]->CheckNextPacket(buf, len, &trans_addr)); });
for (int i = 1; i < 4; i++) {
th_int.BlockingCall([&] { in->SendTo(buf, len, out[i]->address()); });
- webrtc::SocketAddress trans_addr2;
+ SocketAddress trans_addr2;
th_ext.BlockingCall([&] {
EXPECT_TRUE(out[i]->CheckNextPacket(buf, len, &trans_addr2));
bool are_same = (trans_addr == trans_addr2);
@@ -128,30 +127,30 @@
// Tests that when sending from external_addrs to internal_addr, the packet
// is delivered according to the specified filter_ip and filter_port rules.
-void TestRecv(webrtc::SocketServer* internal,
- const webrtc::SocketAddress& internal_addr,
- webrtc::SocketServer* external,
- const webrtc::SocketAddress external_addrs[4],
- webrtc::NATType nat_type,
+void TestRecv(SocketServer* internal,
+ const SocketAddress& internal_addr,
+ SocketServer* external,
+ const SocketAddress external_addrs[4],
+ NATType nat_type,
bool filter_ip,
bool filter_port) {
- webrtc::Thread th_int(internal);
- webrtc::Thread th_ext(external);
+ Thread th_int(internal);
+ Thread th_ext(external);
- webrtc::SocketAddress server_addr = internal_addr;
+ SocketAddress server_addr = internal_addr;
server_addr.SetPort(0); // Auto-select a port
th_int.Start();
th_ext.Start();
- webrtc::NATServer* nat =
- new webrtc::NATServer(nat_type, th_int, internal, server_addr,
- server_addr, th_ext, external, external_addrs[0]);
- webrtc::NATSocketFactory* natsf = new webrtc::NATSocketFactory(
+ NATServer* nat =
+ new NATServer(nat_type, th_int, internal, server_addr, server_addr,
+ th_ext, external, external_addrs[0]);
+ NATSocketFactory* natsf = new NATSocketFactory(
internal, nat->internal_udp_address(), nat->internal_tcp_address());
- webrtc::TestClient* in = nullptr;
+ TestClient* in = nullptr;
th_int.BlockingCall([&] { in = CreateTestClient(natsf, internal_addr); });
- webrtc::TestClient* out[4];
+ TestClient* out[4];
th_ext.BlockingCall([&] {
for (int i = 0; i < 4; i++)
out[i] = CreateTestClient(external, external_addrs[i]);
@@ -161,7 +160,7 @@
size_t len = strlen(buf);
th_int.BlockingCall([&] { in->SendTo(buf, len, out[0]->address()); });
- webrtc::SocketAddress trans_addr;
+ SocketAddress trans_addr;
th_ext.BlockingCall(
[&] { EXPECT_TRUE(out[0]->CheckNextPacket(buf, len, &trans_addr)); });
@@ -190,74 +189,69 @@
}
// Tests that NATServer allocates bindings properly.
-void TestBindings(webrtc::SocketServer* internal,
- const webrtc::SocketAddress& internal_addr,
- webrtc::SocketServer* external,
- const webrtc::SocketAddress external_addrs[4]) {
+void TestBindings(SocketServer* internal,
+ const SocketAddress& internal_addr,
+ SocketServer* external,
+ const SocketAddress external_addrs[4]) {
+ TestSend(internal, internal_addr, external, external_addrs, NAT_OPEN_CONE,
+ true);
TestSend(internal, internal_addr, external, external_addrs,
- webrtc::NAT_OPEN_CONE, true);
+ NAT_ADDR_RESTRICTED, true);
TestSend(internal, internal_addr, external, external_addrs,
- webrtc::NAT_ADDR_RESTRICTED, true);
- TestSend(internal, internal_addr, external, external_addrs,
- webrtc::NAT_PORT_RESTRICTED, true);
- TestSend(internal, internal_addr, external, external_addrs,
- webrtc::NAT_SYMMETRIC, false);
+ NAT_PORT_RESTRICTED, true);
+ TestSend(internal, internal_addr, external, external_addrs, NAT_SYMMETRIC,
+ false);
}
// Tests that NATServer filters packets properly.
-void TestFilters(webrtc::SocketServer* internal,
- const webrtc::SocketAddress& internal_addr,
- webrtc::SocketServer* external,
- const webrtc::SocketAddress external_addrs[4]) {
+void TestFilters(SocketServer* internal,
+ const SocketAddress& internal_addr,
+ SocketServer* external,
+ const SocketAddress external_addrs[4]) {
+ TestRecv(internal, internal_addr, external, external_addrs, NAT_OPEN_CONE,
+ false, false);
TestRecv(internal, internal_addr, external, external_addrs,
- webrtc::NAT_OPEN_CONE, false, false);
+ NAT_ADDR_RESTRICTED, true, false);
TestRecv(internal, internal_addr, external, external_addrs,
- webrtc::NAT_ADDR_RESTRICTED, true, false);
- TestRecv(internal, internal_addr, external, external_addrs,
- webrtc::NAT_PORT_RESTRICTED, true, true);
- TestRecv(internal, internal_addr, external, external_addrs,
- webrtc::NAT_SYMMETRIC, true, true);
+ NAT_PORT_RESTRICTED, true, true);
+ TestRecv(internal, internal_addr, external, external_addrs, NAT_SYMMETRIC,
+ true, true);
}
-bool TestConnectivity(const webrtc::SocketAddress& src,
- const webrtc::IPAddress& dst) {
+bool TestConnectivity(const SocketAddress& src, const IPAddress& dst) {
// The physical NAT tests require connectivity to the selected ip from the
// internal address used for the NAT. Things like firewalls can break that, so
// check to see if it's worth even trying with this ip.
- std::unique_ptr<webrtc::PhysicalSocketServer> pss(
- new webrtc::PhysicalSocketServer());
- std::unique_ptr<webrtc::Socket> client(
- pss->CreateSocket(src.family(), SOCK_DGRAM));
- std::unique_ptr<webrtc::Socket> server(
- pss->CreateSocket(src.family(), SOCK_DGRAM));
- if (client->Bind(webrtc::SocketAddress(src.ipaddr(), 0)) != 0 ||
- server->Bind(webrtc::SocketAddress(dst, 0)) != 0) {
+ std::unique_ptr<PhysicalSocketServer> pss(new PhysicalSocketServer());
+ std::unique_ptr<Socket> client(pss->CreateSocket(src.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> server(pss->CreateSocket(src.family(), SOCK_DGRAM));
+ if (client->Bind(SocketAddress(src.ipaddr(), 0)) != 0 ||
+ server->Bind(SocketAddress(dst, 0)) != 0) {
return false;
}
const char* buf = "hello other socket";
size_t len = strlen(buf);
int sent = client->SendTo(buf, len, server->GetLocalAddress());
- webrtc::Thread::Current()->SleepMs(100);
+ Thread::Current()->SleepMs(100);
Buffer payload;
- webrtc::Socket::ReceiveBuffer receive_buffer(payload);
+ Socket::ReceiveBuffer receive_buffer(payload);
int received = server->RecvFrom(receive_buffer);
return received == sent && ::memcmp(buf, payload.data(), len) == 0;
}
-void TestPhysicalInternal(const webrtc::SocketAddress& int_addr) {
- webrtc::AutoThread main_thread;
- webrtc::PhysicalSocketServer socket_server;
- webrtc::BasicNetworkManager network_manager(CreateEnvironment(),
- &socket_server);
+void TestPhysicalInternal(const SocketAddress& int_addr) {
+ AutoThread main_thread;
+ PhysicalSocketServer socket_server;
+ BasicNetworkManager network_manager(CreateEnvironment(), &socket_server);
network_manager.StartUpdating();
// Process pending messages so the network list is updated.
- webrtc::Thread::Current()->ProcessMessages(0);
+ Thread::Current()->ProcessMessages(0);
- std::vector<const webrtc::Network*> networks = network_manager.GetNetworks();
+ std::vector<const Network*> networks = network_manager.GetNetworks();
networks.erase(std::remove_if(networks.begin(), networks.end(),
- [](const webrtc::Network* network) {
- return webrtc::kDefaultNetworkIgnoreMask &
+ [](const Network* network) {
+ return kDefaultNetworkIgnoreMask &
network->type();
}),
networks.end());
@@ -266,12 +260,12 @@
return;
}
- webrtc::SocketAddress ext_addr1(int_addr);
- webrtc::SocketAddress ext_addr2;
+ SocketAddress ext_addr1(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 (const Network* const network : networks) {
- const webrtc::IPAddress& ip = network->GetBestIP();
+ const IPAddress& ip = network->GetBestIP();
if (ip.family() == int_addr.family() && TestConnectivity(int_addr, ip)) {
ext_addr2.SetIP(ip);
break;
@@ -285,26 +279,24 @@
RTC_LOG(LS_INFO) << "selected ip " << ext_addr2.ipaddr().ToString();
- webrtc::SocketAddress ext_addrs[4] = {
- webrtc::SocketAddress(ext_addr1), webrtc::SocketAddress(ext_addr2),
- webrtc::SocketAddress(ext_addr1), webrtc::SocketAddress(ext_addr2)};
+ SocketAddress ext_addrs[4] = {
+ SocketAddress(ext_addr1), SocketAddress(ext_addr2),
+ SocketAddress(ext_addr1), SocketAddress(ext_addr2)};
- std::unique_ptr<webrtc::PhysicalSocketServer> int_pss(
- new webrtc::PhysicalSocketServer());
- std::unique_ptr<webrtc::PhysicalSocketServer> ext_pss(
- new webrtc::PhysicalSocketServer());
+ std::unique_ptr<PhysicalSocketServer> int_pss(new PhysicalSocketServer());
+ std::unique_ptr<PhysicalSocketServer> ext_pss(new PhysicalSocketServer());
TestBindings(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
TestFilters(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
}
TEST(NatTest, TestPhysicalIPv4) {
- TestPhysicalInternal(webrtc::SocketAddress("127.0.0.1", 0));
+ TestPhysicalInternal(SocketAddress("127.0.0.1", 0));
}
TEST(NatTest, TestPhysicalIPv6) {
- if (webrtc::HasIPv6Enabled()) {
- TestPhysicalInternal(webrtc::SocketAddress("::1", 0));
+ if (HasIPv6Enabled()) {
+ TestPhysicalInternal(SocketAddress("::1", 0));
} else {
RTC_LOG(LS_WARNING) << "No IPv6, skipping";
}
@@ -312,25 +304,23 @@
namespace {
-class TestVirtualSocketServer : public webrtc::VirtualSocketServer {
+class TestVirtualSocketServer : public VirtualSocketServer {
public:
// Expose this publicly
- webrtc::IPAddress GetNextIP(int af) {
- return webrtc::VirtualSocketServer::GetNextIP(af);
- }
+ IPAddress GetNextIP(int af) { return VirtualSocketServer::GetNextIP(af); }
};
} // namespace
void TestVirtualInternal(int family) {
- webrtc::AutoThread main_thread;
+ AutoThread main_thread;
std::unique_ptr<TestVirtualSocketServer> int_vss(
new TestVirtualSocketServer());
std::unique_ptr<TestVirtualSocketServer> ext_vss(
new TestVirtualSocketServer());
- webrtc::SocketAddress int_addr;
- webrtc::SocketAddress ext_addrs[4];
+ SocketAddress int_addr;
+ SocketAddress ext_addrs[4];
int_addr.SetIP(int_vss->GetNextIP(family));
ext_addrs[0].SetIP(ext_vss->GetNextIP(int_addr.family()));
ext_addrs[1].SetIP(ext_vss->GetNextIP(int_addr.family()));
@@ -346,7 +336,7 @@
}
TEST(NatTest, TestVirtualIPv6) {
- if (webrtc::HasIPv6Enabled()) {
+ if (HasIPv6Enabled()) {
TestVirtualInternal(AF_INET6);
} else {
RTC_LOG(LS_WARNING) << "No IPv6, skipping";
@@ -361,48 +351,48 @@
connected_(false),
int_vss_(new TestVirtualSocketServer()),
ext_vss_(new TestVirtualSocketServer()),
- int_thread_(new webrtc::Thread(int_vss_.get())),
- ext_thread_(new webrtc::Thread(ext_vss_.get())),
- nat_(new webrtc::NATServer(webrtc::NAT_OPEN_CONE,
- *int_thread_,
- int_vss_.get(),
- int_addr_,
- int_addr_,
- *ext_thread_,
- ext_vss_.get(),
- ext_addr_)),
- natsf_(new webrtc::NATSocketFactory(int_vss_.get(),
- nat_->internal_udp_address(),
- nat_->internal_tcp_address())) {
+ int_thread_(new Thread(int_vss_.get())),
+ ext_thread_(new Thread(ext_vss_.get())),
+ nat_(new NATServer(NAT_OPEN_CONE,
+ *int_thread_,
+ int_vss_.get(),
+ int_addr_,
+ int_addr_,
+ *ext_thread_,
+ ext_vss_.get(),
+ ext_addr_)),
+ natsf_(new NATSocketFactory(int_vss_.get(),
+ nat_->internal_udp_address(),
+ nat_->internal_tcp_address())) {
int_thread_->Start();
ext_thread_->Start();
}
- void OnConnectEvent(webrtc::Socket* socket) { connected_ = true; }
+ void OnConnectEvent(Socket* socket) { connected_ = true; }
- void OnAcceptEvent(webrtc::Socket* socket) {
+ void OnAcceptEvent(Socket* socket) {
accepted_.reset(server_->Accept(nullptr));
}
- void OnCloseEvent(webrtc::Socket* socket, int error) {}
+ void OnCloseEvent(Socket* socket, int error) {}
void ConnectEvents() {
server_->SignalReadEvent.connect(this, &NatTcpTest::OnAcceptEvent);
client_->SignalConnectEvent.connect(this, &NatTcpTest::OnConnectEvent);
}
- webrtc::SocketAddress int_addr_;
- webrtc::SocketAddress ext_addr_;
+ SocketAddress int_addr_;
+ SocketAddress ext_addr_;
bool connected_;
std::unique_ptr<TestVirtualSocketServer> int_vss_;
std::unique_ptr<TestVirtualSocketServer> ext_vss_;
- std::unique_ptr<webrtc::Thread> int_thread_;
- std::unique_ptr<webrtc::Thread> ext_thread_;
- std::unique_ptr<webrtc::NATServer> nat_;
- std::unique_ptr<webrtc::NATSocketFactory> natsf_;
- std::unique_ptr<webrtc::Socket> client_;
- std::unique_ptr<webrtc::Socket> server_;
- std::unique_ptr<webrtc::Socket> accepted_;
+ std::unique_ptr<Thread> int_thread_;
+ std::unique_ptr<Thread> ext_thread_;
+ std::unique_ptr<NATServer> nat_;
+ std::unique_ptr<NATSocketFactory> natsf_;
+ std::unique_ptr<Socket> client_;
+ std::unique_ptr<Socket> server_;
+ std::unique_ptr<Socket> accepted_;
};
TEST_F(NatTcpTest, DISABLED_TestConnectOut) {
@@ -416,22 +406,19 @@
ConnectEvents();
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return connected_; }, ::testing::IsTrue()),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return connected_; }, ::testing::IsTrue()),
+ IsRtcOk());
EXPECT_EQ(client_->GetRemoteAddress(), server_->GetLocalAddress());
EXPECT_EQ(accepted_->GetRemoteAddress().ipaddr(), ext_addr_.ipaddr());
- std::unique_ptr<webrtc::TestClient> in(
- CreateTCPTestClient(client_.release()));
- std::unique_ptr<webrtc::TestClient> out(
- CreateTCPTestClient(accepted_.release()));
+ std::unique_ptr<TestClient> in(CreateTCPTestClient(client_.release()));
+ std::unique_ptr<TestClient> out(CreateTCPTestClient(accepted_.release()));
const char* buf = "test_packet";
size_t len = strlen(buf);
in->Send(buf, len);
- webrtc::SocketAddress trans_addr;
+ SocketAddress trans_addr;
EXPECT_TRUE(out->CheckNextPacket(buf, len, &trans_addr));
out->Send(buf, len);
diff --git a/p2p/test/test_stun_server.h b/p2p/test/test_stun_server.h
index b65bc85..9cee166 100644
--- a/p2p/test/test_stun_server.h
+++ b/p2p/test/test_stun_server.h
@@ -27,8 +27,7 @@
class TestStunServer : StunServer {
public:
using StunServerPtr =
- std::unique_ptr<TestStunServer,
- std::function<void(webrtc::TestStunServer*)>>;
+ std::unique_ptr<TestStunServer, std::function<void(TestStunServer*)>>;
static StunServerPtr Create(SocketServer* ss,
const SocketAddress& addr,
Thread& network_thread);
diff --git a/p2p/test/test_turn_server.h b/p2p/test/test_turn_server.h
index e416500..6f26b36 100644
--- a/p2p/test/test_turn_server.h
+++ b/p2p/test/test_turn_server.h
@@ -64,7 +64,7 @@
SocketFactory* socket_factory,
const SocketAddress& int_addr,
const SocketAddress& udp_ext_addr,
- ProtocolType int_protocol = webrtc::PROTO_UDP,
+ ProtocolType int_protocol = PROTO_UDP,
bool ignore_bad_cert = true,
absl::string_view common_name = "test turn server")
: server_(thread), socket_factory_(socket_factory) {
@@ -103,23 +103,23 @@
bool ignore_bad_cert = true,
absl::string_view common_name = "test turn server") {
RTC_DCHECK(thread_checker_.IsCurrent());
- if (proto == webrtc::PROTO_UDP) {
+ if (proto == PROTO_UDP) {
server_.AddInternalSocket(
AsyncUDPSocket::Create(socket_factory_, int_addr), proto);
- } else if (proto == webrtc::PROTO_TCP || proto == webrtc::PROTO_TLS) {
+ } else if (proto == PROTO_TCP || proto == PROTO_TLS) {
// For TCP we need to create a server socket which can listen for incoming
// new connections.
Socket* socket = socket_factory_->CreateSocket(AF_INET, SOCK_STREAM);
socket->Bind(int_addr);
socket->Listen(5);
- if (proto == webrtc::PROTO_TLS) {
+ if (proto == PROTO_TLS) {
// For TLS, wrap the TCP socket with an SSL adapter. The adapter must
// be configured with a self-signed certificate for testing.
// Additionally, the client will not present a valid certificate, so we
// must not fail when checking the peer's identity.
std::unique_ptr<SSLAdapterFactory> ssl_adapter_factory =
SSLAdapterFactory::Create();
- ssl_adapter_factory->SetRole(webrtc::SSL_SERVER);
+ ssl_adapter_factory->SetRole(SSL_SERVER);
ssl_adapter_factory->SetIdentity(
SSLIdentity::Create(common_name, KeyParams()));
ssl_adapter_factory->SetIgnoreBadCert(ignore_bad_cert);
diff --git a/p2p/test/turn_server.h b/p2p/test/turn_server.h
index 0a74d52..59397a6 100644
--- a/p2p/test/turn_server.h
+++ b/p2p/test/turn_server.h
@@ -51,7 +51,7 @@
// Encapsulates the client's connection to the server.
class TurnServerConnection {
public:
- TurnServerConnection() : proto_(webrtc::PROTO_UDP), socket_(NULL) {}
+ TurnServerConnection() : proto_(PROTO_UDP), socket_(NULL) {}
TurnServerConnection(const SocketAddress& src,
ProtocolType proto,
AsyncPacketSocket* socket);
