[cleanup] Fix redundant webrtc name specifier
This CL was uploaded by git cl split.
R=hta@webrtc.org
No-IWYU: LSC
Bug: webrtc:42232595
Change-Id: I34e14bba2b09d3b344d434b9779effffba7b745c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/390606
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44575}
diff --git a/rtc_base/async_dns_resolver.cc b/rtc_base/async_dns_resolver.cc
index 625721a..9c9610d 100644
--- a/rtc_base/async_dns_resolver.cc
+++ b/rtc_base/async_dns_resolver.cc
@@ -112,7 +112,7 @@
// Execute the passed function if the state is Active.
void Finish(absl::AnyInvocable<void()> function) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
if (status_ != Status::kActive) {
return;
}
@@ -120,12 +120,12 @@
function();
}
void Kill() {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
status_ = Status::kDead;
}
private:
- webrtc::Mutex mutex_;
+ Mutex mutex_;
Status status_ RTC_GUARDED_BY(mutex_) = Status::kActive;
};
@@ -148,7 +148,7 @@
result_.addr_ = addr;
callback_ = std::move(callback);
auto thread_function = [this, addr, family, flag = safety_.flag(),
- caller_task_queue = webrtc::TaskQueueBase::Current(),
+ caller_task_queue = TaskQueueBase::Current(),
state = state_] {
std::vector<IPAddress> addresses;
int error = ResolveHostname(addr.hostname(), family, addresses);
diff --git a/rtc_base/async_dns_resolver_unittest.cc b/rtc_base/async_dns_resolver_unittest.cc
index e9f1d2b..ae03b20 100644
--- a/rtc_base/async_dns_resolver_unittest.cc
+++ b/rtc_base/async_dns_resolver_unittest.cc
@@ -28,7 +28,7 @@
using ::testing::IsTrue;
-const webrtc::TimeDelta kDefaultTimeout = webrtc::TimeDelta::Millis(1000);
+const TimeDelta kDefaultTimeout = TimeDelta::Millis(1000);
const int kPortNumber = 3027;
TEST(AsyncDnsResolver, ConstructorWorks) {
diff --git a/rtc_base/async_packet_socket.cc b/rtc_base/async_packet_socket.cc
index 2ead920..397e197 100644
--- a/rtc_base/async_packet_socket.cc
+++ b/rtc_base/async_packet_socket.cc
@@ -41,7 +41,7 @@
void AsyncPacketSocket::SubscribeCloseEvent(
const void* removal_tag,
- std::function<void(webrtc::AsyncPacketSocket*, int)> callback) {
+ std::function<void(AsyncPacketSocket*, int)> callback) {
RTC_DCHECK_RUN_ON(&network_checker_);
on_close_.AddReceiver(removal_tag, std::move(callback));
}
@@ -52,8 +52,7 @@
}
void AsyncPacketSocket::RegisterReceivedPacketCallback(
- absl::AnyInvocable<void(webrtc::AsyncPacketSocket*,
- const webrtc::ReceivedIpPacket&)>
+ absl::AnyInvocable<void(AsyncPacketSocket*, const ReceivedIpPacket&)>
received_packet_callback) {
RTC_DCHECK_RUN_ON(&network_checker_);
RTC_CHECK(!received_packet_callback_);
diff --git a/rtc_base/async_packet_socket_unittest.cc b/rtc_base/async_packet_socket_unittest.cc
index 9ed491e..b37334a 100644
--- a/rtc_base/async_packet_socket_unittest.cc
+++ b/rtc_base/async_packet_socket_unittest.cc
@@ -30,7 +30,7 @@
Send,
(const void* pv,
size_t cb,
- const webrtc::AsyncSocketPacketOptions& options),
+ const AsyncSocketPacketOptions& options),
(override));
MOCK_METHOD(int,
@@ -38,7 +38,7 @@
(const void* pv,
size_t cb,
const SocketAddress& addr,
- const webrtc::AsyncSocketPacketOptions& options),
+ const AsyncSocketPacketOptions& options),
(override));
MOCK_METHOD(int, Close, (), (override));
MOCK_METHOD(State, GetState, (), (const, override));
@@ -52,8 +52,7 @@
TEST(AsyncPacketSocket, RegisteredCallbackReceivePacketsFromNotify) {
MockAsyncPacketSocket mock_socket;
- MockFunction<void(webrtc::AsyncPacketSocket*,
- const webrtc::ReceivedIpPacket&)>
+ MockFunction<void(AsyncPacketSocket*, const ReceivedIpPacket&)>
received_packet;
EXPECT_CALL(received_packet, Call);
diff --git a/rtc_base/async_tcp_socket.cc b/rtc_base/async_tcp_socket.cc
index 420d359..e07bfc1 100644
--- a/rtc_base/async_tcp_socket.cc
+++ b/rtc_base/async_tcp_socket.cc
@@ -266,7 +266,7 @@
if (!IsOutBufferEmpty())
return static_cast<int>(cb);
- PacketLength pkt_len = webrtc::HostToNetwork16(static_cast<PacketLength>(cb));
+ PacketLength pkt_len = HostToNetwork16(static_cast<PacketLength>(cb));
AppendToOutBuffer(&pkt_len, kPacketLenSize);
AppendToOutBuffer(pv, cb);
@@ -295,7 +295,7 @@
if (bytes_left < kPacketLenSize)
return processed_bytes;
- PacketLength pkt_len = webrtc::GetBE16(data.data() + processed_bytes);
+ PacketLength pkt_len = GetBE16(data.data() + processed_bytes);
if (bytes_left < kPacketLenSize + pkt_len)
return processed_bytes;
diff --git a/rtc_base/async_udp_socket.cc b/rtc_base/async_udp_socket.cc
index f084687..652c104 100644
--- a/rtc_base/async_udp_socket.cc
+++ b/rtc_base/async_udp_socket.cc
@@ -67,7 +67,7 @@
const AsyncSocketPacketOptions& options) {
SentPacketInfo sent_packet(options.packet_id, TimeMillis(),
options.info_signaled_after_sent);
- webrtc::CopySocketInformationToPacketInfo(cb, *this, &sent_packet.info);
+ CopySocketInformationToPacketInfo(cb, *this, &sent_packet.info);
int ret = socket_->Send(pv, cb);
SignalSentPacket(this, sent_packet);
return ret;
@@ -79,7 +79,7 @@
const AsyncSocketPacketOptions& options) {
SentPacketInfo sent_packet(options.packet_id, TimeMillis(),
options.info_signaled_after_sent);
- webrtc::CopySocketInformationToPacketInfo(cb, *this, &sent_packet.info);
+ CopySocketInformationToPacketInfo(cb, *this, &sent_packet.info);
if (has_set_ect1_options_ != options.ecn_1) {
// It is unclear what is most efficient, setting options on every sent
// packet or when changed. Potentially, can separate send sockets be used?
diff --git a/rtc_base/bit_buffer_unittest.cc b/rtc_base/bit_buffer_unittest.cc
index 923a3df..670275c 100644
--- a/rtc_base/bit_buffer_unittest.cc
+++ b/rtc_base/bit_buffer_unittest.cc
@@ -22,7 +22,6 @@
namespace webrtc {
using ::testing::ElementsAre;
-using ::webrtc::BitstreamReader;
TEST(BitBufferWriterTest, ConsumeBits) {
uint8_t bytes[64] = {0};
diff --git a/rtc_base/boringssl_certificate.cc b/rtc_base/boringssl_certificate.cc
index 016b4da..4a34d05 100644
--- a/rtc_base/boringssl_certificate.cc
+++ b/rtc_base/boringssl_certificate.cc
@@ -265,7 +265,7 @@
SSLIdentityParams actual_params(params);
if (actual_params.common_name.empty()) {
// Use a random string, arbitrarily 8 chars long.
- actual_params.common_name = webrtc::CreateRandomString(8);
+ actual_params.common_name = CreateRandomString(8);
}
bssl::UniquePtr<CRYPTO_BUFFER> cert_buffer =
MakeCertificate(key_pair->pkey(), actual_params);
diff --git a/rtc_base/boringssl_identity.cc b/rtc_base/boringssl_identity.cc
index 5c8f60e..4406962 100644
--- a/rtc_base/boringssl_identity.cc
+++ b/rtc_base/boringssl_identity.cc
@@ -116,9 +116,8 @@
std::unique_ptr<SSLIdentity> BoringSSLIdentity::CreateFromPEMChainStrings(
absl::string_view private_key,
absl::string_view certificate_chain) {
- bssl::UniquePtr<BIO> bio(
- BIO_new_mem_buf(certificate_chain.data(),
- webrtc::dchecked_cast<int>(certificate_chain.size())));
+ bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(
+ certificate_chain.data(), dchecked_cast<int>(certificate_chain.size())));
if (!bio) {
return nullptr;
}
diff --git a/rtc_base/byte_buffer.cc b/rtc_base/byte_buffer.cc
index 0f5ea52..0cf153f 100644
--- a/rtc_base/byte_buffer.cc
+++ b/rtc_base/byte_buffer.cc
@@ -56,7 +56,7 @@
if (!ReadBytes(reinterpret_cast<uint8_t*>(&v), 2)) {
return false;
} else {
- *val = webrtc::NetworkToHost16(v);
+ *val = NetworkToHost16(v);
return true;
}
}
@@ -72,7 +72,7 @@
if (!ReadBytes(read_into, 3)) {
return false;
} else {
- *val = webrtc::NetworkToHost32(v);
+ *val = NetworkToHost32(v);
return true;
}
}
@@ -85,7 +85,7 @@
if (!ReadBytes(reinterpret_cast<uint8_t*>(&v), 4)) {
return false;
} else {
- *val = webrtc::NetworkToHost32(v);
+ *val = NetworkToHost32(v);
return true;
}
}
@@ -98,7 +98,7 @@
if (!ReadBytes(reinterpret_cast<uint8_t*>(&v), 8)) {
return false;
} else {
- *val = webrtc::NetworkToHost64(v);
+ *val = NetworkToHost64(v);
return true;
}
}
diff --git a/rtc_base/byte_buffer_unittest.cc b/rtc_base/byte_buffer_unittest.cc
index 6bf532d..d0b93e2 100644
--- a/rtc_base/byte_buffer_unittest.cc
+++ b/rtc_base/byte_buffer_unittest.cc
@@ -46,35 +46,35 @@
uint32_t n32 = 1;
uint64_t n64 = 1;
- EXPECT_EQ(n16, webrtc::NetworkToHost16(webrtc::HostToNetwork16(n16)));
- EXPECT_EQ(n32, webrtc::NetworkToHost32(webrtc::HostToNetwork32(n32)));
- EXPECT_EQ(n64, webrtc::NetworkToHost64(webrtc::HostToNetwork64(n64)));
+ EXPECT_EQ(n16, NetworkToHost16(HostToNetwork16(n16)));
+ EXPECT_EQ(n32, NetworkToHost32(HostToNetwork32(n32)));
+ EXPECT_EQ(n64, NetworkToHost64(HostToNetwork64(n64)));
- if (webrtc::IsHostBigEndian()) {
+ if (IsHostBigEndian()) {
// The host is the network (big) endian.
- EXPECT_EQ(n16, webrtc::HostToNetwork16(n16));
- EXPECT_EQ(n32, webrtc::HostToNetwork32(n32));
- EXPECT_EQ(n64, webrtc::HostToNetwork64(n64));
+ EXPECT_EQ(n16, HostToNetwork16(n16));
+ EXPECT_EQ(n32, HostToNetwork32(n32));
+ EXPECT_EQ(n64, HostToNetwork64(n64));
// GetBE converts big endian to little endian here.
- EXPECT_EQ(n16 >> 8, webrtc::GetBE16(&n16));
- EXPECT_EQ(n32 >> 24, webrtc::GetBE32(&n32));
- EXPECT_EQ(n64 >> 56, webrtc::GetBE64(&n64));
+ EXPECT_EQ(n16 >> 8, GetBE16(&n16));
+ EXPECT_EQ(n32 >> 24, GetBE32(&n32));
+ EXPECT_EQ(n64 >> 56, GetBE64(&n64));
} else {
// The host is little endian.
- EXPECT_NE(n16, webrtc::HostToNetwork16(n16));
- EXPECT_NE(n32, webrtc::HostToNetwork32(n32));
- EXPECT_NE(n64, webrtc::HostToNetwork64(n64));
+ EXPECT_NE(n16, HostToNetwork16(n16));
+ EXPECT_NE(n32, HostToNetwork32(n32));
+ EXPECT_NE(n64, HostToNetwork64(n64));
// GetBE converts little endian to big endian here.
- EXPECT_EQ(webrtc::GetBE16(&n16), webrtc::HostToNetwork16(n16));
- EXPECT_EQ(webrtc::GetBE32(&n32), webrtc::HostToNetwork32(n32));
- EXPECT_EQ(webrtc::GetBE64(&n64), webrtc::HostToNetwork64(n64));
+ EXPECT_EQ(GetBE16(&n16), HostToNetwork16(n16));
+ EXPECT_EQ(GetBE32(&n32), HostToNetwork32(n32));
+ EXPECT_EQ(GetBE64(&n64), HostToNetwork64(n64));
// GetBE converts little endian to big endian here.
- EXPECT_EQ(n16 << 8, webrtc::GetBE16(&n16));
- EXPECT_EQ(n32 << 24, webrtc::GetBE32(&n32));
- EXPECT_EQ(n64 << 56, webrtc::GetBE64(&n64));
+ EXPECT_EQ(n16 << 8, GetBE16(&n16));
+ EXPECT_EQ(n32 << 24, GetBE32(&n32));
+ EXPECT_EQ(n64 << 56, GetBE64(&n64));
}
}
diff --git a/rtc_base/containers/flat_set_unittest.cc b/rtc_base/containers/flat_set_unittest.cc
index 22c051a..6b0a2f7 100644
--- a/rtc_base/containers/flat_set_unittest.cc
+++ b/rtc_base/containers/flat_set_unittest.cc
@@ -99,7 +99,7 @@
}
TEST(FlatSet, UsingTransparentCompare) {
- using ExplicitInt = webrtc::MoveOnlyInt;
+ using ExplicitInt = MoveOnlyInt;
flat_set<ExplicitInt> s;
const auto& s1 = s;
int x = 0;
diff --git a/rtc_base/cpu_time.cc b/rtc_base/cpu_time.cc
index b0d187c..0ae8906 100644
--- a/rtc_base/cpu_time.cc
+++ b/rtc_base/cpu_time.cc
@@ -58,7 +58,7 @@
#elif defined(WEBRTC_LINUX)
struct timespec ts;
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) == 0) {
- return ts.tv_sec * webrtc::kNumNanosecsPerSec + ts.tv_nsec;
+ return ts.tv_sec * kNumNanosecsPerSec + ts.tv_nsec;
} else {
RTC_LOG_ERR(LS_ERROR) << "clock_gettime() failed.";
}
@@ -106,7 +106,7 @@
#elif defined(WEBRTC_LINUX)
struct timespec ts;
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) == 0) {
- return ts.tv_sec * webrtc::kNumNanosecsPerSec + ts.tv_nsec;
+ return ts.tv_sec * kNumNanosecsPerSec + ts.tv_nsec;
} else {
RTC_LOG_ERR(LS_ERROR) << "clock_gettime() failed.";
}
diff --git a/rtc_base/cpu_time_unittest.cc b/rtc_base/cpu_time_unittest.cc
index fbdd5fa..9d2f4ad 100644
--- a/rtc_base/cpu_time_unittest.cc
+++ b/rtc_base/cpu_time_unittest.cc
@@ -80,25 +80,25 @@
// Therefore GetThreadCpuTime is not a wall clock.
EXPECT_LE(thread_duration_nanos,
(kProcessingTimeMillisecs - kAllowedErrorMillisecs) *
- webrtc::kNumNanosecsPerMillisec);
+ kNumNanosecsPerMillisec);
// Total process time is at least twice working threads' CPU time.
// Therefore process and thread times are correctly related.
EXPECT_GE(process_duration_nanos,
kWorkingThreads *
(kProcessingTimeMillisecs - kAllowedErrorMillisecs) *
- webrtc::kNumNanosecsPerMillisec);
+ kNumNanosecsPerMillisec);
}
TEST(CpuTimeTest, MAYBE_TEST(Sleeping)) {
int64_t process_start_time_nanos = GetProcessCpuTimeNanos();
- webrtc::SleepMs(kProcessingTimeMillisecs);
+ SleepMs(kProcessingTimeMillisecs);
int64_t process_duration_nanos =
GetProcessCpuTimeNanos() - process_start_time_nanos;
// Sleeping should not introduce any additional CPU time.
// Therefore GetProcessCpuTime is not a wall clock.
EXPECT_LE(process_duration_nanos,
(kProcessingTimeMillisecs - kAllowedErrorMillisecs) *
- webrtc::kNumNanosecsPerMillisec);
+ kNumNanosecsPerMillisec);
}
} // namespace webrtc
diff --git a/rtc_base/event.cc b/rtc_base/event.cc
index b78e249..7338670 100644
--- a/rtc_base/event.cc
+++ b/rtc_base/event.cc
@@ -30,8 +30,6 @@
namespace webrtc {
-using ::webrtc::TimeDelta;
-
Event::Event() : Event(false, false) {}
#if defined(WEBRTC_WIN)
@@ -189,7 +187,7 @@
} else {
error = wait(warn_ts);
if (error == ETIMEDOUT) {
- webrtc::WarnThatTheCurrentThreadIsProbablyDeadlocked();
+ WarnThatTheCurrentThreadIsProbablyDeadlocked();
error = wait(give_up_ts);
}
}
diff --git a/rtc_base/file_rotating_stream_unittest.cc b/rtc_base/file_rotating_stream_unittest.cc
index 1422fd1..4ee54dc 100644
--- a/rtc_base/file_rotating_stream_unittest.cc
+++ b/rtc_base/file_rotating_stream_unittest.cc
@@ -30,7 +30,7 @@
void CleanupLogDirectory(const FileRotatingStream& stream) {
for (size_t i = 0; i < stream.GetNumFiles(); ++i) {
// Ignore return value, not all files are expected to exist.
- webrtc::test::RemoveFile(stream.GetFilePath(i));
+ test::RemoveFile(stream.GetFilePath(i));
}
}
@@ -53,14 +53,14 @@
size_t max_file_size,
size_t num_log_files,
bool ensure_trailing_delimiter = true) {
- dir_path_ = webrtc::test::OutputPath();
+ dir_path_ = test::OutputPath();
// Append per-test output path in order to run within gtest parallel.
dir_path_.append(dir_name.begin(), dir_name.end());
if (ensure_trailing_delimiter) {
- dir_path_.append(std::string(webrtc::test::kPathDelimiter));
+ dir_path_.append(std::string(test::kPathDelimiter));
}
- ASSERT_TRUE(webrtc::test::CreateDir(dir_path_));
+ ASSERT_TRUE(test::CreateDir(dir_path_));
stream_.reset(new FileRotatingStream(dir_path_, file_prefix, max_file_size,
num_log_files));
}
@@ -69,7 +69,7 @@
// On windows, open files can't be removed.
stream_->Close();
CleanupLogDirectory(*stream_);
- EXPECT_TRUE(webrtc::test::RemoveDir(dir_path_));
+ EXPECT_TRUE(test::RemoveDir(dir_path_));
stream_.reset();
}
@@ -158,12 +158,12 @@
}
// Check that exactly three files exist.
for (size_t i = 0; i < arraysize(messages); ++i) {
- EXPECT_TRUE(webrtc::test::FileExists(stream_->GetFilePath(i)));
+ EXPECT_TRUE(test::FileExists(stream_->GetFilePath(i)));
}
std::string message("d");
WriteAndFlush(message.c_str(), message.size());
for (size_t i = 0; i < arraysize(messages); ++i) {
- EXPECT_TRUE(webrtc::test::FileExists(stream_->GetFilePath(i)));
+ EXPECT_TRUE(test::FileExists(stream_->GetFilePath(i)));
}
// TODO(tkchin): Maybe check all the files in the dir.
@@ -193,8 +193,7 @@
// Reopen for read.
std::string expected_contents("bbccd");
VerifyStreamRead(expected_contents,
- dir_path_ + std::string(webrtc::test::kPathDelimiter),
- kFilePrefix);
+ dir_path_ + std::string(test::kPathDelimiter), kFilePrefix);
}
// Tests that a write operation followed by a read (without trailing delimiter)
@@ -258,12 +257,12 @@
class MAYBE_CallSessionFileRotatingStreamTest : public ::testing::Test {
protected:
void Init(absl::string_view dir_name, size_t max_total_log_size) {
- dir_path_ = webrtc::test::OutputPath();
+ dir_path_ = test::OutputPath();
// Append per-test output path in order to run within gtest parallel.
dir_path_.append(dir_name.begin(), dir_name.end());
- dir_path_.append(std::string(webrtc::test::kPathDelimiter));
- ASSERT_TRUE(webrtc::test::CreateDir(dir_path_));
+ dir_path_.append(std::string(test::kPathDelimiter));
+ ASSERT_TRUE(test::CreateDir(dir_path_));
stream_.reset(
new CallSessionFileRotatingStream(dir_path_, max_total_log_size));
}
@@ -272,7 +271,7 @@
// On windows, open files can't be removed.
stream_->Close();
CleanupLogDirectory(*stream_);
- EXPECT_TRUE(webrtc::test::RemoveDir(dir_path_));
+ EXPECT_TRUE(test::RemoveDir(dir_path_));
stream_.reset();
}
diff --git a/rtc_base/ifaddrs_converter.cc b/rtc_base/ifaddrs_converter.cc
index de949aa..8b50e3d 100644
--- a/rtc_base/ifaddrs_converter.cc
+++ b/rtc_base/ifaddrs_converter.cc
@@ -31,7 +31,7 @@
return true;
}
case AF_INET6: {
- int ip_attributes = webrtc::IPV6_ADDRESS_FLAG_NONE;
+ int ip_attributes = IPV6_ADDRESS_FLAG_NONE;
if (!ConvertNativeAttributesToIPAttributes(interface, &ip_attributes)) {
return false;
}
@@ -51,7 +51,7 @@
bool IfAddrsConverter::ConvertNativeAttributesToIPAttributes(
const struct ifaddrs* /* interface */,
int* ip_attributes) {
- *ip_attributes = webrtc::IPV6_ADDRESS_FLAG_NONE;
+ *ip_attributes = IPV6_ADDRESS_FLAG_NONE;
return true;
}
diff --git a/rtc_base/ip_address.cc b/rtc_base/ip_address.cc
index 92be158..5c349dc 100644
--- a/rtc_base/ip_address.cc
+++ b/rtc_base/ip_address.cc
@@ -46,7 +46,7 @@
uint32_t IPAddress::v4AddressAsHostOrderInteger() const {
if (family_ == AF_INET) {
- return webrtc::NetworkToHost32(u_.ip4.s_addr);
+ return NetworkToHost32(u_.ip4.s_addr);
} else {
return 0;
}
@@ -112,8 +112,8 @@
// Comparing addresses of the same family.
switch (family_) {
case AF_INET: {
- return webrtc::NetworkToHost32(u_.ip4.s_addr) <
- webrtc::NetworkToHost32(other.u_.ip4.s_addr);
+ return NetworkToHost32(u_.ip4.s_addr) <
+ NetworkToHost32(other.u_.ip4.s_addr);
}
case AF_INET6: {
return memcmp(&u_.ip6.s6_addr, &other.u_.ip6.s6_addr, 16) < 0;
@@ -371,9 +371,9 @@
return IPAddress(INADDR_ANY);
}
int mask = (0xFFFFFFFF << (32 - length));
- uint32_t host_order_ip = webrtc::NetworkToHost32(ip.ipv4_address().s_addr);
+ uint32_t host_order_ip = NetworkToHost32(ip.ipv4_address().s_addr);
in_addr masked;
- masked.s_addr = webrtc::HostToNetwork32(host_order_ip & mask);
+ masked.s_addr = HostToNetwork32(host_order_ip & mask);
return IPAddress(masked);
} else if (ip.family() == AF_INET6) {
if (length > 127) {
@@ -390,8 +390,8 @@
uint32_t* v6_as_ints = reinterpret_cast<uint32_t*>(&v6addr.s6_addr);
for (int i = 0; i < 4; ++i) {
if (i == position) {
- uint32_t host_order_inner = webrtc::NetworkToHost32(v6_as_ints[i]);
- v6_as_ints[i] = webrtc::HostToNetwork32(host_order_inner & inner_mask);
+ uint32_t host_order_inner = NetworkToHost32(v6_as_ints[i]);
+ v6_as_ints[i] = HostToNetwork32(host_order_inner & inner_mask);
} else if (i > position) {
v6_as_ints[i] = 0;
}
@@ -406,7 +406,7 @@
int bits = 0;
switch (mask.family()) {
case AF_INET: {
- word_to_count = webrtc::NetworkToHost32(mask.ipv4_address().s_addr);
+ word_to_count = NetworkToHost32(mask.ipv4_address().s_addr);
break;
}
case AF_INET6: {
@@ -420,7 +420,7 @@
}
}
if (i < 4) {
- word_to_count = webrtc::NetworkToHost32(v6_as_ints[i]);
+ word_to_count = NetworkToHost32(v6_as_ints[i]);
}
bits = (i * 32);
break;
diff --git a/rtc_base/ip_address_unittest.cc b/rtc_base/ip_address_unittest.cc
index 5f5988d..ff6a182 100644
--- a/rtc_base/ip_address_unittest.cc
+++ b/rtc_base/ip_address_unittest.cc
@@ -522,7 +522,7 @@
test_info.ai_next = &next_info;
// Check that we can get an IPv4 address out.
test_info.ai_addr = reinterpret_cast<struct sockaddr*>(&expected4);
- expected4.sin_addr.s_addr = webrtc::HostToNetwork32(kIPv4PublicAddr);
+ expected4.sin_addr.s_addr = HostToNetwork32(kIPv4PublicAddr);
expected4.sin_family = AF_INET;
IPAddress expected(kIPv4PublicAddr);
IPAddress addr;
diff --git a/rtc_base/memory/fifo_buffer.cc b/rtc_base/memory/fifo_buffer.cc
index 8c10200..4eb0dfa 100644
--- a/rtc_base/memory/fifo_buffer.cc
+++ b/rtc_base/memory/fifo_buffer.cc
@@ -24,7 +24,7 @@
namespace webrtc {
FifoBuffer::FifoBuffer(size_t size)
- : state_(webrtc::SS_OPEN),
+ : state_(SS_OPEN),
buffer_(new char[size]),
buffer_length_(size),
data_length_(0),
@@ -34,7 +34,7 @@
}
FifoBuffer::FifoBuffer(size_t size, Thread* owner)
- : state_(webrtc::SS_OPEN),
+ : state_(SS_OPEN),
buffer_(new char[size]),
buffer_length_(size),
data_length_(0),
@@ -64,7 +64,7 @@
size_t copy = 0;
StreamResult result = ReadLocked(buffer.data(), buffer.size(), ©);
- if (result == webrtc::SR_SUCCESS) {
+ if (result == SR_SUCCESS) {
// If read was successful then adjust the read position and number of
// bytes buffered.
read_position_ = (read_position_ + copy) % buffer_length_;
@@ -73,7 +73,7 @@
// if we were full before, and now we're not, post an event
if (!was_writable && copy > 0) {
- PostEvent(webrtc::SE_WRITE, 0);
+ PostEvent(SE_WRITE, 0);
}
}
return result;
@@ -88,13 +88,13 @@
size_t copy = 0;
StreamResult result = WriteLocked(buffer.data(), buffer.size(), ©);
- if (result == webrtc::SR_SUCCESS) {
+ if (result == SR_SUCCESS) {
// If write was successful then adjust the number of readable bytes.
data_length_ += copy;
bytes_written = copy;
// if we didn't have any data to read before, and now we do, post an event
if (!was_readable && copy > 0) {
- PostEvent(webrtc::SE_READ, 0);
+ PostEvent(SE_READ, 0);
}
}
return result;
@@ -102,7 +102,7 @@
void FifoBuffer::Close() {
RTC_DCHECK_RUN_ON(&callback_sequence_);
- state_ = webrtc::SS_CLOSED;
+ state_ = SS_CLOSED;
}
const void* FifoBuffer::GetReadData(size_t* size) {
@@ -120,14 +120,14 @@
read_position_ = (read_position_ + size) % buffer_length_;
data_length_ -= size;
if (!was_writable && size > 0) {
- PostEvent(webrtc::SE_WRITE, 0);
+ PostEvent(SE_WRITE, 0);
}
}
void* FifoBuffer::GetWriteBuffer(size_t* size) {
RTC_DCHECK_RUN_ON(&callback_sequence_);
- if (state_ == webrtc::SS_CLOSED) {
+ if (state_ == SS_CLOSED) {
return nullptr;
}
@@ -151,7 +151,7 @@
const bool was_readable = (data_length_ > 0);
data_length_ += size;
if (!was_readable && size > 0) {
- PostEvent(webrtc::SE_READ, 0);
+ PostEvent(SE_READ, 0);
}
}
@@ -159,7 +159,7 @@
size_t bytes,
size_t* bytes_read) {
if (data_length_ == 0) {
- return (state_ != webrtc::SS_CLOSED) ? webrtc::SR_BLOCK : webrtc::SR_EOS;
+ return (state_ != SS_CLOSED) ? SR_BLOCK : SR_EOS;
}
const size_t available = data_length_;
@@ -173,18 +173,18 @@
if (bytes_read) {
*bytes_read = copy;
}
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
StreamResult FifoBuffer::WriteLocked(const void* buffer,
size_t bytes,
size_t* bytes_written) {
- if (state_ == webrtc::SS_CLOSED) {
- return webrtc::SR_EOS;
+ if (state_ == SS_CLOSED) {
+ return SR_EOS;
}
if (data_length_ >= buffer_length_) {
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
}
const size_t available = buffer_length_ - data_length_;
@@ -199,7 +199,7 @@
if (bytes_written) {
*bytes_written = copy;
}
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
} // namespace webrtc
diff --git a/rtc_base/memory_stream.cc b/rtc_base/memory_stream.cc
index ad6793e..d0b6acb 100644
--- a/rtc_base/memory_stream.cc
+++ b/rtc_base/memory_stream.cc
@@ -23,14 +23,14 @@
namespace webrtc {
StreamState MemoryStream::GetState() const {
- return webrtc::SS_OPEN;
+ return SS_OPEN;
}
StreamResult MemoryStream::Read(ArrayView<uint8_t> buffer,
size_t& bytes_read,
int& error) {
if (seek_position_ >= data_length_) {
- return webrtc::SR_EOS;
+ return SR_EOS;
}
size_t available = data_length_ - seek_position_;
size_t bytes;
@@ -43,7 +43,7 @@
memcpy(buffer.data(), &buffer_[seek_position_], bytes);
seek_position_ += bytes;
bytes_read = bytes;
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
StreamResult MemoryStream::Write(ArrayView<const uint8_t> buffer,
@@ -57,7 +57,7 @@
size_t new_buffer_length = std::max(
((seek_position_ + buffer.size()) | 0xFF) + 1, buffer_length_ * 2);
StreamResult result = DoReserve(new_buffer_length, &error);
- if (webrtc::SR_SUCCESS != result) {
+ if (SR_SUCCESS != result) {
return result;
}
RTC_DCHECK(buffer_length_ >= new_buffer_length);
@@ -74,7 +74,7 @@
data_length_ = seek_position_;
}
bytes_written = bytes;
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
void MemoryStream::Close() {
@@ -105,7 +105,7 @@
}
bool MemoryStream::ReserveSize(size_t size) {
- return (webrtc::SR_SUCCESS == DoReserve(size, nullptr));
+ return (SR_SUCCESS == DoReserve(size, nullptr));
}
///////////////////////////////////////////////////////////////////////////////
@@ -126,7 +126,7 @@
StreamResult MemoryStream::DoReserve(size_t size, int* error) {
if (buffer_length_ >= size)
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
if (char* new_buffer = new char[size]) {
if (buffer_ != nullptr && data_length_ > 0) {
@@ -135,13 +135,13 @@
delete[] buffer_;
buffer_ = new_buffer;
buffer_length_ = size;
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
if (error) {
*error = ENOMEM;
}
- return webrtc::SR_ERROR;
+ return SR_ERROR;
}
} // namespace webrtc
diff --git a/rtc_base/network.cc b/rtc_base/network.cc
index cc796b7..edb78eb 100644
--- a/rtc_base/network.cc
+++ b/rtc_base/network.cc
@@ -62,10 +62,6 @@
namespace webrtc {
namespace {
-using ::webrtc::Environment;
-using ::webrtc::SafeTask;
-using ::webrtc::SocketFactory;
-using ::webrtc::TimeDelta;
// List of MAC addresses of known VPN (for windows).
constexpr uint8_t kVpns[3][6] = {
@@ -101,9 +97,8 @@
// After type, networks are sorted by IP address precedence values
// from RFC 3484-bis
- if (webrtc::IPAddressPrecedence(ip_a) != webrtc::IPAddressPrecedence(ip_b)) {
- return webrtc::IPAddressPrecedence(ip_a) >
- webrtc::IPAddressPrecedence(ip_b);
+ if (IPAddressPrecedence(ip_a) != IPAddressPrecedence(ip_b)) {
+ return IPAddressPrecedence(ip_a) > IPAddressPrecedence(ip_b);
}
// TODO(mallinath) - Add VPN and Link speed conditions while sorting.
@@ -118,37 +113,32 @@
bool add_network_cost_to_vpn) {
// TODO(jonaso) : Rollout support for cellular network cost using A/B
// experiment to make sure it does not introduce regressions.
- int vpnCost =
- (is_vpn && add_network_cost_to_vpn) ? webrtc::kNetworkCostVpn : 0;
+ int vpnCost = (is_vpn && add_network_cost_to_vpn) ? kNetworkCostVpn : 0;
switch (type) {
- case webrtc::ADAPTER_TYPE_ETHERNET:
- case webrtc::ADAPTER_TYPE_LOOPBACK:
- return webrtc::kNetworkCostMin + vpnCost;
- case webrtc::ADAPTER_TYPE_WIFI:
- return webrtc::kNetworkCostLow + vpnCost;
- case webrtc::ADAPTER_TYPE_CELLULAR:
- return webrtc::kNetworkCostCellular + vpnCost;
- case webrtc::ADAPTER_TYPE_CELLULAR_2G:
- return (use_differentiated_cellular_costs
- ? webrtc::kNetworkCostCellular2G
- : webrtc::kNetworkCostCellular) +
+ case ADAPTER_TYPE_ETHERNET:
+ case ADAPTER_TYPE_LOOPBACK:
+ return kNetworkCostMin + vpnCost;
+ case ADAPTER_TYPE_WIFI:
+ return kNetworkCostLow + vpnCost;
+ case ADAPTER_TYPE_CELLULAR:
+ return kNetworkCostCellular + vpnCost;
+ case ADAPTER_TYPE_CELLULAR_2G:
+ return (use_differentiated_cellular_costs ? kNetworkCostCellular2G
+ : kNetworkCostCellular) +
vpnCost;
- case webrtc::ADAPTER_TYPE_CELLULAR_3G:
- return (use_differentiated_cellular_costs
- ? webrtc::kNetworkCostCellular3G
- : webrtc::kNetworkCostCellular) +
+ case ADAPTER_TYPE_CELLULAR_3G:
+ return (use_differentiated_cellular_costs ? kNetworkCostCellular3G
+ : kNetworkCostCellular) +
vpnCost;
- case webrtc::ADAPTER_TYPE_CELLULAR_4G:
- return (use_differentiated_cellular_costs
- ? webrtc::kNetworkCostCellular4G
- : webrtc::kNetworkCostCellular) +
+ case ADAPTER_TYPE_CELLULAR_4G:
+ return (use_differentiated_cellular_costs ? kNetworkCostCellular4G
+ : kNetworkCostCellular) +
vpnCost;
- case webrtc::ADAPTER_TYPE_CELLULAR_5G:
- return (use_differentiated_cellular_costs
- ? webrtc::kNetworkCostCellular5G
- : webrtc::kNetworkCostCellular) +
+ case ADAPTER_TYPE_CELLULAR_5G:
+ return (use_differentiated_cellular_costs ? kNetworkCostCellular5G
+ : kNetworkCostCellular) +
vpnCost;
- case webrtc::ADAPTER_TYPE_ANY:
+ case ADAPTER_TYPE_ANY:
// Candidates gathered from the any-address/wildcard ports, as backups,
// are given the maximum cost so that if there are other candidates with
// known interface types, we would not select candidate pairs using these
@@ -158,13 +148,13 @@
// ADAPTER_TYPE_CELLULAR would then have a higher cost. See
// P2PTransportChannel::SortConnectionsAndUpdateState for how we rank and
// select candidate pairs, where the network cost is among the criteria.
- return webrtc::kNetworkCostMax + vpnCost;
- case webrtc::ADAPTER_TYPE_VPN:
+ return kNetworkCostMax + vpnCost;
+ case ADAPTER_TYPE_VPN:
// The cost of a VPN should be computed using its underlying network type.
RTC_DCHECK_NOTREACHED();
- return webrtc::kNetworkCostUnknown;
+ return kNetworkCostUnknown;
default:
- return webrtc::kNetworkCostUnknown + vpnCost;
+ return kNetworkCostUnknown + vpnCost;
}
}
@@ -177,19 +167,19 @@
// Link-local addresses require scope id to be bound successfully.
// However, our IPAddress structure doesn't carry that so the
// information is lost and causes binding failure.
- if (webrtc::IPIsLinkLocal(ip)) {
+ if (IPIsLinkLocal(ip)) {
RTC_LOG(LS_VERBOSE) << "Ignore link local IP:" << ip.ToSensitiveString();
return true;
}
// Any MAC based IPv6 should be avoided to prevent the MAC tracking.
- if (webrtc::IPIsMacBased(ip) && !allow_mac_based_ipv6) {
+ if (IPIsMacBased(ip) && !allow_mac_based_ipv6) {
RTC_LOG(LS_INFO) << "Ignore Mac based IP:" << ip.ToSensitiveString();
return true;
}
// Ignore deprecated IPv6.
- if (ip.ipv6_flags() & webrtc::IPV6_ADDRESS_FLAG_DEPRECATED) {
+ if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_DEPRECATED) {
RTC_LOG(LS_INFO) << "Ignore deprecated IP:" << ip.ToSensitiveString();
return true;
}
@@ -275,23 +265,23 @@
// Note that we have a more robust way to determine if a network interface
// is a loopback interface by checking the flag IFF_LOOPBACK in ifa_flags of
// an ifaddr struct. See ConvertIfAddrs in this file.
- return webrtc::ADAPTER_TYPE_LOOPBACK;
+ return ADAPTER_TYPE_LOOPBACK;
}
if (MatchTypeNameWithIndexPattern(network_name, "eth")) {
- return webrtc::ADAPTER_TYPE_ETHERNET;
+ return ADAPTER_TYPE_ETHERNET;
}
if (MatchTypeNameWithIndexPattern(network_name, "wlan") ||
MatchTypeNameWithIndexPattern(network_name, "v4-wlan")) {
- return webrtc::ADAPTER_TYPE_WIFI;
+ return ADAPTER_TYPE_WIFI;
}
if (MatchTypeNameWithIndexPattern(network_name, "ipsec") ||
MatchTypeNameWithIndexPattern(network_name, "tun") ||
MatchTypeNameWithIndexPattern(network_name, "utun") ||
MatchTypeNameWithIndexPattern(network_name, "tap")) {
- return webrtc::ADAPTER_TYPE_VPN;
+ return ADAPTER_TYPE_VPN;
}
#if defined(WEBRTC_IOS)
// Cell networks are pdp_ipN on iOS.
@@ -316,7 +306,7 @@
}
#endif
- return webrtc::ADAPTER_TYPE_UNKNOWN;
+ return ADAPTER_TYPE_UNKNOWN;
}
NetworkManager::EnumerationPermission NetworkManager::enumeration_permission()
@@ -355,8 +345,8 @@
std::vector<const Network*> networks;
if (!ipv4_any_address_network_) {
const IPAddress ipv4_any_address(INADDR_ANY);
- ipv4_any_address_network_ = CreateNetwork("any", "any", ipv4_any_address, 0,
- webrtc::ADAPTER_TYPE_ANY);
+ ipv4_any_address_network_ =
+ CreateNetwork("any", "any", ipv4_any_address, 0, ADAPTER_TYPE_ANY);
ipv4_any_address_network_->set_default_local_address_provider(this);
ipv4_any_address_network_->set_mdns_responder_provider(this);
ipv4_any_address_network_->AddIP(ipv4_any_address);
@@ -365,8 +355,8 @@
if (!ipv6_any_address_network_) {
const IPAddress ipv6_any_address(in6addr_any);
- ipv6_any_address_network_ = CreateNetwork("any", "any", ipv6_any_address, 0,
- webrtc::ADAPTER_TYPE_ANY);
+ ipv6_any_address_network_ =
+ CreateNetwork("any", "any", ipv6_any_address, 0, ADAPTER_TYPE_ANY);
ipv6_any_address_network_->set_default_local_address_provider(this);
ipv6_any_address_network_->set_mdns_responder_provider(this);
ipv6_any_address_network_->AddIP(ipv6_any_address);
@@ -446,7 +436,7 @@
Network* existing_net = existing->second.get();
*changed = existing_net->SetIPs(kv.second.ips, *changed);
merged_list.push_back(existing_net);
- if (net->type() != webrtc::ADAPTER_TYPE_UNKNOWN &&
+ if (net->type() != ADAPTER_TYPE_UNKNOWN &&
net->type() != existing_net->type()) {
if (ShouldAdapterChangeTriggerNetworkChange(existing_net->type(),
net->type())) {
@@ -599,8 +589,8 @@
struct ifaddrs* cursor) const {
if (cursor->ifa_flags & IFF_LOOPBACK) {
return {
- .adapter_type = webrtc::ADAPTER_TYPE_LOOPBACK,
- .underlying_type_for_vpn = webrtc::ADAPTER_TYPE_UNKNOWN,
+ .adapter_type = ADAPTER_TYPE_LOOPBACK,
+ .underlying_type_for_vpn = ADAPTER_TYPE_UNKNOWN,
.network_preference = NetworkPreference::NEUTRAL,
.available = true,
};
@@ -608,7 +598,7 @@
return network_monitor_->GetInterfaceInfo(cursor->ifa_name);
} else {
return {.adapter_type = GetAdapterTypeFromName(cursor->ifa_name),
- .underlying_type_for_vpn = webrtc::ADAPTER_TYPE_UNKNOWN,
+ .underlying_type_for_vpn = ADAPTER_TYPE_UNKNOWN,
.network_preference = NetworkPreference::NEUTRAL,
.available = true};
}
@@ -658,8 +648,8 @@
reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_scope_id;
}
- int prefix_length = webrtc::CountIPMaskBits(mask);
- prefix = webrtc::TruncateIP(ip, prefix_length);
+ int prefix_length = CountIPMaskBits(mask);
+ prefix = TruncateIP(ip, prefix_length);
std::string key =
MakeNetworkKey(std::string(cursor->ifa_name), prefix, prefix_length);
@@ -694,10 +684,10 @@
NetworkMonitorInterface::InterfaceInfo if_info = GetInterfaceInfo(cursor);
// Check manually configured VPN override.
- if (if_info.adapter_type != webrtc::ADAPTER_TYPE_VPN &&
+ if (if_info.adapter_type != ADAPTER_TYPE_VPN &&
IsConfiguredVpn(prefix, prefix_length)) {
if_info.underlying_type_for_vpn = if_info.adapter_type;
- if_info.adapter_type = webrtc::ADAPTER_TYPE_VPN;
+ if_info.adapter_type = ADAPTER_TYPE_VPN;
}
auto network = CreateNetwork(cursor->ifa_name, cursor->ifa_name, prefix,
@@ -1177,32 +1167,32 @@
for (const InterfaceAddress& ip : ips_) {
// Ignore any address which has been deprecated already.
- if (ip.ipv6_flags() & webrtc::IPV6_ADDRESS_FLAG_DEPRECATED)
+ if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_DEPRECATED)
continue;
- if (webrtc::IPIsLinkLocal(ip)) {
+ if (IPIsLinkLocal(ip)) {
link_local_ip = ip;
continue;
}
// ULA address should only be returned when we have no other
// global IP.
- if (webrtc::IPIsULA(static_cast<const IPAddress&>(ip))) {
+ if (IPIsULA(static_cast<const IPAddress&>(ip))) {
ula_ip = ip;
continue;
}
selected_ip = ip;
// Search could stop once a temporary non-deprecated one is found.
- if (ip.ipv6_flags() & webrtc::IPV6_ADDRESS_FLAG_TEMPORARY)
+ if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_TEMPORARY)
break;
}
- if (webrtc::IPIsUnspec(selected_ip)) {
- if (!webrtc::IPIsUnspec(link_local_ip)) {
+ if (IPIsUnspec(selected_ip)) {
+ if (!IPIsUnspec(link_local_ip)) {
// No proper global IPv6 address found, use link local address instead.
selected_ip = link_local_ip;
- } else if (!webrtc::IPIsUnspec(ula_ip)) {
+ } else if (!IPIsUnspec(ula_ip)) {
// No proper global and link local address found, use ULA instead.
selected_ip = ula_ip;
}
@@ -1233,45 +1223,45 @@
std::pair<AdapterType, bool /* vpn */> Network::GuessAdapterFromNetworkCost(
int network_cost) {
switch (network_cost) {
- case webrtc::kNetworkCostMin:
- return {webrtc::ADAPTER_TYPE_ETHERNET, false};
- case webrtc::kNetworkCostMin + webrtc::kNetworkCostVpn:
- return {webrtc::ADAPTER_TYPE_ETHERNET, true};
- case webrtc::kNetworkCostLow:
- return {webrtc::ADAPTER_TYPE_WIFI, false};
- case webrtc::kNetworkCostLow + webrtc::kNetworkCostVpn:
- return {webrtc::ADAPTER_TYPE_WIFI, true};
- case webrtc::kNetworkCostCellular:
- return {webrtc::ADAPTER_TYPE_CELLULAR, false};
- case webrtc::kNetworkCostCellular + webrtc::kNetworkCostVpn:
- return {webrtc::ADAPTER_TYPE_CELLULAR, true};
- case webrtc::kNetworkCostCellular2G:
- return {webrtc::ADAPTER_TYPE_CELLULAR_2G, false};
- case webrtc::kNetworkCostCellular2G + webrtc::kNetworkCostVpn:
- return {webrtc::ADAPTER_TYPE_CELLULAR_2G, true};
- case webrtc::kNetworkCostCellular3G:
- return {webrtc::ADAPTER_TYPE_CELLULAR_3G, false};
- case webrtc::kNetworkCostCellular3G + webrtc::kNetworkCostVpn:
- return {webrtc::ADAPTER_TYPE_CELLULAR_3G, true};
- case webrtc::kNetworkCostCellular4G:
- return {webrtc::ADAPTER_TYPE_CELLULAR_4G, false};
- case webrtc::kNetworkCostCellular4G + webrtc::kNetworkCostVpn:
- return {webrtc::ADAPTER_TYPE_CELLULAR_4G, true};
- case webrtc::kNetworkCostCellular5G:
- return {webrtc::ADAPTER_TYPE_CELLULAR_5G, false};
- case webrtc::kNetworkCostCellular5G + webrtc::kNetworkCostVpn:
- return {webrtc::ADAPTER_TYPE_CELLULAR_5G, true};
- case webrtc::kNetworkCostUnknown:
- return {webrtc::ADAPTER_TYPE_UNKNOWN, false};
- case webrtc::kNetworkCostUnknown + webrtc::kNetworkCostVpn:
- return {webrtc::ADAPTER_TYPE_UNKNOWN, true};
- case webrtc::kNetworkCostMax:
- return {webrtc::ADAPTER_TYPE_ANY, false};
- case webrtc::kNetworkCostMax + webrtc::kNetworkCostVpn:
- return {webrtc::ADAPTER_TYPE_ANY, true};
+ case kNetworkCostMin:
+ return {ADAPTER_TYPE_ETHERNET, false};
+ case kNetworkCostMin + kNetworkCostVpn:
+ return {ADAPTER_TYPE_ETHERNET, true};
+ case kNetworkCostLow:
+ return {ADAPTER_TYPE_WIFI, false};
+ case kNetworkCostLow + kNetworkCostVpn:
+ return {ADAPTER_TYPE_WIFI, true};
+ case kNetworkCostCellular:
+ return {ADAPTER_TYPE_CELLULAR, false};
+ case kNetworkCostCellular + kNetworkCostVpn:
+ return {ADAPTER_TYPE_CELLULAR, true};
+ case kNetworkCostCellular2G:
+ return {ADAPTER_TYPE_CELLULAR_2G, false};
+ case kNetworkCostCellular2G + kNetworkCostVpn:
+ return {ADAPTER_TYPE_CELLULAR_2G, true};
+ case kNetworkCostCellular3G:
+ return {ADAPTER_TYPE_CELLULAR_3G, false};
+ case kNetworkCostCellular3G + kNetworkCostVpn:
+ return {ADAPTER_TYPE_CELLULAR_3G, true};
+ case kNetworkCostCellular4G:
+ return {ADAPTER_TYPE_CELLULAR_4G, false};
+ case kNetworkCostCellular4G + kNetworkCostVpn:
+ return {ADAPTER_TYPE_CELLULAR_4G, true};
+ case kNetworkCostCellular5G:
+ return {ADAPTER_TYPE_CELLULAR_5G, false};
+ case kNetworkCostCellular5G + kNetworkCostVpn:
+ return {ADAPTER_TYPE_CELLULAR_5G, true};
+ case kNetworkCostUnknown:
+ return {ADAPTER_TYPE_UNKNOWN, false};
+ case kNetworkCostUnknown + kNetworkCostVpn:
+ return {ADAPTER_TYPE_UNKNOWN, true};
+ case kNetworkCostMax:
+ return {ADAPTER_TYPE_ANY, false};
+ case kNetworkCostMax + kNetworkCostVpn:
+ return {ADAPTER_TYPE_ANY, true};
}
RTC_LOG(LS_VERBOSE) << "Unknown network cost: " << network_cost;
- return {webrtc::ADAPTER_TYPE_UNKNOWN, false};
+ return {ADAPTER_TYPE_UNKNOWN, false};
}
std::string Network::ToString() const {
@@ -1280,9 +1270,9 @@
// the IP address.
ss << "Net[" << description_.substr(0, description_.find(' ')) << ":"
<< prefix_.ToSensitiveString() << "/" << prefix_length_ << ":"
- << webrtc::AdapterTypeToString(type_);
+ << AdapterTypeToString(type_);
if (IsVpn()) {
- ss << "/" << webrtc::AdapterTypeToString(underlying_type_for_vpn_);
+ ss << "/" << AdapterTypeToString(underlying_type_for_vpn_);
}
ss << ":id=" << id_ << "]";
return ss.Release();
@@ -1301,7 +1291,7 @@
RTC_DCHECK_RUN_ON(thread_);
for (const auto& vpn : vpn_) {
if (prefix_length >= vpn.prefix_length()) {
- auto copy = webrtc::TruncateIP(prefix, vpn.prefix_length());
+ auto copy = TruncateIP(prefix, vpn.prefix_length());
if (copy == vpn.address()) {
return true;
}
diff --git a/rtc_base/network_unittest.cc b/rtc_base/network_unittest.cc
index 02c6ee0..35795ed 100644
--- a/rtc_base/network_unittest.cc
+++ b/rtc_base/network_unittest.cc
@@ -79,7 +79,7 @@
IPAddress IPFromString(absl::string_view str) {
IPAddress ip;
- RTC_CHECK(webrtc::IPFromString(str, &ip));
+ RTC_CHECK(IPFromString(str, &ip));
return ip;
}
@@ -90,13 +90,13 @@
bool started() { return started_; }
InterfaceInfo GetInterfaceInfo(absl::string_view if_name) override {
InterfaceInfo if_info = {
- .adapter_type = webrtc::ADAPTER_TYPE_UNKNOWN,
+ .adapter_type = ADAPTER_TYPE_UNKNOWN,
.available = absl::c_count(unavailable_adapters_, if_name) == 0,
};
if (absl::StartsWith(if_name, "wifi")) {
- if_info.adapter_type = webrtc::ADAPTER_TYPE_WIFI;
+ if_info.adapter_type = ADAPTER_TYPE_WIFI;
} else if (absl::StartsWith(if_name, "cellular")) {
- if_info.adapter_type = webrtc::ADAPTER_TYPE_CELLULAR;
+ if_info.adapter_type = ADAPTER_TYPE_CELLULAR;
}
return if_info;
}
@@ -247,7 +247,7 @@
ipv6_addr->sin6_family = AF_INET6;
ipv6_addr->sin6_scope_id = scope_id;
IPAddress ip;
- webrtc::IPFromString(ip_string, &ip);
+ IPFromString(ip_string, &ip);
ipv6_addr->sin6_addr = ip.ipv6_address();
return ipv6_addr;
}
@@ -290,7 +290,7 @@
memset(ipv4_addr, 0, sizeof(struct sockaddr_in));
ipv4_addr->sin_family = AF_INET;
IPAddress ip;
- webrtc::IPFromString(ip_string, &ip);
+ IPFromString(ip_string, &ip);
ipv4_addr->sin_addr = ip.ipv4_address();
return ipv4_addr;
}
@@ -365,11 +365,9 @@
TEST_F(NetworkTest, TestIsIgnoredNetworkIgnoresIPsStartingWith0) {
Network ipv4_network1("test_eth0", "Test Network Adapter 1",
- IPAddress(0x12345600U), 24,
- webrtc::ADAPTER_TYPE_ETHERNET);
+ IPAddress(0x12345600U), 24, ADAPTER_TYPE_ETHERNET);
Network ipv4_network2("test_eth1", "Test Network Adapter 2",
- IPAddress(0x010000U), 24,
- webrtc::ADAPTER_TYPE_ETHERNET);
+ IPAddress(0x010000U), 24, ADAPTER_TYPE_ETHERNET);
PhysicalSocketServer socket_server;
BasicNetworkManager network_manager(CreateEnvironment(), &socket_server);
network_manager.StartUpdating();
@@ -553,25 +551,24 @@
void SetupNetworks(std::vector<std::unique_ptr<Network>>* list) {
IPAddress ip;
IPAddress prefix;
- EXPECT_TRUE(webrtc::IPFromString("abcd::1234:5678:abcd:ef12", &ip));
- EXPECT_TRUE(webrtc::IPFromString("abcd::", &prefix));
+ EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:ef12", &ip));
+ EXPECT_TRUE(IPFromString("abcd::", &prefix));
// First, fake link-locals.
Network ipv6_eth0_linklocalnetwork("test_eth0", "Test NetworkAdapter 1",
prefix, 64);
ipv6_eth0_linklocalnetwork.AddIP(ip);
- EXPECT_TRUE(webrtc::IPFromString("abcd::5678:abcd:ef12:3456", &ip));
+ EXPECT_TRUE(IPFromString("abcd::5678:abcd:ef12:3456", &ip));
Network ipv6_eth1_linklocalnetwork("test_eth1", "Test NetworkAdapter 2",
prefix, 64);
ipv6_eth1_linklocalnetwork.AddIP(ip);
// Public networks:
- EXPECT_TRUE(webrtc::IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ip));
- prefix = webrtc::TruncateIP(ip, 64);
+ EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ip));
+ prefix = TruncateIP(ip, 64);
Network ipv6_eth0_publicnetwork1_ip1("test_eth0", "Test NetworkAdapter 1",
prefix, 64);
ipv6_eth0_publicnetwork1_ip1.AddIP(ip);
- EXPECT_TRUE(
- webrtc::IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
- prefix = webrtc::TruncateIP(ip, 64);
+ EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
+ prefix = TruncateIP(ip, 64);
Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 1",
prefix, 64);
ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
@@ -644,16 +641,15 @@
SetupNetworks(&original_list);
// Make a network that we're going to change.
IPAddress ip;
- EXPECT_TRUE(webrtc::IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip));
- IPAddress prefix = webrtc::TruncateIP(ip, 64);
+ EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip));
+ IPAddress prefix = TruncateIP(ip, 64);
std::unique_ptr<Network> network_to_change = std::make_unique<Network>(
"test_eth0", "Test Network Adapter 1", prefix, 64);
std::unique_ptr<Network> changed_network =
std::make_unique<Network>(*network_to_change);
network_to_change->AddIP(ip);
IPAddress changed_ip;
- EXPECT_TRUE(
- webrtc::IPFromString("2401:fa01:4:1000:be30:f00:f00:f00", &changed_ip));
+ EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:f00:f00:f00", &changed_ip));
changed_network->AddIP(changed_ip);
const Network* const network_to_change_ptr = network_to_change.get();
original_list.push_back(std::move(network_to_change));
@@ -688,13 +684,12 @@
IPAddress check_ip;
IPAddress prefix;
// Add a second IP to the public network on eth0 (2401:fa00:4:1000/64).
- EXPECT_TRUE(webrtc::IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c6", &ip));
- prefix = webrtc::TruncateIP(ip, 64);
+ EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c6", &ip));
+ prefix = TruncateIP(ip, 64);
Network ipv6_eth0_publicnetwork1_ip2("test_eth0", "Test NetworkAdapter 1",
prefix, 64);
// This is the IP that already existed in the public network on eth0.
- EXPECT_TRUE(
- webrtc::IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &check_ip));
+ EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &check_ip));
ipv6_eth0_publicnetwork1_ip2.AddIP(ip);
std::vector<std::unique_ptr<Network>> second_list;
@@ -741,8 +736,8 @@
IPAddress ip;
IPAddress prefix;
// A second network for eth0.
- EXPECT_TRUE(webrtc::IPFromString("2400:4030:1:2c00:be30:5bff:fee5:c3", &ip));
- prefix = webrtc::TruncateIP(ip, 64);
+ EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:5bff:fee5:c3", &ip));
+ prefix = TruncateIP(ip, 64);
Network ipv6_eth0_publicnetwork2_ip1("test_eth0", "Test NetworkAdapter 1",
prefix, 64);
ipv6_eth0_publicnetwork2_ip1.AddIP(ip);
@@ -806,9 +801,8 @@
IPAddress ip;
IPAddress prefix;
- EXPECT_TRUE(
- webrtc::IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
- prefix = webrtc::TruncateIP(ip, 64);
+ EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
+ prefix = TruncateIP(ip, 64);
Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 2",
prefix, 64);
ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
@@ -854,20 +848,20 @@
TEST_F(NetworkTest, TestNetworkAdapterTypes) {
Network wifi("wlan0", "Wireless Adapter", IPAddress(0x12345600U), 24,
- webrtc::ADAPTER_TYPE_WIFI);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_WIFI, wifi.type());
+ ADAPTER_TYPE_WIFI);
+ EXPECT_EQ(ADAPTER_TYPE_WIFI, wifi.type());
Network ethernet("eth0", "Ethernet", IPAddress(0x12345600U), 24,
- webrtc::ADAPTER_TYPE_ETHERNET);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_ETHERNET, ethernet.type());
+ ADAPTER_TYPE_ETHERNET);
+ EXPECT_EQ(ADAPTER_TYPE_ETHERNET, ethernet.type());
Network cellular("test_cell", "Cellular Adapter", IPAddress(0x12345600U), 24,
- webrtc::ADAPTER_TYPE_CELLULAR);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_CELLULAR, cellular.type());
+ ADAPTER_TYPE_CELLULAR);
+ EXPECT_EQ(ADAPTER_TYPE_CELLULAR, cellular.type());
Network vpn("bridge_test", "VPN Adapter", IPAddress(0x12345600U), 24,
- webrtc::ADAPTER_TYPE_VPN);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_VPN, vpn.type());
+ ADAPTER_TYPE_VPN);
+ EXPECT_EQ(ADAPTER_TYPE_VPN, vpn.type());
Network unknown("test", "Test Adapter", IPAddress(0x12345600U), 24,
- webrtc::ADAPTER_TYPE_UNKNOWN);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_UNKNOWN, unknown.type());
+ ADAPTER_TYPE_UNKNOWN);
+ EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, unknown.type());
}
#if defined(WEBRTC_POSIX)
@@ -953,8 +947,7 @@
// A network created without a network monitor will get UNKNOWN type.
ifaddrs* addr_list = InstallIpv6Network(if_name, ipv6_address, ipv6_mask,
manager_without_monitor);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_UNKNOWN,
- GetAdapterType(manager_without_monitor));
+ EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, GetAdapterType(manager_without_monitor));
ReleaseIfAddrs(addr_list);
// With the fake network monitor the type should be correctly determined.
@@ -965,7 +958,7 @@
// detected by the network monitor now.
addr_list = InstallIpv6Network(if_name, ipv6_address, ipv6_mask,
manager_with_monitor);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_WIFI, GetAdapterType(manager_with_monitor));
+ EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager_with_monitor));
ReleaseIfAddrs(addr_list);
}
@@ -986,25 +979,25 @@
char if_name[20] = "ipsec11";
ifaddrs* addr_list =
InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_VPN, GetAdapterType(manager));
+ EXPECT_EQ(ADAPTER_TYPE_VPN, GetAdapterType(manager));
ClearNetworks(manager);
ReleaseIfAddrs(addr_list);
strcpy(if_name, "lo0");
addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_LOOPBACK, GetAdapterType(manager));
+ EXPECT_EQ(ADAPTER_TYPE_LOOPBACK, GetAdapterType(manager));
ClearNetworks(manager);
ReleaseIfAddrs(addr_list);
strcpy(if_name, "eth0");
addr_list = InstallIpv4Network(if_name, ipv4_address1, ipv4_mask, manager);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_ETHERNET, GetAdapterType(manager));
+ EXPECT_EQ(ADAPTER_TYPE_ETHERNET, GetAdapterType(manager));
ClearNetworks(manager);
ReleaseIfAddrs(addr_list);
strcpy(if_name, "wlan0");
addr_list = InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_WIFI, GetAdapterType(manager));
+ EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager));
ClearNetworks(manager);
ReleaseIfAddrs(addr_list);
@@ -1088,14 +1081,12 @@
// Create 2 IPAddress classes with only last digit different.
IPAddress ip1, ip2;
- EXPECT_TRUE(webrtc::IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
- EXPECT_TRUE(webrtc::IPFromString("2400:4030:1:2c00:be30:0:0:2", &ip2));
+ EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
+ EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:2", &ip2));
// Create 2 networks with the same prefix and length.
- auto net1 =
- std::make_unique<Network>("em1", "em1", webrtc::TruncateIP(ip1, 64), 64);
- auto net2 =
- std::make_unique<Network>("em1", "em1", webrtc::TruncateIP(ip1, 64), 64);
+ auto net1 = std::make_unique<Network>("em1", "em1", TruncateIP(ip1, 64), 64);
+ auto net2 = std::make_unique<Network>("em1", "em1", TruncateIP(ip1, 64), 64);
// Add different IP into each.
net1->AddIP(ip1);
@@ -1170,18 +1161,17 @@
std::string ipstr;
ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c3";
- ASSERT_TRUE(
- webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_DEPRECATED, &ip));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_DEPRECATED, &ip));
// Create a network with this prefix.
- Network ipv6_network("test_eth0", "Test NetworkAdapter",
- webrtc::TruncateIP(ip, 64), 64);
+ Network ipv6_network("test_eth0", "Test NetworkAdapter", TruncateIP(ip, 64),
+ 64);
EXPECT_EQ(AF_INET6, ipv6_network.family());
// When there is no address added, it should return an unspecified
// address.
EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress());
- EXPECT_TRUE(webrtc::IPIsUnspec(ipv6_network.GetBestIP()));
+ EXPECT_TRUE(IPIsUnspec(ipv6_network.GetBestIP()));
// Deprecated one should not be returned.
ipv6_network.AddIP(ip);
@@ -1190,20 +1180,19 @@
// Add ULA one. ULA is unique local address which is starting either
// with 0xfc or 0xfd.
ipstr = "fd00:fa00:4:1000:be30:5bff:fee5:c4";
- ASSERT_TRUE(webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_NONE, &ip));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
ipv6_network.AddIP(ip);
EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
// Add global one.
ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c5";
- ASSERT_TRUE(webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_NONE, &ip));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
ipv6_network.AddIP(ip);
EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
// Add global dynamic temporary one.
ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c6";
- ASSERT_TRUE(
- webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_TEMPORARY, &ip));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_TEMPORARY, &ip));
ipv6_network.AddIP(ip);
EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
}
@@ -1214,18 +1203,16 @@
std::string ipstr;
ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c3";
- ASSERT_TRUE(
- webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_DEPRECATED, &ip));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_DEPRECATED, &ip));
// Create a network with this prefix.
- Network ipv6_network("test_eth0", "Test NetworkAdapter",
- webrtc::TruncateIP(ip, 64), 64,
- webrtc::ADAPTER_TYPE_UNKNOWN);
+ Network ipv6_network("test_eth0", "Test NetworkAdapter", TruncateIP(ip, 64),
+ 64, ADAPTER_TYPE_UNKNOWN);
// When there is no address added, it should return an unspecified
// address.
EXPECT_EQ(ipv6_network.GetBestIP(), IPAddress());
- EXPECT_TRUE(webrtc::IPIsUnspec(ipv6_network.GetBestIP()));
+ EXPECT_TRUE(IPIsUnspec(ipv6_network.GetBestIP()));
// Deprecated one should not be returned.
ipv6_network.AddIP(ip);
@@ -1234,43 +1221,39 @@
// Add ULA one. ULA is unique local address which is starting either
// with 0xfc or 0xfd.
ipstr = "fd00:fa00:4:1000:be30:5bff:fee5:c4";
- ASSERT_TRUE(webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_NONE, &ip));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
ipv6_network.AddIP(ip);
EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
// Add link local one.
ipstr = "fe80::aabb:ccff:fedd:eeff";
- ASSERT_TRUE(
- webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_NONE, &link_local));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &link_local));
ipv6_network.AddIP(link_local);
EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(link_local));
// Add global one.
ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c5";
- ASSERT_TRUE(webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_NONE, &ip));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &ip));
ipv6_network.AddIP(ip);
EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
// Add another link local address, then the compatible address is still global
// one.
ipstr = "fe80::aabb:ccff:fedd:eedd";
- ASSERT_TRUE(
- webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_NONE, &link_local));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &link_local));
ipv6_network.AddIP(link_local);
EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
// Add global dynamic temporary one.
ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c6";
- ASSERT_TRUE(
- webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_TEMPORARY, &ip));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_TEMPORARY, &ip));
ipv6_network.AddIP(ip);
EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
// Add another link local address, then the compatible address is still global
// dynamic one.
ipstr = "fe80::aabb:ccff:fedd:eedd";
- ASSERT_TRUE(
- webrtc::IPFromString(ipstr, webrtc::IPV6_ADDRESS_FLAG_NONE, &link_local));
+ ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_NONE, &link_local));
ipv6_network.AddIP(link_local);
EXPECT_EQ(ipv6_network.GetBestIP(), static_cast<IPAddress>(ip));
}
@@ -1284,8 +1267,7 @@
manager.StartUpdating();
FakeNetworkMonitor* network_monitor = GetNetworkMonitor(manager);
EXPECT_TRUE(network_monitor && network_monitor->started());
- EXPECT_THAT(webrtc::WaitUntil([&] { return callback_called_; }, IsTrue()),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return callback_called_; }, IsTrue()), IsRtcOk());
callback_called_ = false;
// Clear the networks so that there will be network changes below.
@@ -1293,8 +1275,7 @@
// Network manager is started, so the callback is called when the network
// monitor fires the network-change event.
network_monitor->InovkeNetworksChangedCallbackForTesting();
- EXPECT_THAT(webrtc::WaitUntil([&] { return callback_called_; }, IsTrue()),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return callback_called_; }, IsTrue()), IsRtcOk());
// Network manager is stopped.
manager.StopUpdating();
@@ -1317,8 +1298,7 @@
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged);
manager.StartUpdating();
- EXPECT_THAT(webrtc::WaitUntil([&] { return callback_called_; }, IsTrue()),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return callback_called_; }, IsTrue()), IsRtcOk());
// Make sure we can query default local address when an address for such
// address family exists.
@@ -1328,7 +1308,7 @@
if (network->GetBestIP().family() == AF_INET) {
EXPECT_TRUE(QueryDefaultLocalAddress(manager, AF_INET) != IPAddress());
} else if (network->GetBestIP().family() == AF_INET6 &&
- !webrtc::IPIsLoopback(network->GetBestIP())) {
+ !IPIsLoopback(network->GetBestIP())) {
// Existence of an IPv6 loopback address doesn't mean it has IPv6 network
// enabled.
EXPECT_TRUE(QueryDefaultLocalAddress(manager, AF_INET6) != IPAddress());
@@ -1336,23 +1316,23 @@
}
// GetDefaultLocalAddress should return the valid default address after set.
- manager.set_default_local_addresses(webrtc::GetLoopbackIP(AF_INET),
- webrtc::GetLoopbackIP(AF_INET6));
+ manager.set_default_local_addresses(GetLoopbackIP(AF_INET),
+ GetLoopbackIP(AF_INET6));
EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET, &ip));
- EXPECT_EQ(ip, webrtc::GetLoopbackIP(AF_INET));
+ EXPECT_EQ(ip, GetLoopbackIP(AF_INET));
EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip));
- EXPECT_EQ(ip, webrtc::GetLoopbackIP(AF_INET6));
+ EXPECT_EQ(ip, GetLoopbackIP(AF_INET6));
// More tests on GetDefaultLocalAddress with ipv6 addresses where the set
// default address may be different from the best IP address of any network.
InterfaceAddress ip1;
- EXPECT_TRUE(webrtc::IPFromString("abcd::1234:5678:abcd:1111",
- webrtc::IPV6_ADDRESS_FLAG_TEMPORARY, &ip1));
+ EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:1111",
+ IPV6_ADDRESS_FLAG_TEMPORARY, &ip1));
// Create a network with a prefix of ip1.
- Network ipv6_network("test_eth0", "Test NetworkAdapter",
- webrtc::TruncateIP(ip1, 64), 64);
+ Network ipv6_network("test_eth0", "Test NetworkAdapter", TruncateIP(ip1, 64),
+ 64);
IPAddress ip2;
- EXPECT_TRUE(webrtc::IPFromString("abcd::1234:5678:abcd:2222", &ip2));
+ EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:2222", &ip2));
ipv6_network.AddIP(ip1);
ipv6_network.AddIP(ip2);
std::vector<std::unique_ptr<Network>> list;
@@ -1362,13 +1342,13 @@
// If the set default address is not in any network, GetDefaultLocalAddress
// should return it.
IPAddress ip3;
- EXPECT_TRUE(webrtc::IPFromString("abcd::1234:5678:abcd:3333", &ip3));
- manager.set_default_local_addresses(webrtc::GetLoopbackIP(AF_INET), ip3);
+ EXPECT_TRUE(IPFromString("abcd::1234:5678:abcd:3333", &ip3));
+ manager.set_default_local_addresses(GetLoopbackIP(AF_INET), ip3);
EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip));
EXPECT_EQ(ip3, ip);
// If the set default address is in a network, GetDefaultLocalAddress will
// return the best IP in that network.
- manager.set_default_local_addresses(webrtc::GetLoopbackIP(AF_INET), ip2);
+ manager.set_default_local_addresses(GetLoopbackIP(AF_INET), ip2);
EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip));
EXPECT_EQ(static_cast<IPAddress>(ip1), ip);
@@ -1382,10 +1362,9 @@
BasicNetworkManager manager(CreateEnvironment(), &socket_server);
IPAddress ip1;
- EXPECT_TRUE(webrtc::IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
- auto net1 =
- std::make_unique<Network>("em1", "em1", webrtc::TruncateIP(ip1, 64), 64);
- net1->set_type(webrtc::ADAPTER_TYPE_CELLULAR_3G);
+ EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
+ auto net1 = std::make_unique<Network>("em1", "em1", TruncateIP(ip1, 64), 64);
+ net1->set_type(ADAPTER_TYPE_CELLULAR_3G);
net1->AddIP(ip1);
std::vector<std::unique_ptr<Network>> list;
list.push_back(std::move(net1));
@@ -1396,14 +1375,14 @@
EXPECT_TRUE(changed);
std::vector<const Network*> list2 = manager.GetNetworks();
EXPECT_EQ(list2.size(), 1uL);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_CELLULAR_3G, list2[0]->type());
+ EXPECT_EQ(ADAPTER_TYPE_CELLULAR_3G, list2[0]->type());
}
// Modify net1 from 3G to 4G
{
- auto net2 = std::make_unique<Network>("em1", "em1",
- webrtc::TruncateIP(ip1, 64), 64);
- net2->set_type(webrtc::ADAPTER_TYPE_CELLULAR_4G);
+ auto net2 =
+ std::make_unique<Network>("em1", "em1", TruncateIP(ip1, 64), 64);
+ net2->set_type(ADAPTER_TYPE_CELLULAR_4G);
net2->AddIP(ip1);
list.clear();
list.push_back(std::move(net2));
@@ -1415,14 +1394,14 @@
EXPECT_FALSE(changed);
std::vector<const Network*> list2 = manager.GetNetworks();
ASSERT_EQ(list2.size(), 1uL);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_CELLULAR_4G, list2[0]->type());
+ EXPECT_EQ(ADAPTER_TYPE_CELLULAR_4G, list2[0]->type());
}
// Don't modify.
{
- auto net2 = std::make_unique<Network>("em1", "em1",
- webrtc::TruncateIP(ip1, 64), 64);
- net2->set_type(webrtc::ADAPTER_TYPE_CELLULAR_4G);
+ auto net2 =
+ std::make_unique<Network>("em1", "em1", TruncateIP(ip1, 64), 64);
+ net2->set_type(ADAPTER_TYPE_CELLULAR_4G);
net2->AddIP(ip1);
list.clear();
list.push_back(std::move(net2));
@@ -1433,7 +1412,7 @@
EXPECT_FALSE(changed);
std::vector<const Network*> list2 = manager.GetNetworks();
ASSERT_EQ(list2.size(), 1uL);
- EXPECT_EQ(webrtc::ADAPTER_TYPE_CELLULAR_4G, list2[0]->type());
+ EXPECT_EQ(ADAPTER_TYPE_CELLULAR_4G, list2[0]->type());
}
}
@@ -1500,9 +1479,9 @@
FakeNetworkMonitor* network_monitor = GetNetworkMonitor(manager);
IPAddress ipv6;
- EXPECT_TRUE(webrtc::IPFromString("1000:2000:3000:4000:0:0:0:1", &ipv6));
+ EXPECT_TRUE(IPFromString("1000:2000:3000:4000:0:0:0:1", &ipv6));
IPAddress ipv4;
- EXPECT_TRUE(webrtc::IPFromString("192.168.0.2", &ipv4));
+ EXPECT_TRUE(IPFromString("192.168.0.2", &ipv4));
// The network monitor only knwos about the ipv6 address, interface.
network_monitor->set_adapters({"wlan0"});
@@ -1518,15 +1497,15 @@
TEST_F(NetworkTest, NetworkCostVpn_Default) {
IPAddress ip1;
- EXPECT_TRUE(webrtc::IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
+ EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
ScopedKeyValueConfig field_trials;
- Network* net1 = new Network("em1", "em1", webrtc::TruncateIP(ip1, 64), 64);
- net1->set_type(webrtc::ADAPTER_TYPE_VPN);
- net1->set_underlying_type_for_vpn(webrtc::ADAPTER_TYPE_ETHERNET);
+ Network* net1 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
+ net1->set_type(ADAPTER_TYPE_VPN);
+ net1->set_underlying_type_for_vpn(ADAPTER_TYPE_ETHERNET);
- Network* net2 = new Network("em1", "em1", webrtc::TruncateIP(ip1, 64), 64);
- net2->set_type(webrtc::ADAPTER_TYPE_ETHERNET);
+ Network* net2 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
+ net2->set_type(ADAPTER_TYPE_ETHERNET);
EXPECT_EQ(net1->GetCost(field_trials), net2->GetCost(field_trials));
delete net1;
@@ -1537,14 +1516,14 @@
ScopedKeyValueConfig field_trials("WebRTC-AddNetworkCostToVpn/Enabled/");
IPAddress ip1;
- EXPECT_TRUE(webrtc::IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
+ EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
- Network* net1 = new Network("em1", "em1", webrtc::TruncateIP(ip1, 64), 64);
- net1->set_type(webrtc::ADAPTER_TYPE_VPN);
- net1->set_underlying_type_for_vpn(webrtc::ADAPTER_TYPE_ETHERNET);
+ Network* net1 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
+ net1->set_type(ADAPTER_TYPE_VPN);
+ net1->set_underlying_type_for_vpn(ADAPTER_TYPE_ETHERNET);
- Network* net2 = new Network("em1", "em1", webrtc::TruncateIP(ip1, 64), 64);
- net2->set_type(webrtc::ADAPTER_TYPE_ETHERNET);
+ Network* net2 = new Network("em1", "em1", TruncateIP(ip1, 64), 64);
+ net2->set_type(ADAPTER_TYPE_ETHERNET);
EXPECT_GT(net1->GetCost(field_trials), net2->GetCost(field_trials));
delete net1;
@@ -1557,35 +1536,35 @@
"WebRTC-UseDifferentiatedCellularCosts/Enabled/");
IPAddress ip1;
- EXPECT_TRUE(webrtc::IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
+ EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:0:0:1", &ip1));
- for (auto type : webrtc::kAllAdapterTypes) {
- if (type == webrtc::ADAPTER_TYPE_VPN)
+ for (auto type : kAllAdapterTypes) {
+ if (type == ADAPTER_TYPE_VPN)
continue;
- Network net1("em1", "em1", webrtc::TruncateIP(ip1, 64), 64);
+ Network net1("em1", "em1", TruncateIP(ip1, 64), 64);
net1.set_type(type);
auto [guess, vpn] =
Network::GuessAdapterFromNetworkCost(net1.GetCost(field_trials));
EXPECT_FALSE(vpn);
- if (type == webrtc::ADAPTER_TYPE_LOOPBACK) {
- EXPECT_EQ(guess, webrtc::ADAPTER_TYPE_ETHERNET);
+ if (type == ADAPTER_TYPE_LOOPBACK) {
+ EXPECT_EQ(guess, ADAPTER_TYPE_ETHERNET);
} else {
EXPECT_EQ(type, guess);
}
}
// VPN
- for (auto type : webrtc::kAllAdapterTypes) {
- if (type == webrtc::ADAPTER_TYPE_VPN)
+ for (auto type : kAllAdapterTypes) {
+ if (type == ADAPTER_TYPE_VPN)
continue;
- Network net1("em1", "em1", webrtc::TruncateIP(ip1, 64), 64);
- net1.set_type(webrtc::ADAPTER_TYPE_VPN);
+ Network net1("em1", "em1", TruncateIP(ip1, 64), 64);
+ net1.set_type(ADAPTER_TYPE_VPN);
net1.set_underlying_type_for_vpn(type);
auto [guess, vpn] =
Network::GuessAdapterFromNetworkCost(net1.GetCost(field_trials));
EXPECT_TRUE(vpn);
- if (type == webrtc::ADAPTER_TYPE_LOOPBACK) {
- EXPECT_EQ(guess, webrtc::ADAPTER_TYPE_ETHERNET);
+ if (type == ADAPTER_TYPE_LOOPBACK) {
+ EXPECT_EQ(guess, ADAPTER_TYPE_ETHERNET);
} else {
EXPECT_EQ(type, guess);
}
@@ -1630,8 +1609,8 @@
std::vector<const Network*> list = manager.GetNetworks();
ASSERT_EQ(1u, list.size());
- EXPECT_EQ(webrtc::ADAPTER_TYPE_VPN, list[0]->type());
- EXPECT_EQ(webrtc::ADAPTER_TYPE_ETHERNET, list[0]->underlying_type_for_vpn());
+ EXPECT_EQ(ADAPTER_TYPE_VPN, list[0]->type());
+ EXPECT_EQ(ADAPTER_TYPE_ETHERNET, list[0]->underlying_type_for_vpn());
ClearNetworks(manager);
ReleaseIfAddrs(addr_list);
}
diff --git a/rtc_base/null_socket_server_unittest.cc b/rtc_base/null_socket_server_unittest.cc
index b89a241..81da9c3 100644
--- a/rtc_base/null_socket_server_unittest.cc
+++ b/rtc_base/null_socket_server_unittest.cc
@@ -33,10 +33,10 @@
thread->PostTask([&ss] { ss.WakeUp(); });
// The process_io will be ignored.
const bool process_io = true;
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return ss.Wait(SocketServer::kForever, process_io); },
- ::testing::IsTrue(), {.timeout = TimeDelta::Millis(5'000)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return ss.Wait(SocketServer::kForever, process_io); },
+ ::testing::IsTrue(), {.timeout = TimeDelta::Millis(5'000)}),
+ IsRtcOk());
}
TEST(NullSocketServerTest, TestWait) {
diff --git a/rtc_base/openssl_adapter.cc b/rtc_base/openssl_adapter.cc
index cb5dfc6..f804f08 100644
--- a/rtc_base/openssl_adapter.cc
+++ b/rtc_base/openssl_adapter.cc
@@ -184,7 +184,6 @@
namespace webrtc {
-using ::webrtc::TimeDelta;
bool OpenSSLAdapter::InitializeSSL() {
// TODO: https://issues.webrtc.org/issues/339300437 - remove once
@@ -206,12 +205,12 @@
ssl_session_cache_(ssl_session_cache),
ssl_cert_verifier_(ssl_cert_verifier),
state_(SSL_NONE),
- role_(webrtc::SSL_CLIENT),
+ role_(SSL_CLIENT),
ssl_read_needs_write_(false),
ssl_write_needs_read_(false),
ssl_(nullptr),
ssl_ctx_(nullptr),
- ssl_mode_(webrtc::SSL_MODE_TLS),
+ ssl_mode_(SSL_MODE_TLS),
ignore_bad_cert_(false),
custom_cert_verifier_status_(false) {
// If a factory is used, take a reference on the factory's SSL_CTX.
@@ -365,12 +364,12 @@
if (!tls_alpn_string.empty()) {
SSL_set_alpn_protos(
ssl_, reinterpret_cast<const unsigned char*>(tls_alpn_string.data()),
- webrtc::dchecked_cast<unsigned>(tls_alpn_string.size()));
+ dchecked_cast<unsigned>(tls_alpn_string.size()));
}
}
if (!elliptic_curves_.empty()) {
- SSL_set1_curves_list(ssl_, webrtc::StrJoin(elliptic_curves_, ":").c_str());
+ SSL_set1_curves_list(ssl_, StrJoin(elliptic_curves_, ":").c_str());
}
// Now that the initial config is done, transfer ownership of `bio` to the
@@ -393,8 +392,7 @@
// Clear the DTLS timer
timer_.reset();
- int code =
- (role_ == webrtc::SSL_CLIENT) ? SSL_connect(ssl_) : SSL_accept(ssl_);
+ int code = (role_ == SSL_CLIENT) ? SSL_connect(ssl_) : SSL_accept(ssl_);
switch (SSL_get_error(ssl_, code)) {
case SSL_ERROR_NONE:
if (!SSLPostConnectionCheck(ssl_, ssl_host_name_)) {
@@ -480,7 +478,7 @@
RTC_DCHECK(error != nullptr);
ssl_write_needs_read_ = false;
- int ret = SSL_write(ssl_, pv, webrtc::checked_cast<int>(cb));
+ int ret = SSL_write(ssl_, pv, checked_cast<int>(cb));
*error = SSL_get_error(ssl_, ret);
switch (*error) {
case SSL_ERROR_NONE:
@@ -574,7 +572,7 @@
pending_data_.SetData(static_cast<const uint8_t*>(pv), cb);
// Since we're taking responsibility for sending this data, return its full
// size. The user of this class can consider it sent.
- return webrtc::dchecked_cast<int>(cb);
+ return dchecked_cast<int>(cb);
}
return ret;
}
@@ -612,7 +610,7 @@
}
ssl_read_needs_write_ = false;
- int code = SSL_read(ssl_, pv, webrtc::checked_cast<int>(cb));
+ int code = SSL_read(ssl_, pv, checked_cast<int>(cb));
int error = SSL_get_error(ssl_, code);
switch (error) {
@@ -944,7 +942,7 @@
: TLS_with_buffers_method());
#else
SSL_CTX* ctx =
- SSL_CTX_new(mode == webrtc::SSL_MODE_DTLS ? DTLS_method() : TLS_method());
+ SSL_CTX_new(mode == SSL_MODE_DTLS ? DTLS_method() : TLS_method());
#endif
if (ctx == nullptr) {
unsigned long error = ERR_get_error(); // NOLINT: type used by OpenSSL.
diff --git a/rtc_base/openssl_digest.cc b/rtc_base/openssl_digest.cc
index 96cac43..ce0c6c1 100644
--- a/rtc_base/openssl_digest.cc
+++ b/rtc_base/openssl_digest.cc
@@ -59,17 +59,17 @@
bool OpenSSLDigest::GetDigestEVP(absl::string_view algorithm,
const EVP_MD** mdp) {
const EVP_MD* md;
- if (algorithm == webrtc::DIGEST_MD5) {
+ if (algorithm == DIGEST_MD5) {
md = EVP_md5();
- } else if (algorithm == webrtc::DIGEST_SHA_1) {
+ } else if (algorithm == DIGEST_SHA_1) {
md = EVP_sha1();
- } else if (algorithm == webrtc::DIGEST_SHA_224) {
+ } else if (algorithm == DIGEST_SHA_224) {
md = EVP_sha224();
- } else if (algorithm == webrtc::DIGEST_SHA_256) {
+ } else if (algorithm == DIGEST_SHA_256) {
md = EVP_sha256();
- } else if (algorithm == webrtc::DIGEST_SHA_384) {
+ } else if (algorithm == DIGEST_SHA_384) {
md = EVP_sha384();
- } else if (algorithm == webrtc::DIGEST_SHA_512) {
+ } else if (algorithm == DIGEST_SHA_512) {
md = EVP_sha512();
} else {
return false;
@@ -87,17 +87,17 @@
int md_type = EVP_MD_type(md);
if (md_type == NID_md5) {
- *algorithm = webrtc::DIGEST_MD5;
+ *algorithm = DIGEST_MD5;
} else if (md_type == NID_sha1) {
- *algorithm = webrtc::DIGEST_SHA_1;
+ *algorithm = DIGEST_SHA_1;
} else if (md_type == NID_sha224) {
- *algorithm = webrtc::DIGEST_SHA_224;
+ *algorithm = DIGEST_SHA_224;
} else if (md_type == NID_sha256) {
- *algorithm = webrtc::DIGEST_SHA_256;
+ *algorithm = DIGEST_SHA_256;
} else if (md_type == NID_sha384) {
- *algorithm = webrtc::DIGEST_SHA_384;
+ *algorithm = DIGEST_SHA_384;
} else if (md_type == NID_sha512) {
- *algorithm = webrtc::DIGEST_SHA_512;
+ *algorithm = DIGEST_SHA_512;
} else {
algorithm->clear();
return false;
diff --git a/rtc_base/openssl_stream_adapter.cc b/rtc_base/openssl_stream_adapter.cc
index 654fc46..3a0a558 100644
--- a/rtc_base/openssl_stream_adapter.cc
+++ b/rtc_base/openssl_stream_adapter.cc
@@ -72,7 +72,6 @@
namespace webrtc {
namespace {
-using ::webrtc::SafeTask;
// SRTP cipher suite table. `internal_name` is used to construct a
// colon-separated profile strings which is needed by
// SSL_CTX_set_tlsext_use_srtp().
@@ -83,10 +82,10 @@
// This isn't elegant, but it's better than an external reference
constexpr SrtpCipherMapEntry kSrtpCipherMap[] = {
- {"SRTP_AES128_CM_SHA1_80", webrtc::kSrtpAes128CmSha1_80},
- {"SRTP_AES128_CM_SHA1_32", webrtc::kSrtpAes128CmSha1_32},
- {"SRTP_AEAD_AES_128_GCM", webrtc::kSrtpAeadAes128Gcm},
- {"SRTP_AEAD_AES_256_GCM", webrtc::kSrtpAeadAes256Gcm}};
+ {"SRTP_AES128_CM_SHA1_80", kSrtpAes128CmSha1_80},
+ {"SRTP_AES128_CM_SHA1_32", kSrtpAes128CmSha1_32},
+ {"SRTP_AEAD_AES_128_GCM", kSrtpAeadAes128Gcm},
+ {"SRTP_AEAD_AES_256_GCM", kSrtpAeadAes256Gcm}};
#ifdef OPENSSL_IS_BORINGSSL
// Enabled by EnableTimeCallbackForTesting. Should never be set in production
@@ -94,38 +93,37 @@
bool g_use_time_callback_for_testing = false;
// Not used in production code. Actual time should be relative to Jan 1, 1970.
void TimeCallbackForTesting(const SSL* ssl, struct timeval* out_clock) {
- int64_t time = webrtc::TimeNanos();
- out_clock->tv_sec = time / webrtc::kNumNanosecsPerSec;
- out_clock->tv_usec =
- (time % webrtc::kNumNanosecsPerSec) / webrtc::kNumNanosecsPerMicrosec;
+ int64_t time = TimeNanos();
+ out_clock->tv_sec = time / kNumNanosecsPerSec;
+ out_clock->tv_usec = (time % kNumNanosecsPerSec) / kNumNanosecsPerMicrosec;
}
#endif
uint16_t GetMaxVersion(SSLMode ssl_mode, SSLProtocolVersion version) {
switch (ssl_mode) {
- case webrtc::SSL_MODE_TLS:
+ case SSL_MODE_TLS:
switch (version) {
default:
- case webrtc::SSL_PROTOCOL_NOT_GIVEN:
- case webrtc::SSL_PROTOCOL_TLS_10:
- case webrtc::SSL_PROTOCOL_TLS_11:
- case webrtc::SSL_PROTOCOL_TLS_12:
+ case SSL_PROTOCOL_NOT_GIVEN:
+ case SSL_PROTOCOL_TLS_10:
+ case SSL_PROTOCOL_TLS_11:
+ case SSL_PROTOCOL_TLS_12:
return TLS1_2_VERSION;
- case webrtc::SSL_PROTOCOL_TLS_13:
+ case SSL_PROTOCOL_TLS_13:
#ifdef TLS1_3_VERSION
return TLS1_3_VERSION;
#else
return TLS1_2_VERSION;
#endif
}
- case webrtc::SSL_MODE_DTLS:
+ case SSL_MODE_DTLS:
switch (version) {
default:
- case webrtc::SSL_PROTOCOL_NOT_GIVEN:
- case webrtc::SSL_PROTOCOL_DTLS_10:
- case webrtc::SSL_PROTOCOL_DTLS_12:
+ case SSL_PROTOCOL_NOT_GIVEN:
+ case SSL_PROTOCOL_DTLS_10:
+ case SSL_PROTOCOL_DTLS_12:
return DTLS1_2_VERSION;
- case webrtc::SSL_PROTOCOL_DTLS_13:
+ case SSL_PROTOCOL_DTLS_13:
#ifdef DTLS1_3_VERSION
return DTLS1_3_VERSION;
#else
@@ -219,9 +217,9 @@
int error;
StreamResult result = stream->Read(
MakeArrayView(reinterpret_cast<uint8_t*>(out), outl), read, error);
- if (result == webrtc::SR_SUCCESS) {
- return webrtc::checked_cast<int>(read);
- } else if (result == webrtc::SR_BLOCK) {
+ if (result == SR_SUCCESS) {
+ return checked_cast<int>(read);
+ } else if (result == SR_BLOCK) {
BIO_set_retry_read(b);
}
return -1;
@@ -237,16 +235,16 @@
int error;
StreamResult result = stream->Write(
MakeArrayView(reinterpret_cast<const uint8_t*>(in), inl), written, error);
- if (result == webrtc::SR_SUCCESS) {
- return webrtc::checked_cast<int>(written);
- } else if (result == webrtc::SR_BLOCK) {
+ if (result == SR_SUCCESS) {
+ return checked_cast<int>(written);
+ } else if (result == SR_BLOCK) {
BIO_set_retry_write(b);
}
return -1;
}
static int stream_puts(BIO* b, const char* str) {
- return stream_write(b, str, webrtc::checked_cast<int>(strlen(str)));
+ return stream_write(b, str, checked_cast<int>(strlen(str)));
}
static long stream_ctrl(BIO* b, int cmd, long num, void* ptr) {
@@ -256,7 +254,7 @@
case BIO_CTRL_EOF: {
StreamInterface* stream = static_cast<StreamInterface*>(ptr);
// 1 means end-of-stream.
- return (stream->GetState() == webrtc::SS_CLOSED) ? 1 : 0;
+ return (stream->GetState() == SS_CLOSED) ? 1 : 0;
}
case BIO_CTRL_WPENDING:
case BIO_CTRL_PENDING:
@@ -295,13 +293,13 @@
handshake_error_(std::move(handshake_error)),
owner_(Thread::Current()),
state_(SSL_NONE),
- role_(webrtc::SSL_CLIENT),
+ role_(SSL_CLIENT),
ssl_read_needs_write_(false),
ssl_write_needs_read_(false),
ssl_(nullptr),
ssl_ctx_(nullptr),
- ssl_mode_(webrtc::SSL_MODE_DTLS),
- ssl_max_version_(webrtc::SSL_PROTOCOL_DTLS_12),
+ ssl_mode_(SSL_MODE_DTLS),
+ ssl_max_version_(SSL_PROTOCOL_DTLS_12),
force_dtls_13_(GetForceDtls13(field_trials)),
disable_ssl_group_ids_(field_trials && field_trials->IsEnabled(
"WebRTC-DisableSslGroupIds")) {
@@ -364,7 +362,7 @@
// Post the event asynchronously to unwind the stack. The caller
// of ContinueSSL may be the same object listening for these
// events and may not be prepared for reentrancy.
- PostEvent(webrtc::SE_OPEN | webrtc::SE_READ | webrtc::SE_WRITE, 0);
+ PostEvent(SE_OPEN | SE_READ | SE_WRITE, 0);
}
return SSLPeerCertificateDigestError::NONE;
}
@@ -395,37 +393,37 @@
SSLProtocolVersion OpenSSLStreamAdapter::GetSslVersion() const {
if (state_ != SSL_CONNECTED) {
- return webrtc::SSL_PROTOCOL_NOT_GIVEN;
+ return SSL_PROTOCOL_NOT_GIVEN;
}
int ssl_version = SSL_version(ssl_);
- if (ssl_mode_ == webrtc::SSL_MODE_DTLS) {
+ if (ssl_mode_ == SSL_MODE_DTLS) {
if (ssl_version == DTLS1_VERSION) {
- return webrtc::SSL_PROTOCOL_DTLS_10;
+ return SSL_PROTOCOL_DTLS_10;
} else if (ssl_version == DTLS1_2_VERSION) {
- return webrtc::SSL_PROTOCOL_DTLS_12;
+ return SSL_PROTOCOL_DTLS_12;
}
#ifdef DTLS1_3_VERSION
if (ssl_version == DTLS1_3_VERSION) {
- return webrtc::SSL_PROTOCOL_DTLS_13;
+ return SSL_PROTOCOL_DTLS_13;
}
#endif
} else {
if (ssl_version == TLS1_VERSION) {
- return webrtc::SSL_PROTOCOL_TLS_10;
+ return SSL_PROTOCOL_TLS_10;
} else if (ssl_version == TLS1_1_VERSION) {
- return webrtc::SSL_PROTOCOL_TLS_11;
+ return SSL_PROTOCOL_TLS_11;
} else if (ssl_version == TLS1_2_VERSION) {
- return webrtc::SSL_PROTOCOL_TLS_12;
+ return SSL_PROTOCOL_TLS_12;
}
#ifdef TLS1_3_VERSION
if (ssl_version == TLS1_3_VERSION) {
- return webrtc::SSL_PROTOCOL_TLS_13;
+ return SSL_PROTOCOL_TLS_13;
}
#endif
}
- return webrtc::SSL_PROTOCOL_NOT_GIVEN;
+ return SSL_PROTOCOL_NOT_GIVEN;
}
bool OpenSSLStreamAdapter::GetSslVersionBytes(int* version) const {
@@ -524,7 +522,7 @@
}
*crypto_suite = srtp_profile->id;
- RTC_DCHECK(!webrtc::SrtpCryptoSuiteToName(*crypto_suite).empty());
+ RTC_DCHECK(!SrtpCryptoSuiteToName(*crypto_suite).empty());
return true;
}
@@ -538,7 +536,7 @@
return -1;
}
- if (stream_->GetState() != webrtc::SS_OPEN) {
+ if (stream_->GetState() != SS_OPEN) {
state_ = SSL_WAIT;
return 0;
}
@@ -565,7 +563,7 @@
void OpenSSLStreamAdapter::SetInitialRetransmissionTimeout(int timeout_ms) {
dtls_handshake_timeout_ms_ = timeout_ms;
#ifdef OPENSSL_IS_BORINGSSL
- if (ssl_ctx_ != nullptr && ssl_mode_ == webrtc::SSL_MODE_DTLS) {
+ if (ssl_ctx_ != nullptr && ssl_mode_ == SSL_MODE_DTLS) {
// TODO (jonaso, webrtc:367395350): Switch to upcoming
// DTLSv1_set_timeout_duration.
DTLSv1_set_initial_timeout_duration(ssl_, dtls_handshake_timeout_ms_);
@@ -594,29 +592,28 @@
return stream_->Write(data, written, error);
case SSL_WAIT:
case SSL_CONNECTING:
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
case SSL_CONNECTED:
if (WaitingToVerifyPeerCertificate()) {
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
}
break;
case SSL_ERROR:
case SSL_CLOSED:
default:
error = ssl_error_code_;
- return webrtc::SR_ERROR;
+ return SR_ERROR;
}
// OpenSSL will return an error if we try to write zero bytes
if (data.size() == 0) {
written = 0;
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
ssl_write_needs_read_ = false;
- int code =
- SSL_write(ssl_, data.data(), webrtc::checked_cast<int>(data.size()));
+ int code = SSL_write(ssl_, data.data(), checked_cast<int>(data.size()));
int ssl_error = SSL_get_error(ssl_, code);
switch (ssl_error) {
case SSL_ERROR_NONE:
@@ -624,19 +621,19 @@
RTC_DCHECK_GT(code, 0);
RTC_DCHECK_LE(code, data.size());
written = code;
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
case SSL_ERROR_WANT_READ:
RTC_DLOG(LS_VERBOSE) << " -- error want read";
ssl_write_needs_read_ = true;
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
case SSL_ERROR_WANT_WRITE:
RTC_DLOG(LS_VERBOSE) << " -- error want write";
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
case SSL_ERROR_ZERO_RETURN:
default:
Error("SSL_write", (ssl_error ? ssl_error : -1), 0, false);
error = ssl_error_code_;
- return webrtc::SR_ERROR;
+ return SR_ERROR;
}
// not reached
}
@@ -651,30 +648,29 @@
return stream_->Read(data, read, error);
case SSL_WAIT:
case SSL_CONNECTING:
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
case SSL_CONNECTED:
if (WaitingToVerifyPeerCertificate()) {
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
}
break;
case SSL_CLOSED:
- return webrtc::SR_EOS;
+ return SR_EOS;
case SSL_ERROR:
default:
error = ssl_error_code_;
- return webrtc::SR_ERROR;
+ return SR_ERROR;
}
// Don't trust OpenSSL with zero byte reads
if (data.size() == 0) {
read = 0;
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
ssl_read_needs_write_ = false;
- const int code =
- SSL_read(ssl_, data.data(), webrtc::checked_cast<int>(data.size()));
+ const int code = SSL_read(ssl_, data.data(), checked_cast<int>(data.size()));
const int ssl_error = SSL_get_error(ssl_, code);
switch (ssl_error) {
@@ -684,33 +680,33 @@
RTC_DCHECK_LE(code, data.size());
read = code;
- if (ssl_mode_ == webrtc::SSL_MODE_DTLS) {
+ if (ssl_mode_ == SSL_MODE_DTLS) {
// Enforce atomic reads -- this is a short read
unsigned int pending = SSL_pending(ssl_);
if (pending) {
RTC_DLOG(LS_INFO) << " -- short DTLS read. flushing";
FlushInput(pending);
- error = webrtc::SSE_MSG_TRUNC;
- return webrtc::SR_ERROR;
+ error = SSE_MSG_TRUNC;
+ return SR_ERROR;
}
}
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
case SSL_ERROR_WANT_READ:
RTC_DLOG(LS_VERBOSE) << " -- error want read";
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
case SSL_ERROR_WANT_WRITE:
RTC_DLOG(LS_VERBOSE) << " -- error want write";
ssl_read_needs_write_ = true;
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
case SSL_ERROR_ZERO_RETURN:
RTC_DLOG(LS_VERBOSE) << " -- remote side closed";
Close();
- return webrtc::SR_EOS;
+ return SR_EOS;
default:
Error("SSL_read", (ssl_error ? ssl_error : -1), 0, false);
error = ssl_error_code_;
- return webrtc::SR_ERROR;
+ return SR_ERROR;
}
// not reached
}
@@ -750,14 +746,14 @@
switch (state_) {
case SSL_WAIT:
case SSL_CONNECTING:
- return webrtc::SS_OPENING;
+ return SS_OPENING;
case SSL_CONNECTED:
if (WaitingToVerifyPeerCertificate()) {
- return webrtc::SS_OPENING;
+ return SS_OPENING;
}
- return webrtc::SS_OPEN;
+ return SS_OPEN;
default:
- return webrtc::SS_CLOSED;
+ return SS_CLOSED;
}
// not reached
}
@@ -767,11 +763,11 @@
int events_to_signal = 0;
int signal_error = 0;
- if ((events & webrtc::SE_OPEN)) {
+ if ((events & SE_OPEN)) {
RTC_DLOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent SE_OPEN";
if (state_ != SSL_WAIT) {
RTC_DCHECK(state_ == SSL_NONE);
- events_to_signal |= webrtc::SE_OPEN;
+ events_to_signal |= SE_OPEN;
} else {
state_ = SSL_CONNECTING;
if (int error = BeginSSL()) {
@@ -781,36 +777,36 @@
}
}
- if ((events & (webrtc::SE_READ | webrtc::SE_WRITE))) {
+ if ((events & (SE_READ | SE_WRITE))) {
RTC_DLOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent"
- << ((events & webrtc::SE_READ) ? " SE_READ" : "")
- << ((events & webrtc::SE_WRITE) ? " SE_WRITE" : "");
+ << ((events & SE_READ) ? " SE_READ" : "")
+ << ((events & SE_WRITE) ? " SE_WRITE" : "");
if (state_ == SSL_NONE) {
- events_to_signal |= events & (webrtc::SE_READ | webrtc::SE_WRITE);
+ events_to_signal |= events & (SE_READ | SE_WRITE);
} else if (state_ == SSL_CONNECTING) {
if (int error = ContinueSSL()) {
Error("ContinueSSL", error, 0, true);
return;
}
} else if (state_ == SSL_CONNECTED) {
- if (((events & webrtc::SE_READ) && ssl_write_needs_read_) ||
- (events & webrtc::SE_WRITE)) {
+ if (((events & SE_READ) && ssl_write_needs_read_) ||
+ (events & SE_WRITE)) {
RTC_DLOG(LS_VERBOSE) << " -- onStreamWriteable";
- events_to_signal |= webrtc::SE_WRITE;
+ events_to_signal |= SE_WRITE;
}
- if (((events & webrtc::SE_WRITE) && ssl_read_needs_write_) ||
- (events & webrtc::SE_READ)) {
+ if (((events & SE_WRITE) && ssl_read_needs_write_) ||
+ (events & SE_READ)) {
RTC_DLOG(LS_VERBOSE) << " -- onStreamReadable";
- events_to_signal |= webrtc::SE_READ;
+ events_to_signal |= SE_READ;
}
}
}
- if ((events & webrtc::SE_CLOSE)) {
+ if ((events & SE_CLOSE)) {
RTC_DLOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent(SE_CLOSE, " << err
<< ")";
Cleanup(0);
- events_to_signal |= webrtc::SE_CLOSE;
+ events_to_signal |= SE_CLOSE;
// SE_CLOSE is the only event that uses the final parameter to OnEvent().
RTC_DCHECK(signal_error == 0);
signal_error = err;
@@ -899,7 +895,7 @@
SSL_set_mtu(ssl_, dtls_mtu_);
#ifdef OPENSSL_IS_BORINGSSL
- if (ssl_mode_ == webrtc::SSL_MODE_DTLS) {
+ if (ssl_mode_ == SSL_MODE_DTLS) {
DTLSv1_set_initial_timeout_duration(ssl_, dtls_handshake_timeout_ms_);
}
@@ -927,8 +923,7 @@
// Clear the DTLS timer
timeout_task_.Stop();
- const int code =
- (role_ == webrtc::SSL_CLIENT) ? SSL_connect(ssl_) : SSL_accept(ssl_);
+ const int code = (role_ == SSL_CLIENT) ? SSL_connect(ssl_) : SSL_accept(ssl_);
const int ssl_error = SSL_get_error(ssl_, code);
switch (ssl_error) {
@@ -948,7 +943,7 @@
// The caller of ContinueSSL may be the same object listening for these
// events and may not be prepared for reentrancy.
// PostEvent(SE_OPEN | SE_READ | SE_WRITE, 0);
- FireEvent(webrtc::SE_OPEN | webrtc::SE_READ | webrtc::SE_WRITE, 0);
+ FireEvent(SE_OPEN | SE_READ | SE_WRITE, 0);
}
break;
case SSL_ERROR_WANT_READ:
@@ -995,7 +990,7 @@
ssl_error_code_ = err;
Cleanup(alert);
if (signal) {
- FireEvent(webrtc::SE_CLOSE, err);
+ FireEvent(SE_CLOSE, err);
}
}
@@ -1045,9 +1040,9 @@
#ifdef OPENSSL_IS_BORINGSSL
// If X509 objects aren't used, we can use these methods to avoid
// linking the sizable crypto/x509 code, using CRYPTO_BUFFER instead.
- SSL_CTX* ctx = SSL_CTX_new(ssl_mode_ == webrtc::SSL_MODE_DTLS
- ? DTLS_with_buffers_method()
- : TLS_with_buffers_method());
+ SSL_CTX* ctx =
+ SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ? DTLS_with_buffers_method()
+ : TLS_with_buffers_method());
#else
SSL_CTX* ctx =
SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ? DTLS_method() : TLS_method());
@@ -1057,7 +1052,7 @@
}
auto min_version =
- ssl_mode_ == webrtc::SSL_MODE_DTLS ? DTLS1_2_VERSION : TLS1_2_VERSION;
+ ssl_mode_ == SSL_MODE_DTLS ? DTLS1_2_VERSION : TLS1_2_VERSION;
auto max_version = GetMaxVersion(ssl_mode_, ssl_max_version_);
#ifdef DTLS1_3_VERSION
if (force_dtls_13_ == kForceDtls13Enabled) {
@@ -1348,7 +1343,7 @@
SSLProtocolVersion OpenSSLStreamAdapter::GetMaxSupportedDTLSProtocolVersion() {
#if defined(OPENSSL_IS_BORINGSSL) && defined(DTLS1_3_VERSION)
- return webrtc::SSL_PROTOCOL_DTLS_13;
+ return SSL_PROTOCOL_DTLS_13;
#else
return SSL_PROTOCOL_DTLS_12;
#endif
diff --git a/rtc_base/openssl_utility.cc b/rtc_base/openssl_utility.cc
index 906127f..9c6dcf8 100644
--- a/rtc_base/openssl_utility.cc
+++ b/rtc_base/openssl_utility.cc
@@ -152,8 +152,8 @@
return false;
}
if (expiration_time) {
- *expiration_time = webrtc::ASN1TimeToSec(CBS_data(¬_after),
- CBS_len(¬_after), long_format);
+ *expiration_time =
+ ASN1TimeToSec(CBS_data(¬_after), CBS_len(¬_after), long_format);
}
// subject Name,
if (!CBS_get_asn1_element(&tbs_certificate, nullptr, CBS_ASN1_SEQUENCE)) {
@@ -248,9 +248,8 @@
for (size_t i = 0; i < arraysize(kSSLCertCertificateList); i++) {
const unsigned char* cert_buffer = kSSLCertCertificateList[i];
size_t cert_buffer_len = kSSLCertCertificateSizeList[i];
- X509* cert =
- d2i_X509(nullptr, &cert_buffer,
- webrtc::checked_cast<long>(cert_buffer_len)); // NOLINT
+ X509* cert = d2i_X509(nullptr, &cert_buffer,
+ checked_cast<long>(cert_buffer_len)); // NOLINT
if (cert) {
int return_value = X509_STORE_add_cert(SSL_CTX_get_cert_store(ctx), cert);
if (return_value == 0) {
diff --git a/rtc_base/openssl_utility_unittest.cc b/rtc_base/openssl_utility_unittest.cc
index 1f0fcd9..3008147 100644
--- a/rtc_base/openssl_utility_unittest.cc
+++ b/rtc_base/openssl_utility_unittest.cc
@@ -187,7 +187,7 @@
const unsigned char* key_ptr = kFakeSSLPrivateKey;
EVP_PKEY* key = d2i_PrivateKey(
EVP_PKEY_EC, nullptr, &key_ptr,
- webrtc::checked_cast<long>(arraysize(kFakeSSLPrivateKey))); // NOLINT
+ checked_cast<long>(arraysize(kFakeSSLPrivateKey))); // NOLINT
RTC_CHECK(key);
#ifdef OPENSSL_IS_BORINGSSL
diff --git a/rtc_base/operations_chain_unittest.cc b/rtc_base/operations_chain_unittest.cc
index ed5cd40..9f7ce22 100644
--- a/rtc_base/operations_chain_unittest.cc
+++ b/rtc_base/operations_chain_unittest.cc
@@ -415,10 +415,9 @@
// Completing the operation empties the chain, invoking the callback.
unblock_async_operation_event0.Set();
async_operation_completed_event0->Wait(Event::kForever);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return on_empty_callback_counter == 1u; },
+ EXPECT_THAT(WaitUntil([&] { return on_empty_callback_counter == 1u; },
::testing::IsTrue(), {.timeout = kDefaultTimeout}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Chain multiple events.
Event unblock_async_operation_event1;
@@ -430,25 +429,22 @@
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event2);
// Again, the callback is not invoked until the operation has completed.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return on_empty_callback_counter == 1u; },
+ EXPECT_THAT(WaitUntil([&] { return on_empty_callback_counter == 1u; },
::testing::IsTrue(), {.timeout = kDefaultTimeout}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Upon completing the first event, the chain is still not empty, so the
// callback must not be invoked yet.
unblock_async_operation_event1.Set();
async_operation_completed_event1->Wait(Event::kForever);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return on_empty_callback_counter == 1u; },
+ EXPECT_THAT(WaitUntil([&] { return on_empty_callback_counter == 1u; },
::testing::IsTrue(), {.timeout = kDefaultTimeout}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Completing the last event empties the chain, invoking the callback.
unblock_async_operation_event2.Set();
async_operation_completed_event2->Wait(Event::kForever);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return on_empty_callback_counter == 2u; },
+ EXPECT_THAT(WaitUntil([&] { return on_empty_callback_counter == 2u; },
::testing::IsTrue(), {.timeout = kDefaultTimeout}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
TEST(OperationsChainTest,
diff --git a/rtc_base/physical_socket_server.cc b/rtc_base/physical_socket_server.cc
index 4769f41..b18052a 100644
--- a/rtc_base/physical_socket_server.cc
+++ b/rtc_base/physical_socket_server.cc
@@ -204,7 +204,7 @@
int result = ::getsockname(s_, addr, &addrlen);
SocketAddress address;
if (result >= 0) {
- webrtc::SocketAddressFromSockAddrStorage(addr_storage, &address);
+ SocketAddressFromSockAddrStorage(addr_storage, &address);
} else {
RTC_LOG(LS_WARNING) << "GetLocalAddress: unable to get local addr, socket="
<< s_;
@@ -219,7 +219,7 @@
int result = ::getpeername(s_, addr, &addrlen);
SocketAddress address;
if (result >= 0) {
- webrtc::SocketAddressFromSockAddrStorage(addr_storage, &address);
+ SocketAddressFromSockAddrStorage(addr_storage, &address);
} else {
RTC_LOG(LS_WARNING)
<< "GetRemoteAddress: unable to get remote addr, socket=" << s_;
@@ -239,8 +239,7 @@
// Since the network binder handled binding the socket to the desired
// network interface, we don't need to (and shouldn't) include an IP in
// the bind() call; bind() just needs to assign a port.
- copied_bind_addr.SetIP(
- webrtc::GetAnyIP(copied_bind_addr.ipaddr().family()));
+ copied_bind_addr.SetIP(GetAnyIP(copied_bind_addr.ipaddr().family()));
} else if (result == NetworkBindingResult::NOT_IMPLEMENTED) {
RTC_LOG(LS_INFO) << "Can't bind socket to network because "
"network binding is not implemented for this OS.";
@@ -305,7 +304,7 @@
uint8_t events = DE_READ | DE_WRITE;
if (err == 0) {
state_ = CS_CONNECTED;
- } else if (webrtc::IsBlockingError(GetError())) {
+ } else if (IsBlockingError(GetError())) {
state_ = CS_CONNECTING;
events |= DE_CONNECT;
} else {
@@ -417,7 +416,7 @@
// We have seen minidumps where this may be false.
RTC_DCHECK(sent <= static_cast<int>(cb));
if ((sent > 0 && sent < static_cast<int>(cb)) ||
- (sent < 0 && webrtc::IsBlockingError(GetError()))) {
+ (sent < 0 && IsBlockingError(GetError()))) {
EnableEvents(DE_WRITE);
}
return sent;
@@ -442,7 +441,7 @@
// We have seen minidumps where this may be false.
RTC_DCHECK(sent <= static_cast<int>(length));
if ((sent > 0 && sent < static_cast<int>(length)) ||
- (sent < 0 && webrtc::IsBlockingError(GetError()))) {
+ (sent < 0 && IsBlockingError(GetError()))) {
EnableEvents(DE_WRITE);
}
return sent;
@@ -465,7 +464,7 @@
UpdateLastError();
int error = GetError();
- bool success = (received >= 0) || webrtc::IsBlockingError(error);
+ bool success = (received >= 0) || IsBlockingError(error);
if (udp_ || success) {
EnableEvents(DE_READ);
}
@@ -483,7 +482,7 @@
UpdateLastError();
int error = GetError();
- bool success = (received >= 0) || webrtc::IsBlockingError(error);
+ bool success = (received >= 0) || IsBlockingError(error);
if (udp_ || success) {
EnableEvents(DE_READ);
}
@@ -507,7 +506,7 @@
}
UpdateLastError();
int error = GetError();
- bool success = (received >= 0) || webrtc::IsBlockingError(error);
+ bool success = (received >= 0) || IsBlockingError(error);
if (udp_ || success) {
EnableEvents(DE_READ);
}
@@ -569,7 +568,7 @@
}
}
if (out_addr) {
- webrtc::SocketAddressFromSockAddrStorage(addr_storage, out_addr);
+ SocketAddressFromSockAddrStorage(addr_storage, out_addr);
}
return received;
@@ -616,7 +615,7 @@
if (s == INVALID_SOCKET)
return nullptr;
if (out_addr != nullptr)
- webrtc::SocketAddressFromSockAddrStorage(addr_storage, out_addr);
+ SocketAddressFromSockAddrStorage(addr_storage, out_addr);
return ss_->WrapSocket(s);
}
diff --git a/rtc_base/physical_socket_server_unittest.cc b/rtc_base/physical_socket_server_unittest.cc
index ac1743e..56ec609 100644
--- a/rtc_base/physical_socket_server_unittest.cc
+++ b/rtc_base/physical_socket_server_unittest.cc
@@ -208,13 +208,13 @@
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client1.get());
EXPECT_EQ(Socket::CS_CLOSED, client1->GetState());
- EXPECT_TRUE(webrtc::IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr()));
+ EXPECT_TRUE(IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr()));
std::unique_ptr<Socket> client2(
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client2.get());
EXPECT_EQ(Socket::CS_CLOSED, client2->GetState());
- EXPECT_TRUE(webrtc::IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr()));
+ EXPECT_TRUE(IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr()));
// Create server and listen.
std::unique_ptr<Socket> server(
@@ -225,7 +225,7 @@
EXPECT_EQ(Socket::CS_CONNECTING, server->GetState());
// Ensure no pending server connections, since we haven't done anything yet.
- EXPECT_FALSE(sink.Check(server.get(), webrtc::testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_TRUE(accept_addr.IsNil());
@@ -236,15 +236,14 @@
// Client is connecting, outcome not yet determined.
EXPECT_EQ(Socket::CS_CONNECTING, client1->GetState());
- EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client1.get(), testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client1.get(), testing::SSE_CLOSE));
// Server has pending connection, try to accept it (will fail).
EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return (sink.Check(server.get(), webrtc::testing::SSE_READ)); },
- ::testing::IsTrue()),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return (sink.Check(server.get(), testing::SSE_READ)); },
+ ::testing::IsTrue()),
+ IsRtcOk());
// Simulate "::accept" returning an error.
SetFailAccept(true);
std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
@@ -252,7 +251,7 @@
ASSERT_TRUE(accept_addr.IsNil());
// Ensure no more pending server connections.
- EXPECT_FALSE(sink.Check(server.get(), webrtc::testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_TRUE(accept_addr.IsNil());
@@ -263,15 +262,14 @@
// Client is connecting, outcome not yet determined.
EXPECT_EQ(Socket::CS_CONNECTING, client2->GetState());
- EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client2.get(), testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client2.get(), testing::SSE_CLOSE));
// Server has pending connection, try to accept it (will succeed).
EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return (sink.Check(server.get(), webrtc::testing::SSE_READ)); },
- ::testing::IsTrue()),
- webrtc::IsRtcOk());
+ WaitUntil([&] { return (sink.Check(server.get(), testing::SSE_READ)); },
+ ::testing::IsTrue()),
+ IsRtcOk());
SetFailAccept(false);
std::unique_ptr<Socket> accepted2(server->Accept(&accept_addr));
ASSERT_TRUE(accepted2);
diff --git a/rtc_base/rate_tracker.cc b/rtc_base/rate_tracker.cc
index 83481c1..f6f4cf3 100644
--- a/rtc_base/rate_tracker.cc
+++ b/rtc_base/rate_tracker.cc
@@ -64,7 +64,7 @@
buckets_to_skip = bucket_count_ - current_bucket_;
milliseconds_to_skip = 0;
available_interval_milliseconds =
- webrtc::TimeDiff(current_time, initialization_time_milliseconds_);
+ TimeDiff(current_time, initialization_time_milliseconds_);
// Let one bucket interval pass after initialization before reporting.
if (available_interval_milliseconds < bucket_milliseconds_) {
return 0.0;
@@ -102,7 +102,7 @@
}
return static_cast<double>(total_sample_count_ * 1000) /
static_cast<double>(
- webrtc::TimeDiff(current_time, initialization_time_milliseconds_));
+ TimeDiff(current_time, initialization_time_milliseconds_));
}
int64_t RateTracker::TotalSampleCount() const {
@@ -139,7 +139,7 @@
}
int64_t RateTracker::Time() const {
- return webrtc::TimeMillis();
+ return TimeMillis();
}
void RateTracker::EnsureInitialized() {
diff --git a/rtc_base/rtc_certificate_generator_unittest.cc b/rtc_base/rtc_certificate_generator_unittest.cc
index a4388f5..06bb581 100644
--- a/rtc_base/rtc_certificate_generator_unittest.cc
+++ b/rtc_base/rtc_certificate_generator_unittest.cc
@@ -97,10 +97,9 @@
// posted to this thread (which is done by `EXPECT_TRUE_WAIT`).
EXPECT_FALSE(fixture_.GenerateAsyncCompleted());
EXPECT_FALSE(fixture_.certificate());
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return fixture_.GenerateAsyncCompleted(); },
+ EXPECT_THAT(WaitUntil([&] { return fixture_.GenerateAsyncCompleted(); },
::testing::IsTrue(), {.timeout = kGenerationTimeoutMs}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_TRUE(fixture_.certificate());
}
@@ -140,10 +139,9 @@
fixture_.generator()->GenerateCertificateAsync(invalid_params, std::nullopt,
fixture_.OnGenerated());
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return fixture_.GenerateAsyncCompleted(); },
+ EXPECT_THAT(WaitUntil([&] { return fixture_.GenerateAsyncCompleted(); },
::testing::IsTrue(), {.timeout = kGenerationTimeoutMs}),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_FALSE(fixture_.certificate());
}
diff --git a/rtc_base/rtc_certificate_unittest.cc b/rtc_base/rtc_certificate_unittest.cc
index 67f7e2c..5233a80 100644
--- a/rtc_base/rtc_certificate_unittest.cc
+++ b/rtc_base/rtc_certificate_unittest.cc
@@ -68,7 +68,7 @@
// or later.
scoped_refptr<RTCCertificate> GenerateCertificateWithExpires(
uint64_t expires_s) const {
- RTC_CHECK(webrtc::IsValueInRangeForNumericType<time_t>(expires_s));
+ RTC_CHECK(IsValueInRangeForNumericType<time_t>(expires_s));
SSLIdentityParams params;
params.common_name = kTestCertCommonName;
diff --git a/rtc_base/socket_address.cc b/rtc_base/socket_address.cc
index 1e7d941..7c08bf4 100644
--- a/rtc_base/socket_address.cc
+++ b/rtc_base/socket_address.cc
@@ -65,11 +65,11 @@
}
bool SocketAddress::IsNil() const {
- return hostname_.empty() && webrtc::IPIsUnspec(ip_) && 0 == port_;
+ return hostname_.empty() && IPIsUnspec(ip_) && 0 == port_;
}
bool SocketAddress::IsComplete() const {
- return (!webrtc::IPIsAny(ip_)) && (0 != port_);
+ return (!IPIsAny(ip_)) && (0 != port_);
}
SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
@@ -97,7 +97,7 @@
void SocketAddress::SetIP(absl::string_view hostname) {
hostname_ = std::string(hostname);
- literal_ = webrtc::IPFromString(hostname, &ip_);
+ literal_ = IPFromString(hostname, &ip_);
if (!literal_) {
ip_ = IPAddress();
}
@@ -115,7 +115,7 @@
}
void SocketAddress::SetPort(int port) {
- port_ = webrtc::dchecked_cast<uint16_t>(port);
+ port_ = dchecked_cast<uint16_t>(port);
}
uint32_t SocketAddress::ip() const {
@@ -214,20 +214,20 @@
}
bool SocketAddress::IsAnyIP() const {
- return webrtc::IPIsAny(ip_);
+ return IPIsAny(ip_);
}
bool SocketAddress::IsLoopbackIP() const {
- return webrtc::IPIsLoopback(ip_) ||
- (webrtc::IPIsAny(ip_) && 0 == strcmp(hostname_.c_str(), "localhost"));
+ return IPIsLoopback(ip_) ||
+ (IPIsAny(ip_) && 0 == strcmp(hostname_.c_str(), "localhost"));
}
bool SocketAddress::IsPrivateIP() const {
- return webrtc::IPIsPrivate(ip_);
+ return IPIsPrivate(ip_);
}
bool SocketAddress::IsUnresolvedIP() const {
- return webrtc::IPIsUnspec(ip_) && !literal_ && !hostname_.empty();
+ return IPIsUnspec(ip_) && !literal_ && !hostname_.empty();
}
bool SocketAddress::operator==(const SocketAddress& addr) const {
@@ -240,8 +240,7 @@
// We only check hostnames if both IPs are ANY or unspecified. This matches
// EqualIPs().
- if ((webrtc::IPIsAny(ip_) || webrtc::IPIsUnspec(ip_)) &&
- hostname_ != addr.hostname_)
+ if ((IPIsAny(ip_) || IPIsUnspec(ip_)) && hostname_ != addr.hostname_)
return hostname_ < addr.hostname_;
return port_ < addr.port_;
@@ -249,8 +248,7 @@
bool SocketAddress::EqualIPs(const SocketAddress& addr) const {
return (ip_ == addr.ip_) &&
- ((!webrtc::IPIsAny(ip_) && !webrtc::IPIsUnspec(ip_)) ||
- (hostname_ == addr.hostname_));
+ ((!IPIsAny(ip_) && !IPIsUnspec(ip_)) || (hostname_ == addr.hostname_));
}
bool SocketAddress::EqualPorts(const SocketAddress& addr) const {
@@ -259,7 +257,7 @@
size_t SocketAddress::Hash() const {
size_t h = 0;
- h ^= webrtc::HashIP(ip_);
+ h ^= HashIP(ip_);
h ^= port_ | (port_ << 16);
return h;
}
@@ -271,8 +269,8 @@
return;
}
saddr->sin_family = AF_INET;
- saddr->sin_port = webrtc::HostToNetwork16(port_);
- if (webrtc::IPIsAny(ip_)) {
+ saddr->sin_port = HostToNetwork16(port_);
+ if (IPIsAny(ip_)) {
saddr->sin_addr.s_addr = INADDR_ANY;
} else {
saddr->sin_addr = ip_.ipv4_address();
@@ -282,8 +280,8 @@
bool SocketAddress::FromSockAddr(const sockaddr_in& saddr) {
if (saddr.sin_family != AF_INET)
return false;
- SetIP(webrtc::NetworkToHost32(saddr.sin_addr.s_addr));
- SetPort(webrtc::NetworkToHost16(saddr.sin_port));
+ SetIP(NetworkToHost32(saddr.sin_addr.s_addr));
+ SetPort(NetworkToHost16(saddr.sin_port));
literal_ = false;
return true;
}
@@ -297,13 +295,13 @@
if (addr->ss_family == AF_INET6) {
sockaddr_in6* saddr = reinterpret_cast<sockaddr_in6*>(addr);
saddr->sin6_addr = ip.ipv6_address();
- saddr->sin6_port = webrtc::HostToNetwork16(port);
+ saddr->sin6_port = HostToNetwork16(port);
saddr->sin6_scope_id = scope_id;
return sizeof(sockaddr_in6);
} else if (addr->ss_family == AF_INET) {
sockaddr_in* saddr = reinterpret_cast<sockaddr_in*>(addr);
saddr->sin_addr = ip.ipv4_address();
- saddr->sin_port = webrtc::HostToNetwork16(port);
+ saddr->sin_port = HostToNetwork16(port);
return sizeof(sockaddr_in);
}
return 0;
@@ -325,12 +323,12 @@
if (addr.ss_family == AF_INET) {
const sockaddr_in* saddr = reinterpret_cast<const sockaddr_in*>(&addr);
*out = SocketAddress(IPAddress(saddr->sin_addr),
- webrtc::NetworkToHost16(saddr->sin_port));
+ NetworkToHost16(saddr->sin_port));
return true;
} else if (addr.ss_family == AF_INET6) {
const sockaddr_in6* saddr = reinterpret_cast<const sockaddr_in6*>(&addr);
*out = SocketAddress(IPAddress(saddr->sin6_addr),
- webrtc::NetworkToHost16(saddr->sin6_port));
+ NetworkToHost16(saddr->sin6_port));
out->SetScopeID(saddr->sin6_scope_id);
return true;
}
diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc
index c7fd137..4f5d219 100644
--- a/rtc_base/socket_unittest.cc
+++ b/rtc_base/socket_unittest.cc
@@ -52,12 +52,12 @@
namespace webrtc {
-using webrtc::testing::SSE_CLOSE;
-using webrtc::testing::SSE_ERROR;
-using webrtc::testing::SSE_OPEN;
-using webrtc::testing::SSE_READ;
-using webrtc::testing::SSE_WRITE;
-using webrtc::testing::StreamSink;
+using testing::SSE_CLOSE;
+using testing::SSE_ERROR;
+using testing::SSE_OPEN;
+using testing::SSE_READ;
+using testing::SSE_WRITE;
+using testing::StreamSink;
// Data size to be used in TcpInternal tests.
static const size_t kTcpInternalDataSize = 1024 * 1024; // bytes
@@ -253,7 +253,7 @@
// values on Windows, but an empty address of the same family on Linux/MacOS X.
bool IsUnspecOrEmptyIP(const IPAddress& address) {
#if !defined(WEBRTC_WIN)
- return webrtc::IPIsAny(address);
+ return IPIsAny(address);
#else
return address.family() == AF_UNSPEC;
#endif
@@ -294,10 +294,9 @@
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection, accept it.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
+ EXPECT_THAT(WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil());
@@ -309,9 +308,9 @@
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
// Connected from client perspective, check the addresses are correct.
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CONNECTED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CONNECTED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@@ -348,10 +347,9 @@
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection, accept it.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
+ EXPECT_THAT(WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil());
@@ -363,9 +361,9 @@
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
// Connected from client perspective, check the addresses are correct.
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CONNECTED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CONNECTED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@@ -394,9 +392,9 @@
EXPECT_EQ(0, client->Connect(bogus_addr));
// Wait for connection to fail (ECONNREFUSED).
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CLOSED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CLOSED)),
+ IsRtcOk());
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_TRUE(client->GetRemoteAddress().IsNil());
@@ -437,9 +435,9 @@
return;
}
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CLOSED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CLOSED)),
+ IsRtcOk());
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_TRUE(client->GetRemoteAddress().IsNil());
@@ -486,10 +484,9 @@
// Accept the original connection.
SocketAddress accept_addr;
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
+ EXPECT_THAT(WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil());
@@ -498,9 +495,9 @@
EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CONNECTED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CONNECTED)),
+ IsRtcOk());
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
@@ -533,16 +530,15 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Close down the server while the socket is in the accept queue.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(server.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(server.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
server->Close();
// This should fail the connection for the client. Clean up.
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CLOSED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CLOSED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
client->Close();
}
@@ -567,10 +563,9 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Close down the client while the socket is in the accept queue.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(server.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(server.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
client->Close();
// The connection should still be able to be accepted.
@@ -580,9 +575,9 @@
EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
// The accepted socket should then close (possibly with err, timing-related)
- EXPECT_THAT(webrtc::WaitUntil([&] { return accepted->GetState(); },
- ::testing::Eq(Socket::CS_CLOSED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return accepted->GetState(); },
+ ::testing::Eq(Socket::CS_CLOSED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE) ||
sink.Check(accepted.get(), SSE_ERROR));
@@ -610,18 +605,17 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Accept connection.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
+ EXPECT_THAT(WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
sink.Monitor(accepted.get());
// Both sides are now connected.
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CONNECTED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CONNECTED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
@@ -632,10 +626,9 @@
EXPECT_EQ(Socket::CS_CLOSED, accepted->GetState());
// Expect that the client is notified, and has not yet closed.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(client.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(client.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
@@ -645,9 +638,9 @@
EXPECT_EQ('a', buffer[0]);
// Now we should close, but the remote address will remain.
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CLOSED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CLOSED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP());
@@ -695,18 +688,17 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Accept connection.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
+ EXPECT_THAT(WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
sink.Monitor(accepted.get());
// Both sides are now connected.
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CONNECTED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CONNECTED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
@@ -720,9 +712,9 @@
EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
// Now we should be closed and invalidated
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CLOSED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CLOSED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_TRUE(Socket::CS_CLOSED == client->GetState());
}
@@ -760,9 +752,8 @@
// event.
SocketDeleter deleter(std::move(socket2));
socket1->SignalReadEvent.connect(&deleter, &SocketDeleter::Delete);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return deleter.deleted(); }, ::testing::IsTrue()),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return deleter.deleted(); }, ::testing::IsTrue()),
+ IsRtcOk());
}
void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
@@ -780,10 +771,9 @@
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
+ EXPECT_THAT(WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
@@ -792,9 +782,9 @@
EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CONNECTED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CONNECTED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@@ -814,10 +804,9 @@
EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
// But should signal when process_io is true.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return (sink.Check(accepted.get(), SSE_READ)); },
+ EXPECT_THAT(WaitUntil([&] { return (sink.Check(accepted.get(), SSE_READ)); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
EXPECT_LT(0, accepted->Recv(buf, 1024, nullptr));
}
@@ -843,18 +832,17 @@
EXPECT_EQ(0, receiver->Connect(server->GetLocalAddress()));
// Accept connection which will be used for sending.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
+ EXPECT_THAT(WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
std::unique_ptr<Socket> sender(server->Accept(&accept_addr));
ASSERT_TRUE(sender);
sink.Monitor(sender.get());
// Both sides are now connected.
- EXPECT_THAT(webrtc::WaitUntil([&] { return receiver->GetState(); },
- ::testing::Eq(Socket::CS_CONNECTED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return receiver->GetState(); },
+ ::testing::Eq(Socket::CS_CONNECTED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(receiver.get(), SSE_OPEN));
EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress());
EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress());
@@ -907,10 +895,10 @@
while (recv_buffer.size() < sent_size) {
if (!readable) {
// Wait until data is available.
- EXPECT_THAT(webrtc::WaitUntil(
- [&] { return sink.Check(receiver.get(), SSE_READ); },
- ::testing::IsTrue()),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return sink.Check(receiver.get(), SSE_READ); },
+ ::testing::IsTrue()),
+ IsRtcOk());
readable = true;
recv_called = false;
}
@@ -939,10 +927,9 @@
// Once all that we've sent has been received, expect to be able to send
// again.
if (!writable) {
- ASSERT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(sender.get(), SSE_WRITE); },
+ ASSERT_THAT(WaitUntil([&] { return sink.Check(sender.get(), SSE_WRITE); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
writable = true;
send_called = false;
}
@@ -955,9 +942,9 @@
// Close down.
sender->Close();
- EXPECT_THAT(webrtc::WaitUntil([&] { return receiver->GetState(); },
- ::testing::Eq(Socket::CS_CLOSED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return receiver->GetState(); },
+ ::testing::Eq(Socket::CS_CLOSED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(receiver.get(), SSE_CLOSE));
receiver->Close();
}
@@ -982,27 +969,25 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Accept connection.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
+ EXPECT_THAT(WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
sink.Monitor(accepted.get());
// Both sides are now connected.
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); },
- ::testing::Eq(Socket::CS_CONNECTED)),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return client->GetState(); },
+ ::testing::Eq(Socket::CS_CONNECTED)),
+ IsRtcOk());
EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
// Expect a writable callback from the connect.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(accepted.get(), SSE_WRITE); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(accepted.get(), SSE_WRITE); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Fill the socket buffer.
char buf[1024 * 16] = {0};
@@ -1012,10 +997,9 @@
EXPECT_TRUE(accepted->IsBlocking());
// Wait until data is available.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(client.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(client.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Pull data.
for (int i = 0; i < sends; ++i) {
@@ -1023,10 +1007,9 @@
}
// Expect at least one additional writable callback.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(accepted.get(), SSE_WRITE); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(accepted.get(), SSE_WRITE); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Adding data in response to the writeable callback shouldn't cause infinite
// callbacks.
@@ -1046,7 +1029,7 @@
}
void SocketTest::UdpInternal(const IPAddress& loopback) {
- SocketAddress empty = webrtc::EmptySocketAddressWithFamily(loopback.family());
+ SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
// Test basic bind and connect behavior.
Socket* socket = socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM);
EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
@@ -1092,7 +1075,7 @@
}
void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
- SocketAddress empty = webrtc::EmptySocketAddressWithFamily(loopback.family());
+ SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
// RFC 5737 - The blocks 192.0.2.0/24 (TEST-NET-1) ... are provided for use in
// documentation.
// RFC 3849 - 2001:DB8::/32 as a documentation-only prefix.
@@ -1133,9 +1116,9 @@
}
EXPECT_EQ(expected_error, error);
EXPECT_FALSE(client->ready_to_send());
- EXPECT_THAT(webrtc::WaitUntil([&] { return client->ready_to_send(); },
- ::testing::IsTrue()),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return client->ready_to_send(); }, ::testing::IsTrue()),
+ IsRtcOk());
RTC_LOG(LS_INFO) << "Got SignalReadyToSend";
}
@@ -1244,10 +1227,9 @@
socket->SendTo("foo", 3, address);
// Wait until data is available.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
Buffer buffer;
Socket::ReceiveBuffer receive_buffer_1(buffer);
ASSERT_GT(socket->RecvFrom(receive_buffer_1), 0);
@@ -1258,10 +1240,9 @@
int64_t send_time_2 = TimeMicros();
socket->SendTo("bar", 3, address);
// Wait until data is available.
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
Socket::ReceiveBuffer receive_buffer_2(buffer);
ASSERT_GT(socket->RecvFrom(receive_buffer_2), 0);
@@ -1274,7 +1255,7 @@
}
void SocketTest::UdpSocketRecvTimestampUseRtcEpoch(const IPAddress& loopback) {
- SocketAddress empty = webrtc::EmptySocketAddressWithFamily(loopback.family());
+ SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
ASSERT_EQ(socket->Bind(SocketAddress(loopback, 0)), 0);
@@ -1311,10 +1292,9 @@
Socket::ReceiveBuffer receive_buffer(buffer);
socket->SendTo("foo", 3, address);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(socket->RecvFrom(receive_buffer), 0);
EXPECT_EQ(receive_buffer.ecn, EcnMarking::kNotEct);
@@ -1322,28 +1302,25 @@
socket->SetOption(Socket::OPT_RECV_ECN, 1);
socket->SendTo("bar", 3, address);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(socket->RecvFrom(receive_buffer), 0);
EXPECT_EQ(receive_buffer.ecn, EcnMarking::kEct1);
socket->SetOption(Socket::OPT_SEND_ECN, 2); // Ect(0)
socket->SendTo("bar", 3, address);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(socket->RecvFrom(receive_buffer), 0);
EXPECT_EQ(receive_buffer.ecn, EcnMarking::kEct0);
socket->SetOption(Socket::OPT_SEND_ECN, 3); // Ce
socket->SendTo("bar", 3, address);
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
+ EXPECT_THAT(WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
::testing::IsTrue()),
- webrtc::IsRtcOk());
+ IsRtcOk());
ASSERT_GT(socket->RecvFrom(receive_buffer), 0);
EXPECT_EQ(receive_buffer.ecn, EcnMarking::kCe);
}
diff --git a/rtc_base/ssl_fingerprint.cc b/rtc_base/ssl_fingerprint.cc
index daca558..ca15d11 100644
--- a/rtc_base/ssl_fingerprint.cc
+++ b/rtc_base/ssl_fingerprint.cc
@@ -61,7 +61,7 @@
std::unique_ptr<SSLFingerprint> SSLFingerprint::CreateUniqueFromRfc4572(
absl::string_view algorithm,
absl::string_view fingerprint) {
- if (algorithm.empty() || !webrtc::IsFips180DigestAlgorithm(algorithm))
+ if (algorithm.empty() || !IsFips180DigestAlgorithm(algorithm))
return nullptr;
if (fingerprint.empty())
diff --git a/rtc_base/ssl_identity.cc b/rtc_base/ssl_identity.cc
index 9e16cb1..35930f8 100644
--- a/rtc_base/ssl_identity.cc
+++ b/rtc_base/ssl_identity.cc
@@ -108,7 +108,7 @@
if (bytes_left != 1) {
return -1;
}
- return webrtc::TmToSeconds(tm);
+ return TmToSeconds(tm);
}
//////////////////////////////////////////////////////////////////////
diff --git a/rtc_base/ssl_stream_adapter.cc b/rtc_base/ssl_stream_adapter.cc
index 02ee729..d02318b 100644
--- a/rtc_base/ssl_stream_adapter.cc
+++ b/rtc_base/ssl_stream_adapter.cc
@@ -86,7 +86,7 @@
std::unique_ptr<SSLStreamAdapter> SSLStreamAdapter::Create(
std::unique_ptr<StreamInterface> stream,
- absl::AnyInvocable<void(webrtc::SSLHandshakeError)> handshake_error,
+ absl::AnyInvocable<void(SSLHandshakeError)> handshake_error,
const FieldTrialsView* field_trials) {
return std::make_unique<OpenSSLStreamAdapter>(
std::move(stream), std::move(handshake_error), field_trials);
diff --git a/rtc_base/strings/string_builder_unittest.cc b/rtc_base/strings/string_builder_unittest.cc
index 44c6c4b..d04e0eb 100644
--- a/rtc_base/strings/string_builder_unittest.cc
+++ b/rtc_base/strings/string_builder_unittest.cc
@@ -20,7 +20,7 @@
TEST(SimpleStringBuilder, Limit) {
char sb_buf[10];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
EXPECT_EQ(0u, strlen(sb.str()));
// Test that for a SSB with a buffer size of 10, that we can write 9 chars
@@ -31,7 +31,7 @@
TEST(SimpleStringBuilder, NumbersAndChars) {
char sb_buf[100];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
sb << 1 << ':' << 2.1 << ":" << 2.2f << ':' << 78187493520ll << ':'
<< 78187493520ul;
EXPECT_EQ(0, strcmp(sb.str(), "1:2.1:2.2:78187493520:78187493520"));
@@ -39,7 +39,7 @@
TEST(SimpleStringBuilder, Format) {
char sb_buf[100];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
sb << "Here we go - ";
sb.AppendFormat("This is a hex formatted value: 0x%08llx", 3735928559ULL);
EXPECT_EQ(0,
@@ -49,7 +49,7 @@
TEST(SimpleStringBuilder, StdString) {
char sb_buf[100];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
std::string str = "does this work?";
sb << str;
EXPECT_EQ(str, sb.str());
@@ -61,7 +61,7 @@
TEST(SimpleStringBuilderDeathTest, BufferOverrunConstCharP) {
char sb_buf[4];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
const char* const msg = "This is just too much";
#if RTC_DCHECK_IS_ON
EXPECT_DEATH(sb << msg, "");
@@ -73,7 +73,7 @@
TEST(SimpleStringBuilderDeathTest, BufferOverrunStdString) {
char sb_buf[4];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
sb << 12;
const std::string msg = "Aw, come on!";
#if RTC_DCHECK_IS_ON
@@ -86,7 +86,7 @@
TEST(SimpleStringBuilderDeathTest, BufferOverrunInt) {
char sb_buf[4];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
constexpr int num = -12345;
#if RTC_DCHECK_IS_ON
EXPECT_DEATH(sb << num, "");
@@ -102,7 +102,7 @@
TEST(SimpleStringBuilderDeathTest, BufferOverrunDouble) {
char sb_buf[5];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
constexpr double num = 123.456;
#if RTC_DCHECK_IS_ON
EXPECT_DEATH(sb << num, "");
@@ -115,7 +115,7 @@
TEST(SimpleStringBuilderDeathTest, BufferOverrunConstCharPAlreadyFull) {
char sb_buf[4];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
sb << 123;
const char* const msg = "This is just too much";
#if RTC_DCHECK_IS_ON
@@ -128,7 +128,7 @@
TEST(SimpleStringBuilderDeathTest, BufferOverrunIntAlreadyFull) {
char sb_buf[4];
- webrtc::SimpleStringBuilder sb(sb_buf);
+ SimpleStringBuilder sb(sb_buf);
sb << "xyz";
constexpr int num = -12345;
#if RTC_DCHECK_IS_ON
@@ -145,7 +145,7 @@
// StringBuilder.
TEST(StringBuilder, Limit) {
- webrtc::StringBuilder sb;
+ StringBuilder sb;
EXPECT_EQ(0u, sb.str().size());
sb << "012345678";
@@ -153,7 +153,7 @@
}
TEST(StringBuilder, NumbersAndChars) {
- webrtc::StringBuilder sb;
+ StringBuilder sb;
sb << 1 << ":" << 2.1 << ":" << 2.2f << ":" << 78187493520ll << ":"
<< 78187493520ul;
EXPECT_THAT(sb.str(),
@@ -161,21 +161,21 @@
}
TEST(StringBuilder, Format) {
- webrtc::StringBuilder sb;
+ StringBuilder sb;
sb << "Here we go - ";
sb.AppendFormat("This is a hex formatted value: 0x%08llx", 3735928559ULL);
EXPECT_EQ(sb.str(), "Here we go - This is a hex formatted value: 0xdeadbeef");
}
TEST(StringBuilder, StdString) {
- webrtc::StringBuilder sb;
+ StringBuilder sb;
std::string str = "does this work?";
sb << str;
EXPECT_EQ(str, sb.str());
}
TEST(StringBuilder, Release) {
- webrtc::StringBuilder sb;
+ StringBuilder sb;
std::string str =
"This string has to be of a moderate length, or we might "
"run into problems with small object optimizations.";
@@ -190,7 +190,7 @@
}
TEST(StringBuilder, Reset) {
- webrtc::StringBuilder sb("abc");
+ StringBuilder sb("abc");
sb << "def";
EXPECT_EQ("abcdef", sb.str());
sb.Clear();
diff --git a/rtc_base/strong_alias_unittest.cc b/rtc_base/strong_alias_unittest.cc
index 711c805..c663cad 100644
--- a/rtc_base/strong_alias_unittest.cc
+++ b/rtc_base/strong_alias_unittest.cc
@@ -282,7 +282,7 @@
TYPED_TEST(StrongAliasTest, CanBeKeysInFlatMap) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
- webrtc::flat_map<FooAlias, std::string> map;
+ flat_map<FooAlias, std::string> map;
FooAlias k1(GetExampleValue<TypeParam>(0));
FooAlias k2(GetExampleValue<TypeParam>(1));
diff --git a/rtc_base/synchronization/mutex_unittest.cc b/rtc_base/synchronization/mutex_unittest.cc
index 06938a2..cafd24c 100644
--- a/rtc_base/synchronization/mutex_unittest.cc
+++ b/rtc_base/synchronization/mutex_unittest.cc
@@ -30,8 +30,6 @@
namespace webrtc {
namespace {
-using ::webrtc::Event;
-using ::webrtc::Thread;
constexpr int kNumThreads = 16;
diff --git a/rtc_base/synchronization/sequence_checker_internal.cc b/rtc_base/synchronization/sequence_checker_internal.cc
index 007acac..3b0a0b1 100644
--- a/rtc_base/synchronization/sequence_checker_internal.cc
+++ b/rtc_base/synchronization/sequence_checker_internal.cc
@@ -56,7 +56,7 @@
#if RTC_DCHECK_IS_ON
std::string SequenceCheckerImpl::ExpectationToString() const {
const TaskQueueBase* const current_queue = TaskQueueBase::Current();
- const webrtc::PlatformThreadRef current_thread = webrtc::CurrentThreadRef();
+ const PlatformThreadRef current_thread = CurrentThreadRef();
MutexLock scoped_lock(&lock_);
if (!attached_)
return "Checker currently not attached.";
@@ -68,7 +68,7 @@
// # Actual: TQ: 0x7fa8f0604190 SysQ: 0x7fa8f0604a30 Thread: 0x700006f1a000
// TaskQueue doesn't match
- webrtc::StringBuilder message;
+ StringBuilder message;
message.AppendFormat(
"# Expected: TQ: %p Thread: %p\n"
"# Actual: TQ: %p Thread: %p\n",
@@ -77,7 +77,7 @@
if ((valid_queue_ || current_queue) && valid_queue_ != current_queue) {
message << "TaskQueue doesn't match\n";
- } else if (!webrtc::IsThreadRefEqual(valid_thread_, current_thread)) {
+ } else if (!IsThreadRefEqual(valid_thread_, current_thread)) {
message << "Threads don't match\n";
}
diff --git a/rtc_base/task_queue_stdlib_unittest.cc b/rtc_base/task_queue_stdlib_unittest.cc
index c090b5e..ca27f82 100644
--- a/rtc_base/task_queue_stdlib_unittest.cc
+++ b/rtc_base/task_queue_stdlib_unittest.cc
@@ -25,7 +25,7 @@
namespace {
std::unique_ptr<TaskQueueFactory> CreateTaskQueueFactory(
- const webrtc::FieldTrialsView*) {
+ const FieldTrialsView*) {
return CreateTaskQueueStdlibFactory();
}
diff --git a/rtc_base/test_client.cc b/rtc_base/test_client.cc
index 3798c59..a204d1c 100644
--- a/rtc_base/test_client.cc
+++ b/rtc_base/test_client.cc
@@ -138,7 +138,7 @@
// advance time. Otherwise, ProcessMessages will work.
if (fake_clock_) {
for (int64_t start = TimeMillis(); TimeMillis() < start + ms;) {
- fake_clock_->AdvanceTime(webrtc::TimeDelta::Millis(1));
+ fake_clock_->AdvanceTime(TimeDelta::Millis(1));
};
} else {
Thread::Current()->ProcessMessages(1);
diff --git a/rtc_base/test_client_unittest.cc b/rtc_base/test_client_unittest.cc
index c585a8e..4a87ae3 100644
--- a/rtc_base/test_client_unittest.cc
+++ b/rtc_base/test_client_unittest.cc
@@ -57,7 +57,7 @@
void TestTcpInternal(const SocketAddress& loopback) {
PhysicalSocketServer socket_server;
AutoSocketServerThread main_thread(&socket_server);
- webrtc::TestEchoServer server(&main_thread, loopback);
+ TestEchoServer server(&main_thread, loopback);
Socket* socket = socket_server.CreateSocket(loopback.family(), SOCK_STREAM);
std::unique_ptr<AsyncTCPSocket> tcp_socket = absl::WrapUnique(
diff --git a/rtc_base/thread.cc b/rtc_base/thread.cc
index 2491335..6599615 100644
--- a/rtc_base/thread.cc
+++ b/rtc_base/thread.cc
@@ -88,8 +88,6 @@
namespace webrtc {
-using ::webrtc::MutexLock;
-using ::webrtc::TimeDelta;
ThreadManager* ThreadManager::Instance() {
static ThreadManager* const thread_manager = new ThreadManager();
@@ -499,7 +497,7 @@
// Add to the priority queue. Gets sorted soonest first.
// Signal for the multiplexer to return.
- int64_t delay_ms = delay.RoundUpTo(webrtc::TimeDelta::Millis(1)).ms<int>();
+ int64_t delay_ms = delay.RoundUpTo(TimeDelta::Millis(1)).ms<int>();
int64_t run_time_ms = TimeAfter(delay_ms);
{
MutexLock lock(&mutex_);
@@ -523,7 +521,7 @@
return 0;
if (!delayed_messages_.empty()) {
- int delay = webrtc::TimeUntil(delayed_messages_.top().run_time_ms);
+ int delay = TimeUntil(delayed_messages_.top().run_time_ms);
if (delay < 0)
delay = 0;
return delay;
@@ -535,10 +533,10 @@
void Thread::Dispatch(absl::AnyInvocable<void() &&> task) {
TRACE_EVENT0("webrtc", "Thread::Dispatch");
RTC_DCHECK_RUN_ON(this);
- int64_t start_time = webrtc::TimeMillis();
+ int64_t start_time = TimeMillis();
std::move(task)();
- int64_t end_time = webrtc::TimeMillis();
- int64_t diff = webrtc::TimeDiff(end_time, start_time);
+ int64_t end_time = TimeMillis();
+ int64_t diff = TimeDiff(end_time, start_time);
if (diff >= dispatch_warning_ms_) {
RTC_LOG(LS_INFO) << "Message to " << name() << " took " << diff
<< "ms to dispatch.";
@@ -850,9 +848,9 @@
// Using ProcessMessages with a custom clock for testing and a time greater
// than 0 doesn't work, since it's not guaranteed to advance the custom
// clock's time, and may get stuck in an infinite loop.
- RTC_DCHECK(webrtc::GetClockForTesting() == nullptr || cmsLoop == 0 ||
+ RTC_DCHECK(GetClockForTesting() == nullptr || cmsLoop == 0 ||
cmsLoop == kForever);
- int64_t msEnd = (kForever == cmsLoop) ? 0 : webrtc::TimeAfter(cmsLoop);
+ int64_t msEnd = (kForever == cmsLoop) ? 0 : TimeAfter(cmsLoop);
int cmsNext = cmsLoop;
while (true) {
@@ -865,7 +863,7 @@
Dispatch(std::move(task));
if (cmsLoop != kForever) {
- cmsNext = static_cast<int>(webrtc::TimeUntil(msEnd));
+ cmsNext = static_cast<int>(TimeUntil(msEnd));
if (cmsNext < 0)
return true;
}
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index 9c417fe..24e7106 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -53,7 +53,6 @@
namespace {
using ::testing::ElementsAre;
-using ::webrtc::TimeDelta;
// Generates a sequence of numbers (collaboratively).
class TestGenerator {
@@ -206,7 +205,7 @@
// (thread_unittest.cc:262): Blocking TestBody: total=2 (actual=1, could=1)
RTC_LOG_THREAD_BLOCK_COUNT();
#if RTC_DCHECK_IS_ON
- webrtc::Thread::ScopedCountBlockingCalls blocked_calls(
+ Thread::ScopedCountBlockingCalls blocked_calls(
[&](uint32_t actual_block, uint32_t could_block) {
EXPECT_EQ(1u, actual_block);
EXPECT_EQ(1u, could_block);
@@ -242,10 +241,10 @@
#if RTC_DCHECK_IS_ON
TEST(ThreadTest, CountBlockingCallsOneCallback) {
- webrtc::AutoThread current;
+ AutoThread current;
bool was_called_back = false;
{
- webrtc::Thread::ScopedCountBlockingCalls blocked_calls(
+ Thread::ScopedCountBlockingCalls blocked_calls(
[&](uint32_t actual_block, uint32_t could_block) {
was_called_back = true;
});
@@ -255,10 +254,10 @@
}
TEST(ThreadTest, CountBlockingCallsSkipCallback) {
- webrtc::AutoThread current;
+ AutoThread current;
bool was_called_back = false;
{
- webrtc::Thread::ScopedCountBlockingCalls blocked_calls(
+ Thread::ScopedCountBlockingCalls blocked_calls(
[&](uint32_t actual_block, uint32_t could_block) {
was_called_back = true;
});
@@ -309,7 +308,7 @@
#if (!defined(NDEBUG) || RTC_DCHECK_IS_ON)
TEST(ThreadTest, InvokeToThreadAllowedReturnsTrueWithoutPolicies) {
- webrtc::AutoThread main_thread;
+ AutoThread main_thread;
// Create and start the thread.
auto thread1 = Thread::CreateWithSocketServer();
auto thread2 = Thread::CreateWithSocketServer();
@@ -320,7 +319,7 @@
}
TEST(ThreadTest, InvokeAllowedWhenThreadsAdded) {
- webrtc::AutoThread main_thread;
+ AutoThread main_thread;
// Create and start the thread.
auto thread1 = Thread::CreateWithSocketServer();
auto thread2 = Thread::CreateWithSocketServer();
@@ -339,7 +338,7 @@
}
TEST(ThreadTest, InvokesDisallowedWhenDisallowAllInvokes) {
- webrtc::AutoThread main_thread;
+ AutoThread main_thread;
// Create and start the thread.
auto thread1 = Thread::CreateWithSocketServer();
auto thread2 = Thread::CreateWithSocketServer();
@@ -469,9 +468,9 @@
SetAndInvokeSet(&async_invoked, thread2, out);
});
- EXPECT_THAT(webrtc::WaitUntil([&] { return async_invoked.Get(); },
- ::testing::IsTrue()),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return async_invoked.Get(); }, ::testing::IsTrue()),
+ IsRtcOk());
}
};
@@ -486,9 +485,9 @@
});
EXPECT_FALSE(thread_a_called.Get());
- EXPECT_THAT(webrtc::WaitUntil([&] { return thread_a_called.Get(); },
- ::testing::IsTrue()),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return thread_a_called.Get(); }, ::testing::IsTrue()),
+ IsRtcOk());
}
static void DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(
@@ -858,7 +857,6 @@
return std::make_unique<ThreadFactory>();
}
-using ::webrtc::TaskQueueTest;
INSTANTIATE_TEST_SUITE_P(RtcThread,
TaskQueueTest,
diff --git a/rtc_base/unique_id_generator.cc b/rtc_base/unique_id_generator.cc
index f817dec..6bd47d3 100644
--- a/rtc_base/unique_id_generator.cc
+++ b/rtc_base/unique_id_generator.cc
@@ -60,7 +60,7 @@
// TODO(webrtc:13579): remove string copy here once absl::string_view version
// of StringToNumber is available.
std::optional<uint32_t> int_value =
- webrtc::StringToNumber<uint32_t>(std::string(value));
+ StringToNumber<uint32_t>(std::string(value));
// The underlying generator works for uint32_t values, so if the provided
// value is not a uint32_t it will never be generated anyway.
if (int_value.has_value()) {
diff --git a/rtc_base/unique_id_generator_unittest.cc b/rtc_base/unique_id_generator_unittest.cc
index 85ed5d4..661ba58 100644
--- a/rtc_base/unique_id_generator_unittest.cc
+++ b/rtc_base/unique_id_generator_unittest.cc
@@ -173,7 +173,7 @@
// Tests that it's OK to construct the generator in one execution environment
// (thread/task queue) but use it in another.
TEST(UniqueNumberGenerator, UsedOnSecondaryThread) {
- const auto* current_tq = webrtc::TaskQueueBase::Current();
+ const auto* current_tq = TaskQueueBase::Current();
// Construct the generator before `fake_task_queue` to ensure that it is
// constructed in a different execution environment than what
// `fake_task_queue` will represent.
@@ -181,7 +181,7 @@
FakeTaskQueue fake_task_queue;
// Sanity check to make sure we're in a different runtime environment.
- ASSERT_NE(current_tq, webrtc::TaskQueueBase::Current());
+ ASSERT_NE(current_tq, TaskQueueBase::Current());
// Generating an id should be fine in this context.
generator.Generate();
diff --git a/rtc_base/virtual_socket_server.cc b/rtc_base/virtual_socket_server.cc
index 9fad9df..20ae789 100644
--- a/rtc_base/virtual_socket_server.cc
+++ b/rtc_base/virtual_socket_server.cc
@@ -31,9 +31,6 @@
namespace webrtc {
-using ::webrtc::MutexLock;
-using ::webrtc::TaskQueueBase;
-using ::webrtc::TimeDelta;
#if defined(WEBRTC_WIN)
const in_addr kInitialNextIPv4 = {{{0x01, 0, 0, 0}}};
@@ -550,7 +547,7 @@
// If we have not been assigned a local port, then get one.
if (local_addr_.IsNil()) {
local_addr_ = server_->AssignBindAddress(
- webrtc::EmptySocketAddressWithFamily(addr.ipaddr().family()));
+ EmptySocketAddressWithFamily(addr.ipaddr().family()));
int result = server_->Bind(this, local_addr_);
if (result != 0) {
local_addr_.Clear();
@@ -681,8 +678,7 @@
IPAddress VirtualSocketServer::GetNextIP(int family) {
if (family == AF_INET) {
IPAddress next_ip(next_ipv4_);
- next_ipv4_.s_addr =
- webrtc::HostToNetwork32(webrtc::NetworkToHost32(next_ipv4_.s_addr) + 1);
+ next_ipv4_.s_addr = HostToNetwork32(NetworkToHost32(next_ipv4_.s_addr) + 1);
return next_ip;
} else if (family == AF_INET6) {
IPAddress next_ip(next_ipv6_);
@@ -791,7 +787,7 @@
const SocketAddress& addr) {
RTC_DCHECK(nullptr != socket);
// Address must be completely specified at this point
- RTC_DCHECK(!webrtc::IPIsUnspec(addr.ipaddr()));
+ RTC_DCHECK(!IPIsUnspec(addr.ipaddr()));
RTC_DCHECK(addr.port() != 0);
// Normalize the address (turns v6-mapped addresses into v4-addresses).
@@ -803,7 +799,7 @@
SocketAddress VirtualSocketServer::AssignBindAddress(
const SocketAddress& app_addr) {
- RTC_DCHECK(!webrtc::IPIsUnspec(app_addr.ipaddr()));
+ RTC_DCHECK(!IPIsUnspec(app_addr.ipaddr()));
// Normalize the IP.
SocketAddress addr;
@@ -840,12 +836,12 @@
}
IPAddress default_ip = GetDefaultSourceAddress(addr.ipaddr().family());
- if (!webrtc::IPIsUnspec(default_ip) && addr.ipaddr() == default_ip) {
+ if (!IPIsUnspec(default_ip) && addr.ipaddr() == default_ip) {
// If we can't find a binding for the packet which is sent to the interface
// corresponding to the default route, it should match a binding with the
// correct port to the any address.
SocketAddress sock_addr =
- webrtc::EmptySocketAddressWithFamily(addr.ipaddr().family());
+ EmptySocketAddressWithFamily(addr.ipaddr().family());
sock_addr.SetPort(addr.port());
return LookupBinding(sock_addr);
}
@@ -1096,7 +1092,7 @@
// route.
SocketAddress sender_addr = sender->GetLocalAddress();
IPAddress default_ip = GetDefaultSourceAddress(sender_addr.ipaddr().family());
- if (sender_addr.IsAnyIP() && !webrtc::IPIsUnspec(default_ip)) {
+ if (sender_addr.IsAnyIP() && !IPIsUnspec(default_ip)) {
sender_addr.SetIP(default_ip);
}
@@ -1285,15 +1281,13 @@
// If ip1 is IPv4 and ip2 is :: and ip2 is not IPV6_V6ONLY.
int remote_v6_only = 0;
remote->GetOption(Socket::OPT_IPV6_V6ONLY, &remote_v6_only);
- if (local_ip.family() == AF_INET && !remote_v6_only &&
- webrtc::IPIsAny(remote_ip)) {
+ if (local_ip.family() == AF_INET && !remote_v6_only && IPIsAny(remote_ip)) {
return true;
}
// Same check, backwards.
int local_v6_only = 0;
local->GetOption(Socket::OPT_IPV6_V6ONLY, &local_v6_only);
- if (remote_ip.family() == AF_INET && !local_v6_only &&
- webrtc::IPIsAny(local_ip)) {
+ if (remote_ip.family() == AF_INET && !local_v6_only && IPIsAny(local_ip)) {
return true;
}
@@ -1319,7 +1313,7 @@
return IPAddress();
}
void VirtualSocketServer::SetDefaultSourceAddress(const IPAddress& from_addr) {
- RTC_DCHECK(!webrtc::IPIsAny(from_addr));
+ RTC_DCHECK(!IPIsAny(from_addr));
if (from_addr.family() == AF_INET) {
default_source_address_v4_ = from_addr;
} else if (from_addr.family() == AF_INET6) {
diff --git a/rtc_base/virtual_socket_unittest.cc b/rtc_base/virtual_socket_unittest.cc
index c05f8d8..c623730 100644
--- a/rtc_base/virtual_socket_unittest.cc
+++ b/rtc_base/virtual_socket_unittest.cc
@@ -42,24 +42,24 @@
namespace webrtc {
namespace {
-using ::webrtc::testing::SSE_CLOSE;
-using ::webrtc::testing::SSE_ERROR;
-using ::webrtc::testing::SSE_OPEN;
-using ::webrtc::testing::SSE_READ;
-using ::webrtc::testing::SSE_WRITE;
-using ::webrtc::testing::StreamSink;
+using testing::SSE_CLOSE;
+using testing::SSE_ERROR;
+using testing::SSE_OPEN;
+using testing::SSE_READ;
+using testing::SSE_WRITE;
+using testing::StreamSink;
// Sends at a constant rate but with random packet sizes.
struct Sender {
- Sender(webrtc::Thread* th, webrtc::Socket* s, uint32_t rt)
+ Sender(Thread* th, Socket* s, uint32_t rt)
: thread(th),
- socket(std::make_unique<webrtc::AsyncUDPSocket>(s)),
+ socket(std::make_unique<AsyncUDPSocket>(s)),
rate(rt),
count(0) {
- last_send = webrtc::TimeMillis();
+ last_send = TimeMillis();
periodic = RepeatingTaskHandle::DelayedStart(thread, NextDelay(), [this] {
- int64_t cur_time = webrtc::TimeMillis();
+ int64_t cur_time = TimeMillis();
int64_t delay = cur_time - last_send;
uint32_t size =
std::clamp<uint32_t>(rate * delay / 1000, sizeof(uint32_t), 4096);
@@ -77,8 +77,8 @@
return TimeDelta::Seconds(1) * size / rate;
}
- webrtc::Thread* thread;
- std::unique_ptr<webrtc::AsyncUDPSocket> socket;
+ Thread* thread;
+ std::unique_ptr<AsyncUDPSocket> socket;
AsyncSocketPacketOptions options;
RepeatingTaskHandle periodic;
uint32_t rate; // bytes per second
@@ -88,9 +88,9 @@
};
struct Receiver : public sigslot::has_slots<> {
- Receiver(webrtc::Thread* th, webrtc::Socket* s, uint32_t bw)
+ Receiver(Thread* th, Socket* s, uint32_t bw)
: thread(th),
- socket(std::make_unique<webrtc::AsyncUDPSocket>(s)),
+ socket(std::make_unique<AsyncUDPSocket>(s)),
bandwidth(bw),
count(0),
sec_count(0),
@@ -115,8 +115,7 @@
~Receiver() override { periodic.Stop(); }
- void OnReadPacket(webrtc::AsyncPacketSocket* s,
- const ReceivedIpPacket& packet) {
+ void OnReadPacket(AsyncPacketSocket* s, const ReceivedIpPacket& packet) {
ASSERT_EQ(socket.get(), s);
ASSERT_GE(packet.payload().size(), 4U);
@@ -125,15 +124,15 @@
uint32_t send_time =
*reinterpret_cast<const uint32_t*>(packet.payload().data());
- uint32_t recv_time = webrtc::TimeMillis();
+ uint32_t recv_time = TimeMillis();
uint32_t delay = recv_time - send_time;
sum += delay;
sum_sq += delay * delay;
samples += 1;
}
- webrtc::Thread* thread;
- std::unique_ptr<webrtc::AsyncUDPSocket> socket;
+ Thread* thread;
+ std::unique_ptr<AsyncUDPSocket> socket;
uint32_t bandwidth;
RepeatingTaskHandle periodic;
size_t count;
@@ -149,14 +148,14 @@
VirtualSocketServerTest()
: ss_(&fake_clock_),
thread_(&ss_),
- kIPv4AnyAddress(webrtc::IPAddress(INADDR_ANY), 0),
- kIPv6AnyAddress(webrtc::IPAddress(in6addr_any), 0) {}
+ kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
+ kIPv6AnyAddress(IPAddress(in6addr_any), 0) {}
- void CheckPortIncrementalization(const webrtc::SocketAddress& post,
- const webrtc::SocketAddress& pre) {
+ void CheckPortIncrementalization(const SocketAddress& post,
+ const SocketAddress& pre) {
EXPECT_EQ(post.port(), pre.port() + 1);
- webrtc::IPAddress post_ip = post.ipaddr();
- webrtc::IPAddress pre_ip = pre.ipaddr();
+ IPAddress post_ip = post.ipaddr();
+ IPAddress pre_ip = pre.ipaddr();
EXPECT_EQ(pre_ip.family(), post_ip.family());
if (post_ip.family() == AF_INET) {
in_addr pre_ipv4 = pre_ip.ipv4_address();
@@ -174,79 +173,72 @@
// Test a client can bind to the any address, and all sent packets will have
// the default source address. Also, it can receive packets sent to the
// default address.
- void TestDefaultSourceAddress(const webrtc::IPAddress& default_address) {
+ void TestDefaultSourceAddress(const IPAddress& default_address) {
ss_.SetDefaultSourceAddress(default_address);
// Create client1 bound to the any address.
- webrtc::Socket* socket =
- ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
- socket->Bind(
- webrtc::EmptySocketAddressWithFamily(default_address.family()));
- webrtc::SocketAddress client1_any_addr = socket->GetLocalAddress();
+ Socket* socket = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
+ socket->Bind(EmptySocketAddressWithFamily(default_address.family()));
+ SocketAddress client1_any_addr = socket->GetLocalAddress();
EXPECT_TRUE(client1_any_addr.IsAnyIP());
- auto client1 = std::make_unique<webrtc::TestClient>(
- std::make_unique<webrtc::AsyncUDPSocket>(socket), &fake_clock_);
+ auto client1 = std::make_unique<TestClient>(
+ std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
// Create client2 bound to the address route.
- webrtc::Socket* socket2 =
- ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
- socket2->Bind(webrtc::SocketAddress(default_address, 0));
- webrtc::SocketAddress client2_addr = socket2->GetLocalAddress();
+ Socket* socket2 = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
+ socket2->Bind(SocketAddress(default_address, 0));
+ SocketAddress client2_addr = socket2->GetLocalAddress();
EXPECT_FALSE(client2_addr.IsAnyIP());
- auto client2 = std::make_unique<webrtc::TestClient>(
- std::make_unique<webrtc::AsyncUDPSocket>(socket2), &fake_clock_);
+ auto client2 = std::make_unique<TestClient>(
+ std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
// Client1 sends to client2, client2 should see the default address as
// client1's address.
- webrtc::SocketAddress client1_addr;
+ SocketAddress client1_addr;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr,
- webrtc::SocketAddress(default_address, client1_any_addr.port()));
+ SocketAddress(default_address, client1_any_addr.port()));
// Client2 can send back to client1's default address.
EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
}
- void BasicTest(const webrtc::SocketAddress& initial_addr) {
- webrtc::Socket* socket =
- ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ void BasicTest(const SocketAddress& initial_addr) {
+ Socket* socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
socket->Bind(initial_addr);
- webrtc::SocketAddress server_addr = socket->GetLocalAddress();
+ SocketAddress server_addr = socket->GetLocalAddress();
// Make sure VSS didn't switch families on us.
EXPECT_EQ(server_addr.family(), initial_addr.family());
- auto client1 = std::make_unique<webrtc::TestClient>(
- std::make_unique<webrtc::AsyncUDPSocket>(socket), &fake_clock_);
- webrtc::Socket* socket2 =
- ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
- auto client2 = std::make_unique<webrtc::TestClient>(
- std::make_unique<webrtc::AsyncUDPSocket>(socket2), &fake_clock_);
+ auto client1 = std::make_unique<TestClient>(
+ std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
+ Socket* socket2 = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ auto client2 = std::make_unique<TestClient>(
+ std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
- webrtc::SocketAddress client2_addr;
+ SocketAddress client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
- webrtc::SocketAddress client1_addr;
+ SocketAddress client1_addr;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr, server_addr);
- webrtc::SocketAddress empty =
- webrtc::EmptySocketAddressWithFamily(initial_addr.family());
+ SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
for (int i = 0; i < 10; i++) {
- client2 = std::make_unique<webrtc::TestClient>(
- absl::WrapUnique(webrtc::AsyncUDPSocket::Create(&ss_, empty)),
- &fake_clock_);
+ client2 = std::make_unique<TestClient>(
+ absl::WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
- webrtc::SocketAddress next_client2_addr;
+ SocketAddress next_client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
CheckPortIncrementalization(next_client2_addr, client2_addr);
// EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
- webrtc::SocketAddress server_addr2;
+ SocketAddress server_addr2;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
EXPECT_EQ(server_addr2, server_addr);
@@ -256,28 +248,28 @@
}
// initial_addr should be made from either INADDR_ANY or in6addr_any.
- void ConnectTest(const webrtc::SocketAddress& initial_addr) {
+ void ConnectTest(const SocketAddress& initial_addr) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
- const webrtc::SocketAddress kEmptyAddr =
- webrtc::EmptySocketAddressWithFamily(initial_addr.family());
+ SocketAddress accept_addr;
+ const SocketAddress kEmptyAddr =
+ EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- std::unique_ptr<webrtc::Socket> client =
+ std::unique_ptr<Socket> client =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_TRUE(client->GetLocalAddress().IsNil());
// Create server
- std::unique_ptr<webrtc::Socket> server =
+ std::unique_ptr<Socket> server =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_NE(0, server->Listen(5)); // Bind required
EXPECT_EQ(0, server->Bind(initial_addr));
EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
EXPECT_EQ(0, server->Listen(5));
- EXPECT_EQ(server->GetState(), webrtc::Socket::CS_CONNECTING);
+ EXPECT_EQ(server->GetState(), Socket::CS_CONNECTING);
// No pending server connections
EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
@@ -291,53 +283,53 @@
EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
// Client is connecting
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CONNECTING);
+ EXPECT_EQ(client->GetState(), Socket::CS_CONNECTING);
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
ss_.ProcessMessagesUntilIdle();
// Client still connecting
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CONNECTING);
+ EXPECT_EQ(client->GetState(), Socket::CS_CONNECTING);
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
- std::unique_ptr<webrtc::Socket> accepted =
+ std::unique_ptr<Socket> accepted =
absl::WrapUnique(server->Accept(&accept_addr));
EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(accept_addr, kEmptyAddr);
EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
- EXPECT_EQ(accepted->GetState(), webrtc::Socket::CS_CONNECTED);
+ EXPECT_EQ(accepted->GetState(), Socket::CS_CONNECTED);
EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
ss_.ProcessMessagesUntilIdle();
// Client has connected
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CONNECTED);
+ EXPECT_EQ(client->GetState(), Socket::CS_CONNECTED);
EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
}
- void ConnectToNonListenerTest(const webrtc::SocketAddress& initial_addr) {
+ void ConnectToNonListenerTest(const SocketAddress& initial_addr) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
- const webrtc::SocketAddress nil_addr;
- const webrtc::SocketAddress empty_addr =
- webrtc::EmptySocketAddressWithFamily(initial_addr.family());
+ SocketAddress accept_addr;
+ const SocketAddress nil_addr;
+ const SocketAddress empty_addr =
+ EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- std::unique_ptr<webrtc::Socket> client =
+ std::unique_ptr<Socket> client =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server
- std::unique_ptr<webrtc::Socket> server =
+ std::unique_ptr<Socket> server =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(initial_addr));
@@ -353,23 +345,23 @@
EXPECT_EQ(accept_addr, nil_addr);
// Connection failed
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
}
- void CloseDuringConnectTest(const webrtc::SocketAddress& initial_addr) {
+ void CloseDuringConnectTest(const SocketAddress& initial_addr) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
- const webrtc::SocketAddress empty_addr =
- webrtc::EmptySocketAddressWithFamily(initial_addr.family());
+ SocketAddress accept_addr;
+ const SocketAddress empty_addr =
+ EmptySocketAddressWithFamily(initial_addr.family());
// Create client and server
- std::unique_ptr<webrtc::Socket> client(
+ std::unique_ptr<Socket> client(
ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
- std::unique_ptr<webrtc::Socket> server(
+ std::unique_ptr<Socket> server(
ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
@@ -387,7 +379,7 @@
ss_.ProcessMessagesUntilIdle();
// Result: connection failed
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
server.reset(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
@@ -409,7 +401,7 @@
ss_.ProcessMessagesUntilIdle();
// Result: connection failed
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
// New server
@@ -427,37 +419,37 @@
// Server accepts connection
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
- std::unique_ptr<webrtc::Socket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(nullptr != accepted.get());
sink.Monitor(accepted.get());
// Client closes before connection complets
- EXPECT_EQ(accepted->GetState(), webrtc::Socket::CS_CONNECTED);
+ EXPECT_EQ(accepted->GetState(), Socket::CS_CONNECTED);
// Connected message has not been processed yet.
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CONNECTING);
+ EXPECT_EQ(client->GetState(), Socket::CS_CONNECTING);
client->Close();
ss_.ProcessMessagesUntilIdle();
// Result: accepted socket closes
- EXPECT_EQ(accepted->GetState(), webrtc::Socket::CS_CLOSED);
+ EXPECT_EQ(accepted->GetState(), Socket::CS_CLOSED);
EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
}
- void CloseTest(const webrtc::SocketAddress& initial_addr) {
+ void CloseTest(const SocketAddress& initial_addr) {
StreamSink sink;
- const webrtc::SocketAddress kEmptyAddr;
+ const SocketAddress kEmptyAddr;
// Create clients
- std::unique_ptr<webrtc::Socket> a =
+ std::unique_ptr<Socket> a =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(a.get());
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
- std::unique_ptr<webrtc::Socket> b =
+ std::unique_ptr<Socket> b =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(b.get());
b->Bind(initial_addr);
@@ -469,11 +461,11 @@
ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(a.get(), SSE_OPEN));
- EXPECT_EQ(a->GetState(), webrtc::Socket::CS_CONNECTED);
+ EXPECT_EQ(a->GetState(), Socket::CS_CONNECTED);
EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
EXPECT_TRUE(sink.Check(b.get(), SSE_OPEN));
- EXPECT_EQ(b->GetState(), webrtc::Socket::CS_CONNECTED);
+ EXPECT_EQ(b->GetState(), Socket::CS_CONNECTED);
EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
EXPECT_EQ(1, a->Send("a", 1));
@@ -487,27 +479,27 @@
EXPECT_EQ(-1, b->Recv(buffer, 10, nullptr));
EXPECT_TRUE(sink.Check(a.get(), SSE_CLOSE));
- EXPECT_EQ(a->GetState(), webrtc::Socket::CS_CLOSED);
+ EXPECT_EQ(a->GetState(), Socket::CS_CLOSED);
EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
// No signal for Closer
EXPECT_FALSE(sink.Check(b.get(), SSE_CLOSE));
- EXPECT_EQ(b->GetState(), webrtc::Socket::CS_CLOSED);
+ EXPECT_EQ(b->GetState(), Socket::CS_CLOSED);
EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
}
- void TcpSendTest(const webrtc::SocketAddress& initial_addr) {
+ void TcpSendTest(const SocketAddress& initial_addr) {
StreamSink sink;
- const webrtc::SocketAddress kEmptyAddr;
+ const SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<webrtc::Socket> a =
+ std::unique_ptr<Socket> a =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(a.get());
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
- std::unique_ptr<webrtc::Socket> b =
+ std::unique_ptr<Socket> b =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(b.get());
b->Bind(initial_addr);
@@ -619,13 +611,13 @@
EXPECT_EQ(0, memcmp(recv_buffer, send_buffer, kDataSize));
}
- void TcpSendsPacketsInOrderTest(const webrtc::SocketAddress& initial_addr) {
- const webrtc::SocketAddress kEmptyAddr;
+ void TcpSendsPacketsInOrderTest(const SocketAddress& initial_addr) {
+ const SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<webrtc::Socket> a =
+ std::unique_ptr<Socket> a =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
- std::unique_ptr<webrtc::Socket> b =
+ std::unique_ptr<Socket> b =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
@@ -676,11 +668,9 @@
// It is important that initial_addr's port has to be 0 such that the
// incremental port behavior could ensure the 2 Binds result in different
// address.
- void BandwidthTest(const webrtc::SocketAddress& initial_addr) {
- webrtc::Socket* send_socket =
- ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
- webrtc::Socket* recv_socket =
- ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ void BandwidthTest(const SocketAddress& initial_addr) {
+ Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
@@ -690,7 +680,7 @@
uint32_t bandwidth = 64 * 1024;
ss_.set_bandwidth(bandwidth);
- webrtc::Thread* pthMain = webrtc::Thread::Current();
+ Thread* pthMain = Thread::Current();
Sender sender(pthMain, send_socket, 80 * 1024);
Receiver receiver(pthMain, recv_socket, bandwidth);
@@ -710,7 +700,7 @@
// It is important that initial_addr's port has to be 0 such that the
// incremental port behavior could ensure the 2 Binds result in different
// address.
- void DelayTest(const webrtc::SocketAddress& initial_addr) {
+ void DelayTest(const SocketAddress& initial_addr) {
time_t seed = ::time(nullptr);
RTC_LOG(LS_VERBOSE) << "seed = " << seed;
srand(static_cast<unsigned int>(seed));
@@ -722,17 +712,15 @@
ss_.set_delay_stddev(stddev);
ss_.UpdateDelayDistribution();
- webrtc::Socket* send_socket =
- ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
- webrtc::Socket* recv_socket =
- ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
- webrtc::Thread* pthMain = webrtc::Thread::Current();
+ Thread* pthMain = Thread::Current();
// Avg packet size is 2K, so at 200KB/s for 10s, we should see about
// 1000 packets, which is necessary to get a good distribution.
Sender sender(pthMain, send_socket, 100 * 2 * 1024);
@@ -767,24 +755,24 @@
// Test cross-family communication between a client bound to client_addr and a
// server bound to server_addr. shouldSucceed indicates if communication is
// expected to work or not.
- void CrossFamilyConnectionTest(const webrtc::SocketAddress& client_addr,
- const webrtc::SocketAddress& server_addr,
+ void CrossFamilyConnectionTest(const SocketAddress& client_addr,
+ const SocketAddress& server_addr,
bool shouldSucceed) {
StreamSink sink;
- webrtc::SocketAddress accept_address;
- const webrtc::SocketAddress kEmptyAddr;
+ SocketAddress accept_address;
+ const SocketAddress kEmptyAddr;
// Client gets a IPv4 address
- std::unique_ptr<webrtc::Socket> client =
+ std::unique_ptr<Socket> client =
absl::WrapUnique(ss_.CreateSocket(client_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
client->Bind(client_addr);
// Server gets a non-mapped non-any IPv6 address.
// IPv4 sockets should not be able to connect to this.
- std::unique_ptr<webrtc::Socket> server =
+ std::unique_ptr<Socket> server =
absl::WrapUnique(ss_.CreateSocket(server_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
server->Bind(server_addr);
@@ -794,7 +782,7 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
- std::unique_ptr<webrtc::Socket> accepted =
+ std::unique_ptr<Socket> accepted =
absl::WrapUnique(server->Accept(&accept_address));
EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(kEmptyAddr, accept_address);
@@ -809,7 +797,7 @@
EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_address));
EXPECT_EQ(accept_address, kEmptyAddr);
- EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
}
@@ -818,25 +806,25 @@
// Test cross-family datagram sending between a client bound to client_addr
// and a server bound to server_addr. shouldSucceed indicates if sending is
// expected to succeed or not.
- void CrossFamilyDatagramTest(const webrtc::SocketAddress& client_addr,
- const webrtc::SocketAddress& server_addr,
+ void CrossFamilyDatagramTest(const SocketAddress& client_addr,
+ const SocketAddress& server_addr,
bool shouldSucceed) {
- webrtc::Socket* socket = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
+ Socket* socket = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
socket->Bind(server_addr);
- webrtc::SocketAddress bound_server_addr = socket->GetLocalAddress();
- auto client1 = std::make_unique<webrtc::TestClient>(
- std::make_unique<webrtc::AsyncUDPSocket>(socket), &fake_clock_);
+ SocketAddress bound_server_addr = socket->GetLocalAddress();
+ auto client1 = std::make_unique<TestClient>(
+ std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
- webrtc::Socket* socket2 = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
+ Socket* socket2 = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
socket2->Bind(client_addr);
- auto client2 = std::make_unique<webrtc::TestClient>(
- std::make_unique<webrtc::AsyncUDPSocket>(socket2), &fake_clock_);
- webrtc::SocketAddress client2_addr;
+ auto client2 = std::make_unique<TestClient>(
+ std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
+ SocketAddress client2_addr;
if (shouldSucceed) {
EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
- webrtc::SocketAddress client1_addr;
+ SocketAddress client1_addr;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr, bound_server_addr);
@@ -847,32 +835,32 @@
}
protected:
- webrtc::ScopedFakeClock fake_clock_;
- webrtc::VirtualSocketServer ss_;
- webrtc::AutoSocketServerThread thread_;
- const webrtc::SocketAddress kIPv4AnyAddress;
- const webrtc::SocketAddress kIPv6AnyAddress;
+ ScopedFakeClock fake_clock_;
+ VirtualSocketServer ss_;
+ AutoSocketServerThread thread_;
+ const SocketAddress kIPv4AnyAddress;
+ const SocketAddress kIPv6AnyAddress;
};
TEST_F(VirtualSocketServerTest, basic_v4) {
- webrtc::SocketAddress ipv4_test_addr(webrtc::IPAddress(INADDR_ANY), 5000);
+ SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
BasicTest(ipv4_test_addr);
}
TEST_F(VirtualSocketServerTest, basic_v6) {
- webrtc::SocketAddress ipv6_test_addr(webrtc::IPAddress(in6addr_any), 5000);
+ SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 5000);
BasicTest(ipv6_test_addr);
}
TEST_F(VirtualSocketServerTest, TestDefaultRoute_v4) {
- webrtc::IPAddress ipv4_default_addr(0x01020304);
+ IPAddress ipv4_default_addr(0x01020304);
TestDefaultSourceAddress(ipv4_default_addr);
}
TEST_F(VirtualSocketServerTest, TestDefaultRoute_v6) {
- webrtc::IPAddress ipv6_default_addr;
- EXPECT_TRUE(webrtc::IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3",
- &ipv6_default_addr));
+ IPAddress ipv6_default_addr;
+ EXPECT_TRUE(
+ IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ipv6_default_addr));
TestDefaultSourceAddress(ipv6_default_addr);
}
@@ -942,105 +930,100 @@
// Works, receiving socket sees 127.0.0.2.
TEST_F(VirtualSocketServerTest, CanConnectFromMappedIPv6ToIPv4Any) {
- CrossFamilyConnectionTest(webrtc::SocketAddress("::ffff:127.0.0.2", 0),
- webrtc::SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyConnectionTest(SocketAddress("::ffff:127.0.0.2", 0),
+ SocketAddress("0.0.0.0", 5000), true);
}
// Fails.
TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToIPv4Any) {
- CrossFamilyConnectionTest(webrtc::SocketAddress("::2", 0),
- webrtc::SocketAddress("0.0.0.0", 5000), false);
+ CrossFamilyConnectionTest(SocketAddress("::2", 0),
+ SocketAddress("0.0.0.0", 5000), false);
}
// Fails.
TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToMappedIPv6) {
- CrossFamilyConnectionTest(webrtc::SocketAddress("::2", 0),
- webrtc::SocketAddress("::ffff:127.0.0.1", 5000),
- false);
+ CrossFamilyConnectionTest(SocketAddress("::2", 0),
+ SocketAddress("::ffff:127.0.0.1", 5000), false);
}
// Works. receiving socket sees ::ffff:127.0.0.2.
TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToIPv6Any) {
- CrossFamilyConnectionTest(webrtc::SocketAddress("127.0.0.2", 0),
- webrtc::SocketAddress("::", 5000), true);
+ CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
+ SocketAddress("::", 5000), true);
}
// Fails.
TEST_F(VirtualSocketServerTest, CantConnectFromIPv4ToUnMappedIPv6) {
- CrossFamilyConnectionTest(webrtc::SocketAddress("127.0.0.2", 0),
- webrtc::SocketAddress("::1", 5000), false);
+ CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
+ SocketAddress("::1", 5000), false);
}
// Works. Receiving socket sees ::ffff:127.0.0.1.
TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToMappedIPv6) {
- CrossFamilyConnectionTest(webrtc::SocketAddress("127.0.0.1", 0),
- webrtc::SocketAddress("::ffff:127.0.0.2", 5000),
- true);
+ CrossFamilyConnectionTest(SocketAddress("127.0.0.1", 0),
+ SocketAddress("::ffff:127.0.0.2", 5000), true);
}
// Works, receiving socket sees a result from GetNextIP.
TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv6ToIPv4Any) {
- CrossFamilyConnectionTest(webrtc::SocketAddress("::", 0),
- webrtc::SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyConnectionTest(SocketAddress("::", 0),
+ SocketAddress("0.0.0.0", 5000), true);
}
// Works, receiving socket sees whatever GetNextIP gave the client.
TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv4ToIPv6Any) {
- CrossFamilyConnectionTest(webrtc::SocketAddress("0.0.0.0", 0),
- webrtc::SocketAddress("::", 5000), true);
+ CrossFamilyConnectionTest(SocketAddress("0.0.0.0", 0),
+ SocketAddress("::", 5000), true);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv4ToIPv6Any) {
- CrossFamilyDatagramTest(webrtc::SocketAddress("0.0.0.0", 0),
- webrtc::SocketAddress("::", 5000), true);
+ CrossFamilyDatagramTest(SocketAddress("0.0.0.0", 0),
+ SocketAddress("::", 5000), true);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromMappedIPv6ToIPv4Any) {
- CrossFamilyDatagramTest(webrtc::SocketAddress("::ffff:127.0.0.1", 0),
- webrtc::SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyDatagramTest(SocketAddress("::ffff:127.0.0.1", 0),
+ SocketAddress("0.0.0.0", 5000), true);
}
TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToIPv4Any) {
- CrossFamilyDatagramTest(webrtc::SocketAddress("::2", 0),
- webrtc::SocketAddress("0.0.0.0", 5000), false);
+ CrossFamilyDatagramTest(SocketAddress("::2", 0),
+ SocketAddress("0.0.0.0", 5000), false);
}
TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToMappedIPv6) {
- CrossFamilyDatagramTest(webrtc::SocketAddress("::2", 0),
- webrtc::SocketAddress("::ffff:127.0.0.1", 5000),
- false);
+ CrossFamilyDatagramTest(SocketAddress("::2", 0),
+ SocketAddress("::ffff:127.0.0.1", 5000), false);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToIPv6Any) {
- CrossFamilyDatagramTest(webrtc::SocketAddress("127.0.0.2", 0),
- webrtc::SocketAddress("::", 5000), true);
+ CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
+ SocketAddress("::", 5000), true);
}
TEST_F(VirtualSocketServerTest, CantSendDatagramFromIPv4ToUnMappedIPv6) {
- CrossFamilyDatagramTest(webrtc::SocketAddress("127.0.0.2", 0),
- webrtc::SocketAddress("::1", 5000), false);
+ CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
+ SocketAddress("::1", 5000), false);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToMappedIPv6) {
- CrossFamilyDatagramTest(webrtc::SocketAddress("127.0.0.1", 0),
- webrtc::SocketAddress("::ffff:127.0.0.2", 5000),
- true);
+ CrossFamilyDatagramTest(SocketAddress("127.0.0.1", 0),
+ SocketAddress("::ffff:127.0.0.2", 5000), true);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
- CrossFamilyDatagramTest(webrtc::SocketAddress("::", 0),
- webrtc::SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyDatagramTest(SocketAddress("::", 0),
+ SocketAddress("0.0.0.0", 5000), true);
}
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
- webrtc::Socket* socket1 =
- ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
- std::unique_ptr<webrtc::Socket> socket2 =
+ Socket* socket1 = ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> socket2 =
absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
socket1->Bind(kIPv4AnyAddress);
socket2->Bind(kIPv4AnyAddress);
- auto client1 = std::make_unique<webrtc::TestClient>(
- std::make_unique<webrtc::AsyncUDPSocket>(socket1), &fake_clock_);
+ auto client1 = std::make_unique<TestClient>(
+ std::make_unique<AsyncUDPSocket>(socket1), &fake_clock_);
ss_.SetSendingBlocked(true);
EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
@@ -1058,9 +1041,9 @@
ss_.set_recv_buffer_capacity(kBufferSize);
StreamSink sink;
- std::unique_ptr<webrtc::Socket> socket1 =
+ std::unique_ptr<Socket> socket1 =
absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
- std::unique_ptr<webrtc::Socket> socket2 =
+ std::unique_ptr<Socket> socket2 =
absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
sink.Monitor(socket1.get());
sink.Monitor(socket2.get());
@@ -1107,9 +1090,9 @@
ASSERT_LT(0u, kTestSamples[sidx]);
const uint32_t kStdDev =
static_cast<uint32_t>(kTestDev[didx] * kTestMean[midx]);
- std::unique_ptr<webrtc::VirtualSocketServer::Function> f =
- webrtc::VirtualSocketServer::CreateDistribution(
- kTestMean[midx], kStdDev, kTestSamples[sidx]);
+ std::unique_ptr<VirtualSocketServer::Function> f =
+ VirtualSocketServer::CreateDistribution(kTestMean[midx], kStdDev,
+ kTestSamples[sidx]);
ASSERT_TRUE(nullptr != f.get());
ASSERT_EQ(kTestSamples[sidx], f->size());
double sum = 0;
