Remove redundant webrtc:: prefixes in rtc_base
Created by
tools_webrtc/remove_extra_namespace.py --namespace webrtc
and manual adjustments.
This CL was uploaded by git cl split.
R=eshr@webrtc.org
No-IWYU: Refactoring
Bug: webrtc:42232595
Change-Id: I4dffbcd86aa0993d735ca3bbcfe9f66a42ceff3c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/396203
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Auto-Submit: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44901}
diff --git a/rtc_base/async_dns_resolver.cc b/rtc_base/async_dns_resolver.cc
index 9c9610d..9cca9a0 100644
--- a/rtc_base/async_dns_resolver.cc
+++ b/rtc_base/async_dns_resolver.cc
@@ -30,7 +30,7 @@
#ifdef __native_client__
int ResolveHostname(absl::string_view hostname,
int family,
- std::vector<webrtc::IPAddress>* addresses) {
+ std::vector<IPAddress>* addresses) {
RTC_DCHECK_NOTREACHED();
RTC_LOG(LS_WARNING) << "ResolveHostname() is not implemented for NaCl";
return -1;
diff --git a/rtc_base/async_dns_resolver.h b/rtc_base/async_dns_resolver.h
index 674e140..d8cb38f 100644
--- a/rtc_base/async_dns_resolver.h
+++ b/rtc_base/async_dns_resolver.h
@@ -21,7 +21,7 @@
namespace webrtc {
// This file contains a default implementation of
-// webrtc::AsyncDnsResolverInterface, for use when there is no need for special
+// AsyncDnsResolverInterface, for use when there is no need for special
// treatment.
class AsyncDnsResolverResultImpl : public AsyncDnsResolverResult {
@@ -32,7 +32,7 @@
private:
friend class AsyncDnsResolver;
- RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker sequence_checker_;
+ RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
SocketAddress addr_ RTC_GUARDED_BY(sequence_checker_);
std::vector<IPAddress> addresses_ RTC_GUARDED_BY(sequence_checker_);
int error_ RTC_GUARDED_BY(sequence_checker_);
diff --git a/rtc_base/async_packet_socket.h b/rtc_base/async_packet_socket.h
index e06de43..b1a2045 100644
--- a/rtc_base/async_packet_socket.h
+++ b/rtc_base/async_packet_socket.h
@@ -61,10 +61,10 @@
// https://www.rfc-editor.org/rfc/rfc9331.html
bool ecn_1 = false;
- // When used with RTP packets (for example, webrtc::PacketOptions), the value
+ // When used with RTP packets (for example, PacketOptions), the value
// should be 16 bits. A value of -1 represents "not set".
int64_t packet_id = -1;
- webrtc::PacketTimeUpdateParams packet_time_params;
+ PacketTimeUpdateParams packet_time_params;
// PacketInfo is passed to SentPacket when signaling this packet is sent.
PacketInfo info_signaled_after_sent;
// True if this is a batchable packet. Batchable packets are collected at low
@@ -127,12 +127,11 @@
// Register a callback to be called when the socket is closed.
void SubscribeCloseEvent(
const void* removal_tag,
- std::function<void(webrtc::AsyncPacketSocket*, int)> callback);
+ std::function<void(AsyncPacketSocket*, int)> callback);
void UnsubscribeCloseEvent(const void* removal_tag);
void RegisterReceivedPacketCallback(
- absl::AnyInvocable<void(webrtc::AsyncPacketSocket*,
- const webrtc::ReceivedIpPacket&)>
+ absl::AnyInvocable<void(AsyncPacketSocket*, const ReceivedIpPacket&)>
received_packet_callback);
void DeregisterReceivedPacketCallback();
@@ -173,8 +172,7 @@
private:
CallbackList<AsyncPacketSocket*, int> on_close_
RTC_GUARDED_BY(&network_checker_);
- absl::AnyInvocable<void(webrtc::AsyncPacketSocket*,
- const webrtc::ReceivedIpPacket&)>
+ absl::AnyInvocable<void(AsyncPacketSocket*, const ReceivedIpPacket&)>
received_packet_callback_ RTC_GUARDED_BY(&network_checker_);
};
diff --git a/rtc_base/async_tcp_socket_unittest.cc b/rtc_base/async_tcp_socket_unittest.cc
index 149780d..f531ed9 100644
--- a/rtc_base/async_tcp_socket_unittest.cc
+++ b/rtc_base/async_tcp_socket_unittest.cc
@@ -21,7 +21,7 @@
class AsyncTCPSocketTest : public ::testing::Test, public sigslot::has_slots<> {
public:
AsyncTCPSocketTest()
- : vss_(new webrtc::VirtualSocketServer()),
+ : vss_(new VirtualSocketServer()),
socket_(vss_->CreateSocket(SOCK_STREAM)),
tcp_socket_(new AsyncTCPSocket(socket_, true)),
ready_to_send_(false) {
@@ -29,9 +29,7 @@
&AsyncTCPSocketTest::OnReadyToSend);
}
- void OnReadyToSend(webrtc::AsyncPacketSocket* socket) {
- ready_to_send_ = true;
- }
+ void OnReadyToSend(AsyncPacketSocket* socket) { ready_to_send_ = true; }
protected:
std::unique_ptr<VirtualSocketServer> vss_;
diff --git a/rtc_base/bit_buffer.h b/rtc_base/bit_buffer.h
index 17084a4..870ddc8 100644
--- a/rtc_base/bit_buffer.h
+++ b/rtc_base/bit_buffer.h
@@ -25,7 +25,7 @@
// Byte order is assumed big-endian/network.
class BitBufferWriter {
public:
- static constexpr DataSize kMaxLeb128Length = webrtc::DataSize::Bytes(10);
+ static constexpr DataSize kMaxLeb128Length = DataSize::Bytes(10);
// Constructs a bit buffer for the writable buffer of `bytes`.
BitBufferWriter(uint8_t* bytes, size_t byte_count);
diff --git a/rtc_base/byte_buffer.h b/rtc_base/byte_buffer.h
index b962f45..edf236a 100644
--- a/rtc_base/byte_buffer.h
+++ b/rtc_base/byte_buffer.h
@@ -61,21 +61,21 @@
WriteBytesInternal(reinterpret_cast<const value_type*>(&val), 1);
}
void WriteUInt16(uint16_t val) {
- uint16_t v = webrtc::HostToNetwork16(val);
+ uint16_t v = HostToNetwork16(val);
WriteBytesInternal(reinterpret_cast<const value_type*>(&v), 2);
}
void WriteUInt24(uint32_t val) {
- uint32_t v = webrtc::HostToNetwork32(val);
+ uint32_t v = HostToNetwork32(val);
value_type* start = reinterpret_cast<value_type*>(&v);
++start;
WriteBytesInternal(start, 3);
}
void WriteUInt32(uint32_t val) {
- uint32_t v = webrtc::HostToNetwork32(val);
+ uint32_t v = HostToNetwork32(val);
WriteBytesInternal(reinterpret_cast<const value_type*>(&v), 4);
}
void WriteUInt64(uint64_t val) {
- uint64_t v = webrtc::HostToNetwork64(val);
+ uint64_t v = HostToNetwork64(val);
WriteBytesInternal(reinterpret_cast<const value_type*>(&v), 8);
}
// Serializes an unsigned varint in the format described by
diff --git a/rtc_base/copy_on_write_buffer.h b/rtc_base/copy_on_write_buffer.h
index 6dfa289..0429949 100644
--- a/rtc_base/copy_on_write_buffer.h
+++ b/rtc_base/copy_on_write_buffer.h
@@ -307,7 +307,7 @@
}
}
- // buffer_ is either null, or points to an webrtc::Buffer with capacity > 0.
+ // buffer_ is either null, or points to an Buffer with capacity > 0.
scoped_refptr<RefCountedBuffer> buffer_;
// This buffer may represent a slice of a original data.
size_t offset_; // Offset of a current slice in the original data in buffer_.
diff --git a/rtc_base/deprecated/recursive_critical_section.h b/rtc_base/deprecated/recursive_critical_section.h
index e347e48..e4a2053 100644
--- a/rtc_base/deprecated/recursive_critical_section.h
+++ b/rtc_base/deprecated/recursive_critical_section.h
@@ -42,7 +42,7 @@
namespace webrtc {
-// NOTE: This class is deprecated. Please use webrtc::Mutex instead!
+// NOTE: This class is deprecated. Please use Mutex instead!
// Search using https://www.google.com/?q=recursive+lock+considered+harmful
// to find the reasons.
//
diff --git a/rtc_base/event.cc b/rtc_base/event.cc
index 7338670..e7ad91c 100644
--- a/rtc_base/event.cc
+++ b/rtc_base/event.cc
@@ -55,10 +55,9 @@
bool Event::Wait(TimeDelta give_up_after, TimeDelta /*warn_after*/) {
ScopedYieldPolicy::YieldExecution();
- const DWORD ms =
- give_up_after.IsPlusInfinity()
- ? INFINITE
- : give_up_after.RoundUpTo(webrtc::TimeDelta::Millis(1)).ms();
+ const DWORD ms = give_up_after.IsPlusInfinity()
+ ? INFINITE
+ : give_up_after.RoundUpTo(TimeDelta::Millis(1)).ms();
return (WaitForSingleObject(event_handle_, ms) == WAIT_OBJECT_0);
}
@@ -123,7 +122,7 @@
timeval tv;
gettimeofday(&tv, nullptr);
ts.tv_sec = tv.tv_sec;
- ts.tv_nsec = tv.tv_usec * webrtc::kNumNanosecsPerMicrosec;
+ ts.tv_nsec = tv.tv_usec * kNumNanosecsPerMicrosec;
#endif
// Add the specified number of milliseconds to it.
diff --git a/rtc_base/event.h b/rtc_base/event.h
index 0f5527e..908247a 100644
--- a/rtc_base/event.h
+++ b/rtc_base/event.h
@@ -27,8 +27,8 @@
// RTC_DISALLOW_WAIT() utility
//
-// Sets a stack-scoped flag that disallows use of `webrtc::Event::Wait` by means
-// of raising a DCHECK when a call to `webrtc::Event::Wait()` is made..
+// Sets a stack-scoped flag that disallows use of `Event::Wait` by means
+// of raising a DCHECK when a call to `Event::Wait()` is made..
// This is useful to guard synchronization-free scopes against regressions.
//
// Example of what this would catch (`ScopeToProtect` calls `Foo`):
@@ -99,7 +99,7 @@
};
// These classes are provided for compatibility with Chromium.
-// The webrtc::Event implementation is overriden inside of Chromium for the
+// The Event implementation is overriden inside of Chromium for the
// purposes of detecting when threads are blocked that shouldn't be as well as
// to use the more accurate event implementation that's there than is provided
// by default on some platforms (e.g. Windows).
@@ -128,7 +128,7 @@
public:
void YieldExecution() override { RTC_DCHECK_NOTREACHED(); }
} handler_;
- webrtc::ScopedYieldPolicy policy{&handler_};
+ ScopedYieldPolicy policy{&handler_};
};
#endif
diff --git a/rtc_base/event_unittest.cc b/rtc_base/event_unittest.cc
index 44a829f..8e64252 100644
--- a/rtc_base/event_unittest.cc
+++ b/rtc_base/event_unittest.cc
@@ -102,7 +102,7 @@
}
#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
-// Tests that we crash if we attempt to call webrtc::Event::Wait while we're
+// Tests that we crash if we attempt to call Event::Wait while we're
// not allowed to (as per `RTC_DISALLOW_WAIT()`).
TEST(EventTestDeathTest, DisallowEventWait) {
Event event;
diff --git a/rtc_base/fake_clock.h b/rtc_base/fake_clock.h
index 66050c7..a529b6c 100644
--- a/rtc_base/fake_clock.h
+++ b/rtc_base/fake_clock.h
@@ -24,7 +24,7 @@
// Fake clock for use with unit tests, which does not tick on its own.
// Starts at time 0.
//
-// TODO(deadbeef): Unify with webrtc::SimulatedClock.
+// TODO(deadbeef): Unify with SimulatedClock.
class FakeClock : public ClockInterface {
public:
FakeClock() = default;
diff --git a/rtc_base/fake_network.h b/rtc_base/fake_network.h
index b8c2213..7fede14 100644
--- a/rtc_base/fake_network.h
+++ b/rtc_base/fake_network.h
@@ -109,7 +109,7 @@
using NetworkManagerBase::set_default_local_addresses;
using NetworkManagerBase::set_enumeration_permission;
- // webrtc::NetworkManager override.
+ // NetworkManager override.
MdnsResponderInterface* GetMdnsResponder() const override {
return mdns_responder_.get();
}
@@ -131,8 +131,7 @@
} else if (it->socket_address.ipaddr().family() == AF_INET6) {
prefix_length = kFakeIPv6NetworkPrefixLength;
}
- IPAddress prefix =
- webrtc::TruncateIP(it->socket_address.ipaddr(), prefix_length);
+ IPAddress prefix = TruncateIP(it->socket_address.ipaddr(), prefix_length);
auto net = std::make_unique<Network>(
it->socket_address.hostname(), it->socket_address.hostname(), prefix,
prefix_length, it->adapter_type);
diff --git a/rtc_base/internal/default_socket_server.cc b/rtc_base/internal/default_socket_server.cc
index 043c2ce..1ebe391 100644
--- a/rtc_base/internal/default_socket_server.cc
+++ b/rtc_base/internal/default_socket_server.cc
@@ -24,7 +24,7 @@
std::unique_ptr<SocketServer> CreateDefaultSocketServer() {
#if defined(__native_client__)
- return std::unique_ptr<SocketServer>(new webrtc::NullSocketServer);
+ return std::unique_ptr<SocketServer>(new NullSocketServer);
#else
return std::unique_ptr<SocketServer>(new PhysicalSocketServer);
#endif
diff --git a/rtc_base/ip_address.h b/rtc_base/ip_address.h
index 8636fc6..efcabcb 100644
--- a/rtc_base/ip_address.h
+++ b/rtc_base/ip_address.h
@@ -79,7 +79,7 @@
explicit IPAddress(uint32_t ip_in_host_byte_order) : family_(AF_INET) {
memset(&u_, 0, sizeof(u_));
- u_.ip4.s_addr = webrtc::HostToNetwork32(ip_in_host_byte_order);
+ u_.ip4.s_addr = HostToNetwork32(ip_in_host_byte_order);
}
IPAddress(const IPAddress& other) : family_(other.family_) {
diff --git a/rtc_base/mdns_responder_interface.h b/rtc_base/mdns_responder_interface.h
index fb4c1c9..d70fdf9 100644
--- a/rtc_base/mdns_responder_interface.h
+++ b/rtc_base/mdns_responder_interface.h
@@ -24,7 +24,7 @@
class MdnsResponderInterface {
public:
using NameCreatedCallback =
- std::function<void(const webrtc::IPAddress&, absl::string_view)>;
+ std::function<void(const IPAddress&, absl::string_view)>;
using NameRemovedCallback = std::function<void(bool)>;
MdnsResponderInterface() = default;
diff --git a/rtc_base/memory/fifo_buffer.h b/rtc_base/memory/fifo_buffer.h
index a36717d..a153ddf 100644
--- a/rtc_base/memory/fifo_buffer.h
+++ b/rtc_base/memory/fifo_buffer.h
@@ -84,11 +84,10 @@
private:
void PostEvent(int events, int err) {
RTC_DCHECK_RUN_ON(owner_);
- owner_->PostTask(
- webrtc::SafeTask(task_safety_.flag(), [this, events, err]() {
- RTC_DCHECK_RUN_ON(&callback_sequence_);
- FireEvent(events, err);
- }));
+ owner_->PostTask(SafeTask(task_safety_.flag(), [this, events, err]() {
+ RTC_DCHECK_RUN_ON(&callback_sequence_);
+ FireEvent(events, err);
+ }));
}
// Helper method that implements Read. Caller must acquire a lock
diff --git a/rtc_base/network.cc b/rtc_base/network.cc
index edb78eb..5a0f0df 100644
--- a/rtc_base/network.cc
+++ b/rtc_base/network.cc
@@ -201,15 +201,14 @@
}
#if defined(WEBRTC_WIN)
-bool IpAddressAttributesEnabled(const webrtc::FieldTrialsView* field_trials) {
+bool IpAddressAttributesEnabled(const FieldTrialsView* field_trials) {
// Field trial key reserved in bugs.webrtc.org/14334
if (field_trials &&
field_trials->IsEnabled("WebRTC-IPv6NetworkResolutionFixes")) {
- webrtc::FieldTrialParameter<bool> ip_address_attributes_enabled(
+ FieldTrialParameter<bool> ip_address_attributes_enabled(
"IpAddressAttributesEnabled", false);
- webrtc::ParseFieldTrial(
- {&ip_address_attributes_enabled},
- field_trials->Lookup("WebRTC-IPv6NetworkResolutionFixes"));
+ ParseFieldTrial({&ip_address_attributes_enabled},
+ field_trials->Lookup("WebRTC-IPv6NetworkResolutionFixes"));
return ip_address_attributes_enabled;
}
return false;
@@ -628,7 +627,7 @@
continue;
}
// Convert to InterfaceAddress.
- // TODO(webrtc:13114): Convert ConvertIfAddrs to use webrtc::Netmask.
+ // TODO(webrtc:13114): Convert ConvertIfAddrs to use Netmask.
if (!ifaddrs_converter->ConvertIfAddrsToIPAddress(cursor, &ip, &mask)) {
continue;
}
@@ -887,7 +886,7 @@
adapter_type = ADAPTER_TYPE_VPN;
}
if (adapter_type != ADAPTER_TYPE_VPN &&
- IsVpnMacAddress(webrtc::ArrayView<const uint8_t>(
+ IsVpnMacAddress(ArrayView<const uint8_t>(
reinterpret_cast<const uint8_t*>(
adapter_addrs->PhysicalAddress),
adapter_addrs->PhysicalAddressLength))) {
diff --git a/rtc_base/network.h b/rtc_base/network.h
index f8ccfc7..c87142e 100644
--- a/rtc_base/network.h
+++ b/rtc_base/network.h
@@ -52,7 +52,7 @@
class Network;
// By default, ignore loopback interfaces on the host.
-const int kDefaultNetworkIgnoreMask = webrtc::ADAPTER_TYPE_LOOPBACK;
+const int kDefaultNetworkIgnoreMask = ADAPTER_TYPE_LOOPBACK;
namespace webrtc_network_internal {
bool CompareNetworks(const std::unique_ptr<Network>& a,
@@ -201,7 +201,7 @@
description,
prefix,
prefix_length,
- webrtc::ADAPTER_TYPE_UNKNOWN) {}
+ ADAPTER_TYPE_UNKNOWN) {}
Network(absl::string_view name,
absl::string_view description,
@@ -213,7 +213,7 @@
~Network();
// This signal is fired whenever type() or underlying_type_for_vpn() changes.
- // Mutable, to support connecting on the const Network passed to webrtc::Port
+ // Mutable, to support connecting on the const Network passed to Port
// constructor.
mutable sigslot::signal1<const Network*> SignalTypeChanged;
@@ -314,8 +314,8 @@
return;
}
type_ = type;
- if (type != webrtc::ADAPTER_TYPE_VPN) {
- underlying_type_for_vpn_ = webrtc::ADAPTER_TYPE_UNKNOWN;
+ if (type != ADAPTER_TYPE_VPN) {
+ underlying_type_for_vpn_ = ADAPTER_TYPE_UNKNOWN;
}
SignalTypeChanged(this);
}
@@ -328,17 +328,17 @@
SignalTypeChanged(this);
}
- bool IsVpn() const { return type_ == webrtc::ADAPTER_TYPE_VPN; }
+ bool IsVpn() const { return type_ == ADAPTER_TYPE_VPN; }
bool IsCellular() const { return IsCellular(type_); }
static bool IsCellular(AdapterType type) {
switch (type) {
- case webrtc::ADAPTER_TYPE_CELLULAR:
- case webrtc::ADAPTER_TYPE_CELLULAR_2G:
- case webrtc::ADAPTER_TYPE_CELLULAR_3G:
- case webrtc::ADAPTER_TYPE_CELLULAR_4G:
- case webrtc::ADAPTER_TYPE_CELLULAR_5G:
+ case ADAPTER_TYPE_CELLULAR:
+ case ADAPTER_TYPE_CELLULAR_2G:
+ case ADAPTER_TYPE_CELLULAR_3G:
+ case ADAPTER_TYPE_CELLULAR_4G:
+ case ADAPTER_TYPE_CELLULAR_5G:
return true;
default:
return false;
@@ -398,7 +398,7 @@
int scope_id_;
bool ignored_;
AdapterType type_;
- AdapterType underlying_type_for_vpn_ = webrtc::ADAPTER_TYPE_UNKNOWN;
+ AdapterType underlying_type_for_vpn_ = ADAPTER_TYPE_UNKNOWN;
int preference_;
bool active_ = true;
uint16_t id_ = 0;
diff --git a/rtc_base/network/received_packet.h b/rtc_base/network/received_packet.h
index 5de54cd..b0cee33 100644
--- a/rtc_base/network/received_packet.h
+++ b/rtc_base/network/received_packet.h
@@ -38,24 +38,20 @@
// Caller must keep memory pointed to by payload and address valid for the
// lifetime of this ReceivedPacket.
ReceivedIpPacket(ArrayView<const uint8_t> payload,
- const webrtc::SocketAddress& source_address,
- std::optional<webrtc::Timestamp> arrival_time = std::nullopt,
+ const SocketAddress& source_address,
+ std::optional<Timestamp> arrival_time = std::nullopt,
EcnMarking ecn = EcnMarking::kNotEct,
DecryptionInfo decryption = kNotDecrypted);
ReceivedIpPacket CopyAndSet(DecryptionInfo decryption_info) const;
// Address/port of the packet sender.
- const webrtc::SocketAddress& source_address() const {
- return source_address_;
- }
+ const SocketAddress& source_address() const { return source_address_; }
ArrayView<const uint8_t> payload() const { return payload_; }
// Timestamp when this packet was received. Not available on all socket
// implementations.
- std::optional<webrtc::Timestamp> arrival_time() const {
- return arrival_time_;
- }
+ std::optional<Timestamp> arrival_time() const { return arrival_time_; }
// L4S Explicit Congestion Notification.
EcnMarking ecn() const { return ecn_; }
@@ -66,7 +62,7 @@
const char* data,
size_t size,
int64_t packet_time_us,
- const webrtc::SocketAddress& addr = webrtc::SocketAddress()) {
+ const SocketAddress& addr = SocketAddress()) {
return CreateFromLegacy(reinterpret_cast<const uint8_t*>(data), size,
packet_time_us, addr);
}
@@ -75,12 +71,12 @@
const uint8_t* data,
size_t size,
int64_t packet_time_us,
- const webrtc::SocketAddress& = webrtc::SocketAddress());
+ const SocketAddress& = SocketAddress());
private:
ArrayView<const uint8_t> payload_;
- std::optional<webrtc::Timestamp> arrival_time_;
- const webrtc::SocketAddress& source_address_;
+ std::optional<Timestamp> arrival_time_;
+ const SocketAddress& source_address_;
EcnMarking ecn_;
DecryptionInfo decryption_info_;
};
diff --git a/rtc_base/network_monitor.h b/rtc_base/network_monitor.h
index f954a4d..02dc830 100644
--- a/rtc_base/network_monitor.h
+++ b/rtc_base/network_monitor.h
@@ -77,7 +77,7 @@
AdapterType adapter_type;
// Is ADAPTER_TYPE_UNKNOWN unless adapter_type == ADAPTER_TYPE_VPN.
- AdapterType underlying_type_for_vpn = webrtc::ADAPTER_TYPE_UNKNOWN;
+ AdapterType underlying_type_for_vpn = ADAPTER_TYPE_UNKNOWN;
// The OS/firmware specific preference of this interface.
NetworkPreference network_preference = NetworkPreference::NEUTRAL;
diff --git a/rtc_base/network_route.h b/rtc_base/network_route.h
index 7f437cf..153836c 100644
--- a/rtc_base/network_route.h
+++ b/rtc_base/network_route.h
@@ -42,7 +42,7 @@
// Used by tests.
static RouteEndpoint CreateWithNetworkId(uint16_t network_id) {
- return RouteEndpoint(webrtc::ADAPTER_TYPE_UNKNOWN,
+ return RouteEndpoint(ADAPTER_TYPE_UNKNOWN,
/* adapter_id = */ 0, network_id,
/* uses_turn = */ false);
}
@@ -58,7 +58,7 @@
bool operator==(const RouteEndpoint& other) const;
private:
- AdapterType adapter_type_ = webrtc::ADAPTER_TYPE_UNKNOWN;
+ AdapterType adapter_type_ = ADAPTER_TYPE_UNKNOWN;
uint16_t adapter_id_ = 0;
uint16_t network_id_ = 0;
bool uses_turn_ = false;
@@ -78,10 +78,10 @@
StringBuilder oss;
oss << "[ connected: " << connected << " local: [ " << local.adapter_id()
<< "/" << local.network_id() << " "
- << webrtc::AdapterTypeToString(local.adapter_type())
+ << AdapterTypeToString(local.adapter_type())
<< " turn: " << local.uses_turn() << " ] remote: [ "
<< remote.adapter_id() << "/" << remote.network_id() << " "
- << webrtc::AdapterTypeToString(remote.adapter_type())
+ << AdapterTypeToString(remote.adapter_type())
<< " turn: " << remote.uses_turn()
<< " ] packet_overhead_bytes: " << packet_overhead << " ]";
return oss.Release();
diff --git a/rtc_base/network_unittest.cc b/rtc_base/network_unittest.cc
index 8a754cc..dde29cb 100644
--- a/rtc_base/network_unittest.cc
+++ b/rtc_base/network_unittest.cc
@@ -401,7 +401,7 @@
IPAddress ip = (*it)->GetBestIP();
SocketAddress bindaddress(ip, 0);
bindaddress.SetScopeID((*it)->scope_id());
- // TODO(thaloun): Use webrtc::Socket once it supports IPv6.
+ // TODO(thaloun): Use Socket once it supports IPv6.
int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP));
if (fd > 0) {
size_t ipsize = bindaddress.ToSockAddrStorage(&storage);
diff --git a/rtc_base/openssl_adapter.cc b/rtc_base/openssl_adapter.cc
index b25e9fb..b13778b 100644
--- a/rtc_base/openssl_adapter.cc
+++ b/rtc_base/openssl_adapter.cc
@@ -258,8 +258,8 @@
identity_ =
absl::WrapUnique(static_cast<BoringSSLIdentity*>(identity.release()));
#else
- identity_ = absl::WrapUnique(
- static_cast<webrtc::OpenSSLIdentity*>(identity.release()));
+ identity_ =
+ absl::WrapUnique(static_cast<OpenSSLIdentity*>(identity.release()));
#endif
}
@@ -912,7 +912,7 @@
}
const BoringSSLCertificate cert(std::move(crypto_buffer));
#else
- const webrtc::OpenSSLCertificate cert(X509_STORE_CTX_get_current_cert(store));
+ const OpenSSLCertificate cert(X509_STORE_CTX_get_current_cert(store));
#endif
if (!ssl_cert_verifier_->Verify(cert)) {
RTC_LOG(LS_INFO) << "Failed to verify certificate using custom callback";
diff --git a/rtc_base/openssl_adapter.h b/rtc_base/openssl_adapter.h
index 479b1a6..3f3951d 100644
--- a/rtc_base/openssl_adapter.h
+++ b/rtc_base/openssl_adapter.h
@@ -148,7 +148,7 @@
#ifdef OPENSSL_IS_BORINGSSL
std::unique_ptr<BoringSSLIdentity> identity_;
#else
- std::unique_ptr<webrtc::OpenSSLIdentity> identity_;
+ std::unique_ptr<OpenSSLIdentity> identity_;
#endif
// Indicates whethere this is a client or a server.
SSLRole role_;
@@ -211,8 +211,8 @@
private:
// Holds the SSLMode (DTLS,TLS) that will be used to set the session cache.
- SSLMode ssl_mode_ = webrtc::SSL_MODE_TLS;
- SSLRole ssl_role_ = webrtc::SSL_CLIENT;
+ SSLMode ssl_mode_ = SSL_MODE_TLS;
+ SSLRole ssl_role_ = SSL_CLIENT;
bool ignore_bad_cert_ = false;
std::unique_ptr<SSLIdentity> identity_;
diff --git a/rtc_base/openssl_identity.cc b/rtc_base/openssl_identity.cc
index 32b8b3b..11b8aa8 100644
--- a/rtc_base/openssl_identity.cc
+++ b/rtc_base/openssl_identity.cc
@@ -115,9 +115,8 @@
std::unique_ptr<SSLIdentity> OpenSSLIdentity::CreateFromPEMChainStrings(
absl::string_view private_key,
absl::string_view certificate_chain) {
- BIO* bio =
- BIO_new_mem_buf(certificate_chain.data(),
- webrtc::dchecked_cast<int>(certificate_chain.size()));
+ BIO* bio = BIO_new_mem_buf(certificate_chain.data(),
+ dchecked_cast<int>(certificate_chain.size()));
if (!bio)
return nullptr;
BIO_set_mem_eof_return(bio, 0);
diff --git a/rtc_base/openssl_stream_adapter.cc b/rtc_base/openssl_stream_adapter.cc
index 944567b..ef704d3 100644
--- a/rtc_base/openssl_stream_adapter.cc
+++ b/rtc_base/openssl_stream_adapter.cc
@@ -317,7 +317,7 @@
#ifdef OPENSSL_IS_BORINGSSL
identity_.reset(static_cast<BoringSSLIdentity*>(identity.release()));
#else
- identity_.reset(static_cast<webrtc::OpenSSLIdentity*>(identity.release()));
+ identity_.reset(static_cast<OpenSSLIdentity*>(identity.release()));
#endif
}
@@ -1203,7 +1203,7 @@
// Record the peer's certificate.
X509* cert = X509_STORE_CTX_get0_cert(store);
stream->peer_cert_chain_.reset(
- new SSLCertChain(std::make_unique<webrtc::OpenSSLCertificate>(cert)));
+ new SSLCertChain(std::make_unique<OpenSSLCertificate>(cert)));
// If the peer certificate digest isn't known yet, we'll wait to verify
// until it's known, and for now just return a success status.
diff --git a/rtc_base/openssl_stream_adapter.h b/rtc_base/openssl_stream_adapter.h
index 257f100..2cce9c1 100644
--- a/rtc_base/openssl_stream_adapter.h
+++ b/rtc_base/openssl_stream_adapter.h
@@ -79,7 +79,7 @@
SSLIdentity* GetIdentityForTesting() const override;
// Default argument is for compatibility
- void SetServerRole(SSLRole role = webrtc::SSL_SERVER) override;
+ void SetServerRole(SSLRole role = SSL_SERVER) override;
SSLPeerCertificateDigestError SetPeerCertificateDigest(
absl::string_view digest_alg,
ArrayView<const uint8_t> digest_val) override;
@@ -232,7 +232,7 @@
#ifdef OPENSSL_IS_BORINGSSL
std::unique_ptr<BoringSSLIdentity> identity_;
#else
- std::unique_ptr<webrtc::OpenSSLIdentity> identity_;
+ std::unique_ptr<OpenSSLIdentity> identity_;
#endif
// The certificate chain that the peer presented. Initially null, until the
// connection is established.
diff --git a/rtc_base/physical_socket_server.cc b/rtc_base/physical_socket_server.cc
index b18052a..fa4e15dd 100644
--- a/rtc_base/physical_socket_server.cc
+++ b/rtc_base/physical_socket_server.cc
@@ -1825,7 +1825,7 @@
int64_t msStop = -1;
if (cmsWait != kForeverMs) {
msWait = cmsWait;
- msStop = webrtc::TimeAfter(cmsWait);
+ msStop = TimeAfter(cmsWait);
}
std::vector<pollfd> pollfds;
@@ -1833,7 +1833,7 @@
while (fWait_) {
{
- webrtc::CritScope cr(&crit_);
+ CritScope cr(&crit_);
current_dispatcher_keys_.clear();
pollfds.clear();
pollfds.reserve(dispatcher_by_key_.size());
@@ -1867,7 +1867,7 @@
return true;
} else {
// We have signaled descriptors
- webrtc::CritScope cr(&crit_);
+ CritScope cr(&crit_);
// Iterate only on the dispatchers whose file descriptors were passed into
// poll; this avoids the ABA problem (a socket being destroyed and a new
// one created with the same file descriptor).
@@ -1880,7 +1880,7 @@
}
if (cmsWait != kForeverMs) {
- msWait = webrtc::TimeDiff(msStop, webrtc::TimeMillis());
+ msWait = TimeDiff(msStop, TimeMillis());
if (msWait < 0) {
// Return success on timeout.
return true;
@@ -1896,8 +1896,7 @@
#endif // WEBRTC_POSIX
#if defined(WEBRTC_WIN)
-bool PhysicalSocketServer::Wait(webrtc::TimeDelta max_wait_duration,
- bool process_io) {
+bool PhysicalSocketServer::Wait(TimeDelta max_wait_duration, bool process_io) {
// We don't support reentrant waiting.
RTC_DCHECK(!waiting_);
ScopedSetTrue set(&waiting_);
@@ -1905,7 +1904,7 @@
int cmsWait = ToCmsWait(max_wait_duration);
int64_t cmsTotal = cmsWait;
int64_t cmsElapsed = 0;
- int64_t msStart = webrtc::Time();
+ int64_t msStart = Time();
fWait_ = true;
while (fWait_) {
@@ -1915,7 +1914,7 @@
events.push_back(socket_ev_);
{
- webrtc::CritScope cr(&crit_);
+ CritScope cr(&crit_);
// Get a snapshot of all current dispatchers; this is used to avoid the
// ABA problem (see later comment) and avoids the dispatcher_by_key_
// iterator being invalidated by calling CheckSignalClose, which may
@@ -1971,7 +1970,7 @@
return true;
} else {
// Figure out which one it is and call it
- webrtc::CritScope cr(&crit_);
+ CritScope cr(&crit_);
int index = dw - WSA_WAIT_EVENT_0;
if (index > 0) {
--index; // The first event is the socket event
@@ -2064,7 +2063,7 @@
// Break?
if (!fWait_)
break;
- cmsElapsed = webrtc::TimeSince(msStart);
+ cmsElapsed = TimeSince(msStart);
if ((cmsWait != kForeverMs) && (cmsElapsed >= cmsWait)) {
break;
}
diff --git a/rtc_base/ref_counted_object.h b/rtc_base/ref_counted_object.h
index 032e9ad..79c2d12 100644
--- a/rtc_base/ref_counted_object.h
+++ b/rtc_base/ref_counted_object.h
@@ -54,7 +54,7 @@
protected:
~RefCountedObject() override {}
- mutable webrtc::webrtc_impl::RefCounter ref_count_{0};
+ mutable webrtc_impl::RefCounter ref_count_{0};
};
template <class T>
@@ -81,7 +81,7 @@
private:
~FinalRefCountedObject() = default;
- mutable webrtc::webrtc_impl::RefCounter ref_count_{0};
+ mutable webrtc_impl::RefCounter ref_count_{0};
};
} // namespace webrtc
diff --git a/rtc_base/rtc_certificate_generator.h b/rtc_base/rtc_certificate_generator.h
index ca5d419..b5be206 100644
--- a/rtc_base/rtc_certificate_generator.h
+++ b/rtc_base/rtc_certificate_generator.h
@@ -30,8 +30,7 @@
public:
// Functor that will be called when certificate is generated asynchroniosly.
// Called with nullptr as the parameter on failure.
- using Callback =
- absl::AnyInvocable<void(scoped_refptr<webrtc::RTCCertificate>) &&>;
+ using Callback = absl::AnyInvocable<void(scoped_refptr<RTCCertificate>) &&>;
virtual ~RTCCertificateGeneratorInterface() = default;
diff --git a/rtc_base/ssl_certificate.cc b/rtc_base/ssl_certificate.cc
index 7db106c..d6c170d 100644
--- a/rtc_base/ssl_certificate.cc
+++ b/rtc_base/ssl_certificate.cc
@@ -138,7 +138,7 @@
#ifdef OPENSSL_IS_BORINGSSL
return BoringSSLCertificate::FromPEMString(pem_string);
#else
- return webrtc::OpenSSLCertificate::FromPEMString(pem_string);
+ return OpenSSLCertificate::FromPEMString(pem_string);
#endif
}
diff --git a/rtc_base/ssl_stream_adapter.h b/rtc_base/ssl_stream_adapter.h
index f8f8173..baa4912 100644
--- a/rtc_base/ssl_stream_adapter.h
+++ b/rtc_base/ssl_stream_adapter.h
@@ -125,8 +125,7 @@
// Caller is responsible for freeing the returned object.
static std::unique_ptr<SSLStreamAdapter> Create(
std::unique_ptr<StreamInterface> stream,
- absl::AnyInvocable<void(webrtc::SSLHandshakeError)> handshake_error =
- nullptr,
+ absl::AnyInvocable<void(SSLHandshakeError)> handshake_error = nullptr,
const FieldTrialsView* field_trials = nullptr);
SSLStreamAdapter() = default;
diff --git a/rtc_base/ssl_stream_adapter_unittest.cc b/rtc_base/ssl_stream_adapter_unittest.cc
index ac0714e..6de76994 100644
--- a/rtc_base/ssl_stream_adapter_unittest.cc
+++ b/rtc_base/ssl_stream_adapter_unittest.cc
@@ -209,9 +209,9 @@
// This is needed because in this file, tests connect both client and server
// streams (SSLDummyStream) to the same underlying `stream` objects
// (see CreateClientStream() and CreateServerStream()).
-class StreamWrapper : public webrtc::StreamInterface {
+class StreamWrapper : public StreamInterface {
public:
- explicit StreamWrapper(std::unique_ptr<webrtc::StreamInterface> stream)
+ explicit StreamWrapper(std::unique_ptr<StreamInterface> stream)
: stream_(std::move(stream)) {
stream_->SetEventCallback([this](int events, int err) {
RTC_DCHECK_RUN_ON(&callback_sequence_);
@@ -229,28 +229,28 @@
callbacks_.RemoveReceivers(removal_tag);
}
- webrtc::StreamState GetState() const override { return stream_->GetState(); }
+ StreamState GetState() const override { return stream_->GetState(); }
void Close() override { stream_->Close(); }
- webrtc::StreamResult Read(webrtc::ArrayView<uint8_t> buffer,
- size_t& read,
- int& error) override {
+ StreamResult Read(ArrayView<uint8_t> buffer,
+ size_t& read,
+ int& error) override {
return stream_->Read(buffer, read, error);
}
- webrtc::StreamResult Write(webrtc::ArrayView<const uint8_t> data,
- size_t& written,
- int& error) override {
+ StreamResult Write(ArrayView<const uint8_t> data,
+ size_t& written,
+ int& error) override {
return stream_->Write(data, written, error);
}
private:
- const std::unique_ptr<webrtc::StreamInterface> stream_;
- webrtc::CallbackList<int, int> callbacks_;
+ const std::unique_ptr<StreamInterface> stream_;
+ CallbackList<int, int> callbacks_;
};
-class SSLDummyStream final : public webrtc::StreamInterface {
+class SSLDummyStream final : public StreamInterface {
public:
SSLDummyStream(SSLStreamAdapterTestBase* test,
absl::string_view side,
@@ -270,30 +270,30 @@
out_->UnsubscribeStreamEvent(this);
}
- webrtc::StreamState GetState() const override { return webrtc::SS_OPEN; }
+ StreamState GetState() const override { return SS_OPEN; }
- webrtc::StreamResult Read(webrtc::ArrayView<uint8_t> buffer,
- size_t& read,
- int& error) override {
- webrtc::StreamResult r;
+ StreamResult Read(ArrayView<uint8_t> buffer,
+ size_t& read,
+ int& error) override {
+ StreamResult r;
r = in_->Read(buffer, read, error);
- if (r == webrtc::SR_BLOCK)
- return webrtc::SR_BLOCK;
- if (r == webrtc::SR_EOS)
- return webrtc::SR_EOS;
+ if (r == SR_BLOCK)
+ return SR_BLOCK;
+ if (r == SR_EOS)
+ return SR_EOS;
- if (r != webrtc::SR_SUCCESS) {
+ if (r != SR_SUCCESS) {
ADD_FAILURE();
- return webrtc::SR_ERROR;
+ return SR_ERROR;
}
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
// Catch readability events on in and pass them up.
void OnEventIn(int sig, int err) {
- int mask = (webrtc::SE_READ | webrtc::SE_CLOSE);
+ int mask = (SE_READ | SE_CLOSE);
if (sig & mask) {
RTC_LOG(LS_VERBOSE) << "SSLDummyStream::OnEventIn side=" << side_
@@ -304,24 +304,24 @@
// Catch writeability events on out and pass them up.
void OnEventOut(int sig, int err) {
- if (sig & webrtc::SE_WRITE) {
+ if (sig & SE_WRITE) {
RTC_LOG(LS_VERBOSE) << "SSLDummyStream::OnEventOut side=" << side_
<< " sig=" << sig << " forwarding upward";
- PostEvent(sig & webrtc::SE_WRITE, 0);
+ PostEvent(sig & SE_WRITE, 0);
}
}
// Write to the outgoing FifoBuffer
- webrtc::StreamResult WriteData(webrtc::ArrayView<const uint8_t> data,
- size_t& written,
- int& error) {
+ StreamResult WriteData(ArrayView<const uint8_t> data,
+ size_t& written,
+ int& error) {
return out_->Write(data, written, error);
}
- webrtc::StreamResult Write(webrtc::ArrayView<const uint8_t> data,
- size_t& written,
- int& error) override;
+ StreamResult Write(ArrayView<const uint8_t> data,
+ size_t& written,
+ int& error) override;
void Close() override {
RTC_LOG(LS_INFO) << "Closing outbound stream";
@@ -336,8 +336,8 @@
}));
}
- webrtc::ScopedTaskSafety task_safety_;
- webrtc::Thread* const thread_ = webrtc::Thread::Current();
+ ScopedTaskSafety task_safety_;
+ Thread* const thread_ = Thread::Current();
SSLStreamAdapterTestBase* test_base_;
const std::string side_;
StreamWrapper* const in_;
@@ -345,7 +345,7 @@
bool first_packet_;
};
-class BufferQueueStream : public webrtc::StreamInterface {
+class BufferQueueStream : public StreamInterface {
public:
BufferQueueStream(size_t capacity, size_t default_size)
: buffer_(capacity, default_size) {}
@@ -353,42 +353,42 @@
// Implementation of abstract StreamInterface methods.
// A buffer queue stream is always "open".
- webrtc::StreamState GetState() const override { return webrtc::SS_OPEN; }
+ StreamState GetState() const override { return SS_OPEN; }
// Reading a buffer queue stream will either succeed or block.
- webrtc::StreamResult Read(webrtc::ArrayView<uint8_t> buffer,
- size_t& read,
- int& error) override {
+ StreamResult Read(ArrayView<uint8_t> buffer,
+ size_t& read,
+ int& error) override {
const bool was_writable = buffer_.is_writable();
if (!buffer_.ReadFront(buffer.data(), buffer.size(), &read))
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
if (!was_writable)
NotifyWritableForTest();
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
// Writing to a buffer queue stream will either succeed or block.
- webrtc::StreamResult Write(webrtc::ArrayView<const uint8_t> data,
- size_t& written,
- int& error) override {
+ StreamResult Write(ArrayView<const uint8_t> data,
+ size_t& written,
+ int& error) override {
const bool was_readable = buffer_.is_readable();
if (!buffer_.WriteBack(data.data(), data.size(), &written))
- return webrtc::SR_BLOCK;
+ return SR_BLOCK;
if (!was_readable)
NotifyReadableForTest();
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
// A buffer queue stream can not be closed.
void Close() override {}
protected:
- void NotifyReadableForTest() { PostEvent(webrtc::SE_READ, 0); }
- void NotifyWritableForTest() { PostEvent(webrtc::SE_WRITE, 0); }
+ void NotifyReadableForTest() { PostEvent(SE_READ, 0); }
+ void NotifyWritableForTest() { PostEvent(SE_WRITE, 0); }
private:
void PostEvent(int events, int err) {
@@ -398,9 +398,9 @@
}));
}
- webrtc::Thread* const thread_ = webrtc::Thread::Current();
- webrtc::ScopedTaskSafety task_safety_;
- webrtc::BufferQueue buffer_;
+ Thread* const thread_ = Thread::Current();
+ ScopedTaskSafety task_safety_;
+ BufferQueue buffer_;
};
static const int kBufferCapacity = 1;
@@ -409,14 +409,14 @@
class SSLStreamAdapterTestBase : public ::testing::Test,
public sigslot::has_slots<> {
public:
- SSLStreamAdapterTestBase(
- absl::string_view client_cert_pem,
- absl::string_view client_private_key_pem,
- bool dtls,
- webrtc::KeyParams client_key_type = webrtc::KeyParams(webrtc::KT_DEFAULT),
- webrtc::KeyParams server_key_type = webrtc::KeyParams(webrtc::KT_DEFAULT),
- std::pair<std::string, size_t> digest =
- std::make_pair(webrtc::DIGEST_SHA_256, SHA256_DIGEST_LENGTH))
+ SSLStreamAdapterTestBase(absl::string_view client_cert_pem,
+ absl::string_view client_private_key_pem,
+ bool dtls,
+ KeyParams client_key_type = KeyParams(KT_DEFAULT),
+ KeyParams server_key_type = KeyParams(KT_DEFAULT),
+ std::pair<std::string, size_t> digest =
+ std::make_pair(DIGEST_SHA_256,
+ SHA256_DIGEST_LENGTH))
: client_cert_pem_(client_cert_pem),
client_private_key_pem_(client_private_key_pem),
client_key_type_(client_key_type),
@@ -429,29 +429,28 @@
lose_first_packet_(false),
damage_(false),
dtls_(dtls),
- handshake_wait_(webrtc::TimeDelta::Millis(5000)),
+ handshake_wait_(TimeDelta::Millis(5000)),
identities_set_(false) {
// Set use of the test RNG to get predictable loss patterns.
- webrtc::SetRandomTestMode(true);
+ SetRandomTestMode(true);
}
~SSLStreamAdapterTestBase() override {
// Put it back for the next test.
- webrtc::SetRandomTestMode(false);
+ SetRandomTestMode(false);
}
void SetUp() override {
InitializeClientAndServerStreams();
- std::unique_ptr<webrtc::SSLIdentity> client_identity;
+ std::unique_ptr<SSLIdentity> client_identity;
if (!client_cert_pem_.empty() && !client_private_key_pem_.empty()) {
- client_identity = webrtc::SSLIdentity::CreateFromPEMStrings(
+ client_identity = SSLIdentity::CreateFromPEMStrings(
client_private_key_pem_, client_cert_pem_);
} else {
- client_identity = webrtc::SSLIdentity::Create("client", client_key_type_);
+ client_identity = SSLIdentity::Create("client", client_key_type_);
}
- auto server_identity =
- webrtc::SSLIdentity::Create("server", server_key_type_);
+ auto server_identity = SSLIdentity::Create("server", server_key_type_);
client_ssl_->SetIdentity(std::move(client_identity));
server_ssl_->SetIdentity(std::move(server_identity));
@@ -462,8 +461,8 @@
server_ssl_.reset(nullptr);
}
- virtual std::unique_ptr<webrtc::StreamInterface> CreateClientStream() = 0;
- virtual std::unique_ptr<webrtc::StreamInterface> CreateServerStream() = 0;
+ virtual std::unique_ptr<StreamInterface> CreateClientStream() = 0;
+ virtual std::unique_ptr<StreamInterface> CreateServerStream() = 0;
void InitializeClientAndServerStreams(
absl::string_view client_experiment = "",
@@ -473,13 +472,13 @@
// The field trials are read when the OpenSSLStreamAdapter is initialized.
{
FieldTrials trial = CreateTestFieldTrials(client_experiment);
- client_ssl_ = webrtc::SSLStreamAdapter::Create(CreateClientStream(),
- nullptr, &trial);
+ client_ssl_ =
+ SSLStreamAdapter::Create(CreateClientStream(), nullptr, &trial);
}
{
FieldTrials trial = CreateTestFieldTrials(server_experiment);
- server_ssl_ = webrtc::SSLStreamAdapter::Create(CreateServerStream(),
- nullptr, &trial);
+ server_ssl_ =
+ SSLStreamAdapter::Create(CreateServerStream(), nullptr, &trial);
}
client_ssl_->SetEventCallback(
[this](int events, int err) { OnClientEvent(events, err); });
@@ -495,32 +494,31 @@
time_t now = time(nullptr);
- webrtc::SSLIdentityParams client_params;
- client_params.key_params = webrtc::KeyParams(webrtc::KT_DEFAULT);
+ SSLIdentityParams client_params;
+ client_params.key_params = KeyParams(KT_DEFAULT);
client_params.common_name = "client";
client_params.not_before = now + not_before;
client_params.not_after = now + not_after;
- auto client_identity = webrtc::SSLIdentity::CreateForTest(client_params);
+ auto client_identity = SSLIdentity::CreateForTest(client_params);
- webrtc::SSLIdentityParams server_params;
- server_params.key_params = webrtc::KeyParams(webrtc::KT_DEFAULT);
+ SSLIdentityParams server_params;
+ server_params.key_params = KeyParams(KT_DEFAULT);
server_params.common_name = "server";
server_params.not_before = now + not_before;
server_params.not_after = now + not_after;
- auto server_identity = webrtc::SSLIdentity::CreateForTest(server_params);
+ auto server_identity = SSLIdentity::CreateForTest(server_params);
client_ssl_->SetIdentity(std::move(client_identity));
server_ssl_->SetIdentity(std::move(server_identity));
}
void SetPeerIdentitiesByDigest(bool correct, bool expect_success) {
- webrtc::Buffer server_digest(0, EVP_MAX_MD_SIZE);
- webrtc::Buffer client_digest(0, EVP_MAX_MD_SIZE);
- webrtc::SSLPeerCertificateDigestError err;
- webrtc::SSLPeerCertificateDigestError expected_err =
- expect_success
- ? webrtc::SSLPeerCertificateDigestError::NONE
- : webrtc::SSLPeerCertificateDigestError::VERIFICATION_FAILED;
+ Buffer server_digest(0, EVP_MAX_MD_SIZE);
+ Buffer client_digest(0, EVP_MAX_MD_SIZE);
+ SSLPeerCertificateDigestError err;
+ SSLPeerCertificateDigestError expected_err =
+ expect_success ? SSLPeerCertificateDigestError::NONE
+ : SSLPeerCertificateDigestError::VERIFICATION_FAILED;
RTC_LOG(LS_INFO) << "Setting peer identities by digest";
RTC_DCHECK(server_identity());
@@ -550,8 +548,8 @@
identities_set_ = true;
}
- void SetupProtocolVersions(webrtc::SSLProtocolVersion server_version,
- webrtc::SSLProtocolVersion client_version) {
+ void SetupProtocolVersions(SSLProtocolVersion server_version,
+ SSLProtocolVersion client_version) {
server_ssl_->SetMaxProtocolVersion(server_version);
client_ssl_->SetMaxProtocolVersion(client_version);
}
@@ -581,20 +579,19 @@
// Now run the handshake
if (expect_success) {
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
- return (client_ssl_->GetState() == webrtc::SS_OPEN) &&
- (server_ssl_->GetState() == webrtc::SS_OPEN);
+ return (client_ssl_->GetState() == SS_OPEN) &&
+ (server_ssl_->GetState() == SS_OPEN);
},
::testing::IsTrue(),
{.timeout = handshake_wait_, .clock = &clock_}),
- webrtc::IsRtcOk());
+ IsRtcOk());
} else {
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return client_ssl_->GetState(); },
- ::testing::Eq(webrtc::SS_CLOSED),
+ EXPECT_THAT(WaitUntil([&] { return client_ssl_->GetState(); },
+ ::testing::Eq(SS_CLOSED),
{.timeout = handshake_wait_, .clock = &clock_}),
- webrtc::IsRtcOk());
+ IsRtcOk());
}
}
@@ -602,7 +599,7 @@
// Only works for BoringSSL which allows advancing the fake clock.
void TestHandshakeTimeout() {
int64_t time_start = clock_.TimeNanos();
- webrtc::TimeDelta time_increment = webrtc::TimeDelta::Millis(1000);
+ TimeDelta time_increment = TimeDelta::Millis(1000);
if (!dtls_) {
// Make sure we simulate a reliable network for TLS.
@@ -628,19 +625,19 @@
// Now wait for the handshake to timeout (or fail after an hour of simulated
// time).
- while (client_ssl_->GetState() == webrtc::SS_OPENING &&
- (webrtc::TimeDiff(clock_.TimeNanos(), time_start) <
- 3600 * webrtc::kNumNanosecsPerSec)) {
- EXPECT_THAT(webrtc::WaitUntil(
+ while (client_ssl_->GetState() == SS_OPENING &&
+ (TimeDiff(clock_.TimeNanos(), time_start) <
+ 3600 * kNumNanosecsPerSec)) {
+ EXPECT_THAT(WaitUntil(
[&] {
- return !((client_ssl_->GetState() == webrtc::SS_OPEN) &&
- (server_ssl_->GetState() == webrtc::SS_OPEN));
+ return !((client_ssl_->GetState() == SS_OPEN) &&
+ (server_ssl_->GetState() == SS_OPEN));
},
::testing::IsTrue(), {.clock = &clock_}),
- webrtc::IsRtcOk());
+ IsRtcOk());
clock_.AdvanceTime(time_increment);
}
- EXPECT_EQ(client_ssl_->GetState(), webrtc::SS_CLOSED);
+ EXPECT_EQ(client_ssl_->GetState(), SS_CLOSED);
}
// This tests that the handshake can complete before the identity is verified,
@@ -662,30 +659,30 @@
ASSERT_EQ(0, client_ssl_->StartSSL());
// Now run the handshake.
- EXPECT_THAT(webrtc::WaitUntil(
+ EXPECT_THAT(WaitUntil(
[&] {
return client_ssl_->IsTlsConnected() &&
server_ssl_->IsTlsConnected();
},
::testing::IsTrue(),
{.timeout = handshake_wait_, .clock = &clock_}),
- webrtc::IsRtcOk());
+ IsRtcOk());
// Until the identity has been verified, the state should still be
// SS_OPENING and writes should return SR_BLOCK.
- EXPECT_EQ(webrtc::SS_OPENING, client_ssl_->GetState());
- EXPECT_EQ(webrtc::SS_OPENING, server_ssl_->GetState());
+ EXPECT_EQ(SS_OPENING, client_ssl_->GetState());
+ EXPECT_EQ(SS_OPENING, server_ssl_->GetState());
uint8_t packet[1] = {0};
size_t sent;
size_t read;
int error;
- EXPECT_EQ(webrtc::SR_BLOCK, client_ssl_->Write(packet, sent, error));
- EXPECT_EQ(webrtc::SR_BLOCK, server_ssl_->Write(packet, sent, error));
+ EXPECT_EQ(SR_BLOCK, client_ssl_->Write(packet, sent, error));
+ EXPECT_EQ(SR_BLOCK, server_ssl_->Write(packet, sent, error));
// Collect both of the certificate digests; needs to be done before calling
// SetPeerCertificateDigest as that may reset the identity.
- webrtc::Buffer server_digest(0, EVP_MAX_MD_SIZE);
- webrtc::Buffer client_digest(0, EVP_MAX_MD_SIZE);
+ Buffer server_digest(0, EVP_MAX_MD_SIZE);
+ Buffer client_digest(0, EVP_MAX_MD_SIZE);
ASSERT_THAT(server_identity(), NotNull());
ASSERT_TRUE(server_identity()->certificate().ComputeDigest(
@@ -702,24 +699,23 @@
}
// Set the peer certificate digest for the client.
- webrtc::SSLPeerCertificateDigestError err;
- webrtc::SSLPeerCertificateDigestError expected_err =
- valid_identity
- ? webrtc::SSLPeerCertificateDigestError::NONE
- : webrtc::SSLPeerCertificateDigestError::VERIFICATION_FAILED;
+ SSLPeerCertificateDigestError err;
+ SSLPeerCertificateDigestError expected_err =
+ valid_identity ? SSLPeerCertificateDigestError::NONE
+ : SSLPeerCertificateDigestError::VERIFICATION_FAILED;
err =
client_ssl_->SetPeerCertificateDigest(digest_algorithm_, server_digest);
EXPECT_EQ(expected_err, err);
// State should then transition to SS_OPEN or SS_CLOSED based on validation
// of the identity.
if (valid_identity) {
- EXPECT_EQ(webrtc::SS_OPEN, client_ssl_->GetState());
+ EXPECT_EQ(SS_OPEN, client_ssl_->GetState());
// If the client sends a packet while the server still hasn't verified the
// client identity, the server should continue to return SR_BLOCK.
- EXPECT_EQ(webrtc::SR_SUCCESS, client_ssl_->Write(packet, sent, error));
- EXPECT_EQ(webrtc::SR_BLOCK, server_ssl_->Read(packet, read, error));
+ EXPECT_EQ(SR_SUCCESS, client_ssl_->Write(packet, sent, error));
+ EXPECT_EQ(SR_BLOCK, server_ssl_->Read(packet, read, error));
} else {
- EXPECT_EQ(webrtc::SS_CLOSED, client_ssl_->GetState());
+ EXPECT_EQ(SS_CLOSED, client_ssl_->GetState());
}
// Set the peer certificate digest for the server.
@@ -727,27 +723,27 @@
server_ssl_->SetPeerCertificateDigest(digest_algorithm_, client_digest);
EXPECT_EQ(expected_err, err);
if (valid_identity) {
- EXPECT_EQ(webrtc::SS_OPEN, server_ssl_->GetState());
+ EXPECT_EQ(SS_OPEN, server_ssl_->GetState());
} else {
- EXPECT_EQ(webrtc::SS_CLOSED, server_ssl_->GetState());
+ EXPECT_EQ(SS_CLOSED, server_ssl_->GetState());
}
}
- webrtc::StreamResult DataWritten(SSLDummyStream* from,
- const void* data,
- size_t data_len,
- size_t& written,
- int& error) {
+ StreamResult DataWritten(SSLDummyStream* from,
+ const void* data,
+ size_t data_len,
+ size_t& written,
+ int& error) {
// Randomly drop loss_ percent of packets
- if (webrtc::CreateRandomId() % 100 < static_cast<uint32_t>(loss_)) {
+ if (CreateRandomId() % 100 < static_cast<uint32_t>(loss_)) {
RTC_LOG(LS_VERBOSE) << "Randomly dropping packet, size=" << data_len;
written = data_len;
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
if (dtls_ && (data_len > mtu_)) {
RTC_LOG(LS_VERBOSE) << "Dropping packet > mtu, size=" << data_len;
written = data_len;
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
max_seen_mtu_ = std::max(max_seen_mtu_, data_len);
@@ -760,12 +756,11 @@
RTC_LOG(LS_VERBOSE) << "Damaging packet";
memcpy(&buf[0], data, data_len);
buf[data_len - 1]++;
- return from->WriteData(webrtc::MakeArrayView(&buf[0], data_len), written,
- error);
+ return from->WriteData(MakeArrayView(&buf[0], data_len), written, error);
}
return from->WriteData(
- webrtc::MakeArrayView(reinterpret_cast<const uint8_t*>(data), data_len),
+ MakeArrayView(reinterpret_cast<const uint8_t*>(data), data_len),
written, error);
}
@@ -782,9 +777,7 @@
void SetMtu(size_t mtu) { mtu_ = mtu; }
size_t GetMaxSeenMtu() const { return max_seen_mtu_; }
- void SetHandshakeWait(int wait) {
- handshake_wait_ = webrtc::TimeDelta::Millis(wait);
- }
+ void SetHandshakeWait(int wait) { handshake_wait_ = TimeDelta::Millis(wait); }
void SetDtlsSrtpCryptoSuites(const std::vector<int>& ciphers, bool client) {
if (client)
@@ -800,8 +793,8 @@
return server_ssl_->GetDtlsSrtpCryptoSuite(retval);
}
- std::unique_ptr<webrtc::SSLCertificate> GetPeerCertificate(bool client) {
- std::unique_ptr<webrtc::SSLCertChain> chain;
+ std::unique_ptr<SSLCertificate> GetPeerCertificate(bool client) {
+ std::unique_ptr<SSLCertChain> chain;
if (client)
chain = client_ssl_->GetPeerSSLCertChain();
else
@@ -825,7 +818,7 @@
// To be implemented by subclasses.
virtual void WriteData() = 0;
- virtual void ReadData(webrtc::StreamInterface* stream) = 0;
+ virtual void ReadData(StreamInterface* stream) = 0;
virtual void TestTransfer(int size) = 0;
private:
@@ -833,11 +826,11 @@
RTC_LOG(LS_VERBOSE) << "SSLStreamAdapterTestBase::OnClientEvent sig="
<< sig;
- if (sig & webrtc::SE_READ) {
+ if (sig & SE_READ) {
ReadData(client_ssl_.get());
}
- if (sig & webrtc::SE_WRITE) {
+ if (sig & SE_WRITE) {
WriteData();
}
}
@@ -845,35 +838,35 @@
void OnServerEvent(int sig, int err) {
RTC_LOG(LS_VERBOSE) << "SSLStreamAdapterTestBase::OnServerEvent sig="
<< sig;
- if (sig & webrtc::SE_READ) {
+ if (sig & SE_READ) {
ReadData(server_ssl_.get());
}
}
protected:
- webrtc::SSLIdentity* client_identity() const {
+ SSLIdentity* client_identity() const {
if (!client_ssl_) {
return nullptr;
}
return client_ssl_->GetIdentityForTesting();
}
- webrtc::SSLIdentity* server_identity() const {
+ SSLIdentity* server_identity() const {
if (!server_ssl_) {
return nullptr;
}
return server_ssl_->GetIdentityForTesting();
}
- webrtc::AutoThread main_thread_;
- webrtc::ScopedFakeClock clock_;
+ AutoThread main_thread_;
+ ScopedFakeClock clock_;
std::string client_cert_pem_;
std::string client_private_key_pem_;
- webrtc::KeyParams client_key_type_;
- webrtc::KeyParams server_key_type_;
+ KeyParams client_key_type_;
+ KeyParams server_key_type_;
std::string digest_algorithm_;
size_t digest_length_;
- std::unique_ptr<webrtc::SSLStreamAdapter> client_ssl_;
- std::unique_ptr<webrtc::SSLStreamAdapter> server_ssl_;
+ std::unique_ptr<SSLStreamAdapter> client_ssl_;
+ std::unique_ptr<SSLStreamAdapter> server_ssl_;
int delay_;
size_t mtu_;
size_t max_seen_mtu_ = 0;
@@ -881,14 +874,14 @@
bool lose_first_packet_;
bool damage_;
bool dtls_;
- webrtc::TimeDelta handshake_wait_;
+ TimeDelta handshake_wait_;
bool identities_set_;
};
class SSLStreamAdapterTestDTLSBase : public SSLStreamAdapterTestBase {
public:
- SSLStreamAdapterTestDTLSBase(webrtc::KeyParams param1,
- webrtc::KeyParams param2,
+ SSLStreamAdapterTestDTLSBase(KeyParams param1,
+ KeyParams param2,
std::pair<std::string, size_t> digest)
: SSLStreamAdapterTestBase("", "", true, param1, param2, digest),
packet_size_(1000),
@@ -902,12 +895,12 @@
count_(0),
sent_(0) {}
- std::unique_ptr<webrtc::StreamInterface> CreateClientStream() override final {
+ std::unique_ptr<StreamInterface> CreateClientStream() override final {
return absl::WrapUnique(
new SSLDummyStream(this, "c2s", &client_buffer_, &server_buffer_));
}
- std::unique_ptr<webrtc::StreamInterface> CreateServerStream() override final {
+ std::unique_ptr<StreamInterface> CreateServerStream() override final {
return absl::WrapUnique(
new SSLDummyStream(this, "s2c", &server_buffer_, &client_buffer_));
}
@@ -926,12 +919,12 @@
size_t sent;
int error;
- webrtc::StreamResult rv = client_ssl_->Write(
- webrtc::MakeArrayView(packet, packet_size_), sent, error);
- if (rv == webrtc::SR_SUCCESS) {
+ StreamResult rv =
+ client_ssl_->Write(MakeArrayView(packet, packet_size_), sent, error);
+ if (rv == SR_SUCCESS) {
RTC_LOG(LS_VERBOSE) << "Sent: " << sent_;
sent_++;
- } else if (rv == webrtc::SR_BLOCK) {
+ } else if (rv == SR_BLOCK) {
RTC_LOG(LS_VERBOSE) << "Blocked...";
break;
} else {
@@ -943,26 +936,26 @@
delete[] packet;
}
- void ReadData(webrtc::StreamInterface* stream) override final {
+ void ReadData(StreamInterface* stream) override final {
uint8_t buffer[2000];
size_t bread;
int err2;
- webrtc::StreamResult r;
+ StreamResult r;
for (;;) {
r = stream->Read(buffer, bread, err2);
- if (r == webrtc::SR_ERROR) {
+ if (r == SR_ERROR) {
// Unfortunately, errors are the way that the stream adapter
// signals close right now
stream->Close();
return;
}
- if (r == webrtc::SR_BLOCK)
+ if (r == SR_BLOCK)
break;
- ASSERT_EQ(webrtc::SR_SUCCESS, r);
+ ASSERT_EQ(SR_SUCCESS, r);
RTC_LOG(LS_VERBOSE) << "Read " << bread;
// Now parse the datagram
@@ -984,20 +977,20 @@
WriteData();
- EXPECT_THAT(webrtc::WaitUntil([&] { return sent_; }, ::testing::Eq(count_),
- {.timeout = webrtc::TimeDelta::Millis(10000),
- .clock = &clock_}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(
+ WaitUntil([&] { return sent_; }, ::testing::Eq(count_),
+ {.timeout = TimeDelta::Millis(10000), .clock = &clock_}),
+ IsRtcOk());
RTC_LOG(LS_INFO) << "sent_ == " << sent_;
if (damage_) {
- clock_.AdvanceTime(webrtc::TimeDelta::Millis(2000));
+ clock_.AdvanceTime(TimeDelta::Millis(2000));
EXPECT_EQ(0U, received_.size());
} else if (loss_ == 0) {
- EXPECT_THAT(webrtc::WaitUntil([&] { return received_.size(); },
- ::testing::Eq(static_cast<size_t>(sent_)),
- {.clock = &clock_}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(WaitUntil([&] { return received_.size(); },
+ ::testing::Eq(static_cast<size_t>(sent_)),
+ {.clock = &clock_}),
+ IsRtcOk());
} else {
RTC_LOG(LS_INFO) << "Sent " << sent_ << " packets; received "
<< received_.size();
@@ -1017,10 +1010,9 @@
std::set<int> received_;
};
-webrtc::StreamResult SSLDummyStream::Write(
- webrtc::ArrayView<const uint8_t> data,
- size_t& written,
- int& error) {
+webrtc::StreamResult SSLDummyStream::Write(ArrayView<const uint8_t> data,
+ size_t& written,
+ int& error) {
RTC_LOG(LS_VERBOSE) << "Writing to loopback " << data.size();
if (first_packet_) {
@@ -1028,7 +1020,7 @@
if (test_base_->GetLoseFirstPacket()) {
RTC_LOG(LS_INFO) << "Losing initial packet of length " << data.size();
written = data.size(); // Fake successful writing also to writer.
- return webrtc::SR_SUCCESS;
+ return SR_SUCCESS;
}
}
@@ -1049,12 +1041,12 @@
client_ssl_->SetInitialRetransmissionTimeout(/*timeout_ms=*/1000);
server_ssl_->SetInitialRetransmissionTimeout(/*timeout_ms=*/1000);
- std::unique_ptr<webrtc::SSLIdentity> client_identity;
+ std::unique_ptr<SSLIdentity> client_identity;
if (!client_cert_pem_.empty() && !client_private_key_pem_.empty()) {
- client_identity = webrtc::SSLIdentity::CreateFromPEMStrings(
+ client_identity = SSLIdentity::CreateFromPEMStrings(
client_private_key_pem_, client_cert_pem_);
} else {
- client_identity = webrtc::SSLIdentity::Create("client", client_key_type_);
+ client_identity = SSLIdentity::Create("client", client_key_type_);
}
client_ssl_->SetIdentity(std::move(client_identity));
@@ -1062,11 +1054,11 @@
};
TEST_F(SSLStreamAdapterTestDTLSCertChain, TwoCertHandshake) {
- auto server_identity = webrtc::SSLIdentity::CreateFromPEMChainStrings(
+ auto server_identity = SSLIdentity::CreateFromPEMChainStrings(
kRSA_PRIVATE_KEY_PEM, std::string(kCERT_PEM) + kCACert);
server_ssl_->SetIdentity(std::move(server_identity));
TestHandshake();
- std::unique_ptr<webrtc::SSLCertChain> peer_cert_chain =
+ std::unique_ptr<SSLCertChain> peer_cert_chain =
client_ssl_->GetPeerSSLCertChain();
ASSERT_NE(nullptr, peer_cert_chain);
EXPECT_EQ(kCERT_PEM, peer_cert_chain->Get(0).ToPEMString());
@@ -1079,10 +1071,10 @@
}
TEST_F(SSLStreamAdapterTestDTLSCertChain, TwoCertHandshakeWithCopy) {
- server_ssl_->SetIdentity(webrtc::SSLIdentity::CreateFromPEMChainStrings(
+ server_ssl_->SetIdentity(SSLIdentity::CreateFromPEMChainStrings(
kRSA_PRIVATE_KEY_PEM, std::string(kCERT_PEM) + kCACert));
TestHandshake();
- std::unique_ptr<webrtc::SSLCertChain> peer_cert_chain =
+ std::unique_ptr<SSLCertChain> peer_cert_chain =
client_ssl_->GetPeerSSLCertChain();
ASSERT_NE(nullptr, peer_cert_chain);
EXPECT_EQ(kCERT_PEM, peer_cert_chain->Get(0).ToPEMString());
@@ -1095,10 +1087,10 @@
}
TEST_F(SSLStreamAdapterTestDTLSCertChain, ThreeCertHandshake) {
- server_ssl_->SetIdentity(webrtc::SSLIdentity::CreateFromPEMChainStrings(
+ server_ssl_->SetIdentity(SSLIdentity::CreateFromPEMChainStrings(
kRSA_PRIVATE_KEY_PEM, std::string(kCERT_PEM) + kIntCert1 + kCACert));
TestHandshake();
- std::unique_ptr<webrtc::SSLCertChain> peer_cert_chain =
+ std::unique_ptr<SSLCertChain> peer_cert_chain =
client_ssl_->GetPeerSSLCertChain();
ASSERT_NE(nullptr, peer_cert_chain);
EXPECT_EQ(kCERT_PEM, peer_cert_chain->Get(0).ToPEMString());
@@ -1113,9 +1105,8 @@
class SSLStreamAdapterTestDTLSHandshake
: public SSLStreamAdapterTestDTLSBase,
- public WithParamInterface<tuple<webrtc::KeyParams,
- webrtc::KeyParams,
- std::pair<std::string, size_t>>> {
+ public WithParamInterface<
+ tuple<KeyParams, KeyParams, std::pair<std::string, size_t>>> {
public:
SSLStreamAdapterTestDTLSHandshake()
: SSLStreamAdapterTestDTLSBase(::testing::get<0>(GetParam()),
@@ -1131,8 +1122,7 @@
// Test getting the used DTLS ciphers.
// DTLS 1.2 has different cipher suite than 1.3.
TEST_P(SSLStreamAdapterTestDTLSHandshake, TestGetSslCipherSuite) {
- SetupProtocolVersions(webrtc::SSL_PROTOCOL_DTLS_12,
- webrtc::SSL_PROTOCOL_DTLS_12);
+ SetupProtocolVersions(SSL_PROTOCOL_DTLS_12, SSL_PROTOCOL_DTLS_12);
TestHandshake();
int client_cipher;
@@ -1141,7 +1131,7 @@
ASSERT_TRUE(GetSslCipherSuite(false, &server_cipher));
ASSERT_EQ(client_cipher, server_cipher);
- ASSERT_TRUE(webrtc::SSLStreamAdapter::IsAcceptableCipher(
+ ASSERT_TRUE(SSLStreamAdapter::IsAcceptableCipher(
server_cipher, ::testing::get<1>(GetParam()).type()));
}
@@ -1152,36 +1142,33 @@
INSTANTIATE_TEST_SUITE_P(
SSLStreamAdapterTestDTLSHandshakeKeyParameters,
SSLStreamAdapterTestDTLSHandshake,
- Values(std::make_tuple(webrtc::KeyParams::ECDSA(webrtc::EC_NIST_P256),
- webrtc::KeyParams::RSA(webrtc::kRsaDefaultModSize,
- webrtc::kRsaDefaultExponent),
- std::make_pair(webrtc::DIGEST_SHA_256,
- SHA256_DIGEST_LENGTH)),
- std::make_tuple(
- webrtc::KeyParams::RSA(1152, webrtc::kRsaDefaultExponent),
- webrtc::KeyParams::ECDSA(webrtc::EC_NIST_P256),
- std::make_pair(webrtc::DIGEST_SHA_256, SHA256_DIGEST_LENGTH))));
+ Values(
+ std::make_tuple(KeyParams::ECDSA(EC_NIST_P256),
+ KeyParams::RSA(kRsaDefaultModSize, kRsaDefaultExponent),
+ std::make_pair(DIGEST_SHA_256, SHA256_DIGEST_LENGTH)),
+ std::make_tuple(KeyParams::RSA(1152, kRsaDefaultExponent),
+ KeyParams::ECDSA(EC_NIST_P256),
+ std::make_pair(DIGEST_SHA_256, SHA256_DIGEST_LENGTH))));
INSTANTIATE_TEST_SUITE_P(
SSLStreamAdapterTestDTLSHandshakeSignatureAlgorithms,
SSLStreamAdapterTestDTLSHandshake,
- Combine(Values(webrtc::KeyParams::ECDSA(webrtc::EC_NIST_P256)),
- Values(webrtc::KeyParams::ECDSA(webrtc::EC_NIST_P256)),
- Values(std::make_pair(webrtc::DIGEST_SHA_1, SHA_DIGEST_LENGTH),
- std::make_pair(webrtc::DIGEST_SHA_224, SHA224_DIGEST_LENGTH),
- std::make_pair(webrtc::DIGEST_SHA_256, SHA256_DIGEST_LENGTH),
- std::make_pair(webrtc::DIGEST_SHA_384, SHA384_DIGEST_LENGTH),
- std::make_pair(webrtc::DIGEST_SHA_512,
- SHA512_DIGEST_LENGTH))));
+ Combine(Values(KeyParams::ECDSA(EC_NIST_P256)),
+ Values(KeyParams::ECDSA(EC_NIST_P256)),
+ Values(std::make_pair(DIGEST_SHA_1, SHA_DIGEST_LENGTH),
+ std::make_pair(DIGEST_SHA_224, SHA224_DIGEST_LENGTH),
+ std::make_pair(DIGEST_SHA_256, SHA256_DIGEST_LENGTH),
+ std::make_pair(DIGEST_SHA_384, SHA384_DIGEST_LENGTH),
+ std::make_pair(DIGEST_SHA_512, SHA512_DIGEST_LENGTH))));
// Basic tests done with ECDSA certificates and SHA-256.
class SSLStreamAdapterTestDTLS : public SSLStreamAdapterTestDTLSBase {
public:
SSLStreamAdapterTestDTLS()
: SSLStreamAdapterTestDTLSBase(
- webrtc::KeyParams::ECDSA(webrtc::EC_NIST_P256),
- webrtc::KeyParams::ECDSA(webrtc::EC_NIST_P256),
- std::make_pair(webrtc::DIGEST_SHA_256, SHA256_DIGEST_LENGTH)) {}
+ KeyParams::ECDSA(EC_NIST_P256),
+ KeyParams::ECDSA(EC_NIST_P256),
+ std::make_pair(DIGEST_SHA_256, SHA256_DIGEST_LENGTH)) {}
};
#ifdef OPENSSL_IS_BORINGSSL
@@ -1273,7 +1260,7 @@
// Test DTLS-SRTP with SrtpAes128CmSha1_80
TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpAes128CmSha1_80) {
- const std::vector<int> crypto_suites = {webrtc::kSrtpAes128CmSha1_80};
+ const std::vector<int> crypto_suites = {kSrtpAes128CmSha1_80};
SetDtlsSrtpCryptoSuites(crypto_suites, true);
SetDtlsSrtpCryptoSuites(crypto_suites, false);
TestHandshake();
@@ -1284,12 +1271,12 @@
ASSERT_TRUE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
ASSERT_EQ(client_cipher, server_cipher);
- ASSERT_EQ(client_cipher, webrtc::kSrtpAes128CmSha1_80);
+ ASSERT_EQ(client_cipher, kSrtpAes128CmSha1_80);
}
// Test DTLS-SRTP with SrtpAes128CmSha1_32
TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpAes128CmSha1_32) {
- const std::vector<int> crypto_suites = {webrtc::kSrtpAes128CmSha1_32};
+ const std::vector<int> crypto_suites = {kSrtpAes128CmSha1_32};
SetDtlsSrtpCryptoSuites(crypto_suites, true);
SetDtlsSrtpCryptoSuites(crypto_suites, false);
TestHandshake();
@@ -1300,13 +1287,13 @@
ASSERT_TRUE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
ASSERT_EQ(client_cipher, server_cipher);
- ASSERT_EQ(client_cipher, webrtc::kSrtpAes128CmSha1_32);
+ ASSERT_EQ(client_cipher, kSrtpAes128CmSha1_32);
}
// Test DTLS-SRTP with incompatible cipher suites -- should not converge.
TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpIncompatibleCipherSuites) {
- SetDtlsSrtpCryptoSuites({webrtc::kSrtpAes128CmSha1_80}, true);
- SetDtlsSrtpCryptoSuites({webrtc::kSrtpAes128CmSha1_32}, false);
+ SetDtlsSrtpCryptoSuites({kSrtpAes128CmSha1_80}, true);
+ SetDtlsSrtpCryptoSuites({kSrtpAes128CmSha1_32}, false);
TestHandshake();
int client_cipher;
@@ -1318,8 +1305,8 @@
// Test DTLS-SRTP with each side being mixed -- should select the stronger
// cipher.
TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpMixed) {
- const std::vector<int> crypto_suites = {webrtc::kSrtpAes128CmSha1_80,
- webrtc::kSrtpAes128CmSha1_32};
+ const std::vector<int> crypto_suites = {kSrtpAes128CmSha1_80,
+ kSrtpAes128CmSha1_32};
SetDtlsSrtpCryptoSuites(crypto_suites, true);
SetDtlsSrtpCryptoSuites(crypto_suites, false);
TestHandshake();
@@ -1330,12 +1317,12 @@
ASSERT_TRUE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
ASSERT_EQ(client_cipher, server_cipher);
- ASSERT_EQ(client_cipher, webrtc::kSrtpAes128CmSha1_80);
+ ASSERT_EQ(client_cipher, kSrtpAes128CmSha1_80);
}
// Test DTLS-SRTP with SrtpAeadAes128Gcm.
TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpAeadAes128Gcm) {
- std::vector<int> crypto_suites = {webrtc::kSrtpAeadAes128Gcm};
+ std::vector<int> crypto_suites = {kSrtpAeadAes128Gcm};
SetDtlsSrtpCryptoSuites(crypto_suites, true);
SetDtlsSrtpCryptoSuites(crypto_suites, false);
TestHandshake();
@@ -1346,12 +1333,12 @@
ASSERT_TRUE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
ASSERT_EQ(client_cipher, server_cipher);
- ASSERT_EQ(client_cipher, webrtc::kSrtpAeadAes128Gcm);
+ ASSERT_EQ(client_cipher, kSrtpAeadAes128Gcm);
}
// Test DTLS-SRTP with all GCM-256 ciphers.
TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpGCM256) {
- std::vector<int> crypto_suites = {webrtc::kSrtpAeadAes256Gcm};
+ std::vector<int> crypto_suites = {kSrtpAeadAes256Gcm};
SetDtlsSrtpCryptoSuites(crypto_suites, true);
SetDtlsSrtpCryptoSuites(crypto_suites, false);
TestHandshake();
@@ -1362,13 +1349,13 @@
ASSERT_TRUE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
ASSERT_EQ(client_cipher, server_cipher);
- ASSERT_EQ(client_cipher, webrtc::kSrtpAeadAes256Gcm);
+ ASSERT_EQ(client_cipher, kSrtpAeadAes256Gcm);
}
// Test DTLS-SRTP with incompatbile GCM-128/-256 ciphers -- should not converge.
TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpIncompatibleGcmCipherSuites) {
- SetDtlsSrtpCryptoSuites({webrtc::kSrtpAeadAes128Gcm}, true);
- SetDtlsSrtpCryptoSuites({webrtc::kSrtpAeadAes256Gcm}, false);
+ SetDtlsSrtpCryptoSuites({kSrtpAeadAes128Gcm}, true);
+ SetDtlsSrtpCryptoSuites({kSrtpAeadAes256Gcm}, false);
TestHandshake();
int client_cipher;
@@ -1379,8 +1366,7 @@
// Test DTLS-SRTP with both GCM-128/-256 ciphers -- should select GCM-256.
TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpGCMMixed) {
- std::vector<int> crypto_suites = {webrtc::kSrtpAeadAes256Gcm,
- webrtc::kSrtpAeadAes128Gcm};
+ std::vector<int> crypto_suites = {kSrtpAeadAes256Gcm, kSrtpAeadAes128Gcm};
SetDtlsSrtpCryptoSuites(crypto_suites, true);
SetDtlsSrtpCryptoSuites(crypto_suites, false);
TestHandshake();
@@ -1391,7 +1377,7 @@
ASSERT_TRUE(GetDtlsSrtpCryptoSuite(false, &server_cipher));
ASSERT_EQ(client_cipher, server_cipher);
- ASSERT_EQ(client_cipher, webrtc::kSrtpAeadAes256Gcm);
+ ASSERT_EQ(client_cipher, kSrtpAeadAes256Gcm);
}
// Test SRTP cipher suite lengths.
@@ -1399,33 +1385,33 @@
int key_len;
int salt_len;
- ASSERT_FALSE(webrtc::GetSrtpKeyAndSaltLengths(webrtc::kSrtpInvalidCryptoSuite,
- &key_len, &salt_len));
+ ASSERT_FALSE(
+ GetSrtpKeyAndSaltLengths(kSrtpInvalidCryptoSuite, &key_len, &salt_len));
- ASSERT_TRUE(webrtc::GetSrtpKeyAndSaltLengths(webrtc::kSrtpAes128CmSha1_32,
- &key_len, &salt_len));
+ ASSERT_TRUE(
+ GetSrtpKeyAndSaltLengths(kSrtpAes128CmSha1_32, &key_len, &salt_len));
ASSERT_EQ(128 / 8, key_len);
ASSERT_EQ(112 / 8, salt_len);
- ASSERT_TRUE(webrtc::GetSrtpKeyAndSaltLengths(webrtc::kSrtpAes128CmSha1_80,
- &key_len, &salt_len));
+ ASSERT_TRUE(
+ GetSrtpKeyAndSaltLengths(kSrtpAes128CmSha1_80, &key_len, &salt_len));
ASSERT_EQ(128 / 8, key_len);
ASSERT_EQ(112 / 8, salt_len);
- ASSERT_TRUE(webrtc::GetSrtpKeyAndSaltLengths(webrtc::kSrtpAeadAes128Gcm,
- &key_len, &salt_len));
+ ASSERT_TRUE(
+ GetSrtpKeyAndSaltLengths(kSrtpAeadAes128Gcm, &key_len, &salt_len));
ASSERT_EQ(128 / 8, key_len);
ASSERT_EQ(96 / 8, salt_len);
- ASSERT_TRUE(webrtc::GetSrtpKeyAndSaltLengths(webrtc::kSrtpAeadAes256Gcm,
- &key_len, &salt_len));
+ ASSERT_TRUE(
+ GetSrtpKeyAndSaltLengths(kSrtpAeadAes256Gcm, &key_len, &salt_len));
ASSERT_EQ(256 / 8, key_len);
ASSERT_EQ(96 / 8, salt_len);
}
// Test the DTLS-SRTP key exporter
TEST_F(SSLStreamAdapterTestDTLS, TestDTLSSrtpExporter) {
- const std::vector<int> crypto_suites = {webrtc::kSrtpAes128CmSha1_80};
+ const std::vector<int> crypto_suites = {kSrtpAes128CmSha1_80};
SetDtlsSrtpCryptoSuites(crypto_suites, true);
SetDtlsSrtpCryptoSuites(crypto_suites, false);
@@ -1434,10 +1420,10 @@
EXPECT_TRUE(GetDtlsSrtpCryptoSuite(/*client=*/false, &selected_crypto_suite));
int key_len;
int salt_len;
- ASSERT_TRUE(webrtc::GetSrtpKeyAndSaltLengths(selected_crypto_suite, &key_len,
- &salt_len));
- webrtc::ZeroOnFreeBuffer<uint8_t> client_out(2 * (key_len + salt_len));
- webrtc::ZeroOnFreeBuffer<uint8_t> server_out(2 * (key_len + salt_len));
+ ASSERT_TRUE(
+ GetSrtpKeyAndSaltLengths(selected_crypto_suite, &key_len, &salt_len));
+ ZeroOnFreeBuffer<uint8_t> client_out(2 * (key_len + salt_len));
+ ZeroOnFreeBuffer<uint8_t> server_out(2 * (key_len + salt_len));
EXPECT_TRUE(client_ssl_->ExportSrtpKeyingMaterial(client_out));
EXPECT_TRUE(server_ssl_->ExportSrtpKeyingMaterial(server_out));
@@ -1482,8 +1468,7 @@
TestHandshake();
// The client should have a peer certificate after the handshake.
- std::unique_ptr<webrtc::SSLCertificate> client_peer_cert =
- GetPeerCertificate(true);
+ std::unique_ptr<SSLCertificate> client_peer_cert = GetPeerCertificate(true);
ASSERT_TRUE(client_peer_cert);
// It's not kCERT_PEM.
@@ -1491,8 +1476,7 @@
ASSERT_NE(kCERT_PEM, client_peer_string);
// The server should have a peer certificate after the handshake.
- std::unique_ptr<webrtc::SSLCertificate> server_peer_cert =
- GetPeerCertificate(false);
+ std::unique_ptr<SSLCertificate> server_peer_cert = GetPeerCertificate(false);
ASSERT_TRUE(server_peer_cert);
// It's kCERT_PEM
@@ -1503,23 +1487,22 @@
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
TEST_F(SSLStreamAdapterTestDTLSFromPEMStrings,
DeprecatedSetPeerCertificateDigest) {
- webrtc::SSLPeerCertificateDigestError error;
+ SSLPeerCertificateDigestError error;
// Pass in a wrong length to trigger an error.
- bool ret = client_ssl_->SetPeerCertificateDigest(webrtc::DIGEST_SHA_256, {},
+ bool ret = client_ssl_->SetPeerCertificateDigest(DIGEST_SHA_256, {},
/*length=*/0, &error);
EXPECT_FALSE(ret);
- EXPECT_EQ(error, webrtc::SSLPeerCertificateDigestError::INVALID_LENGTH);
+ EXPECT_EQ(error, SSLPeerCertificateDigestError::INVALID_LENGTH);
}
#pragma clang diagnostic pop
struct SSLStreamAdapterTestDTLSHandshakeVersion
: public SSLStreamAdapterTestDTLS,
public WithParamInterface<std::tuple<
- /* client*/ webrtc::SSLProtocolVersion,
- /* server*/ webrtc::SSLProtocolVersion>> {
- webrtc::SSLProtocolVersion GetMin(
- const std::vector<webrtc::SSLProtocolVersion>& array) {
- webrtc::SSLProtocolVersion min = array[0];
+ /* client*/ SSLProtocolVersion,
+ /* server*/ SSLProtocolVersion>> {
+ SSLProtocolVersion GetMin(const std::vector<SSLProtocolVersion>& array) {
+ SSLProtocolVersion min = array[0];
for (const auto& e : array) {
if (static_cast<int>(e) < static_cast<int>(min)) {
min = e;
@@ -1527,14 +1510,14 @@
}
return min;
}
- uint16_t AsDtlsVersionBytes(webrtc::SSLProtocolVersion version) {
+ uint16_t AsDtlsVersionBytes(SSLProtocolVersion version) {
switch (version) {
- case webrtc::SSL_PROTOCOL_DTLS_10:
- return webrtc::kDtls10VersionBytes;
- case webrtc::SSL_PROTOCOL_DTLS_12:
- return webrtc::kDtls12VersionBytes;
- case webrtc::SSL_PROTOCOL_DTLS_13:
- return webrtc::kDtls13VersionBytes;
+ case SSL_PROTOCOL_DTLS_10:
+ return kDtls10VersionBytes;
+ case SSL_PROTOCOL_DTLS_12:
+ return kDtls12VersionBytes;
+ case SSL_PROTOCOL_DTLS_13:
+ return kDtls13VersionBytes;
default:
break;
}
@@ -1542,12 +1525,11 @@
}
};
-INSTANTIATE_TEST_SUITE_P(SSLStreamAdapterTestDTLSHandshakeVersion,
- SSLStreamAdapterTestDTLSHandshakeVersion,
- Combine(Values(webrtc::SSL_PROTOCOL_DTLS_12,
- webrtc::SSL_PROTOCOL_DTLS_13),
- Values(webrtc::SSL_PROTOCOL_DTLS_12,
- webrtc::SSL_PROTOCOL_DTLS_13)));
+INSTANTIATE_TEST_SUITE_P(
+ SSLStreamAdapterTestDTLSHandshakeVersion,
+ SSLStreamAdapterTestDTLSHandshakeVersion,
+ Combine(Values(SSL_PROTOCOL_DTLS_12, SSL_PROTOCOL_DTLS_13),
+ Values(SSL_PROTOCOL_DTLS_12, SSL_PROTOCOL_DTLS_13)));
TEST_P(SSLStreamAdapterTestDTLSHandshakeVersion, TestGetSslVersionBytes) {
auto client = ::testing::get<0>(GetParam());
@@ -1560,9 +1542,8 @@
ASSERT_TRUE(GetSslVersionBytes(true, &client_version));
ASSERT_TRUE(GetSslVersionBytes(false, &server_version));
- webrtc::SSLProtocolVersion expect =
- GetMin({client, server,
- webrtc::SSLStreamAdapter::GetMaxSupportedDTLSProtocolVersion()});
+ SSLProtocolVersion expect = GetMin(
+ {client, server, SSLStreamAdapter::GetMaxSupportedDTLSProtocolVersion()});
auto expect_bytes = AsDtlsVersionBytes(expect);
EXPECT_EQ(client_version, expect_bytes);
@@ -1581,8 +1562,7 @@
ASSERT_TRUE(GetSslCipherSuite(false, &server_cipher));
ASSERT_EQ(client_cipher, server_cipher);
- ASSERT_TRUE(webrtc::SSLStreamAdapter::IsAcceptableCipher(server_cipher,
- webrtc::KT_DEFAULT));
+ ASSERT_TRUE(SSLStreamAdapter::IsAcceptableCipher(server_cipher, KT_DEFAULT));
}
#ifdef OPENSSL_IS_BORINGSSL
@@ -1591,15 +1571,15 @@
auto server_version = ::testing::get<1>(GetParam());
SetupProtocolVersions(client_version, server_version);
- webrtc::CryptoOptions::EphemeralKeyExchangeCipherGroups groups;
+ CryptoOptions::EphemeralKeyExchangeCipherGroups groups;
std::vector<uint16_t> enabled = groups.GetEnabled();
std::vector<uint16_t> groups_with_pqc;
- if (std::find(enabled.begin(), enabled.end(),
- webrtc::CryptoOptions::EphemeralKeyExchangeCipherGroups::
- kX25519_MLKEM768) == enabled.end()) {
+ if (std::find(
+ enabled.begin(), enabled.end(),
+ CryptoOptions::EphemeralKeyExchangeCipherGroups::kX25519_MLKEM768) ==
+ enabled.end()) {
groups_with_pqc.push_back(
- webrtc::CryptoOptions::EphemeralKeyExchangeCipherGroups::
- kX25519_MLKEM768);
+ CryptoOptions::EphemeralKeyExchangeCipherGroups::kX25519_MLKEM768);
}
for (auto val : enabled) {
groups_with_pqc.push_back(val);
@@ -1611,19 +1591,19 @@
EXPECT_EQ(server_ssl_->GetSslGroupId(), 0);
TestHandshake();
- if (client_version == webrtc::SSL_PROTOCOL_DTLS_13 &&
- server_version == webrtc::SSL_PROTOCOL_DTLS_13) {
- EXPECT_EQ(client_ssl_->GetSslGroupId(),
- webrtc::CryptoOptions::EphemeralKeyExchangeCipherGroups::
- kX25519_MLKEM768);
- EXPECT_EQ(server_ssl_->GetSslGroupId(),
- webrtc::CryptoOptions::EphemeralKeyExchangeCipherGroups::
- kX25519_MLKEM768);
+ if (client_version == SSL_PROTOCOL_DTLS_13 &&
+ server_version == SSL_PROTOCOL_DTLS_13) {
+ EXPECT_EQ(
+ client_ssl_->GetSslGroupId(),
+ CryptoOptions::EphemeralKeyExchangeCipherGroups::kX25519_MLKEM768);
+ EXPECT_EQ(
+ server_ssl_->GetSslGroupId(),
+ CryptoOptions::EphemeralKeyExchangeCipherGroups::kX25519_MLKEM768);
} else {
EXPECT_EQ(client_ssl_->GetSslGroupId(),
- webrtc::CryptoOptions::EphemeralKeyExchangeCipherGroups::kX25519);
+ CryptoOptions::EphemeralKeyExchangeCipherGroups::kX25519);
EXPECT_EQ(server_ssl_->GetSslGroupId(),
- webrtc::CryptoOptions::EphemeralKeyExchangeCipherGroups::kX25519);
+ CryptoOptions::EphemeralKeyExchangeCipherGroups::kX25519);
}
}
#endif
diff --git a/rtc_base/stream.h b/rtc_base/stream.h
index 9bee2be..938f70c 100644
--- a/rtc_base/stream.h
+++ b/rtc_base/stream.h
@@ -140,7 +140,7 @@
}
RTC_NO_UNIQUE_ADDRESS SequenceChecker callback_sequence_{
- webrtc::SequenceChecker::kDetached};
+ SequenceChecker::kDetached};
private:
absl::AnyInvocable<void(int, int)> callback_
diff --git a/rtc_base/string_encode.h b/rtc_base/string_encode.h
index 4d6fc0c..d1f03e3 100644
--- a/rtc_base/string_encode.h
+++ b/rtc_base/string_encode.h
@@ -75,7 +75,7 @@
int>::type = 0>
static bool FromString(absl::string_view s, T* t) {
RTC_DCHECK(t);
- std::optional<T> result = webrtc::StringToNumber<T>(s);
+ std::optional<T> result = StringToNumber<T>(s);
if (result)
*t = *result;
diff --git a/rtc_base/string_utils.h b/rtc_base/string_utils.h
index ca2607b..3c6d190 100644
--- a/rtc_base/string_utils.h
+++ b/rtc_base/string_utils.h
@@ -37,7 +37,7 @@
// std::map that support heterogenous lookup.
//
// Example usage:
-// std::map<std::string, int, webrtc::AbslStringViewCmp> my_map;
+// std::map<std::string, int, AbslStringViewCmp> my_map;
struct AbslStringViewCmp {
using is_transparent = void;
bool operator()(absl::string_view a, absl::string_view b) const {
diff --git a/rtc_base/system_time.cc b/rtc_base/system_time.cc
index c6a9b7b..83a08f6 100644
--- a/rtc_base/system_time.cc
+++ b/rtc_base/system_time.cc
@@ -56,7 +56,7 @@
RTC_DCHECK_NE(b, 0);
RTC_DCHECK_LE(a, std::numeric_limits<int64_t>::max() / b)
<< "The multiplication " << a << " * " << b << " overflows";
- return webrtc::dchecked_cast<int64_t>(a * b);
+ return dchecked_cast<int64_t>(a * b);
};
ticks = mul(mach_absolute_time(), timebase.numer) / timebase.denom;
#elif defined(WEBRTC_POSIX)
@@ -90,7 +90,7 @@
ticks = now + (num_wrap_timegettime << 32);
// TODO(deadbeef): Calculate with nanosecond precision. Otherwise, we're
// just wasting a multiply and divide when doing Time() on Windows.
- ticks = ticks * webrtc::kNumNanosecsPerMillisec;
+ ticks = ticks * kNumNanosecsPerMillisec;
#pragma clang diagnostic pop
#else
#error Unsupported platform.
diff --git a/rtc_base/task_queue_for_test.h b/rtc_base/task_queue_for_test.h
index 2f1ca08..cdbf925 100644
--- a/rtc_base/task_queue_for_test.h
+++ b/rtc_base/task_queue_for_test.h
@@ -52,21 +52,19 @@
// Returns non-owning pointer to the task queue implementation.
TaskQueueBase* Get() { return impl_.get(); }
- void PostTask(
- absl::AnyInvocable<void() &&> task,
- const webrtc::Location& location = webrtc::Location::Current()) {
+ void PostTask(absl::AnyInvocable<void() &&> task,
+ const Location& location = Location::Current()) {
impl_->PostTask(std::move(task), location);
}
- void PostDelayedTask(
- absl::AnyInvocable<void() &&> task,
- webrtc::TimeDelta delay,
- const webrtc::Location& location = webrtc::Location::Current()) {
+ void PostDelayedTask(absl::AnyInvocable<void() &&> task,
+ TimeDelta delay,
+ const Location& location = Location::Current()) {
impl_->PostDelayedTask(std::move(task), delay, location);
}
void PostDelayedHighPrecisionTask(
absl::AnyInvocable<void() &&> task,
- webrtc::TimeDelta delay,
- const webrtc::Location& location = webrtc::Location::Current()) {
+ TimeDelta delay,
+ const Location& location = Location::Current()) {
impl_->PostDelayedHighPrecisionTask(std::move(task), delay, location);
}
diff --git a/rtc_base/task_queue_win.cc b/rtc_base/task_queue_win.cc
index 67aa8fe..490ea83 100644
--- a/rtc_base/task_queue_win.cc
+++ b/rtc_base/task_queue_win.cc
@@ -50,7 +50,7 @@
void CALLBACK InitializeQueueThread(ULONG_PTR param) {
MSG msg;
::PeekMessage(&msg, nullptr, WM_USER, WM_USER, PM_NOREMOVE);
- webrtc::Event* data = reinterpret_cast<webrtc::Event*>(param);
+ Event* data = reinterpret_cast<Event*>(param);
data->Set();
}
@@ -197,9 +197,9 @@
ThreadPriority priority)
: in_queue_(::CreateEvent(nullptr, true, false, nullptr)) {
RTC_DCHECK(in_queue_);
- thread_ = webrtc::PlatformThread::SpawnJoinable(
- [this] { RunThreadMain(); }, queue_name,
- webrtc::ThreadAttributes().SetPriority(priority));
+ thread_ =
+ PlatformThread::SpawnJoinable([this] { RunThreadMain(); }, queue_name,
+ ThreadAttributes().SetPriority(priority));
Event event(false, false);
RTC_CHECK(thread_.QueueAPC(&InitializeQueueThread,
diff --git a/rtc_base/thread.cc b/rtc_base/thread.cc
index 6599615..815ac34 100644
--- a/rtc_base/thread.cc
+++ b/rtc_base/thread.cc
@@ -906,7 +906,7 @@
: Thread(CreateDefaultSocketServer(), /*do_init=*/false) {
if (!ThreadManager::Instance()->CurrentThread()) {
// DoInit registers with ThreadManager. Do that only if we intend to
- // be webrtc::Thread::Current(), otherwise ProcessAllMessageQueuesInternal
+ // be Thread::Current(), otherwise ProcessAllMessageQueuesInternal
// will post a message to a queue that no running thread is serving.
DoInit();
ThreadManager::Instance()->SetCurrentThread(this);
diff --git a/rtc_base/thread.h b/rtc_base/thread.h
index 69c74fe..ef970b4 100644
--- a/rtc_base/thread.h
+++ b/rtc_base/thread.h
@@ -366,7 +366,7 @@
// These functions are public to avoid injecting test hooks. Don't call them
// outside of tests.
// This method should be called when thread is created using non standard
- // method, like derived implementation of webrtc::Thread and it can not be
+ // method, like derived implementation of Thread and it can not be
// started by calling Start(). This will set started flag to true and
// owned to false. This must be called from the current thread.
bool WrapCurrent();
diff --git a/rtc_base/time_utils.h b/rtc_base/time_utils.h
index 30cb8b8..d4dbb2b 100644
--- a/rtc_base/time_utils.h
+++ b/rtc_base/time_utils.h
@@ -127,7 +127,7 @@
// Note that this function obeys the system's idea about what the time
// is. It is not guaranteed to be monotonic; it will jump in case the
// system time is changed, e.g., by some other process calling
-// settimeofday. Always use webrtc::TimeMicros(), not this function, for
+// settimeofday. Always use TimeMicros(), not this function, for
// measuring time intervals and timeouts.
RTC_EXPORT int64_t TimeUTCMicros();
diff --git a/rtc_base/timestamp_aligner.h b/rtc_base/timestamp_aligner.h
index d060a35..a3eda6c 100644
--- a/rtc_base/timestamp_aligner.h
+++ b/rtc_base/timestamp_aligner.h
@@ -19,13 +19,13 @@
namespace webrtc {
// The TimestampAligner class helps translating timestamps of a capture system
-// into the same timescale as is used by webrtc::TimeMicros(). Some capture
+// into the same timescale as is used by TimeMicros(). Some capture
// systems provide timestamps, which comes from the capturing hardware (camera
// or sound card) or stamped close to the capturing hardware. Such timestamps
// are more accurate (less jittery) than reading the system clock, but may have
// a different epoch and unknown clock drift. Frame timestamps in webrtc should
-// use webrtc::TimeMicros (system monotonic time), and this class provides a
-// filter which lets us use the webrtc::TimeMicros timescale, and at the same
+// use TimeMicros (system monotonic time), and this class provides a
+// filter which lets us use the TimeMicros timescale, and at the same
// time take advantage of higher accuracy of the capturer's clock.
// This class is not thread safe, so all calls to it must be synchronized
@@ -46,9 +46,9 @@
static constexpr int64_t kMinFrameIntervalUs = kNumMicrosecsPerMillisec;
// Translates timestamps of a capture system to the same timescale as is used
- // by webrtc::TimeMicros(). `capturer_time_us` is assumed to be accurate, but
+ // by TimeMicros(). `capturer_time_us` is assumed to be accurate, but
// with an unknown epoch and clock drift. `system_time_us` is
- // time according to webrtc::TimeMicros(), preferably read as soon as
+ // time according to TimeMicros(), preferably read as soon as
// possible when the frame is captured. It may have poor accuracy
// due to poor resolution or scheduling delays. Returns the
// translated timestamp.
diff --git a/rtc_base/unique_id_generator.h b/rtc_base/unique_id_generator.h
index 5fe3366..7047c15 100644
--- a/rtc_base/unique_id_generator.h
+++ b/rtc_base/unique_id_generator.h
@@ -54,7 +54,7 @@
private:
RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_{
- webrtc::SequenceChecker::kDetached};
+ SequenceChecker::kDetached};
static_assert(std::is_integral<TIntegral>::value, "Must be integral type.");
TIntegral counter_ RTC_GUARDED_BY(sequence_checker_);
std::set<TIntegral> known_ids_ RTC_GUARDED_BY(sequence_checker_);
diff --git a/rtc_base/win32.cc b/rtc_base/win32.cc
index d7105fc6..a505017 100644
--- a/rtc_base/win32.cc
+++ b/rtc_base/win32.cc
@@ -137,7 +137,7 @@
for (int i = 0; i < run_array_size; ++i) {
if (runpos[i] == -1) {
cursor += snprintf(cursor, INET6_ADDRSTRLEN - (cursor - dst), "%x",
- webrtc::NetworkToHost16(as_shorts[i]));
+ NetworkToHost16(as_shorts[i]));
if (i != 7 && runpos[i + 1] != 1) {
*cursor++ = ':';
}
@@ -292,7 +292,7 @@
if (sscanf(readcursor, "%4hx%n", &word, &bytesread) != 1) {
return 0;
} else {
- *addr_cursor = webrtc::HostToNetwork16(word);
+ *addr_cursor = HostToNetwork16(word);
++addr_cursor;
readcursor += bytesread;
if (*readcursor != ':' && *readcursor != '\0') {
