Move tests and fakes to webrtc namespace
- fake_video_renderer.h
- mock_channel_interface.h
- fake_network.h
- test_utils.h
- fake_webrtc_call.h
- fake_clock.h
- srtp_test_util.h
- fake_dtls_transport.h
- fake_network_interface.h
- fake_frame_source.h
- mock_packet_socket_factory.h
- fake_ssl_identity.h
Bug: webrtc:42232595
Change-Id: Ia363a95b7956d7c92fb87e4cf684bffe92c81409
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/381403
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44141}
diff --git a/api/test/mock_packet_socket_factory.h b/api/test/mock_packet_socket_factory.h
index 0e4a42c..0974297 100644
--- a/api/test/mock_packet_socket_factory.h
+++ b/api/test/mock_packet_socket_factory.h
@@ -21,24 +21,24 @@
#include "rtc_base/socket_address.h"
#include "test/gmock.h"
-namespace rtc {
-class MockPacketSocketFactory : public PacketSocketFactory {
+namespace webrtc {
+class MockPacketSocketFactory : public rtc::PacketSocketFactory {
public:
- MOCK_METHOD(AsyncPacketSocket*,
+ MOCK_METHOD(rtc::AsyncPacketSocket*,
CreateUdpSocket,
- (const webrtc::SocketAddress&, uint16_t, uint16_t),
+ (const SocketAddress&, uint16_t, uint16_t),
(override));
- MOCK_METHOD(AsyncListenSocket*,
+ MOCK_METHOD(rtc::AsyncListenSocket*,
CreateServerTcpSocket,
- (const webrtc::SocketAddress&, uint16_t, uint16_t, int opts),
+ (const SocketAddress&, uint16_t, uint16_t, int opts),
(override));
- MOCK_METHOD(AsyncPacketSocket*,
+ MOCK_METHOD(rtc::AsyncPacketSocket*,
CreateClientTcpSocket,
- (const webrtc::SocketAddress& local_address,
- const webrtc::SocketAddress&,
- const PacketSocketTcpOptions&),
+ (const SocketAddress& local_address,
+ const SocketAddress&,
+ const rtc::PacketSocketTcpOptions&),
(override));
- MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
+ MOCK_METHOD(std::unique_ptr<AsyncDnsResolverInterface>,
CreateAsyncDnsResolver,
(),
(override));
@@ -46,6 +46,12 @@
static_assert(!std::is_abstract_v<MockPacketSocketFactory>, "");
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::MockPacketSocketFactory;
} // namespace rtc
#endif // API_TEST_MOCK_PACKET_SOCKET_FACTORY_H_
diff --git a/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc b/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc
index c08b3e4..2d87df8 100644
--- a/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc
+++ b/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc
@@ -555,7 +555,7 @@
CheckLastEncoderName(expected_name);
}
- rtc::ScopedFakeClock clock_;
+ ScopedFakeClock clock_;
};
class ForcedFallbackTestEnabled : public ForcedFallbackTest {
diff --git a/common_audio/smoothing_filter_unittest.cc b/common_audio/smoothing_filter_unittest.cc
index 47f6c71..01bfa56 100644
--- a/common_audio/smoothing_filter_unittest.cc
+++ b/common_audio/smoothing_filter_unittest.cc
@@ -28,7 +28,7 @@
: smoothing_filter(init_time_ms) {
fake_clock.AdvanceTime(TimeDelta::Millis(kClockInitialTime));
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
SmoothingFilterImpl smoothing_filter;
};
diff --git a/common_video/bitrate_adjuster_unittest.cc b/common_video/bitrate_adjuster_unittest.cc
index 995aac1..1ff911c 100644
--- a/common_video/bitrate_adjuster_unittest.cc
+++ b/common_video/bitrate_adjuster_unittest.cc
@@ -64,7 +64,7 @@
protected:
static const float kMinAdjustedBitratePct;
static const float kMaxAdjustedBitratePct;
- rtc::ScopedFakeClock clock_;
+ ScopedFakeClock clock_;
BitrateAdjuster adjuster_;
};
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
index 8043619..af0c2c2 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
@@ -972,7 +972,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
@@ -1012,7 +1012,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
@@ -1052,7 +1052,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
@@ -1092,7 +1092,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
@@ -1131,7 +1131,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
@@ -1170,7 +1170,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
@@ -1209,7 +1209,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
@@ -1248,7 +1248,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
@@ -1287,7 +1287,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
@@ -1329,7 +1329,7 @@
return;
}
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
std::unique_ptr<RtcEventLogEncoder> encoder = CreateEncoder();
diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc
index eafe857..6c57e9d 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest.cc
@@ -234,7 +234,7 @@
const RtcEventLog::EncodingType encoding_type_;
test::EventGenerator gen_;
test::EventVerifier verifier_;
- rtc::ScopedFakeClock clock_;
+ ScopedFakeClock clock_;
std::string temp_filename_;
MemoryLogStorage log_storage_;
std::unique_ptr<LogWriterFactoryInterface> log_output_factory_;
@@ -952,8 +952,8 @@
std::replace(test_name.begin(), test_name.end(), '/', '_');
const std::string temp_filename = test::OutputPath() + test_name;
- std::unique_ptr<rtc::ScopedFakeClock> fake_clock =
- std::make_unique<rtc::ScopedFakeClock>();
+ std::unique_ptr<ScopedFakeClock> fake_clock =
+ std::make_unique<ScopedFakeClock>();
fake_clock->SetTime(Timestamp::Seconds(kStartTimeSeconds));
// Create a scope for the TQ and event log factories.
@@ -1017,7 +1017,7 @@
// recreate the clock. However we must ensure that the old fake_clock is
// destroyed before the new one is created, so we have to reset() first.
fake_clock.reset();
- fake_clock = std::make_unique<rtc::ScopedFakeClock>();
+ fake_clock = std::make_unique<ScopedFakeClock>();
fake_clock->SetTime(Timestamp::Millis(first_timestamp_ms));
for (size_t i = 1; i < probe_success_events.size(); i++) {
fake_clock->AdvanceTime(TimeDelta::Millis(10));
diff --git a/media/base/fake_frame_source.cc b/media/base/fake_frame_source.cc
index 61bc585..a94de3b 100644
--- a/media/base/fake_frame_source.cc
+++ b/media/base/fake_frame_source.cc
@@ -16,7 +16,7 @@
#include "rtc_base/checks.h"
#include "rtc_base/time_utils.h"
-namespace cricket {
+namespace webrtc {
FakeFrameSource::FakeFrameSource(int width,
int height,
@@ -35,15 +35,15 @@
FakeFrameSource::FakeFrameSource(int width, int height, int interval_us)
: FakeFrameSource(width, height, interval_us, rtc::TimeMicros()) {}
-webrtc::VideoRotation FakeFrameSource::GetRotation() const {
+VideoRotation FakeFrameSource::GetRotation() const {
return rotation_;
}
-void FakeFrameSource::SetRotation(webrtc::VideoRotation rotation) {
+void FakeFrameSource::SetRotation(VideoRotation rotation) {
rotation_ = rotation;
}
-webrtc::VideoFrame FakeFrameSource::GetFrameRotationApplied() {
+VideoFrame FakeFrameSource::GetFrameRotationApplied() {
switch (rotation_) {
case webrtc::kVideoRotation_0:
case webrtc::kVideoRotation_180:
@@ -59,30 +59,29 @@
return GetFrame();
}
-webrtc::VideoFrame FakeFrameSource::GetFrame() {
+VideoFrame FakeFrameSource::GetFrame() {
return GetFrame(width_, height_, rotation_, interval_us_);
}
-webrtc::VideoFrame FakeFrameSource::GetFrame(int width,
- int height,
- webrtc::VideoRotation rotation,
- int interval_us) {
+VideoFrame FakeFrameSource::GetFrame(int width,
+ int height,
+ VideoRotation rotation,
+ int interval_us) {
RTC_CHECK_GT(width, 0);
RTC_CHECK_GT(height, 0);
RTC_CHECK_GT(interval_us, 0);
- rtc::scoped_refptr<webrtc::I420Buffer> buffer(
- webrtc::I420Buffer::Create(width, height));
+ scoped_refptr<I420Buffer> buffer(I420Buffer::Create(width, height));
buffer->InitializeData();
- webrtc::VideoFrame frame = webrtc::VideoFrame::Builder()
- .set_video_frame_buffer(buffer)
- .set_rotation(rotation)
- .set_timestamp_us(next_timestamp_us_)
- .build();
+ VideoFrame frame = VideoFrame::Builder()
+ .set_video_frame_buffer(buffer)
+ .set_rotation(rotation)
+ .set_timestamp_us(next_timestamp_us_)
+ .build();
next_timestamp_us_ += interval_us;
return frame;
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/media/base/fake_frame_source.h b/media/base/fake_frame_source.h
index 4c56204..e1bd0b2 100644
--- a/media/base/fake_frame_source.h
+++ b/media/base/fake_frame_source.h
@@ -14,7 +14,7 @@
#include "api/video/video_frame.h"
#include "rtc_base/time_utils.h"
-namespace cricket {
+namespace webrtc {
class FakeFrameSource {
public:
@@ -24,27 +24,33 @@
int64_t timestamp_offset_us);
FakeFrameSource(int width, int height, int interval_us);
- webrtc::VideoRotation GetRotation() const;
- void SetRotation(webrtc::VideoRotation rotation);
+ VideoRotation GetRotation() const;
+ void SetRotation(VideoRotation rotation);
- webrtc::VideoFrame GetFrame();
- webrtc::VideoFrame GetFrameRotationApplied();
+ VideoFrame GetFrame();
+ VideoFrame GetFrameRotationApplied();
// Override configuration.
- webrtc::VideoFrame GetFrame(int width,
- int height,
- webrtc::VideoRotation rotation,
- int interval_us);
+ VideoFrame GetFrame(int width,
+ int height,
+ VideoRotation rotation,
+ int interval_us);
private:
const int width_;
const int height_;
const int interval_us_;
- webrtc::VideoRotation rotation_ = webrtc::kVideoRotation_0;
+ VideoRotation rotation_ = webrtc::kVideoRotation_0;
int64_t next_timestamp_us_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::FakeFrameSource;
} // namespace cricket
#endif // MEDIA_BASE_FAKE_FRAME_SOURCE_H_
diff --git a/media/base/fake_network_interface.h b/media/base/fake_network_interface.h
index fba7f9d..678da58 100644
--- a/media/base/fake_network_interface.h
+++ b/media/base/fake_network_interface.h
@@ -30,10 +30,10 @@
#include "rtc_base/thread.h"
#include "rtc_base/time_utils.h"
-namespace cricket {
+namespace webrtc {
// Fake NetworkInterface that sends/receives RTP/RTCP packets.
-class FakeNetworkInterface : public MediaChannelNetworkInterface {
+class FakeNetworkInterface : public cricket::MediaChannelNetworkInterface {
public:
FakeNetworkInterface()
: thread_(rtc::Thread::Current()),
@@ -43,20 +43,22 @@
recvbuf_size_(-1),
dscp_(rtc::DSCP_NO_CHANGE) {}
- void SetDestination(MediaReceiveChannelInterface* dest) { dest_ = dest; }
+ void SetDestination(cricket::MediaReceiveChannelInterface* dest) {
+ dest_ = dest;
+ }
// Conference mode is a mode where instead of simply forwarding the packets,
// the transport will send multiple copies of the packet with the specified
// SSRCs. This allows us to simulate receiving media from multiple sources.
void SetConferenceMode(bool conf, const std::vector<uint32_t>& ssrcs)
RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
conf_ = conf;
conf_sent_ssrcs_ = ssrcs;
}
int NumRtpBytes() RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
int bytes = 0;
for (size_t i = 0; i < rtp_packets_.size(); ++i) {
bytes += static_cast<int>(rtp_packets_[i].size());
@@ -65,31 +67,31 @@
}
int NumRtpBytes(uint32_t ssrc) RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
int bytes = 0;
GetNumRtpBytesAndPackets(ssrc, &bytes, NULL);
return bytes;
}
int NumRtpPackets() RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return static_cast<int>(rtp_packets_.size());
}
int NumRtpPackets(uint32_t ssrc) RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
int packets = 0;
GetNumRtpBytesAndPackets(ssrc, NULL, &packets);
return packets;
}
int NumSentSsrcs() RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return static_cast<int>(sent_ssrcs_.size());
}
- rtc::CopyOnWriteBuffer GetRtpPacket(int index) RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ CopyOnWriteBuffer GetRtpPacket(int index) RTC_LOCKS_EXCLUDED(mutex_) {
+ MutexLock lock(&mutex_);
if (index >= static_cast<int>(rtp_packets_.size())) {
return {};
}
@@ -97,18 +99,17 @@
}
int NumRtcpPackets() RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return static_cast<int>(rtcp_packets_.size());
}
// Note: callers are responsible for deleting the returned buffer.
- const rtc::CopyOnWriteBuffer* GetRtcpPacket(int index)
- RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ const CopyOnWriteBuffer* GetRtcpPacket(int index) RTC_LOCKS_EXCLUDED(mutex_) {
+ MutexLock lock(&mutex_);
if (index >= static_cast<int>(rtcp_packets_.size())) {
return NULL;
}
- return new rtc::CopyOnWriteBuffer(rtcp_packets_[index]);
+ return new CopyOnWriteBuffer(rtcp_packets_[index]);
}
int sendbuf_size() const { return sendbuf_size_; }
@@ -117,14 +118,14 @@
rtc::PacketOptions options() const { return options_; }
protected:
- virtual bool SendPacket(rtc::CopyOnWriteBuffer* packet,
+ virtual bool SendPacket(CopyOnWriteBuffer* packet,
const rtc::PacketOptions& options)
RTC_LOCKS_EXCLUDED(mutex_) {
if (!webrtc::IsRtpPacket(*packet)) {
return false;
}
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
sent_ssrcs_[webrtc::ParseRtpSsrc(*packet)]++;
options_ = options;
@@ -140,10 +141,10 @@
return true;
}
- virtual bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
+ virtual bool SendRtcp(CopyOnWriteBuffer* packet,
const rtc::PacketOptions& options)
RTC_LOCKS_EXCLUDED(mutex_) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
rtcp_packets_.push_back(*packet);
options_ = options;
if (!conf_) {
@@ -167,24 +168,23 @@
return 0;
}
- void PostPacket(rtc::CopyOnWriteBuffer packet) {
- thread_->PostTask(
- SafeTask(safety_.flag(), [this, packet = std::move(packet)]() mutable {
- if (dest_) {
- webrtc::RtpPacketReceived parsed_packet;
- if (parsed_packet.Parse(packet)) {
- parsed_packet.set_arrival_time(
- webrtc::Timestamp::Micros(rtc::TimeMicros()));
- dest_->OnPacketReceived(std::move(parsed_packet));
- } else {
- RTC_DCHECK_NOTREACHED();
- }
- }
- }));
+ void PostPacket(CopyOnWriteBuffer packet) {
+ thread_->PostTask(SafeTask(safety_.flag(), [this, packet = std::move(
+ packet)]() mutable {
+ if (dest_) {
+ RtpPacketReceived parsed_packet;
+ if (parsed_packet.Parse(packet)) {
+ parsed_packet.set_arrival_time(Timestamp::Micros(rtc::TimeMicros()));
+ dest_->OnPacketReceived(std::move(parsed_packet));
+ } else {
+ RTC_DCHECK_NOTREACHED();
+ }
+ }
+ }));
}
private:
- void SetRtpSsrc(uint32_t ssrc, rtc::CopyOnWriteBuffer& buffer) {
+ void SetRtpSsrc(uint32_t ssrc, CopyOnWriteBuffer& buffer) {
RTC_CHECK_GE(buffer.size(), 12);
webrtc::SetBE32(buffer.MutableData() + 8, ssrc);
}
@@ -208,8 +208,8 @@
}
}
- webrtc::TaskQueueBase* thread_;
- MediaReceiveChannelInterface* dest_;
+ TaskQueueBase* thread_;
+ cricket::MediaReceiveChannelInterface* dest_;
bool conf_;
// The ssrcs used in sending out packets in conference mode.
std::vector<uint32_t> conf_sent_ssrcs_;
@@ -218,17 +218,23 @@
std::map<uint32_t, uint32_t> sent_ssrcs_;
// Map to track packet-number that needs to be dropped per ssrc.
std::map<uint32_t, std::set<uint32_t> > drop_map_;
- webrtc::Mutex mutex_;
- std::vector<rtc::CopyOnWriteBuffer> rtp_packets_;
- std::vector<rtc::CopyOnWriteBuffer> rtcp_packets_;
+ Mutex mutex_;
+ std::vector<CopyOnWriteBuffer> rtp_packets_;
+ std::vector<CopyOnWriteBuffer> rtcp_packets_;
int sendbuf_size_;
int recvbuf_size_;
rtc::DiffServCodePoint dscp_;
// Options of the most recently sent packet.
rtc::PacketOptions options_;
- webrtc::ScopedTaskSafety safety_;
+ ScopedTaskSafety safety_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::FakeNetworkInterface;
} // namespace cricket
#endif // MEDIA_BASE_FAKE_NETWORK_INTERFACE_H_
diff --git a/media/base/fake_video_renderer.cc b/media/base/fake_video_renderer.cc
index b235738..b307a99 100644
--- a/media/base/fake_video_renderer.cc
+++ b/media/base/fake_video_renderer.cc
@@ -10,9 +10,9 @@
#include "media/base/fake_video_renderer.h"
-namespace cricket {
+namespace webrtc {
namespace {
-bool CheckFrameColorYuv(const webrtc::VideoFrame& frame) {
+bool CheckFrameColorYuv(const VideoFrame& frame) {
// TODO(zhurunz) Check with VP8 team to see if we can remove this
// tolerance on Y values. Some unit tests produce Y values close
// to 16 rather than close to zero, for supposedly black frames.
@@ -28,7 +28,7 @@
if (!frame.video_frame_buffer()) {
return false;
}
- rtc::scoped_refptr<const webrtc::I420BufferInterface> i420_buffer =
+ scoped_refptr<const I420BufferInterface> i420_buffer =
frame.video_frame_buffer()->ToI420();
// Y
int y_width = frame.width();
@@ -74,8 +74,8 @@
FakeVideoRenderer::FakeVideoRenderer() = default;
-void FakeVideoRenderer::OnFrame(const webrtc::VideoFrame& frame) {
- webrtc::MutexLock lock(&mutex_);
+void FakeVideoRenderer::OnFrame(const VideoFrame& frame) {
+ MutexLock lock(&mutex_);
black_frame_ = CheckFrameColorYuv(frame);
++num_rendered_frames_;
width_ = frame.width();
@@ -84,4 +84,4 @@
timestamp_us_ = frame.timestamp_us();
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/media/base/fake_video_renderer.h b/media/base/fake_video_renderer.h
index 33d99a2..74c8fc7 100644
--- a/media/base/fake_video_renderer.h
+++ b/media/base/fake_video_renderer.h
@@ -20,54 +20,60 @@
#include "api/video/video_sink_interface.h"
#include "rtc_base/synchronization/mutex.h"
-namespace cricket {
+namespace webrtc {
// Faked video renderer that has a callback for actions on rendering.
-class FakeVideoRenderer : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+class FakeVideoRenderer : public rtc::VideoSinkInterface<VideoFrame> {
public:
FakeVideoRenderer();
- void OnFrame(const webrtc::VideoFrame& frame) override;
+ void OnFrame(const VideoFrame& frame) override;
int width() const {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return width_;
}
int height() const {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return height_;
}
- webrtc::VideoRotation rotation() const {
- webrtc::MutexLock lock(&mutex_);
+ VideoRotation rotation() const {
+ MutexLock lock(&mutex_);
return rotation_;
}
int64_t timestamp_us() const {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return timestamp_us_;
}
int num_rendered_frames() const {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return num_rendered_frames_;
}
bool black_frame() const {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return black_frame_;
}
private:
int width_ = 0;
int height_ = 0;
- webrtc::VideoRotation rotation_ = webrtc::kVideoRotation_0;
+ VideoRotation rotation_ = webrtc::kVideoRotation_0;
int64_t timestamp_us_ = 0;
int num_rendered_frames_ = 0;
bool black_frame_ = false;
- mutable webrtc::Mutex mutex_;
+ mutable Mutex mutex_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::FakeVideoRenderer;
} // namespace cricket
#endif // MEDIA_BASE_FAKE_VIDEO_RENDERER_H_
diff --git a/media/base/test_utils.cc b/media/base/test_utils.cc
index 1b28873..dc33d55 100644
--- a/media/base/test_utils.cc
+++ b/media/base/test_utils.cc
@@ -15,7 +15,7 @@
#include "api/video/video_frame.h"
#include "api/video/video_source_interface.h"
-namespace cricket {
+namespace webrtc {
cricket::StreamParams CreateSimStreamParams(
const std::string& cname,
@@ -52,4 +52,4 @@
return sp;
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/media/base/test_utils.h b/media/base/test_utils.h
index dc14e44..f968c6e 100644
--- a/media/base/test_utils.h
+++ b/media/base/test_utils.h
@@ -22,7 +22,7 @@
class VideoFrame;
}
-namespace cricket {
+namespace webrtc {
// Returns size of 420 image with rounding on chroma for odd sizes.
#define I420_SIZE(w, h) (w * h + (((w + 1) / 2) * ((h + 1) / 2)) * 2)
@@ -33,7 +33,7 @@
inline std::vector<T> MakeVector(const T a[], size_t s) {
return std::vector<T>(a, a + s);
}
-#define MAKE_VECTOR(a) cricket::MakeVector(a, arraysize(a))
+#define MAKE_VECTOR(a) webrtc::MakeVector(a, arraysize(a))
// Create Simulcast StreamParams with given `ssrcs` and `cname`.
cricket::StreamParams CreateSimStreamParams(const std::string& cname,
@@ -51,6 +51,15 @@
uint32_t primary_ssrc,
uint32_t flexfec_ssrc);
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::CreatePrimaryWithFecFrStreamParams;
+using ::webrtc::CreateSimStreamParams;
+using ::webrtc::CreateSimWithRtxStreamParams;
+using ::webrtc::MakeVector;
} // namespace cricket
#endif // MEDIA_BASE_TEST_UTILS_H_
diff --git a/media/base/video_adapter_unittest.cc b/media/base/video_adapter_unittest.cc
index e1a8055..1bd974b 100644
--- a/media/base/video_adapter_unittest.cc
+++ b/media/base/video_adapter_unittest.cc
@@ -77,7 +77,7 @@
explicit VideoAdapterTest(const std::string& field_trials,
int source_resolution_alignment)
: override_field_trials_(field_trials),
- frame_source_(std::make_unique<FakeFrameSource>(
+ frame_source_(std::make_unique<webrtc::FakeFrameSource>(
kWidth,
kHeight,
VideoFormat::FpsToInterval(kDefaultFps) /
@@ -176,7 +176,7 @@
}
webrtc::test::ScopedFieldTrials override_field_trials_;
- const std::unique_ptr<FakeFrameSource> frame_source_;
+ const std::unique_ptr<webrtc::FakeFrameSource> frame_source_;
VideoAdapter adapter_;
int64_t timestamp_ns_ = 0;
int cropped_width_;
diff --git a/media/base/video_broadcaster_unittest.cc b/media/base/video_broadcaster_unittest.cc
index b75b42e..e05117e 100644
--- a/media/base/video_broadcaster_unittest.cc
+++ b/media/base/video_broadcaster_unittest.cc
@@ -21,9 +21,9 @@
#include "test/gmock.h"
#include "test/gtest.h"
-using cricket::FakeVideoRenderer;
using rtc::VideoBroadcaster;
using rtc::VideoSinkWants;
+using ::webrtc::FakeVideoRenderer;
using FrameSize = rtc::VideoSinkWants::FrameSize;
using ::testing::AllOf;
diff --git a/media/engine/fake_webrtc_call.cc b/media/engine/fake_webrtc_call.cc
index f866060..f4543bd 100644
--- a/media/engine/fake_webrtc_call.cc
+++ b/media/engine/fake_webrtc_call.cc
@@ -56,29 +56,26 @@
#include "video/config/encoder_stream_factory.h"
#include "video/config/video_encoder_config.h"
-namespace cricket {
+namespace webrtc {
using ::webrtc::Environment;
using ::webrtc::ParseRtpSsrc;
-FakeAudioSendStream::FakeAudioSendStream(
- int id,
- const webrtc::AudioSendStream::Config& config)
+FakeAudioSendStream::FakeAudioSendStream(int id,
+ const AudioSendStream::Config& config)
: id_(id), config_(config) {}
-void FakeAudioSendStream::Reconfigure(
- const webrtc::AudioSendStream::Config& config,
- webrtc::SetParametersCallback callback) {
+void FakeAudioSendStream::Reconfigure(const AudioSendStream::Config& config,
+ SetParametersCallback callback) {
config_ = config;
- webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
+ webrtc::InvokeSetParametersCallback(callback, RTCError::OK());
}
-const webrtc::AudioSendStream::Config& FakeAudioSendStream::GetConfig() const {
+const AudioSendStream::Config& FakeAudioSendStream::GetConfig() const {
return config_;
}
-void FakeAudioSendStream::SetStats(
- const webrtc::AudioSendStream::Stats& stats) {
+void FakeAudioSendStream::SetStats(const AudioSendStream::Stats& stats) {
stats_ = stats;
}
@@ -102,33 +99,33 @@
muted_ = muted;
}
-webrtc::AudioSendStream::Stats FakeAudioSendStream::GetStats() const {
+AudioSendStream::Stats FakeAudioSendStream::GetStats() const {
return stats_;
}
-webrtc::AudioSendStream::Stats FakeAudioSendStream::GetStats(
+AudioSendStream::Stats FakeAudioSendStream::GetStats(
bool /*has_remote_tracks*/) const {
return stats_;
}
FakeAudioReceiveStream::FakeAudioReceiveStream(
int id,
- const webrtc::AudioReceiveStreamInterface::Config& config)
+ const AudioReceiveStreamInterface::Config& config)
: id_(id), config_(config) {}
-const webrtc::AudioReceiveStreamInterface::Config&
-FakeAudioReceiveStream::GetConfig() const {
+const AudioReceiveStreamInterface::Config& FakeAudioReceiveStream::GetConfig()
+ const {
return config_;
}
void FakeAudioReceiveStream::SetStats(
- const webrtc::AudioReceiveStreamInterface::Stats& stats) {
+ const AudioReceiveStreamInterface::Stats& stats) {
stats_ = stats;
}
bool FakeAudioReceiveStream::VerifyLastPacket(const uint8_t* data,
size_t length) const {
- return last_packet_ == rtc::Buffer(data, length);
+ return last_packet_ == Buffer(data, length);
}
bool FakeAudioReceiveStream::DeliverRtp(const uint8_t* packet,
@@ -140,12 +137,12 @@
}
void FakeAudioReceiveStream::SetDepacketizerToDecoderFrameTransformer(
- rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
+ scoped_refptr<FrameTransformerInterface> frame_transformer) {
config_.frame_transformer = std::move(frame_transformer);
}
void FakeAudioReceiveStream::SetDecoderMap(
- std::map<int, webrtc::SdpAudioFormat> decoder_map) {
+ std::map<int, SdpAudioFormat> decoder_map) {
config_.decoder_map = std::move(decoder_map);
}
@@ -153,7 +150,7 @@
config_.rtp.nack.rtp_history_ms = history_ms;
}
-void FakeAudioReceiveStream::SetRtcpMode(webrtc::RtcpMode mode) {
+void FakeAudioReceiveStream::SetRtcpMode(RtcpMode mode) {
config_.rtp.rtcp_mode = mode;
}
@@ -162,16 +159,16 @@
}
void FakeAudioReceiveStream::SetFrameDecryptor(
- rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) {
+ scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
config_.frame_decryptor = std::move(frame_decryptor);
}
-webrtc::AudioReceiveStreamInterface::Stats FakeAudioReceiveStream::GetStats(
+AudioReceiveStreamInterface::Stats FakeAudioReceiveStream::GetStats(
bool /* get_and_clear_legacy_stats */) const {
return stats_;
}
-void FakeAudioReceiveStream::SetSink(webrtc::AudioSinkInterface* sink) {
+void FakeAudioReceiveStream::SetSink(AudioSinkInterface* sink) {
sink_ = sink;
}
@@ -179,10 +176,9 @@
gain_ = gain;
}
-FakeVideoSendStream::FakeVideoSendStream(
- const Environment& env,
- webrtc::VideoSendStream::Config config,
- webrtc::VideoEncoderConfig encoder_config)
+FakeVideoSendStream::FakeVideoSendStream(const Environment& env,
+ VideoSendStream::Config config,
+ VideoEncoderConfig encoder_config)
: env_(env),
sending_(false),
config_(std::move(config)),
@@ -201,17 +197,15 @@
source_->RemoveSink(this);
}
-const webrtc::VideoSendStream::Config& FakeVideoSendStream::GetConfig() const {
+const VideoSendStream::Config& FakeVideoSendStream::GetConfig() const {
return config_;
}
-const webrtc::VideoEncoderConfig& FakeVideoSendStream::GetEncoderConfig()
- const {
+const VideoEncoderConfig& FakeVideoSendStream::GetEncoderConfig() const {
return encoder_config_;
}
-const std::vector<webrtc::VideoStream>& FakeVideoSendStream::GetVideoStreams()
- const {
+const std::vector<VideoStream>& FakeVideoSendStream::GetVideoStreams() const {
return video_streams_;
}
@@ -219,8 +213,7 @@
return sending_;
}
-bool FakeVideoSendStream::GetVp8Settings(
- webrtc::VideoCodecVP8* settings) const {
+bool FakeVideoSendStream::GetVp8Settings(VideoCodecVP8* settings) const {
if (!codec_settings_set_) {
return false;
}
@@ -229,8 +222,7 @@
return true;
}
-bool FakeVideoSendStream::GetVp9Settings(
- webrtc::VideoCodecVP9* settings) const {
+bool FakeVideoSendStream::GetVp9Settings(VideoCodecVP9* settings) const {
if (!codec_settings_set_) {
return false;
}
@@ -239,8 +231,7 @@
return true;
}
-bool FakeVideoSendStream::GetH264Settings(
- webrtc::VideoCodecH264* settings) const {
+bool FakeVideoSendStream::GetH264Settings(VideoCodecH264* settings) const {
if (!codec_settings_set_) {
return false;
}
@@ -249,8 +240,7 @@
return true;
}
-bool FakeVideoSendStream::GetAv1Settings(
- webrtc::VideoCodecAV1* settings) const {
+bool FakeVideoSendStream::GetAv1Settings(VideoCodecAV1* settings) const {
if (!codec_settings_set_) {
return false;
}
@@ -276,7 +266,7 @@
return last_frame_->render_time_ms();
}
-void FakeVideoSendStream::OnFrame(const webrtc::VideoFrame& frame) {
+void FakeVideoSendStream::OnFrame(const VideoFrame& frame) {
++num_swapped_frames_;
if (!last_frame_ || frame.width() != last_frame_->width() ||
frame.height() != last_frame_->height() ||
@@ -288,9 +278,8 @@
env_.field_trials(), frame.width(), frame.height(),
encoder_config_);
} else {
- webrtc::VideoEncoder::EncoderInfo encoder_info;
- auto factory =
- rtc::make_ref_counted<webrtc::EncoderStreamFactory>(encoder_info);
+ VideoEncoder::EncoderInfo encoder_info;
+ auto factory = rtc::make_ref_counted<EncoderStreamFactory>(encoder_info);
video_streams_ = factory->CreateEncoderStreams(
env_.field_trials(), frame.width(), frame.height(), encoder_config_);
@@ -299,23 +288,21 @@
last_frame_ = frame;
}
-void FakeVideoSendStream::SetStats(
- const webrtc::VideoSendStream::Stats& stats) {
+void FakeVideoSendStream::SetStats(const VideoSendStream::Stats& stats) {
stats_ = stats;
}
-webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() {
+VideoSendStream::Stats FakeVideoSendStream::GetStats() {
return stats_;
}
-void FakeVideoSendStream::ReconfigureVideoEncoder(
- webrtc::VideoEncoderConfig config) {
+void FakeVideoSendStream::ReconfigureVideoEncoder(VideoEncoderConfig config) {
ReconfigureVideoEncoder(std::move(config), nullptr);
}
void FakeVideoSendStream::ReconfigureVideoEncoder(
- webrtc::VideoEncoderConfig config,
- webrtc::SetParametersCallback callback) {
+ VideoEncoderConfig config,
+ SetParametersCallback callback) {
int width, height;
if (last_frame_) {
width = last_frame_->width();
@@ -328,9 +315,8 @@
video_streams_ = config.video_stream_factory->CreateEncoderStreams(
env_.field_trials(), width, height, config);
} else {
- webrtc::VideoEncoder::EncoderInfo encoder_info;
- auto factory =
- rtc::make_ref_counted<webrtc::EncoderStreamFactory>(encoder_info);
+ VideoEncoder::EncoderInfo encoder_info;
+ auto factory = rtc::make_ref_counted<EncoderStreamFactory>(encoder_info);
video_streams_ = factory->CreateEncoderStreams(env_.field_trials(), width,
height, config);
@@ -367,7 +353,7 @@
codec_settings_set_ = config.encoder_specific_settings != nullptr;
encoder_config_ = std::move(config);
++num_encoder_reconfigurations_;
- webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
+ webrtc::InvokeSetParametersCallback(callback, RTCError::OK());
}
void FakeVideoSendStream::Start() {
@@ -379,33 +365,33 @@
}
void FakeVideoSendStream::AddAdaptationResource(
- rtc::scoped_refptr<webrtc::Resource> /* resource */) {}
+ scoped_refptr<Resource> /* resource */) {}
-std::vector<rtc::scoped_refptr<webrtc::Resource>>
+std::vector<scoped_refptr<Resource>>
FakeVideoSendStream::GetAdaptationResources() {
return {};
}
void FakeVideoSendStream::SetSource(
- rtc::VideoSourceInterface<webrtc::VideoFrame>* source,
- const webrtc::DegradationPreference& degradation_preference) {
+ rtc::VideoSourceInterface<VideoFrame>* source,
+ const DegradationPreference& degradation_preference) {
if (source_)
source_->RemoveSink(this);
source_ = source;
switch (degradation_preference) {
- case webrtc::DegradationPreference::MAINTAIN_FRAMERATE:
+ case DegradationPreference::MAINTAIN_FRAMERATE:
resolution_scaling_enabled_ = true;
framerate_scaling_enabled_ = false;
break;
- case webrtc::DegradationPreference::MAINTAIN_RESOLUTION:
+ case DegradationPreference::MAINTAIN_RESOLUTION:
resolution_scaling_enabled_ = false;
framerate_scaling_enabled_ = true;
break;
- case webrtc::DegradationPreference::BALANCED:
+ case DegradationPreference::BALANCED:
resolution_scaling_enabled_ = true;
framerate_scaling_enabled_ = true;
break;
- case webrtc::DegradationPreference::DISABLED:
+ case DegradationPreference::DISABLED:
resolution_scaling_enabled_ = false;
framerate_scaling_enabled_ = false;
break;
@@ -428,11 +414,11 @@
}
FakeVideoReceiveStream::FakeVideoReceiveStream(
- webrtc::VideoReceiveStreamInterface::Config config)
+ VideoReceiveStreamInterface::Config config)
: config_(std::move(config)), receiving_(false) {}
-const webrtc::VideoReceiveStreamInterface::Config&
-FakeVideoReceiveStream::GetConfig() const {
+const VideoReceiveStreamInterface::Config& FakeVideoReceiveStream::GetConfig()
+ const {
return config_;
}
@@ -440,12 +426,11 @@
return receiving_;
}
-void FakeVideoReceiveStream::InjectFrame(const webrtc::VideoFrame& frame) {
+void FakeVideoReceiveStream::InjectFrame(const VideoFrame& frame) {
config_.renderer->OnFrame(frame);
}
-webrtc::VideoReceiveStreamInterface::Stats FakeVideoReceiveStream::GetStats()
- const {
+VideoReceiveStreamInterface::Stats FakeVideoReceiveStream::GetStats() const {
return stats_;
}
@@ -458,20 +443,20 @@
}
void FakeVideoReceiveStream::SetStats(
- const webrtc::VideoReceiveStreamInterface::Stats& stats) {
+ const VideoReceiveStreamInterface::Stats& stats) {
stats_ = stats;
}
FakeFlexfecReceiveStream::FakeFlexfecReceiveStream(
- const webrtc::FlexfecReceiveStream::Config config)
+ const FlexfecReceiveStream::Config config)
: config_(std::move(config)) {}
-const webrtc::FlexfecReceiveStream::Config&
-FakeFlexfecReceiveStream::GetConfig() const {
+const FlexfecReceiveStream::Config& FakeFlexfecReceiveStream::GetConfig()
+ const {
return config_;
}
-void FakeFlexfecReceiveStream::OnRtpPacket(const webrtc::RtpPacketReceived&) {
+void FakeFlexfecReceiveStream::OnRtpPacket(const RtpPacketReceived&) {
RTC_DCHECK_NOTREACHED() << "Not implemented.";
}
@@ -479,8 +464,8 @@
: FakeCall(env, rtc::Thread::Current(), rtc::Thread::Current()) {}
FakeCall::FakeCall(const Environment& env,
- webrtc::TaskQueueBase* worker_thread,
- webrtc::TaskQueueBase* network_thread)
+ TaskQueueBase* worker_thread,
+ TaskQueueBase* network_thread)
: env_(env),
network_thread_(network_thread),
worker_thread_(worker_thread),
@@ -544,15 +529,15 @@
return flexfec_receive_streams_;
}
-webrtc::NetworkState FakeCall::GetNetworkState(webrtc::MediaType media) const {
+NetworkState FakeCall::GetNetworkState(MediaType media) const {
switch (media) {
- case webrtc::MediaType::AUDIO:
+ case MediaType::AUDIO:
return audio_network_state_;
- case webrtc::MediaType::VIDEO:
+ case MediaType::VIDEO:
return video_network_state_;
- case webrtc::MediaType::DATA:
- case webrtc::MediaType::ANY:
- case webrtc::MediaType::UNSUPPORTED:
+ case MediaType::DATA:
+ case MediaType::ANY:
+ case MediaType::UNSUPPORTED:
ADD_FAILURE() << "GetNetworkState called with unknown parameter.";
return webrtc::kNetworkDown;
}
@@ -563,8 +548,8 @@
return webrtc::kNetworkDown;
}
-webrtc::AudioSendStream* FakeCall::CreateAudioSendStream(
- const webrtc::AudioSendStream::Config& config) {
+AudioSendStream* FakeCall::CreateAudioSendStream(
+ const AudioSendStream::Config& config) {
FakeAudioSendStream* fake_stream =
new FakeAudioSendStream(next_stream_id_++, config);
audio_send_streams_.push_back(fake_stream);
@@ -572,7 +557,7 @@
return fake_stream;
}
-void FakeCall::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
+void FakeCall::DestroyAudioSendStream(AudioSendStream* send_stream) {
auto it = absl::c_find(audio_send_streams_,
static_cast<FakeAudioSendStream*>(send_stream));
if (it == audio_send_streams_.end()) {
@@ -583,8 +568,8 @@
}
}
-webrtc::AudioReceiveStreamInterface* FakeCall::CreateAudioReceiveStream(
- const webrtc::AudioReceiveStreamInterface::Config& config) {
+AudioReceiveStreamInterface* FakeCall::CreateAudioReceiveStream(
+ const AudioReceiveStreamInterface::Config& config) {
audio_receive_streams_.push_back(
new FakeAudioReceiveStream(next_stream_id_++, config));
++num_created_receive_streams_;
@@ -592,7 +577,7 @@
}
void FakeCall::DestroyAudioReceiveStream(
- webrtc::AudioReceiveStreamInterface* receive_stream) {
+ AudioReceiveStreamInterface* receive_stream) {
auto it = absl::c_find(audio_receive_streams_,
static_cast<FakeAudioReceiveStream*>(receive_stream));
if (it == audio_receive_streams_.end()) {
@@ -603,9 +588,9 @@
}
}
-webrtc::VideoSendStream* FakeCall::CreateVideoSendStream(
- webrtc::VideoSendStream::Config config,
- webrtc::VideoEncoderConfig encoder_config) {
+VideoSendStream* FakeCall::CreateVideoSendStream(
+ VideoSendStream::Config config,
+ VideoEncoderConfig encoder_config) {
FakeVideoSendStream* fake_stream = new FakeVideoSendStream(
env_, std::move(config), std::move(encoder_config));
video_send_streams_.push_back(fake_stream);
@@ -613,7 +598,7 @@
return fake_stream;
}
-void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
+void FakeCall::DestroyVideoSendStream(VideoSendStream* send_stream) {
auto it = absl::c_find(video_send_streams_,
static_cast<FakeVideoSendStream*>(send_stream));
if (it == video_send_streams_.end()) {
@@ -624,8 +609,8 @@
}
}
-webrtc::VideoReceiveStreamInterface* FakeCall::CreateVideoReceiveStream(
- webrtc::VideoReceiveStreamInterface::Config config) {
+VideoReceiveStreamInterface* FakeCall::CreateVideoReceiveStream(
+ VideoReceiveStreamInterface::Config config) {
video_receive_streams_.push_back(
new FakeVideoReceiveStream(std::move(config)));
++num_created_receive_streams_;
@@ -633,7 +618,7 @@
}
void FakeCall::DestroyVideoReceiveStream(
- webrtc::VideoReceiveStreamInterface* receive_stream) {
+ VideoReceiveStreamInterface* receive_stream) {
auto it = absl::c_find(video_receive_streams_,
static_cast<FakeVideoReceiveStream*>(receive_stream));
if (it == video_receive_streams_.end()) {
@@ -644,8 +629,8 @@
}
}
-webrtc::FlexfecReceiveStream* FakeCall::CreateFlexfecReceiveStream(
- const webrtc::FlexfecReceiveStream::Config config) {
+FlexfecReceiveStream* FakeCall::CreateFlexfecReceiveStream(
+ const FlexfecReceiveStream::Config config) {
FakeFlexfecReceiveStream* fake_stream =
new FakeFlexfecReceiveStream(std::move(config));
flexfec_receive_streams_.push_back(fake_stream);
@@ -654,7 +639,7 @@
}
void FakeCall::DestroyFlexfecReceiveStream(
- webrtc::FlexfecReceiveStream* receive_stream) {
+ FlexfecReceiveStream* receive_stream) {
auto it =
absl::c_find(flexfec_receive_streams_,
static_cast<FakeFlexfecReceiveStream*>(receive_stream));
@@ -667,16 +652,15 @@
}
}
-void FakeCall::AddAdaptationResource(
- rtc::scoped_refptr<webrtc::Resource> /* resource */) {}
+void FakeCall::AddAdaptationResource(scoped_refptr<Resource> /* resource */) {}
-webrtc::PacketReceiver* FakeCall::Receiver() {
+PacketReceiver* FakeCall::Receiver() {
return this;
}
void FakeCall::DeliverRtpPacket(
- webrtc::MediaType media_type,
- webrtc::RtpPacketReceived packet,
+ MediaType media_type,
+ RtpPacketReceived packet,
OnUndemuxablePacketHandler undemuxable_packet_handler) {
if (!DeliverPacketInternal(media_type, packet.Ssrc(), packet.Buffer(),
packet.arrival_time())) {
@@ -688,16 +672,15 @@
last_received_rtp_packet_ = packet;
}
-bool FakeCall::DeliverPacketInternal(webrtc::MediaType media_type,
+bool FakeCall::DeliverPacketInternal(MediaType media_type,
uint32_t ssrc,
- const rtc::CopyOnWriteBuffer& packet,
- webrtc::Timestamp arrival_time) {
+ const CopyOnWriteBuffer& packet,
+ Timestamp arrival_time) {
EXPECT_GE(packet.size(), 12u);
RTC_DCHECK(arrival_time.IsFinite());
- RTC_DCHECK(media_type == webrtc::MediaType::AUDIO ||
- media_type == webrtc::MediaType::VIDEO);
+ RTC_DCHECK(media_type == MediaType::AUDIO || media_type == MediaType::VIDEO);
- if (media_type == webrtc::MediaType::VIDEO) {
+ if (media_type == MediaType::VIDEO) {
for (auto receiver : video_receive_streams_) {
if (receiver->GetConfig().rtp.remote_ssrc == ssrc ||
receiver->GetConfig().rtp.rtx_ssrc == ssrc) {
@@ -706,7 +689,7 @@
}
}
}
- if (media_type == webrtc::MediaType::AUDIO) {
+ if (media_type == MediaType::AUDIO) {
for (auto receiver : audio_receive_streams_) {
if (receiver->GetConfig().rtp.remote_ssrc == ssrc) {
receiver->DeliverRtp(packet.cdata(), packet.size(), arrival_time.us());
@@ -718,7 +701,7 @@
return false;
}
-void FakeCall::SetStats(const webrtc::Call::Stats& stats) {
+void FakeCall::SetStats(const Call::Stats& stats) {
stats_ = stats;
}
@@ -730,30 +713,29 @@
return num_created_receive_streams_;
}
-webrtc::Call::Stats FakeCall::GetStats() const {
+Call::Stats FakeCall::GetStats() const {
return stats_;
}
-webrtc::TaskQueueBase* FakeCall::network_thread() const {
+TaskQueueBase* FakeCall::network_thread() const {
return network_thread_;
}
-webrtc::TaskQueueBase* FakeCall::worker_thread() const {
+TaskQueueBase* FakeCall::worker_thread() const {
return worker_thread_;
}
-void FakeCall::SignalChannelNetworkState(webrtc::MediaType media,
- webrtc::NetworkState state) {
+void FakeCall::SignalChannelNetworkState(MediaType media, NetworkState state) {
switch (media) {
- case webrtc::MediaType::AUDIO:
+ case MediaType::AUDIO:
audio_network_state_ = state;
break;
- case webrtc::MediaType::VIDEO:
+ case MediaType::VIDEO:
video_network_state_ = state;
break;
- case webrtc::MediaType::DATA:
- case webrtc::MediaType::ANY:
- case webrtc::MediaType::UNSUPPORTED:
+ case MediaType::DATA:
+ case MediaType::ANY:
+ case MediaType::UNSUPPORTED:
ADD_FAILURE()
<< "SignalChannelNetworkState called with unknown parameter.";
}
@@ -762,25 +744,25 @@
void FakeCall::OnAudioTransportOverheadChanged(
int /* transport_overhead_per_packet */) {}
-void FakeCall::OnLocalSsrcUpdated(webrtc::AudioReceiveStreamInterface& stream,
+void FakeCall::OnLocalSsrcUpdated(AudioReceiveStreamInterface& stream,
uint32_t local_ssrc) {
auto& fake_stream = static_cast<FakeAudioReceiveStream&>(stream);
fake_stream.SetLocalSsrc(local_ssrc);
}
-void FakeCall::OnLocalSsrcUpdated(webrtc::VideoReceiveStreamInterface& stream,
+void FakeCall::OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) {
auto& fake_stream = static_cast<FakeVideoReceiveStream&>(stream);
fake_stream.SetLocalSsrc(local_ssrc);
}
-void FakeCall::OnLocalSsrcUpdated(webrtc::FlexfecReceiveStream& stream,
+void FakeCall::OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
uint32_t local_ssrc) {
auto& fake_stream = static_cast<FakeFlexfecReceiveStream&>(stream);
fake_stream.SetLocalSsrc(local_ssrc);
}
-void FakeCall::OnUpdateSyncGroup(webrtc::AudioReceiveStreamInterface& stream,
+void FakeCall::OnUpdateSyncGroup(AudioReceiveStreamInterface& stream,
absl::string_view sync_group) {
auto& fake_stream = static_cast<FakeAudioReceiveStream&>(stream);
fake_stream.SetSyncGroup(sync_group);
@@ -793,4 +775,4 @@
}
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/media/engine/fake_webrtc_call.h b/media/engine/fake_webrtc_call.h
index 4e7f68f..983bd4b 100644
--- a/media/engine/fake_webrtc_call.h
+++ b/media/engine/fake_webrtc_call.h
@@ -70,8 +70,8 @@
#include "test/gmock.h"
#include "video/config/video_encoder_config.h"
-namespace cricket {
-class FakeAudioSendStream final : public webrtc::AudioSendStream {
+namespace webrtc {
+class FakeAudioSendStream final : public AudioSendStream {
public:
struct TelephoneEvent {
int payload_type = -1;
@@ -80,54 +80,50 @@
int duration_ms = 0;
};
- explicit FakeAudioSendStream(int id,
- const webrtc::AudioSendStream::Config& config);
+ explicit FakeAudioSendStream(int id, const AudioSendStream::Config& config);
int id() const { return id_; }
- const webrtc::AudioSendStream::Config& GetConfig() const override;
- void SetStats(const webrtc::AudioSendStream::Stats& stats);
+ const AudioSendStream::Config& GetConfig() const override;
+ void SetStats(const AudioSendStream::Stats& stats);
TelephoneEvent GetLatestTelephoneEvent() const;
bool IsSending() const { return sending_; }
bool muted() const { return muted_; }
private:
// webrtc::AudioSendStream implementation.
- void Reconfigure(const webrtc::AudioSendStream::Config& config,
- webrtc::SetParametersCallback callback) override;
+ void Reconfigure(const AudioSendStream::Config& config,
+ SetParametersCallback callback) override;
void Start() override { sending_ = true; }
void Stop() override { sending_ = false; }
- void SendAudioData(
- std::unique_ptr<webrtc::AudioFrame> /* audio_frame */) override {}
+ void SendAudioData(std::unique_ptr<AudioFrame> /* audio_frame */) override {}
bool SendTelephoneEvent(int payload_type,
int payload_frequency,
int event,
int duration_ms) override;
void SetMuted(bool muted) override;
- webrtc::AudioSendStream::Stats GetStats() const override;
- webrtc::AudioSendStream::Stats GetStats(
- bool has_remote_tracks) const override;
+ AudioSendStream::Stats GetStats() const override;
+ AudioSendStream::Stats GetStats(bool has_remote_tracks) const override;
int id_ = -1;
TelephoneEvent latest_telephone_event_;
- webrtc::AudioSendStream::Config config_;
- webrtc::AudioSendStream::Stats stats_;
+ AudioSendStream::Config config_;
+ AudioSendStream::Stats stats_;
bool sending_ = false;
bool muted_ = false;
};
-class FakeAudioReceiveStream final
- : public webrtc::AudioReceiveStreamInterface {
+class FakeAudioReceiveStream final : public AudioReceiveStreamInterface {
public:
explicit FakeAudioReceiveStream(
int id,
- const webrtc::AudioReceiveStreamInterface::Config& config);
+ const AudioReceiveStreamInterface::Config& config);
int id() const { return id_; }
- const webrtc::AudioReceiveStreamInterface::Config& GetConfig() const;
- void SetStats(const webrtc::AudioReceiveStreamInterface::Stats& stats);
+ const AudioReceiveStreamInterface::Config& GetConfig() const;
+ void SetStats(const AudioReceiveStreamInterface::Stats& stats);
int received_packets() const { return received_packets_; }
bool VerifyLastPacket(const uint8_t* data, size_t length) const;
- const webrtc::AudioSinkInterface* sink() const { return sink_; }
+ const AudioSinkInterface* sink() const { return sink_; }
float gain() const { return gain_; }
bool DeliverRtp(const uint8_t* packet, size_t length, int64_t packet_time_us);
bool started() const { return started_; }
@@ -148,19 +144,17 @@
void Stop() override { started_ = false; }
bool IsRunning() const override { return started_; }
void SetDepacketizerToDecoderFrameTransformer(
- rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
- override;
- void SetDecoderMap(
- std::map<int, webrtc::SdpAudioFormat> decoder_map) override;
+ scoped_refptr<FrameTransformerInterface> frame_transformer) override;
+ void SetDecoderMap(std::map<int, SdpAudioFormat> decoder_map) override;
void SetNackHistory(int history_ms) override;
- void SetRtcpMode(webrtc::RtcpMode mode) override;
+ void SetRtcpMode(RtcpMode mode) override;
void SetNonSenderRttMeasurement(bool enabled) override;
- void SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
- frame_decryptor) override;
+ void SetFrameDecryptor(
+ scoped_refptr<FrameDecryptorInterface> frame_decryptor) override;
- webrtc::AudioReceiveStreamInterface::Stats GetStats(
+ AudioReceiveStreamInterface::Stats GetStats(
bool get_and_clear_legacy_stats) const override;
- void SetSink(webrtc::AudioSinkInterface* sink) override;
+ void SetSink(AudioSinkInterface* sink) override;
void SetGain(float gain) override;
bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override {
base_mininum_playout_delay_ms_ = delay_ms;
@@ -169,49 +163,48 @@
int GetBaseMinimumPlayoutDelayMs() const override {
return base_mininum_playout_delay_ms_;
}
- std::vector<webrtc::RtpSource> GetSources() const override {
- return std::vector<webrtc::RtpSource>();
+ std::vector<RtpSource> GetSources() const override {
+ return std::vector<RtpSource>();
}
- webrtc::AudioMixer::Source* source() override {
+ AudioMixer::Source* source() override {
// TODO(b/397376626): Add a Fake AudioMixer::Source
return nullptr;
}
private:
int id_ = -1;
- webrtc::AudioReceiveStreamInterface::Config config_;
- webrtc::AudioReceiveStreamInterface::Stats stats_;
+ AudioReceiveStreamInterface::Config config_;
+ AudioReceiveStreamInterface::Stats stats_;
int received_packets_ = 0;
- webrtc::AudioSinkInterface* sink_ = nullptr;
+ AudioSinkInterface* sink_ = nullptr;
float gain_ = 1.0f;
- rtc::Buffer last_packet_;
+ Buffer last_packet_;
bool started_ = false;
int base_mininum_playout_delay_ms_ = 0;
};
-class FakeVideoSendStream final
- : public webrtc::VideoSendStream,
- public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+class FakeVideoSendStream final : public VideoSendStream,
+ public rtc::VideoSinkInterface<VideoFrame> {
public:
- FakeVideoSendStream(const webrtc::Environment& env,
- webrtc::VideoSendStream::Config config,
- webrtc::VideoEncoderConfig encoder_config);
+ FakeVideoSendStream(const Environment& env,
+ VideoSendStream::Config config,
+ VideoEncoderConfig encoder_config);
~FakeVideoSendStream() override;
- const webrtc::VideoSendStream::Config& GetConfig() const;
- const webrtc::VideoEncoderConfig& GetEncoderConfig() const;
- const std::vector<webrtc::VideoStream>& GetVideoStreams() const;
+ const VideoSendStream::Config& GetConfig() const;
+ const VideoEncoderConfig& GetEncoderConfig() const;
+ const std::vector<VideoStream>& GetVideoStreams() const;
bool IsSending() const;
- bool GetVp8Settings(webrtc::VideoCodecVP8* settings) const;
- bool GetVp9Settings(webrtc::VideoCodecVP9* settings) const;
- bool GetH264Settings(webrtc::VideoCodecH264* settings) const;
- bool GetAv1Settings(webrtc::VideoCodecAV1* settings) const;
+ bool GetVp8Settings(VideoCodecVP8* settings) const;
+ bool GetVp9Settings(VideoCodecVP9* settings) const;
+ bool GetH264Settings(VideoCodecH264* settings) const;
+ bool GetAv1Settings(VideoCodecAV1* settings) const;
int GetNumberOfSwappedFrames() const;
int GetLastWidth() const;
int GetLastHeight() const;
int64_t GetLastTimestamp() const;
- void SetStats(const webrtc::VideoSendStream::Stats& stats);
+ void SetStats(const VideoSendStream::Stats& stats);
int num_encoder_reconfigurations() const {
return num_encoder_reconfigurations_;
}
@@ -222,9 +215,7 @@
bool framerate_scaling_enabled() const { return framerate_scaling_enabled_; }
void InjectVideoSinkWants(const rtc::VideoSinkWants& wants);
- rtc::VideoSourceInterface<webrtc::VideoFrame>* source() const {
- return source_;
- }
+ rtc::VideoSourceInterface<VideoFrame>* source() const { return source_; }
void GenerateKeyFrame(const std::vector<std::string>& rids);
const std::vector<std::string>& GetKeyFramesRequested() const {
return keyframes_requested_by_rid_;
@@ -232,65 +223,60 @@
private:
// rtc::VideoSinkInterface<VideoFrame> implementation.
- void OnFrame(const webrtc::VideoFrame& frame) override;
+ void OnFrame(const VideoFrame& frame) override;
// webrtc::VideoSendStream implementation.
void Start() override;
void Stop() override;
bool started() override { return IsSending(); }
- void AddAdaptationResource(
- rtc::scoped_refptr<webrtc::Resource> resource) override;
- std::vector<rtc::scoped_refptr<webrtc::Resource>> GetAdaptationResources()
- override;
- void SetSource(
- rtc::VideoSourceInterface<webrtc::VideoFrame>* source,
- const webrtc::DegradationPreference& degradation_preference) override;
- webrtc::VideoSendStream::Stats GetStats() override;
+ void AddAdaptationResource(scoped_refptr<Resource> resource) override;
+ std::vector<scoped_refptr<Resource>> GetAdaptationResources() override;
+ void SetSource(rtc::VideoSourceInterface<VideoFrame>* source,
+ const DegradationPreference& degradation_preference) override;
+ VideoSendStream::Stats GetStats() override;
- void ReconfigureVideoEncoder(webrtc::VideoEncoderConfig config) override;
- void ReconfigureVideoEncoder(webrtc::VideoEncoderConfig config,
- webrtc::SetParametersCallback callback) override;
+ void ReconfigureVideoEncoder(VideoEncoderConfig config) override;
+ void ReconfigureVideoEncoder(VideoEncoderConfig config,
+ SetParametersCallback callback) override;
- const webrtc::Environment env_;
+ const Environment env_;
bool sending_;
- webrtc::VideoSendStream::Config config_;
- webrtc::VideoEncoderConfig encoder_config_;
- std::vector<webrtc::VideoStream> video_streams_;
+ VideoSendStream::Config config_;
+ VideoEncoderConfig encoder_config_;
+ std::vector<VideoStream> video_streams_;
rtc::VideoSinkWants sink_wants_;
bool codec_settings_set_;
union CodecSpecificSettings {
- webrtc::VideoCodecVP8 vp8;
- webrtc::VideoCodecVP9 vp9;
- webrtc::VideoCodecH264 h264;
- webrtc::VideoCodecAV1 av1;
+ VideoCodecVP8 vp8;
+ VideoCodecVP9 vp9;
+ VideoCodecH264 h264;
+ VideoCodecAV1 av1;
} codec_specific_settings_;
bool resolution_scaling_enabled_;
bool framerate_scaling_enabled_;
- rtc::VideoSourceInterface<webrtc::VideoFrame>* source_;
+ rtc::VideoSourceInterface<VideoFrame>* source_;
int num_swapped_frames_;
- std::optional<webrtc::VideoFrame> last_frame_;
- webrtc::VideoSendStream::Stats stats_;
+ std::optional<VideoFrame> last_frame_;
+ VideoSendStream::Stats stats_;
int num_encoder_reconfigurations_ = 0;
std::vector<std::string> keyframes_requested_by_rid_;
};
-class FakeVideoReceiveStream final
- : public webrtc::VideoReceiveStreamInterface {
+class FakeVideoReceiveStream final : public VideoReceiveStreamInterface {
public:
- explicit FakeVideoReceiveStream(
- webrtc::VideoReceiveStreamInterface::Config config);
+ explicit FakeVideoReceiveStream(VideoReceiveStreamInterface::Config config);
- const webrtc::VideoReceiveStreamInterface::Config& GetConfig() const;
+ const VideoReceiveStreamInterface::Config& GetConfig() const;
bool IsReceiving() const;
- void InjectFrame(const webrtc::VideoFrame& frame);
+ void InjectFrame(const VideoFrame& frame);
- void SetStats(const webrtc::VideoReceiveStreamInterface::Stats& stats);
+ void SetStats(const VideoReceiveStreamInterface::Stats& stats);
- std::vector<webrtc::RtpSource> GetSources() const override {
- return std::vector<webrtc::RtpSource>();
+ std::vector<RtpSource> GetSources() const override {
+ return std::vector<RtpSource>();
}
int base_mininum_playout_delay_ms() const {
@@ -303,13 +289,12 @@
void UpdateRtxSsrc(uint32_t ssrc) { config_.rtp.rtx_ssrc = ssrc; }
- void SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
+ void SetFrameDecryptor(scoped_refptr<FrameDecryptorInterface>
/* frame_decryptor */) override {}
void SetDepacketizerToDecoderFrameTransformer(
- rtc::scoped_refptr<
- webrtc::FrameTransformerInterface> /* frame_transformer */) override {
- }
+ scoped_refptr<FrameTransformerInterface> /* frame_transformer */)
+ override {}
RecordingState SetAndGetRecordingState(
RecordingState /* state */,
@@ -318,11 +303,9 @@
}
void GenerateKeyFrame() override {}
- void SetRtcpMode(webrtc::RtcpMode mode) override {
- config_.rtp.rtcp_mode = mode;
- }
+ void SetRtcpMode(RtcpMode mode) override { config_.rtp.rtcp_mode = mode; }
- void SetFlexFecProtection(webrtc::RtpPacketSinkInterface* sink) override {
+ void SetFlexFecProtection(RtpPacketSinkInterface* sink) override {
config_.rtp.packet_sink_ = sink;
config_.rtp.protected_by_flexfec = (sink != nullptr);
}
@@ -331,7 +314,7 @@
config_.rtp.lntf.enabled = enabled;
}
- void SetNackHistory(webrtc::TimeDelta history) override {
+ void SetNackHistory(TimeDelta history) override {
config_.rtp.nack.rtp_history_ms = history.ms();
}
@@ -353,7 +336,7 @@
void Start() override;
void Stop() override;
- webrtc::VideoReceiveStreamInterface::Stats GetStats() const override;
+ VideoReceiveStreamInterface::Stats GetStats() const override;
bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override {
base_mininum_playout_delay_ms_ = delay_ms;
@@ -365,54 +348,51 @@
}
private:
- webrtc::VideoReceiveStreamInterface::Config config_;
+ VideoReceiveStreamInterface::Config config_;
bool receiving_;
- webrtc::VideoReceiveStreamInterface::Stats stats_;
+ VideoReceiveStreamInterface::Stats stats_;
int base_mininum_playout_delay_ms_ = 0;
};
-class FakeFlexfecReceiveStream final : public webrtc::FlexfecReceiveStream {
+class FakeFlexfecReceiveStream final : public FlexfecReceiveStream {
public:
- explicit FakeFlexfecReceiveStream(
- const webrtc::FlexfecReceiveStream::Config config);
+ explicit FakeFlexfecReceiveStream(const FlexfecReceiveStream::Config config);
void SetLocalSsrc(uint32_t local_ssrc) {
config_.rtp.local_ssrc = local_ssrc;
}
- void SetRtcpMode(webrtc::RtcpMode mode) override { config_.rtcp_mode = mode; }
+ void SetRtcpMode(RtcpMode mode) override { config_.rtcp_mode = mode; }
int payload_type() const override { return config_.payload_type; }
void SetPayloadType(int payload_type) override {
config_.payload_type = payload_type;
}
- const webrtc::FlexfecReceiveStream::Config& GetConfig() const;
+ const FlexfecReceiveStream::Config& GetConfig() const;
uint32_t remote_ssrc() const { return config_.rtp.remote_ssrc; }
- const webrtc::ReceiveStatistics* GetStats() const override { return nullptr; }
+ const ReceiveStatistics* GetStats() const override { return nullptr; }
private:
- void OnRtpPacket(const webrtc::RtpPacketReceived& packet) override;
+ void OnRtpPacket(const RtpPacketReceived& packet) override;
- webrtc::FlexfecReceiveStream::Config config_;
+ FlexfecReceiveStream::Config config_;
};
-class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver {
+class FakeCall final : public Call, public PacketReceiver {
public:
- explicit FakeCall(const webrtc::Environment& env);
- FakeCall(const webrtc::Environment& env,
- webrtc::TaskQueueBase* worker_thread,
- webrtc::TaskQueueBase* network_thread);
+ explicit FakeCall(const Environment& env);
+ FakeCall(const Environment& env,
+ TaskQueueBase* worker_thread,
+ TaskQueueBase* network_thread);
~FakeCall() override;
- webrtc::PayloadTypeSuggester* GetPayloadTypeSuggester() {
- return &pt_suggester_;
- }
+ PayloadTypeSuggester* GetPayloadTypeSuggester() { return &pt_suggester_; }
- webrtc::MockRtpTransportControllerSend* GetMockTransportControllerSend() {
+ MockRtpTransportControllerSend* GetMockTransportControllerSend() {
return &transport_controller_send_;
}
@@ -428,7 +408,7 @@
const std::vector<FakeFlexfecReceiveStream*>& GetFlexfecReceiveStreams();
rtc::SentPacket last_sent_packet() const { return last_sent_packet_; }
- const webrtc::RtpPacketReceived& last_received_rtp_packet() const {
+ const RtpPacketReceived& last_received_rtp_packet() const {
return last_received_rtp_packet_;
}
size_t GetDeliveredPacketsForSsrc(uint32_t ssrc) const {
@@ -442,100 +422,95 @@
return last_sent_nonnegative_packet_id_;
}
- webrtc::NetworkState GetNetworkState(webrtc::MediaType media) const;
+ NetworkState GetNetworkState(MediaType media) const;
int GetNumCreatedSendStreams() const;
int GetNumCreatedReceiveStreams() const;
- void SetStats(const webrtc::Call::Stats& stats);
+ void SetStats(const Call::Stats& stats);
void SetClientBitratePreferences(
- const webrtc::BitrateSettings& /* preferences */) override {}
- const webrtc::FieldTrialsView& trials() const override {
- return env_.field_trials();
- }
+ const BitrateSettings& /* preferences */) override {}
+ const FieldTrialsView& trials() const override { return env_.field_trials(); }
void EnableSendCongestionControlFeedbackAccordingToRfc8888() override {}
int FeedbackAccordingToRfc8888Count() { return 0; }
int FeedbackAccordingToTransportCcCount() { return 0; }
private:
- webrtc::AudioSendStream* CreateAudioSendStream(
- const webrtc::AudioSendStream::Config& config) override;
- void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override;
+ AudioSendStream* CreateAudioSendStream(
+ const AudioSendStream::Config& config) override;
+ void DestroyAudioSendStream(AudioSendStream* send_stream) override;
- webrtc::AudioReceiveStreamInterface* CreateAudioReceiveStream(
- const webrtc::AudioReceiveStreamInterface::Config& config) override;
+ AudioReceiveStreamInterface* CreateAudioReceiveStream(
+ const AudioReceiveStreamInterface::Config& config) override;
void DestroyAudioReceiveStream(
- webrtc::AudioReceiveStreamInterface* receive_stream) override;
+ AudioReceiveStreamInterface* receive_stream) override;
- webrtc::VideoSendStream* CreateVideoSendStream(
- webrtc::VideoSendStream::Config config,
- webrtc::VideoEncoderConfig encoder_config) override;
- void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override;
+ VideoSendStream* CreateVideoSendStream(
+ VideoSendStream::Config config,
+ VideoEncoderConfig encoder_config) override;
+ void DestroyVideoSendStream(VideoSendStream* send_stream) override;
- webrtc::VideoReceiveStreamInterface* CreateVideoReceiveStream(
- webrtc::VideoReceiveStreamInterface::Config config) override;
+ VideoReceiveStreamInterface* CreateVideoReceiveStream(
+ VideoReceiveStreamInterface::Config config) override;
void DestroyVideoReceiveStream(
- webrtc::VideoReceiveStreamInterface* receive_stream) override;
+ VideoReceiveStreamInterface* receive_stream) override;
- webrtc::FlexfecReceiveStream* CreateFlexfecReceiveStream(
- const webrtc::FlexfecReceiveStream::Config config) override;
+ FlexfecReceiveStream* CreateFlexfecReceiveStream(
+ const FlexfecReceiveStream::Config config) override;
void DestroyFlexfecReceiveStream(
- webrtc::FlexfecReceiveStream* receive_stream) override;
+ FlexfecReceiveStream* receive_stream) override;
- void AddAdaptationResource(
- rtc::scoped_refptr<webrtc::Resource> resource) override;
+ void AddAdaptationResource(scoped_refptr<Resource> resource) override;
- webrtc::PacketReceiver* Receiver() override;
+ PacketReceiver* Receiver() override;
- void DeliverRtcpPacket(rtc::CopyOnWriteBuffer /* packet */) override {}
+ void DeliverRtcpPacket(CopyOnWriteBuffer /* packet */) override {}
void DeliverRtpPacket(
- webrtc::MediaType media_type,
- webrtc::RtpPacketReceived packet,
+ MediaType media_type,
+ RtpPacketReceived packet,
OnUndemuxablePacketHandler un_demuxable_packet_handler) override;
- bool DeliverPacketInternal(webrtc::MediaType media_type,
+ bool DeliverPacketInternal(MediaType media_type,
uint32_t ssrc,
- const rtc::CopyOnWriteBuffer& packet,
- webrtc::Timestamp arrival_time);
+ const CopyOnWriteBuffer& packet,
+ Timestamp arrival_time);
- webrtc::RtpTransportControllerSendInterface* GetTransportControllerSend()
- override {
+ RtpTransportControllerSendInterface* GetTransportControllerSend() override {
return &transport_controller_send_;
}
- webrtc::Call::Stats GetStats() const override;
+ Call::Stats GetStats() const override;
- webrtc::TaskQueueBase* network_thread() const override;
- webrtc::TaskQueueBase* worker_thread() const override;
+ TaskQueueBase* network_thread() const override;
+ TaskQueueBase* worker_thread() const override;
- void SignalChannelNetworkState(webrtc::MediaType media,
- webrtc::NetworkState state) override;
+ void SignalChannelNetworkState(MediaType media, NetworkState state) override;
void OnAudioTransportOverheadChanged(
int transport_overhead_per_packet) override;
- void OnLocalSsrcUpdated(webrtc::AudioReceiveStreamInterface& stream,
+ void OnLocalSsrcUpdated(AudioReceiveStreamInterface& stream,
uint32_t local_ssrc) override;
- void OnLocalSsrcUpdated(webrtc::VideoReceiveStreamInterface& stream,
+ void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) override;
- void OnLocalSsrcUpdated(webrtc::FlexfecReceiveStream& stream,
+ void OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
uint32_t local_ssrc) override;
- void OnUpdateSyncGroup(webrtc::AudioReceiveStreamInterface& stream,
+ void OnUpdateSyncGroup(AudioReceiveStreamInterface& stream,
absl::string_view sync_group) override;
void OnSentPacket(const rtc::SentPacket& sent_packet) override;
- const webrtc::Environment env_;
- webrtc::TaskQueueBase* const network_thread_;
- webrtc::TaskQueueBase* const worker_thread_;
+ const Environment env_;
+ TaskQueueBase* const network_thread_;
+ TaskQueueBase* const worker_thread_;
- ::testing::NiceMock<webrtc::MockRtpTransportControllerSend>
+ ::testing::NiceMock<MockRtpTransportControllerSend>
transport_controller_send_;
- webrtc::NetworkState audio_network_state_;
- webrtc::NetworkState video_network_state_;
+ NetworkState audio_network_state_;
+ NetworkState video_network_state_;
rtc::SentPacket last_sent_packet_;
- webrtc::RtpPacketReceived last_received_rtp_packet_;
+ RtpPacketReceived last_received_rtp_packet_;
int last_sent_nonnegative_packet_id_ = -1;
int next_stream_id_ = 665;
- webrtc::Call::Stats stats_;
+ Call::Stats stats_;
std::vector<FakeVideoSendStream*> video_send_streams_;
std::vector<FakeAudioSendStream*> audio_send_streams_;
std::vector<FakeVideoReceiveStream*> video_receive_streams_;
@@ -546,8 +521,19 @@
int num_created_send_streams_;
int num_created_receive_streams_;
- webrtc::FakePayloadTypeSuggester pt_suggester_;
+ FakePayloadTypeSuggester pt_suggester_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::FakeAudioReceiveStream;
+using ::webrtc::FakeAudioSendStream;
+using ::webrtc::FakeCall;
+using ::webrtc::FakeFlexfecReceiveStream;
+using ::webrtc::FakeVideoReceiveStream;
+using ::webrtc::FakeVideoSendStream;
} // namespace cricket
#endif // MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_
diff --git a/media/engine/fake_webrtc_video_engine.cc b/media/engine/fake_webrtc_video_engine.cc
index 0fa87f5..8344639 100644
--- a/media/engine/fake_webrtc_video_engine.cc
+++ b/media/engine/fake_webrtc_video_engine.cc
@@ -22,18 +22,16 @@
#include "rtc_base/logging.h"
#include "rtc_base/time_utils.h"
-namespace cricket {
+namespace webrtc {
namespace {
using ::webrtc::Environment;
-static constexpr webrtc::TimeDelta kEventTimeout =
- webrtc::TimeDelta::Seconds(10);
+static constexpr TimeDelta kEventTimeout = TimeDelta::Seconds(10);
-bool IsScalabilityModeSupported(
- const std::vector<webrtc::SdpVideoFormat>& formats,
- std::optional<std::string> scalability_mode) {
+bool IsScalabilityModeSupported(const std::vector<SdpVideoFormat>& formats,
+ std::optional<std::string> scalability_mode) {
if (!scalability_mode.has_value()) {
return true;
}
@@ -63,13 +61,13 @@
return true;
}
-int32_t FakeWebRtcVideoDecoder::Decode(const webrtc::EncodedImage&, int64_t) {
+int32_t FakeWebRtcVideoDecoder::Decode(const EncodedImage&, int64_t) {
num_frames_received_++;
return WEBRTC_VIDEO_CODEC_OK;
}
int32_t FakeWebRtcVideoDecoder::RegisterDecodeCompleteCallback(
- webrtc::DecodedImageCallback*) {
+ DecodedImageCallback*) {
return WEBRTC_VIDEO_CODEC_OK;
}
@@ -85,9 +83,9 @@
FakeWebRtcVideoDecoderFactory::FakeWebRtcVideoDecoderFactory()
: num_created_decoders_(0) {}
-std::vector<webrtc::SdpVideoFormat>
-FakeWebRtcVideoDecoderFactory::GetSupportedFormats() const {
- std::vector<webrtc::SdpVideoFormat> formats;
+std::vector<SdpVideoFormat> FakeWebRtcVideoDecoderFactory::GetSupportedFormats()
+ const {
+ std::vector<SdpVideoFormat> formats;
for (const webrtc::SdpVideoFormat& format : supported_codec_formats_) {
// We need to test erroneous scenarios, so just warn if there's
@@ -102,9 +100,9 @@
return formats;
}
-std::unique_ptr<webrtc::VideoDecoder> FakeWebRtcVideoDecoderFactory::Create(
- const webrtc::Environment& /* env */,
- const webrtc::SdpVideoFormat& format) {
+std::unique_ptr<VideoDecoder> FakeWebRtcVideoDecoderFactory::Create(
+ const Environment& /* env */,
+ const SdpVideoFormat& format) {
if (format.IsCodecInList(supported_codec_formats_)) {
num_created_decoders_++;
std::unique_ptr<FakeWebRtcVideoDecoder> decoder =
@@ -123,7 +121,7 @@
}
void FakeWebRtcVideoDecoderFactory::AddSupportedVideoCodec(
- const webrtc::SdpVideoFormat& format) {
+ const SdpVideoFormat& format) {
supported_codec_formats_.push_back(format);
}
@@ -132,7 +130,7 @@
// This is to match the default H264 params of cricket::Codec.
cricket::Codec video_codec = cricket::CreateVideoCodec(name);
supported_codec_formats_.push_back(
- webrtc::SdpVideoFormat(video_codec.name, video_codec.params));
+ SdpVideoFormat(video_codec.name, video_codec.params));
}
int FakeWebRtcVideoDecoderFactory::GetNumCreatedDecoders() {
@@ -156,30 +154,30 @@
}
void FakeWebRtcVideoEncoder::SetFecControllerOverride(
- webrtc::FecControllerOverride* /* fec_controller_override */) {
+ FecControllerOverride* /* fec_controller_override */) {
// Ignored.
}
int32_t FakeWebRtcVideoEncoder::InitEncode(
- const webrtc::VideoCodec* codecSettings,
+ const VideoCodec* codecSettings,
const VideoEncoder::Settings& /* settings */) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
codec_settings_ = *codecSettings;
init_encode_event_.Set();
return WEBRTC_VIDEO_CODEC_OK;
}
int32_t FakeWebRtcVideoEncoder::Encode(
- const webrtc::VideoFrame& /* inputImage */,
- const std::vector<webrtc::VideoFrameType>* /* frame_types */) {
- webrtc::MutexLock lock(&mutex_);
+ const VideoFrame& /* inputImage */,
+ const std::vector<VideoFrameType>* /* frame_types */) {
+ MutexLock lock(&mutex_);
++num_frames_encoded_;
init_encode_event_.Set();
return WEBRTC_VIDEO_CODEC_OK;
}
int32_t FakeWebRtcVideoEncoder::RegisterEncodeCompleteCallback(
- webrtc::EncodedImageCallback* /* callback */) {
+ EncodedImageCallback* /* callback */) {
return WEBRTC_VIDEO_CODEC_OK;
}
@@ -190,8 +188,7 @@
void FakeWebRtcVideoEncoder::SetRates(
const RateControlParameters& /* parameters */) {}
-webrtc::VideoEncoder::EncoderInfo FakeWebRtcVideoEncoder::GetEncoderInfo()
- const {
+VideoEncoder::EncoderInfo FakeWebRtcVideoEncoder::GetEncoderInfo() const {
EncoderInfo info;
info.is_hardware_accelerated = true;
return info;
@@ -201,13 +198,13 @@
return init_encode_event_.Wait(kEventTimeout);
}
-webrtc::VideoCodec FakeWebRtcVideoEncoder::GetCodecSettings() {
- webrtc::MutexLock lock(&mutex_);
+VideoCodec FakeWebRtcVideoEncoder::GetCodecSettings() {
+ MutexLock lock(&mutex_);
return codec_settings_;
}
int FakeWebRtcVideoEncoder::GetNumEncodedFrames() {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return num_frames_encoded_;
}
@@ -215,9 +212,9 @@
FakeWebRtcVideoEncoderFactory::FakeWebRtcVideoEncoderFactory()
: num_created_encoders_(0), vp8_factory_mode_(false) {}
-std::vector<webrtc::SdpVideoFormat>
-FakeWebRtcVideoEncoderFactory::GetSupportedFormats() const {
- std::vector<webrtc::SdpVideoFormat> formats;
+std::vector<SdpVideoFormat> FakeWebRtcVideoEncoderFactory::GetSupportedFormats()
+ const {
+ std::vector<SdpVideoFormat> formats;
for (const webrtc::SdpVideoFormat& format : formats_) {
// Don't add same codec twice.
@@ -228,11 +225,11 @@
return formats;
}
-webrtc::VideoEncoderFactory::CodecSupport
+VideoEncoderFactory::CodecSupport
FakeWebRtcVideoEncoderFactory::QueryCodecSupport(
- const webrtc::SdpVideoFormat& format,
+ const SdpVideoFormat& format,
std::optional<std::string> scalability_mode) const {
- std::vector<webrtc::SdpVideoFormat> supported_formats;
+ std::vector<SdpVideoFormat> supported_formats;
for (const auto& f : formats_) {
if (format.IsSameCodec(f))
supported_formats.push_back(f);
@@ -244,19 +241,19 @@
return {.is_supported = false};
}
-std::unique_ptr<webrtc::VideoEncoder> FakeWebRtcVideoEncoderFactory::Create(
+std::unique_ptr<VideoEncoder> FakeWebRtcVideoEncoderFactory::Create(
const Environment& env,
- const webrtc::SdpVideoFormat& format) {
- webrtc::MutexLock lock(&mutex_);
- std::unique_ptr<webrtc::VideoEncoder> encoder;
+ const SdpVideoFormat& format) {
+ MutexLock lock(&mutex_);
+ std::unique_ptr<VideoEncoder> encoder;
if (format.IsCodecInList(formats_)) {
- if (absl::EqualsIgnoreCase(format.name, kVp8CodecName) &&
+ if (absl::EqualsIgnoreCase(format.name, cricket::kVp8CodecName) &&
!vp8_factory_mode_) {
// The simulcast adapter will ask this factory for multiple VP8
// encoders. Enter vp8_factory_mode so that we now create these encoders
// instead of more adapters.
vp8_factory_mode_ = true;
- encoder = std::make_unique<webrtc::SimulcastEncoderAdapter>(
+ encoder = std::make_unique<SimulcastEncoderAdapter>(
env, /*primary_factory=*/this, /*fallback_factory=*/nullptr, format);
} else {
num_created_encoders_++;
@@ -276,42 +273,42 @@
if (GetNumCreatedEncoders() >= num_encoders)
return true;
wait_time = kEventTimeout.ms() - (rtc::TimeMillis() - start_offset_ms);
- } while (wait_time > 0 && created_video_encoder_event_.Wait(
- webrtc::TimeDelta::Millis(wait_time)));
+ } while (wait_time > 0 &&
+ created_video_encoder_event_.Wait(TimeDelta::Millis(wait_time)));
return false;
}
void FakeWebRtcVideoEncoderFactory::EncoderDestroyed(
FakeWebRtcVideoEncoder* encoder) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
encoders_.erase(std::remove(encoders_.begin(), encoders_.end(), encoder),
encoders_.end());
}
void FakeWebRtcVideoEncoderFactory::AddSupportedVideoCodec(
- const webrtc::SdpVideoFormat& format) {
+ const SdpVideoFormat& format) {
formats_.push_back(format);
}
void FakeWebRtcVideoEncoderFactory::AddSupportedVideoCodecType(
const std::string& name,
- const std::vector<webrtc::ScalabilityMode>& scalability_modes) {
+ const std::vector<ScalabilityMode>& scalability_modes) {
// This is to match the default H264 params of cricket::Codec.
cricket::Codec video_codec = cricket::CreateVideoCodec(name);
- formats_.push_back(webrtc::SdpVideoFormat(
- video_codec.name, video_codec.params,
- {scalability_modes.begin(), scalability_modes.end()}));
+ formats_.push_back(
+ SdpVideoFormat(video_codec.name, video_codec.params,
+ {scalability_modes.begin(), scalability_modes.end()}));
}
int FakeWebRtcVideoEncoderFactory::GetNumCreatedEncoders() {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return num_created_encoders_;
}
const std::vector<FakeWebRtcVideoEncoder*>
FakeWebRtcVideoEncoderFactory::encoders() {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return encoders_;
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/media/engine/fake_webrtc_video_engine.h b/media/engine/fake_webrtc_video_engine.h
index 8d78e86..6fa4edc 100644
--- a/media/engine/fake_webrtc_video_engine.h
+++ b/media/engine/fake_webrtc_video_engine.h
@@ -34,21 +34,20 @@
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
-namespace cricket {
+namespace webrtc {
class FakeWebRtcVideoDecoderFactory;
class FakeWebRtcVideoEncoderFactory;
// Fake class for mocking out webrtc::VideoDecoder
-class FakeWebRtcVideoDecoder : public webrtc::VideoDecoder {
+class FakeWebRtcVideoDecoder : public VideoDecoder {
public:
explicit FakeWebRtcVideoDecoder(FakeWebRtcVideoDecoderFactory* factory);
~FakeWebRtcVideoDecoder();
bool Configure(const Settings& settings) override;
- int32_t Decode(const webrtc::EncodedImage&, int64_t) override;
- int32_t RegisterDecodeCompleteCallback(
- webrtc::DecodedImageCallback*) override;
+ int32_t Decode(const EncodedImage&, int64_t) override;
+ int32_t RegisterDecodeCompleteCallback(DecodedImageCallback*) override;
int32_t Release() override;
int GetNumFramesReceived() const;
@@ -59,90 +58,96 @@
};
// Fake class for mocking out webrtc::VideoDecoderFactory.
-class FakeWebRtcVideoDecoderFactory : public webrtc::VideoDecoderFactory {
+class FakeWebRtcVideoDecoderFactory : public VideoDecoderFactory {
public:
FakeWebRtcVideoDecoderFactory();
- std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override;
- std::unique_ptr<webrtc::VideoDecoder> Create(
- const webrtc::Environment& env,
- const webrtc::SdpVideoFormat& format) override;
+ std::vector<SdpVideoFormat> GetSupportedFormats() const override;
+ std::unique_ptr<VideoDecoder> Create(const Environment& env,
+ const SdpVideoFormat& format) override;
void DecoderDestroyed(FakeWebRtcVideoDecoder* decoder);
- void AddSupportedVideoCodec(const webrtc::SdpVideoFormat& format);
+ void AddSupportedVideoCodec(const SdpVideoFormat& format);
void AddSupportedVideoCodecType(const std::string& name);
int GetNumCreatedDecoders();
const std::vector<FakeWebRtcVideoDecoder*>& decoders();
private:
- std::vector<webrtc::SdpVideoFormat> supported_codec_formats_;
+ std::vector<SdpVideoFormat> supported_codec_formats_;
std::vector<FakeWebRtcVideoDecoder*> decoders_;
int num_created_decoders_;
};
// Fake class for mocking out webrtc::VideoEnoder
-class FakeWebRtcVideoEncoder : public webrtc::VideoEncoder {
+class FakeWebRtcVideoEncoder : public VideoEncoder {
public:
explicit FakeWebRtcVideoEncoder(FakeWebRtcVideoEncoderFactory* factory);
~FakeWebRtcVideoEncoder();
void SetFecControllerOverride(
- webrtc::FecControllerOverride* fec_controller_override) override;
- int32_t InitEncode(const webrtc::VideoCodec* codecSettings,
+ FecControllerOverride* fec_controller_override) override;
+ int32_t InitEncode(const VideoCodec* codecSettings,
const VideoEncoder::Settings& settings) override;
- int32_t Encode(
- const webrtc::VideoFrame& inputImage,
- const std::vector<webrtc::VideoFrameType>* frame_types) override;
+ int32_t Encode(const VideoFrame& inputImage,
+ const std::vector<VideoFrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(
- webrtc::EncodedImageCallback* callback) override;
+ EncodedImageCallback* callback) override;
int32_t Release() override;
void SetRates(const RateControlParameters& parameters) override;
- webrtc::VideoEncoder::EncoderInfo GetEncoderInfo() const override;
+ VideoEncoder::EncoderInfo GetEncoderInfo() const override;
bool WaitForInitEncode();
- webrtc::VideoCodec GetCodecSettings();
+ VideoCodec GetCodecSettings();
int GetNumEncodedFrames();
private:
- webrtc::Mutex mutex_;
+ Mutex mutex_;
rtc::Event init_encode_event_;
int num_frames_encoded_ RTC_GUARDED_BY(mutex_);
- webrtc::VideoCodec codec_settings_ RTC_GUARDED_BY(mutex_);
+ VideoCodec codec_settings_ RTC_GUARDED_BY(mutex_);
FakeWebRtcVideoEncoderFactory* factory_;
};
// Fake class for mocking out webrtc::VideoEncoderFactory.
-class FakeWebRtcVideoEncoderFactory : public webrtc::VideoEncoderFactory {
+class FakeWebRtcVideoEncoderFactory : public VideoEncoderFactory {
public:
FakeWebRtcVideoEncoderFactory();
- std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override;
- webrtc::VideoEncoderFactory::CodecSupport QueryCodecSupport(
- const webrtc::SdpVideoFormat& format,
+ std::vector<SdpVideoFormat> GetSupportedFormats() const override;
+ VideoEncoderFactory::CodecSupport QueryCodecSupport(
+ const SdpVideoFormat& format,
std::optional<std::string> scalability_mode) const override;
- std::unique_ptr<webrtc::VideoEncoder> Create(
- const webrtc::Environment& env,
- const webrtc::SdpVideoFormat& format) override;
+ std::unique_ptr<VideoEncoder> Create(const Environment& env,
+ const SdpVideoFormat& format) override;
bool WaitForCreatedVideoEncoders(int num_encoders);
void EncoderDestroyed(FakeWebRtcVideoEncoder* encoder);
void set_encoders_have_internal_sources(bool internal_source);
- void AddSupportedVideoCodec(const webrtc::SdpVideoFormat& format);
+ void AddSupportedVideoCodec(const SdpVideoFormat& format);
void AddSupportedVideoCodecType(
const std::string& name,
- const std::vector<webrtc::ScalabilityMode>& scalability_modes = {});
+ const std::vector<ScalabilityMode>& scalability_modes = {});
int GetNumCreatedEncoders();
const std::vector<FakeWebRtcVideoEncoder*> encoders();
private:
- webrtc::Mutex mutex_;
+ Mutex mutex_;
rtc::Event created_video_encoder_event_;
- std::vector<webrtc::SdpVideoFormat> formats_;
+ std::vector<SdpVideoFormat> formats_;
std::vector<FakeWebRtcVideoEncoder*> encoders_ RTC_GUARDED_BY(mutex_);
int num_created_encoders_ RTC_GUARDED_BY(mutex_);
bool vp8_factory_mode_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::FakeWebRtcVideoDecoder;
+using ::webrtc::FakeWebRtcVideoDecoderFactory;
+using ::webrtc::FakeWebRtcVideoEncoder;
+using ::webrtc::FakeWebRtcVideoEncoderFactory;
} // namespace cricket
#endif // MEDIA_ENGINE_FAKE_WEBRTC_VIDEO_ENGINE_H_
diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc
index 23e85ab..39d9bfc 100644
--- a/media/engine/webrtc_video_engine_unittest.cc
+++ b/media/engine/webrtc_video_engine_unittest.cc
@@ -406,13 +406,13 @@
time_controller_.CreateTaskQueueFactory(),
time_controller_.GetClock())),
call_(Call::Create(CallConfig(env_))),
- encoder_factory_(new cricket::FakeWebRtcVideoEncoderFactory),
- decoder_factory_(new cricket::FakeWebRtcVideoDecoderFactory),
+ encoder_factory_(new webrtc::FakeWebRtcVideoEncoderFactory),
+ decoder_factory_(new webrtc::FakeWebRtcVideoDecoderFactory),
video_bitrate_allocator_factory_(
webrtc::CreateBuiltinVideoBitrateAllocatorFactory()),
- engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
+ engine_(std::unique_ptr<webrtc::FakeWebRtcVideoEncoderFactory>(
encoder_factory_),
- std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
+ std::unique_ptr<webrtc::FakeWebRtcVideoDecoderFactory>(
decoder_factory_),
field_trials_) {}
@@ -448,8 +448,8 @@
// Used in WebRtcVideoEngineVoiceTest, but defined here so it's properly
// initialized when the constructor is called.
std::unique_ptr<Call> call_;
- cricket::FakeWebRtcVideoEncoderFactory* encoder_factory_;
- cricket::FakeWebRtcVideoDecoderFactory* decoder_factory_;
+ webrtc::FakeWebRtcVideoEncoderFactory* encoder_factory_;
+ webrtc::FakeWebRtcVideoDecoderFactory* decoder_factory_;
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory_;
WebRtcVideoEngine engine_;
@@ -772,8 +772,8 @@
EXPECT_EQ(0, encoder_factory_->GetNumCreatedEncoders());
EXPECT_TRUE(send_channel->SetSend(true));
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(send_channel->SetVideoSend(kSsrc, nullptr, &frame_forwarder));
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
time_controller_.AdvanceTime(webrtc::TimeDelta::Zero());
@@ -852,7 +852,7 @@
TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) {
AddSupportedVideoCodecType("VP8");
- FakeCall* fake_call = new FakeCall(env_);
+ webrtc::FakeCall* fake_call = new webrtc::FakeCall(env_);
call_.reset(fake_call);
auto send_channel = SetSendParamsWithAllSupportedCodecs();
@@ -860,12 +860,12 @@
send_channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 60);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 60);
EXPECT_TRUE(send_channel->SetVideoSend(kSsrc, nullptr, &frame_forwarder));
send_channel->SetSend(true);
- FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
+ webrtc::FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
int64_t last_timestamp = stream->GetLastTimestamp();
@@ -1039,7 +1039,7 @@
std::unique_ptr<VideoMediaReceiveChannelInterface> receive_channel =
engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions());
- cricket::FakeNetworkInterface network;
+ webrtc::FakeNetworkInterface network;
receive_channel->SetInterface(&network);
EXPECT_EQ(10000, network.recvbuf_size());
receive_channel->SetInterface(nullptr);
@@ -1053,7 +1053,7 @@
std::unique_ptr<VideoMediaReceiveChannelInterface> receive_channel =
engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions());
- cricket::FakeNetworkInterface network;
+ webrtc::FakeNetworkInterface network;
receive_channel->SetInterface(&network);
EXPECT_EQ(kVideoRtpRecvBufferSize, network.recvbuf_size());
receive_channel->SetInterface(nullptr);
@@ -1066,7 +1066,7 @@
std::unique_ptr<VideoMediaReceiveChannelInterface> receive_channel =
engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions());
- cricket::FakeNetworkInterface network;
+ webrtc::FakeNetworkInterface network;
receive_channel->SetInterface(&network);
EXPECT_EQ(kVideoRtpRecvBufferSize, network.recvbuf_size());
receive_channel->SetInterface(nullptr);
@@ -1123,13 +1123,13 @@
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- EXPECT_TRUE(
- send_channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
+ EXPECT_TRUE(send_channel->AddSendStream(
+ webrtc::CreateSimStreamParams("cname", ssrcs)));
EXPECT_TRUE(send_channel->SetSend(true));
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 60);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 60);
EXPECT_TRUE(
send_channel->SetVideoSend(ssrcs.front(), nullptr, &frame_forwarder));
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
@@ -1160,8 +1160,8 @@
// Frame source.
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
std::unique_ptr<VideoMediaSendChannelInterface> send_channel =
engine_.CreateSendChannel(call_.get(), GetMediaConfig(), VideoOptions(),
@@ -1206,16 +1206,16 @@
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- EXPECT_TRUE(
- send_channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
+ EXPECT_TRUE(send_channel->AddSendStream(
+ webrtc::CreateSimStreamParams("cname", ssrcs)));
EXPECT_TRUE(send_channel->SetSend(true));
// Send a fake frame, or else the media engine will configure the simulcast
// encoder adapter at a low-enough size that it'll only create a single
// encoder layer.
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(
send_channel->SetVideoSend(ssrcs.front(), nullptr, &frame_forwarder));
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
@@ -1249,8 +1249,8 @@
// Send a frame of 720p. This should trigger a "real" encoder initialization.
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(send_channel->SetVideoSend(kSsrc, nullptr, &frame_forwarder));
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
time_controller_.AdvanceTime(webrtc::TimeDelta::Zero());
@@ -1279,19 +1279,19 @@
const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
EXPECT_TRUE(send_channel->AddSendStream(
- cricket::CreateSimStreamParams("cname", ssrcs)));
+ webrtc::CreateSimStreamParams("cname", ssrcs)));
// Send a frame of 720p. This should trigger a "real" encoder initialization.
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(send_channel->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder));
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
time_controller_.AdvanceTime(webrtc::TimeDelta::Zero());
ASSERT_TRUE(encoder_factory_->WaitForCreatedVideoEncoders(1));
ASSERT_EQ(1u, encoder_factory_->encoders().size());
- FakeWebRtcVideoEncoder* encoder = encoder_factory_->encoders()[0];
+ webrtc::FakeWebRtcVideoEncoder* encoder = encoder_factory_->encoders()[0];
ASSERT_TRUE(encoder_factory_->encoders()[0]->WaitForInitEncode());
EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType);
EXPECT_LT(1u, encoder->GetCodecSettings().numberOfSimulcastStreams);
@@ -1526,7 +1526,7 @@
// Mock encoder creation. `engine` take ownership of the encoder.
const webrtc::SdpVideoFormat format("VP8");
EXPECT_CALL(*encoder_factory, Create(_, format)).WillOnce([&] {
- return std::make_unique<FakeWebRtcVideoEncoder>(nullptr);
+ return std::make_unique<webrtc::FakeWebRtcVideoEncoder>(nullptr);
});
// Expect no decoder to be created at this point. The decoder will only be
@@ -1557,8 +1557,8 @@
// Set capturer.
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(send_channel->SetVideoSend(send_ssrc, nullptr, &frame_forwarder));
// Sending one frame will allocate the encoder.
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
@@ -1586,7 +1586,7 @@
TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
- auto fake_call = std::make_unique<FakeCall>(env_);
+ auto fake_call = std::make_unique<webrtc::FakeCall>(env_);
auto send_channel = SetSendParamsWithAllSupportedCodecs();
ASSERT_TRUE(
@@ -1599,8 +1599,8 @@
ASSERT_TRUE(send_channel->SetSenderParameters(parameters));
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
VideoOptions options;
EXPECT_TRUE(send_channel->SetVideoSend(kSsrc, &options, &frame_forwarder));
@@ -1727,8 +1727,8 @@
WebRtcVideoEngine engine_;
std::unique_ptr<VideoMediaSendChannelInterface> send_channel_;
std::unique_ptr<VideoMediaReceiveChannelInterface> receive_channel_;
- cricket::FakeNetworkInterface network_interface_;
- cricket::FakeVideoRenderer renderer_;
+ webrtc::FakeNetworkInterface network_interface_;
+ webrtc::FakeVideoRenderer renderer_;
};
const std::vector<webrtc::SdpVideoFormat>
@@ -1884,7 +1884,7 @@
receive_channel_->SetReceiverParameters(parameters);
EXPECT_TRUE(send_channel_->AddSendStream(DefaultSendStreamParams()));
frame_forwarder_ = std::make_unique<webrtc::test::FrameForwarder>();
- frame_source_ = std::make_unique<cricket::FakeFrameSource>(
+ frame_source_ = std::make_unique<webrtc::FakeFrameSource>(
640, 480, rtc::kNumMicrosecsPerSec / kFramerate);
EXPECT_TRUE(
send_channel_->SetVideoSend(kSsrc, nullptr, frame_forwarder_.get()));
@@ -1942,7 +1942,7 @@
bool SetDefaultCodec() { return SetOneCodec(DefaultCodec()); }
bool SetOneCodec(const cricket::Codec& codec) {
- frame_source_ = std::make_unique<cricket::FakeFrameSource>(
+ frame_source_ = std::make_unique<webrtc::FakeFrameSource>(
kVideoWidth, kVideoHeight, rtc::kNumMicrosecsPerSec / kFramerate);
bool sending = SendImpl()->sending();
@@ -2066,17 +2066,17 @@
video_bitrate_allocator_factory_;
WebRtcVideoEngine engine_;
- std::unique_ptr<cricket::FakeFrameSource> frame_source_;
+ std::unique_ptr<webrtc::FakeFrameSource> frame_source_;
std::unique_ptr<webrtc::test::FrameForwarder> frame_forwarder_;
std::unique_ptr<webrtc::test::FrameForwarder> frame_forwarder_2_;
std::unique_ptr<VideoMediaSendChannelInterface> send_channel_;
std::unique_ptr<VideoMediaReceiveChannelInterface> receive_channel_;
- cricket::FakeNetworkInterface network_interface_;
- cricket::FakeVideoRenderer renderer_;
+ webrtc::FakeNetworkInterface network_interface_;
+ webrtc::FakeVideoRenderer renderer_;
// Used by test cases where 2 streams are run on the same channel.
- cricket::FakeVideoRenderer renderer2_;
+ webrtc::FakeVideoRenderer renderer2_;
};
// Test that SetSend works.
@@ -2173,7 +2173,7 @@
// Test that stats work properly for a conf call with multiple recv streams.
TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleRecvStreams) {
- cricket::FakeVideoRenderer renderer1, renderer2;
+ webrtc::FakeVideoRenderer renderer1, renderer2;
EXPECT_TRUE(SetOneCodec(DefaultCodec()));
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(DefaultCodec());
@@ -2242,12 +2242,12 @@
EXPECT_FRAME(1, kVideoWidth, kVideoHeight);
// Add an additional capturer, and hook up a renderer to receive it.
- cricket::FakeVideoRenderer renderer2;
+ webrtc::FakeVideoRenderer renderer2;
webrtc::test::FrameForwarder frame_forwarder;
const int kTestWidth = 160;
const int kTestHeight = 120;
- cricket::FakeFrameSource frame_source(kTestWidth, kTestHeight,
- rtc::kNumMicrosecsPerSec / 5);
+ webrtc::FakeFrameSource frame_source(kTestWidth, kTestHeight,
+ rtc::kNumMicrosecsPerSec / 5);
EXPECT_TRUE(
send_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(5678)));
EXPECT_TRUE(send_channel_->SetVideoSend(5678, nullptr, &frame_forwarder));
@@ -2379,7 +2379,7 @@
// Tests the behavior of incoming streams in a conference scenario.
TEST_F(WebRtcVideoChannelBaseTest, SimulateConference) {
- cricket::FakeVideoRenderer renderer1, renderer2;
+ webrtc::FakeVideoRenderer renderer1, renderer2;
EXPECT_TRUE(SetDefaultCodec());
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(DefaultCodec());
@@ -2428,8 +2428,8 @@
EXPECT_FRAME(1, kVideoWidth, kVideoHeight);
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(480, 360, rtc::kNumMicrosecsPerSec / 30,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(480, 360, rtc::kNumMicrosecsPerSec / 30,
+ rtc::kNumMicrosecsPerSec / 30);
// TODO(nisse): This testcase fails if we don't configure
// screencast. It's unclear why, I see nothing obvious in this
@@ -2507,7 +2507,7 @@
kVideoWidth, kVideoHeight,
cricket::VideoFormat::FpsToInterval(kFramerate), cricket::FOURCC_I420);
// Set up additional stream 1.
- cricket::FakeVideoRenderer renderer1;
+ webrtc::FakeVideoRenderer renderer1;
EXPECT_FALSE(receive_channel_->SetSink(1, &renderer1));
EXPECT_TRUE(
receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
@@ -2516,11 +2516,11 @@
send_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(1)));
webrtc::test::FrameForwarder frame_forwarder1;
- cricket::FakeFrameSource frame_source(kVideoWidth, kVideoHeight,
- rtc::kNumMicrosecsPerSec / kFramerate);
+ webrtc::FakeFrameSource frame_source(kVideoWidth, kVideoHeight,
+ rtc::kNumMicrosecsPerSec / kFramerate);
// Set up additional stream 2.
- cricket::FakeVideoRenderer renderer2;
+ webrtc::FakeVideoRenderer renderer2;
EXPECT_FALSE(receive_channel_->SetSink(2, &renderer2));
EXPECT_TRUE(
receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
@@ -2764,7 +2764,7 @@
AddSupportedVideoCodecType("H264");
#endif
- fake_call_ = std::make_unique<FakeCall>(env_);
+ fake_call_ = std::make_unique<webrtc::FakeCall>(env_);
send_channel_ = engine_.CreateSendChannel(
fake_call_.get(), GetMediaConfig(), VideoOptions(),
webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get());
@@ -2837,31 +2837,31 @@
}
protected:
- FakeVideoSendStream* AddSendStream() {
+ webrtc::FakeVideoSendStream* AddSendStream() {
return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
}
- FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
+ webrtc::FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
size_t num_streams = fake_call_->GetVideoSendStreams().size();
EXPECT_TRUE(send_channel_->AddSendStream(sp));
- std::vector<FakeVideoSendStream*> streams =
+ std::vector<webrtc::FakeVideoSendStream*> streams =
fake_call_->GetVideoSendStreams();
EXPECT_EQ(num_streams + 1, streams.size());
return streams[streams.size() - 1];
}
- std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
+ std::vector<webrtc::FakeVideoSendStream*> GetFakeSendStreams() {
return fake_call_->GetVideoSendStreams();
}
- FakeVideoReceiveStream* AddRecvStream() {
+ webrtc::FakeVideoReceiveStream* AddRecvStream() {
return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_));
}
- FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
+ webrtc::FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
EXPECT_TRUE(receive_channel_->AddRecvStream(sp));
- std::vector<FakeVideoReceiveStream*> streams =
+ std::vector<webrtc::FakeVideoReceiveStream*> streams =
fake_call_->GetVideoReceiveStreams();
EXPECT_EQ(num_streams + 1, streams.size());
return streams[streams.size() - 1];
@@ -2931,7 +2931,7 @@
cricket::VideoSenderParameters parameters = send_parameters_;
parameters.extensions.push_back(RtpExtension(ext_uri, id));
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(123));
// Verify the send extension id.
@@ -3000,12 +3000,12 @@
EXPECT_TRUE(send_channel_->SetSend(true));
// Send side.
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(1));
EXPECT_EQ(send_stream->GetConfig().rtp.lntf.enabled, expect_lntf_enabled);
// Receiver side.
- FakeVideoReceiveStream* recv_stream =
+ webrtc::FakeVideoReceiveStream* recv_stream =
AddRecvStream(cricket::StreamParams::CreateLegacy(1));
EXPECT_EQ(recv_stream->GetConfig().rtp.lntf.enabled, expect_lntf_enabled);
}
@@ -3021,7 +3021,7 @@
parameters.extensions.push_back(RtpExtension(extension, id++));
}
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(123));
// Verify that only one of them has been set, and that it is the one with
@@ -3040,7 +3040,7 @@
void TestReceiveUnsignaledSsrcPacket(uint8_t payload_type,
bool expect_created_receive_stream);
- FakeVideoSendStream* SetDenoisingOption(
+ webrtc::FakeVideoSendStream* SetDenoisingOption(
uint32_t ssrc,
webrtc::test::FrameForwarder* frame_forwarder,
bool enabled) {
@@ -3053,7 +3053,7 @@
return fake_call_->GetVideoSendStreams().back();
}
- FakeVideoSendStream* SetUpSimulcast(bool enabled, bool with_rtx) {
+ webrtc::FakeVideoSendStream* SetUpSimulcast(bool enabled, bool with_rtx) {
const int kRtxSsrcOffset = 0xDEADBEEF;
last_ssrc_ += 3;
std::vector<uint32_t> ssrcs;
@@ -3068,16 +3068,16 @@
}
if (with_rtx) {
return AddSendStream(
- cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
+ webrtc::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
}
- return AddSendStream(CreateSimStreamParams("cname", ssrcs));
+ return AddSendStream(webrtc::CreateSimStreamParams("cname", ssrcs));
}
int GetMaxEncoderBitrate() {
- std::vector<FakeVideoSendStream*> streams =
+ std::vector<webrtc::FakeVideoSendStream*> streams =
fake_call_->GetVideoSendStreams();
EXPECT_EQ(1u, streams.size());
- FakeVideoSendStream* stream = streams[streams.size() - 1];
+ webrtc::FakeVideoSendStream* stream = streams[streams.size() - 1];
EXPECT_EQ(1u, stream->GetEncoderConfig().number_of_streams);
return stream->GetVideoStreams()[0].max_bitrate_bps;
}
@@ -3117,8 +3117,8 @@
return layers;
}
- cricket::FakeFrameSource frame_source_;
- std::unique_ptr<FakeCall> fake_call_;
+ webrtc::FakeFrameSource frame_source_;
+ std::unique_ptr<webrtc::FakeCall> fake_call_;
std::unique_ptr<VideoMediaSendChannelInterface> send_channel_;
std::unique_ptr<VideoMediaReceiveChannelInterface> receive_channel_;
cricket::VideoSenderParameters send_parameters_;
@@ -3151,16 +3151,16 @@
// Send side.
const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
- FakeVideoSendStream* send_stream = AddSendStream(
- cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
+ webrtc::FakeVideoSendStream* send_stream = AddSendStream(
+ webrtc::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
// Receiver side.
- FakeVideoReceiveStream* recv_stream = AddRecvStream(
- cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
+ webrtc::FakeVideoReceiveStream* recv_stream = AddRecvStream(
+ webrtc::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
EXPECT_FALSE(
recv_stream->GetConfig().rtp.rtx_associated_payload_types.empty());
EXPECT_TRUE(VerifyRtxReceiveAssociations(recv_stream->GetConfig()))
@@ -3177,7 +3177,7 @@
cricket::StreamParams params =
cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
- FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
+ webrtc::FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
EXPECT_EQ(kRtxSsrcs1[0], recv_stream->GetConfig().rtp.rtx_ssrc);
EXPECT_TRUE(VerifyRtxReceiveAssociations(recv_stream->GetConfig()))
@@ -3191,7 +3191,7 @@
// Setup one channel without an associated RTX stream.
cricket::StreamParams params =
cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
- FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
+ webrtc::FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
ASSERT_EQ(0U, recv_stream->GetConfig().rtp.rtx_ssrc);
}
@@ -3210,7 +3210,7 @@
}
TEST_F(WebRtcVideoChannelTest, NoHeaderExtesionsByDefault) {
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
@@ -3281,7 +3281,7 @@
TEST_F(WebRtcVideoChannelTest, DisableFrameInstrumentationByDefault) {
EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(123));
EXPECT_FALSE(send_stream->GetConfig()
.encoder_settings.enable_frame_instrumentation_generator);
@@ -3294,7 +3294,7 @@
RtpExtension::kCorruptionDetectionUri, /*id=*/1, /*encrypt=*/true));
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(123));
EXPECT_TRUE(send_stream->GetConfig()
.encoder_settings.enable_frame_instrumentation_generator);
@@ -3307,7 +3307,7 @@
RtpExtension::kCorruptionDetectionUri, /*id=*/1, /*encrypt=*/false));
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(123));
EXPECT_FALSE(send_stream->GetConfig()
.encoder_settings.enable_frame_instrumentation_generator);
@@ -3322,7 +3322,7 @@
RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(123));
EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
@@ -3352,7 +3352,7 @@
send_parameters_.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(123));
// Only timestamp offset extension is set to send stream,
@@ -3464,7 +3464,7 @@
}
TEST_F(WebRtcVideoChannelTest, RtcpIsCompoundByDefault) {
- FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
EXPECT_EQ(webrtc::RtcpMode::kCompound, stream->GetConfig().rtp.rtcp_mode);
}
@@ -3495,10 +3495,10 @@
}
// Start with LNTF enabled.
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(1));
ASSERT_TRUE(send_stream->GetConfig().rtp.lntf.enabled);
- FakeVideoReceiveStream* recv_stream =
+ webrtc::FakeVideoReceiveStream* recv_stream =
AddRecvStream(cricket::StreamParams::CreateLegacy(1));
ASSERT_TRUE(recv_stream->GetConfig().rtp.lntf.enabled);
@@ -3531,12 +3531,12 @@
EXPECT_TRUE(send_channel_->SetSend(true));
// Send side.
- FakeVideoSendStream* send_stream =
+ webrtc::FakeVideoSendStream* send_stream =
AddSendStream(cricket::StreamParams::CreateLegacy(1));
EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
// Receiver side.
- FakeVideoReceiveStream* recv_stream =
+ webrtc::FakeVideoReceiveStream* recv_stream =
AddRecvStream(cricket::StreamParams::CreateLegacy(1));
EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
@@ -3546,8 +3546,8 @@
}
TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) {
- FakeVideoSendStream* send_stream = AddSendStream();
- FakeVideoReceiveStream* recv_stream = AddRecvStream();
+ webrtc::FakeVideoSendStream* send_stream = AddSendStream();
+ webrtc::FakeVideoReceiveStream* recv_stream = AddRecvStream();
EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
@@ -3583,7 +3583,7 @@
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
send_channel_->SetSend(false);
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
// No frames entered.
std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
@@ -3591,8 +3591,8 @@
EXPECT_EQ(0u, streams[0].height);
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(
send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
@@ -3615,8 +3615,8 @@
AddSendStream();
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
VideoOptions min_bitrate_options;
min_bitrate_options.screencast_min_bitrate_kbps = kScreenshareMinBitrateKbps;
EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, &min_bitrate_options,
@@ -3626,7 +3626,8 @@
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
@@ -3677,15 +3678,16 @@
VideoOptions options;
options.is_screencast = true;
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(
send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
EXPECT_TRUE(send_channel_->SetSend(true));
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
webrtc::VideoEncoderConfig encoder_config =
send_stream->GetEncoderConfig().Copy();
@@ -3705,7 +3707,7 @@
}
TEST_F(WebRtcVideoChannelTest, SuspendBelowMinBitrateDisabledByDefault) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
}
@@ -3722,7 +3724,7 @@
send_channel_->SetSenderParameters(send_parameters_);
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
media_config.video.suspend_below_min_bitrate = false;
@@ -3740,7 +3742,7 @@
}
TEST_F(WebRtcVideoChannelTest, Vp8DenoisingEnabledByDefault) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoCodecVP8 vp8_settings;
ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
EXPECT_TRUE(vp8_settings.denoisingOn);
@@ -3754,7 +3756,8 @@
// Single-stream settings should apply with RTX as well (verifies that we
// check number of regular SSRCs and not StreamParams::ssrcs which contains
// both RTX and regular SSRCs).
- FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/true);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(false, /*with_rtx=*/true);
webrtc::test::FrameForwarder frame_forwarder;
EXPECT_TRUE(
@@ -3830,7 +3833,8 @@
// Single-stream settings should apply with RTX as well (verifies that we
// check number of regular SSRCs and not StreamParams::ssrcs which contains
// both RTX and regular SSRCs).
- FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/true);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(false, /*with_rtx=*/true);
EXPECT_TRUE(
send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
send_channel_->SetSend(true);
@@ -3866,7 +3870,8 @@
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
EXPECT_TRUE(
send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
@@ -3899,7 +3904,8 @@
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
EXPECT_TRUE(
send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
@@ -3949,7 +3955,8 @@
parameters.codecs.push_back(GetEngineCodec("VP9"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(false, /*with_rtx=*/false);
webrtc::test::FrameForwarder frame_forwarder;
EXPECT_TRUE(
@@ -4046,8 +4053,8 @@
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- FakeVideoSendStream* stream =
- AddSendStream(CreateSimStreamParams("cname", ssrcs));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreateSimStreamParams("cname", ssrcs));
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
@@ -4075,8 +4082,8 @@
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- FakeVideoSendStream* stream =
- AddSendStream(CreateSimStreamParams("cname", ssrcs));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreateSimStreamParams("cname", ssrcs));
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
@@ -4106,8 +4113,8 @@
const size_t kNumSpatialLayers = 3;
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- FakeVideoSendStream* stream =
- AddSendStream(CreateSimStreamParams("cname", ssrcs));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreateSimStreamParams("cname", ssrcs));
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(ssrcs[0]);
@@ -4138,8 +4145,8 @@
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- FakeVideoSendStream* stream =
- AddSendStream(CreateSimStreamParams("cname", ssrcs));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreateSimStreamParams("cname", ssrcs));
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
@@ -4184,8 +4191,8 @@
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- FakeVideoSendStream* stream =
- AddSendStream(CreateSimStreamParams("cname", ssrcs));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreateSimStreamParams("cname", ssrcs));
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
@@ -4235,7 +4242,8 @@
parameters.codecs.push_back(GetEngineCodec("VP9"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(false, /*with_rtx=*/false);
webrtc::test::FrameForwarder frame_forwarder;
EXPECT_TRUE(
@@ -4366,7 +4374,8 @@
send_channel_->SetVideoSend(last_ssrc_, &camera_options, &frame_forwarder);
ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
EXPECT_TRUE(send_stream->resolution_scaling_enabled());
// Dont' expect anything on framerate_scaling_enabled, since the default is
@@ -4420,7 +4429,8 @@
EXPECT_TRUE(send_channel_->SetSend(true));
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
EXPECT_EQ(resolution_scaling_enabled,
send_stream->resolution_scaling_enabled());
EXPECT_EQ(fps_scaling_enabled, send_stream->framerate_scaling_enabled());
@@ -4457,7 +4467,8 @@
EXPECT_TRUE(send_channel_->SetSend(true));
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
if (!enable_overuse) {
EXPECT_FALSE(send_stream->resolution_scaling_enabled());
@@ -4479,8 +4490,8 @@
static const int kFrameOffsetMs = 20;
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
- FakeVideoReceiveStream* stream = AddRecvStream();
- cricket::FakeVideoRenderer renderer;
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoRenderer renderer;
EXPECT_TRUE(receive_channel_->SetSink(last_ssrc_, &renderer));
webrtc::VideoFrame video_frame =
@@ -4528,8 +4539,8 @@
// Using a RTX setup to verify that the default RTX payload type is good.
const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
- FakeVideoSendStream* stream = AddSendStream(
- cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
+ webrtc::FakeVideoSendStream* stream = AddSendStream(
+ webrtc::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
// Make sure NACK and FEC are enabled on the correct payload types.
@@ -4548,7 +4559,7 @@
parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
const webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_FALSE(config.rtp.raw_payload);
}
@@ -4559,7 +4570,7 @@
parameters.codecs.back().packetization = kPacketizationParamRaw;
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
const webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_TRUE(config.rtp.raw_payload);
}
@@ -4569,7 +4580,7 @@
// TODO(brandtr): Remove or update these tests when FlexFEC _is_ enabled by
// default.
TEST_F(WebRtcVideoChannelTest, FlexfecSendCodecWithoutSsrcNotExposedByDefault) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
@@ -4578,8 +4589,9 @@
}
TEST_F(WebRtcVideoChannelTest, FlexfecSendCodecWithSsrcNotExposedByDefault) {
- FakeVideoSendStream* stream = AddSendStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreatePrimaryWithFecFrStreamParams(
+ "cname", kSsrcs1[0], kFlexfecSsrc));
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
@@ -4590,16 +4602,16 @@
TEST_F(WebRtcVideoChannelTest, FlexfecRecvCodecWithoutSsrcNotExposedByDefault) {
AddRecvStream();
- const std::vector<FakeFlexfecReceiveStream*>& streams =
+ const std::vector<webrtc::FakeFlexfecReceiveStream*>& streams =
fake_call_->GetFlexfecReceiveStreams();
EXPECT_TRUE(streams.empty());
}
TEST_F(WebRtcVideoChannelTest, FlexfecRecvCodecWithSsrcExposedByDefault) {
- AddRecvStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ AddRecvStream(webrtc::CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0],
+ kFlexfecSsrc));
- const std::vector<FakeFlexfecReceiveStream*>& streams =
+ const std::vector<webrtc::FakeFlexfecReceiveStream*>& streams =
fake_call_->GetFlexfecReceiveStreams();
EXPECT_EQ(1U, streams.size());
}
@@ -4621,14 +4633,14 @@
TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithoutSsrc) {
AddRecvStream();
- const std::vector<FakeFlexfecReceiveStream*>& streams =
+ const std::vector<webrtc::FakeFlexfecReceiveStream*>& streams =
fake_call_->GetFlexfecReceiveStreams();
EXPECT_TRUE(streams.empty());
- const std::vector<FakeVideoReceiveStream*>& video_streams =
+ const std::vector<webrtc::FakeVideoReceiveStream*>& video_streams =
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1U, video_streams.size());
- const FakeVideoReceiveStream& video_stream = *video_streams.front();
+ const webrtc::FakeVideoReceiveStream& video_stream = *video_streams.front();
const webrtc::VideoReceiveStreamInterface::Config& video_config =
video_stream.GetConfig();
EXPECT_FALSE(video_config.rtp.protected_by_flexfec);
@@ -4636,10 +4648,10 @@
}
TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithSsrc) {
- AddRecvStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ AddRecvStream(webrtc::CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0],
+ kFlexfecSsrc));
- const std::vector<FakeFlexfecReceiveStream*>& streams =
+ const std::vector<webrtc::FakeFlexfecReceiveStream*>& streams =
fake_call_->GetFlexfecReceiveStreams();
ASSERT_EQ(1U, streams.size());
const auto* stream = streams.front();
@@ -4649,10 +4661,10 @@
ASSERT_EQ(1U, config.protected_media_ssrcs.size());
EXPECT_EQ(kSsrcs1[0], config.protected_media_ssrcs[0]);
- const std::vector<FakeVideoReceiveStream*>& video_streams =
+ const std::vector<webrtc::FakeVideoReceiveStream*>& video_streams =
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1U, video_streams.size());
- const FakeVideoReceiveStream& video_stream = *video_streams.front();
+ const webrtc::FakeVideoReceiveStream& video_stream = *video_streams.front();
const webrtc::VideoReceiveStreamInterface::Config& video_config =
video_stream.GetConfig();
EXPECT_TRUE(video_config.rtp.protected_by_flexfec);
@@ -4669,13 +4681,13 @@
recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters));
- AddRecvStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ AddRecvStream(webrtc::CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0],
+ kFlexfecSsrc));
EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
- const std::vector<FakeVideoReceiveStream*>& video_streams =
+ const std::vector<webrtc::FakeVideoReceiveStream*>& video_streams =
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1U, video_streams.size());
- const FakeVideoReceiveStream* video_stream = video_streams.front();
+ const webrtc::FakeVideoReceiveStream* video_stream = video_streams.front();
const webrtc::VideoReceiveStreamInterface::Config* video_config =
&video_stream->GetConfig();
EXPECT_FALSE(video_config->rtp.protected_by_flexfec);
@@ -4711,14 +4723,14 @@
recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters));
- AddRecvStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ AddRecvStream(webrtc::CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0],
+ kFlexfecSsrc));
EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
EXPECT_EQ(1U, fake_call_->GetFlexfecReceiveStreams().size());
- const std::vector<FakeVideoReceiveStream*>& video_streams =
+ const std::vector<webrtc::FakeVideoReceiveStream*>& video_streams =
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1U, video_streams.size());
- const FakeVideoReceiveStream* video_stream = video_streams.front();
+ const webrtc::FakeVideoReceiveStream* video_stream = video_streams.front();
const webrtc::VideoReceiveStreamInterface::Config* video_config =
&video_stream->GetConfig();
EXPECT_TRUE(video_config->rtp.protected_by_flexfec);
@@ -4754,10 +4766,10 @@
recv_parameters.codecs.push_back(duplicate);
ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters));
- AddRecvStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ AddRecvStream(webrtc::CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0],
+ kFlexfecSsrc));
- const std::vector<FakeFlexfecReceiveStream*>& streams =
+ const std::vector<webrtc::FakeFlexfecReceiveStream*>& streams =
fake_call_->GetFlexfecReceiveStreams();
ASSERT_EQ(1U, streams.size());
const auto* stream = streams.front();
@@ -4777,7 +4789,7 @@
};
TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetDefaultSendCodecsWithoutSsrc) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(GetEngineCodec("flexfec-03").id, config.rtp.flexfec.payload_type);
@@ -4786,8 +4798,9 @@
}
TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetDefaultSendCodecsWithSsrc) {
- FakeVideoSendStream* stream = AddSendStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreatePrimaryWithFecFrStreamParams(
+ "cname", kSsrcs1[0], kFlexfecSsrc));
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(GetEngineCodec("flexfec-03").id, config.rtp.flexfec.payload_type);
@@ -4801,7 +4814,7 @@
parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type);
@@ -4813,25 +4826,26 @@
parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
}
TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) {
- AddRecvStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ AddRecvStream(webrtc::CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0],
+ kFlexfecSsrc));
cricket::VideoReceiverParameters recv_parameters;
recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters));
- const std::vector<FakeFlexfecReceiveStream*>& flexfec_streams =
+ const std::vector<webrtc::FakeFlexfecReceiveStream*>& flexfec_streams =
fake_call_->GetFlexfecReceiveStreams();
ASSERT_EQ(1U, flexfec_streams.size());
- const FakeFlexfecReceiveStream* flexfec_stream = flexfec_streams.front();
+ const webrtc::FakeFlexfecReceiveStream* flexfec_stream =
+ flexfec_streams.front();
const webrtc::FlexfecReceiveStream::Config& flexfec_stream_config =
flexfec_stream->GetConfig();
EXPECT_EQ(GetEngineCodec("flexfec-03").id,
@@ -4839,9 +4853,9 @@
EXPECT_EQ(kFlexfecSsrc, flexfec_stream_config.rtp.remote_ssrc);
ASSERT_EQ(1U, flexfec_stream_config.protected_media_ssrcs.size());
EXPECT_EQ(kSsrcs1[0], flexfec_stream_config.protected_media_ssrcs[0]);
- const std::vector<FakeVideoReceiveStream*>& video_streams =
+ const std::vector<webrtc::FakeVideoReceiveStream*>& video_streams =
fake_call_->GetVideoReceiveStreams();
- const FakeVideoReceiveStream* video_stream = video_streams.front();
+ const webrtc::FakeVideoReceiveStream* video_stream = video_streams.front();
const webrtc::VideoReceiveStreamInterface::Config& video_stream_config =
video_stream->GetConfig();
EXPECT_EQ(video_stream_config.rtp.local_ssrc,
@@ -4862,7 +4876,7 @@
parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
@@ -4877,8 +4891,9 @@
parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreatePrimaryWithFecFrStreamParams(
+ "cname", kSsrcs1[0], kFlexfecSsrc));
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
@@ -4968,7 +4983,7 @@
parameters.codecs.push_back(GetEngineCodec("ulpfec"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type);
@@ -4989,8 +5004,9 @@
parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreatePrimaryWithFecFrStreamParams(
+ "cname", kSsrcs1[0], kFlexfecSsrc));
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
EXPECT_EQ(GetEngineCodec("flexfec-03").id, config.rtp.flexfec.payload_type);
@@ -5016,7 +5032,7 @@
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
send_channel_->SetSend(true);
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::test::FrameForwarder frame_forwarder;
EXPECT_TRUE(
send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
@@ -5144,7 +5160,7 @@
TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthAndAddSendStream) {
send_parameters_.max_bandwidth_bps = 99999;
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
ASSERT_EQ(1u, stream->GetVideoStreams().size());
@@ -5171,9 +5187,10 @@
ExpectSetMaxBitrate(300000);
ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
- std::vector<FakeVideoSendStream*> video_send_streams = GetFakeSendStreams();
+ std::vector<webrtc::FakeVideoSendStream*> video_send_streams =
+ GetFakeSendStreams();
ASSERT_EQ(1u, video_send_streams.size());
- FakeVideoSendStream* video_send_stream = video_send_streams[0];
+ webrtc::FakeVideoSendStream* video_send_stream = video_send_streams[0];
ASSERT_EQ(1u, video_send_streams[0]->GetVideoStreams().size());
// First the max bitrate is set based upon the codec param.
EXPECT_EQ(300000,
@@ -5200,9 +5217,10 @@
ExpectSetMaxBitrate(300000);
ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
- std::vector<FakeVideoSendStream*> video_send_streams = GetFakeSendStreams();
+ std::vector<webrtc::FakeVideoSendStream*> video_send_streams =
+ GetFakeSendStreams();
ASSERT_EQ(1u, video_send_streams.size());
- FakeVideoSendStream* video_send_stream = video_send_streams[0];
+ webrtc::FakeVideoSendStream* video_send_stream = video_send_streams[0];
ASSERT_EQ(1u, video_send_stream->GetVideoStreams().size());
// First the max bitrate is set based upon the codec param.
EXPECT_EQ(300000, video_send_stream->GetVideoStreams()[0].max_bitrate_bps);
@@ -5221,7 +5239,7 @@
TEST_F(WebRtcVideoChannelTest,
MaxBitrateIsMinimumOfMaxSendBandwidthAndMaxEncodingBitrate) {
send_parameters_.max_bandwidth_bps = 99999;
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
ASSERT_EQ(1u, stream->GetVideoStreams().size());
@@ -5250,7 +5268,7 @@
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
send_channel_->SetSend(true);
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::test::FrameForwarder frame_forwarder;
EXPECT_TRUE(
@@ -5276,8 +5294,8 @@
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
send_channel_->SetSend(true);
- FakeVideoSendStream* stream = AddSendStream(
- cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
+ webrtc::FakeVideoSendStream* stream = AddSendStream(
+ webrtc::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
// Send a frame to make sure this scales up to >1 stream (simulcast).
webrtc::test::FrameForwarder frame_forwarder;
@@ -5444,7 +5462,7 @@
kSecondUlpfecPayloadType, cricket::kUlpfecCodecName));
ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters));
- FakeVideoReceiveStream* recv_stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* recv_stream = AddRecvStream();
EXPECT_EQ(kFirstUlpfecPayloadType,
recv_stream->GetConfig().rtp.ulpfec_payload_type);
}
@@ -5461,7 +5479,7 @@
cricket::CreateVideoCodec(kSecondRedPayloadType, cricket::kRedCodecName));
ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters));
- FakeVideoReceiveStream* recv_stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* recv_stream = AddRecvStream();
EXPECT_EQ(kFirstRedPayloadType,
recv_stream->GetConfig().rtp.red_payload_type);
}
@@ -5593,7 +5611,7 @@
parameters.codecs = engine_.LegacyRecvCodecs();
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
- FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
const webrtc::VideoReceiveStreamInterface::Config& config =
stream->GetConfig();
EXPECT_EQ(engine_.LegacyRecvCodecs()[0].name,
@@ -5622,7 +5640,7 @@
send_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters));
- FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
EXPECT_EQ(GetEngineCodec("ulpfec").id,
stream->GetConfig().rtp.ulpfec_payload_type);
@@ -5637,13 +5655,13 @@
}
TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvParamsWithoutFecDisablesFec) {
- AddRecvStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
- const std::vector<FakeFlexfecReceiveStream*>& streams =
+ AddRecvStream(webrtc::CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0],
+ kFlexfecSsrc));
+ const std::vector<webrtc::FakeFlexfecReceiveStream*>& streams =
fake_call_->GetFlexfecReceiveStreams();
ASSERT_EQ(1U, streams.size());
- const FakeFlexfecReceiveStream* stream = streams.front();
+ const webrtc::FakeFlexfecReceiveStream* stream = streams.front();
EXPECT_EQ(GetEngineCodec("flexfec-03").id, stream->GetConfig().payload_type);
EXPECT_EQ(kFlexfecSsrc, stream->remote_ssrc());
ASSERT_EQ(1U, stream->GetConfig().protected_media_ssrcs.size());
@@ -5657,7 +5675,7 @@
}
TEST_F(WebRtcVideoChannelTest, SetSendParamsWithFecEnablesFec) {
- FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
EXPECT_EQ(GetEngineCodec("ulpfec").id,
stream->GetConfig().rtp.ulpfec_payload_type);
@@ -5685,9 +5703,9 @@
TEST_F(WebRtcVideoChannelFlexfecSendRecvTest,
SetSendRecvParamsWithFecEnablesFec) {
- AddRecvStream(
- CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
- const std::vector<FakeFlexfecReceiveStream*>& streams =
+ AddRecvStream(webrtc::CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0],
+ kFlexfecSsrc));
+ const std::vector<webrtc::FakeFlexfecReceiveStream*>& streams =
fake_call_->GetFlexfecReceiveStreams();
cricket::VideoReceiverParameters recv_parameters;
@@ -5695,7 +5713,8 @@
recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters));
ASSERT_EQ(1U, streams.size());
- const FakeFlexfecReceiveStream* stream_with_recv_params = streams.front();
+ const webrtc::FakeFlexfecReceiveStream* stream_with_recv_params =
+ streams.front();
EXPECT_EQ(GetEngineCodec("flexfec-03").id,
stream_with_recv_params->GetConfig().payload_type);
EXPECT_EQ(kFlexfecSsrc, stream_with_recv_params->GetConfig().rtp.remote_ssrc);
@@ -5709,7 +5728,8 @@
send_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters));
ASSERT_EQ(1U, streams.size());
- const FakeFlexfecReceiveStream* stream_with_send_params = streams.front();
+ const webrtc::FakeFlexfecReceiveStream* stream_with_send_params =
+ streams.front();
EXPECT_EQ(GetEngineCodec("flexfec-03").id,
stream_with_send_params->GetConfig().payload_type);
EXPECT_EQ(kFlexfecSsrc, stream_with_send_params->GetConfig().rtp.remote_ssrc);
@@ -5781,7 +5801,7 @@
}
TEST_F(WebRtcVideoChannelTest, SetSend) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
EXPECT_FALSE(stream->IsSending());
// false->true
@@ -5798,15 +5818,15 @@
EXPECT_FALSE(stream->IsSending());
EXPECT_TRUE(send_channel_->SetSend(true));
- FakeVideoSendStream* new_stream = AddSendStream();
+ webrtc::FakeVideoSendStream* new_stream = AddSendStream();
EXPECT_TRUE(new_stream->IsSending())
<< "Send stream created after SetSend(true) not sending initially.";
}
// This test verifies DSCP settings are properly applied on video media channel.
TEST_F(WebRtcVideoChannelTest, TestSetDscpOptions) {
- std::unique_ptr<cricket::FakeNetworkInterface> network_interface(
- new cricket::FakeNetworkInterface);
+ std::unique_ptr<webrtc::FakeNetworkInterface> network_interface(
+ new webrtc::FakeNetworkInterface);
MediaConfig config;
std::unique_ptr<cricket::VideoMediaSendChannelInterface> send_channel;
webrtc::RtpParameters parameters;
@@ -5865,7 +5885,7 @@
// send video streams.
TEST_F(WebRtcVideoChannelTest, TestSetSendRtcpReducedSize) {
// Create stream, expecting that default mode is "compound".
- FakeVideoSendStream* stream1 = AddSendStream();
+ webrtc::FakeVideoSendStream* stream1 = AddSendStream();
EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(last_ssrc_);
@@ -5880,7 +5900,7 @@
EXPECT_TRUE(rtp_parameters.rtcp.reduced_size);
// Create a new stream and ensure it picks up the reduced size mode.
- FakeVideoSendStream* stream2 = AddSendStream();
+ webrtc::FakeVideoSendStream* stream2 = AddSendStream();
EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
}
@@ -5888,7 +5908,7 @@
// receive video streams.
TEST_F(WebRtcVideoChannelTest, TestSetRecvRtcpReducedSize) {
// Create stream, expecting that default mode is "compound".
- FakeVideoReceiveStream* stream1 = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream1 = AddRecvStream();
EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
// Now enable reduced size mode.
@@ -5900,7 +5920,7 @@
EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode);
// Create a new stream and ensure it picks up the reduced size mode.
- FakeVideoReceiveStream* stream2 = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream2 = AddRecvStream();
EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
}
@@ -5939,7 +5959,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsEncoderImplementationName) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.encoder_implementation_name = "encoder_implementation_name";
stream->SetStats(stats);
@@ -5954,7 +5974,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsPowerEfficientEncoder) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.power_efficient_encoder = true;
stream->SetStats(stats);
@@ -5968,7 +5988,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsCpuOveruseMetrics) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.avg_encode_time_ms = 13;
stats.encode_usage_percent = 42;
@@ -5985,7 +6005,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsFramesEncoded) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.frames_encoded = 13;
stream->SetStats(stats);
@@ -5999,7 +6019,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsKeyFramesEncoded) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.substreams[123].frame_counts.key_frames = 10;
stats.substreams[456].frame_counts.key_frames = 87;
@@ -6017,7 +6037,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsPerLayerQpSum) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.substreams[123].qp_sum = 15;
stats.substreams[456].qp_sum = 11;
@@ -6072,7 +6092,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportWithoutSubStreams) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
auto stats = GetInitialisedStats();
stream->SetStats(stats);
cricket::VideoMediaSendInfo send_info;
@@ -6146,7 +6166,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportForSubStreams) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
auto stats = GetInitialisedStats();
const uint32_t ssrc_1 = 123u;
@@ -6271,7 +6291,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetPerLayerStatsReportForSubStreams) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
auto stats = GetInitialisedStats();
const uint32_t ssrc_1 = 123u;
@@ -6403,8 +6423,8 @@
// Create simulcast stream from both SSRCs.
// `kSsrc1` is the "main" ssrc used for getting parameters.
- FakeVideoSendStream* stream =
- AddSendStream(cricket::CreateSimStreamParams("cname", {kSsrc1, kSsrc2}));
+ webrtc::FakeVideoSendStream* stream =
+ AddSendStream(webrtc::CreateSimStreamParams("cname", {kSsrc1, kSsrc2}));
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(kSsrc1);
@@ -6444,8 +6464,8 @@
// Configuring SVC is done the same way that simulcast is configured, the only
// difference is that the VP9 codec is used. This triggers special hacks that
// we depend on because we don't have a proper SVC API yet.
- FakeVideoSendStream* stream = AddSendStream(
- cricket::CreateSimStreamParams("cname", {kSsrc1, kSsrc2, kSsrc3}));
+ webrtc::FakeVideoSendStream* stream = AddSendStream(
+ webrtc::CreateSimStreamParams("cname", {kSsrc1, kSsrc2, kSsrc3}));
// Expect that we got SVC.
EXPECT_EQ(stream->GetEncoderConfig().number_of_streams, 1u);
webrtc::VideoCodecVP9 vp9_settings;
@@ -6492,7 +6512,7 @@
}
TEST_F(WebRtcVideoChannelTest, MediaSubstreamMissingProducesEmpyStats) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
const uint32_t kRtxSsrc = 123u;
const uint32_t kMissingMediaSsrc = 124u;
@@ -6516,7 +6536,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsUpperResolution) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.substreams[17].width = 123;
stats.substreams[17].height = 40;
@@ -6544,7 +6564,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsCpuAdaptationStats) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.number_of_cpu_adapt_changes = 2;
stats.cpu_limited_resolution = true;
@@ -6563,7 +6583,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsAdaptationAndBandwidthStats) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.number_of_cpu_adapt_changes = 2;
stats.cpu_limited_resolution = true;
@@ -6684,7 +6704,7 @@
TEST_F(WebRtcVideoChannelTest,
GetStatsReportsTransmittedAndRetransmittedBytesAndPacketsCorrectly) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
// Simulcast layer 1, RTP stream. header+padding=10, payload=20, packets=3.
stats.substreams[101].type =
@@ -6766,7 +6786,7 @@
TEST_F(WebRtcVideoChannelTest,
GetStatsTranslatesBandwidthLimitedResolutionCorrectly) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.bw_limited_resolution = true;
stream->SetStats(stats);
@@ -6782,7 +6802,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2;
stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3;
@@ -6814,7 +6834,7 @@
TEST_F(WebRtcVideoChannelTest,
GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
- FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStreamInterface::Stats stats;
stats.rtcp_packet_type_counts.fir_packets = 2;
stats.rtcp_packet_type_counts.nack_packets = 3;
@@ -6837,7 +6857,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesDecodeStatsCorrectly) {
- FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStreamInterface::Stats stats;
stats.decoder_implementation_name = "decoder_implementation_name";
stats.decode_ms = 2;
@@ -6925,7 +6945,7 @@
TEST_F(WebRtcVideoChannelTest,
GetStatsTranslatesInterFrameDelayStatsCorrectly) {
- FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStreamInterface::Stats stats;
stats.total_inter_frame_delay = 0.123;
stats.total_squared_inter_frame_delay = 0.00456;
@@ -6943,7 +6963,7 @@
}
TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesReceivePacketStatsCorrectly) {
- FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStreamInterface::Stats stats;
stats.rtp_stats.packet_counter.payload_bytes = 2;
stats.rtp_stats.packet_counter.header_bytes = 3;
@@ -6985,7 +7005,7 @@
}
TEST_F(WebRtcVideoChannelTest, TranslatesSenderBitrateStatsCorrectly) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.target_media_bitrate_bps = 156;
stats.media_bitrate_bps = 123;
@@ -6995,7 +7015,7 @@
stats.substreams[42].retransmit_bitrate_bps = 4;
stream->SetStats(stats);
- FakeVideoSendStream* stream2 = AddSendStream();
+ webrtc::FakeVideoSendStream* stream2 = AddSendStream();
webrtc::VideoSendStream::Stats stats2;
stats2.target_media_bitrate_bps = 200;
stats2.media_bitrate_bps = 321;
@@ -7043,12 +7063,13 @@
ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
<< "No default receive stream created.";
- FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
+ webrtc::FakeVideoReceiveStream* recv_stream =
+ fake_call_->GetVideoReceiveStreams()[0];
EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx_ssrc)
<< "Default receive stream should not have configured RTX";
EXPECT_TRUE(receive_channel_->AddRecvStream(
- cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
+ webrtc::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
<< "AddRecvStream should have reconfigured, not added a new receiver.";
recv_stream = fake_call_->GetVideoReceiveStreams()[0];
@@ -7069,7 +7090,7 @@
const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
StreamParams sp =
- cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
+ webrtc::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
sp.ssrcs = ssrcs; // Without RTXs, this is the important part.
EXPECT_FALSE(send_channel_->AddSendStream(sp));
@@ -7083,7 +7104,7 @@
const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
StreamParams sp =
- cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
+ webrtc::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
EXPECT_TRUE(send_channel_->AddSendStream(sp));
EXPECT_TRUE(receive_channel_->AddRecvStream(sp));
@@ -7108,14 +7129,14 @@
EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
StreamParams sp =
- cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
+ webrtc::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
EXPECT_TRUE(send_channel_->AddSendStream(sp));
EXPECT_TRUE(receive_channel_->AddRecvStream(sp));
// One of the SSRCs is already used in previous streams, using it should fail.
- sp = cricket::CreateSimStreamParams("cname",
- MAKE_VECTOR(kOverlappingStreamSsrcs));
+ sp = webrtc::CreateSimStreamParams("cname",
+ MAKE_VECTOR(kOverlappingStreamSsrcs));
EXPECT_FALSE(send_channel_->AddSendStream(sp));
EXPECT_FALSE(receive_channel_->AddRecvStream(sp));
@@ -7133,7 +7154,7 @@
static const uint32_t kSenderSsrcs[] = {4, 7, 10};
static const uint32_t kSenderRtxSsrcs[] = {5, 8, 11};
- StreamParams sender_sp = cricket::CreateSimWithRtxStreamParams(
+ StreamParams sender_sp = webrtc::CreateSimWithRtxStreamParams(
"cname", MAKE_VECTOR(kSenderSsrcs), MAKE_VECTOR(kSenderRtxSsrcs));
EXPECT_TRUE(send_channel_->AddSendStream(sender_sp));
@@ -7141,7 +7162,7 @@
static const uint32_t kReceiverSsrcs[] = {3};
static const uint32_t kReceiverRtxSsrcs[] = {2};
- StreamParams receiver_sp = cricket::CreateSimWithRtxStreamParams(
+ StreamParams receiver_sp = webrtc::CreateSimWithRtxStreamParams(
"cname", MAKE_VECTOR(kReceiverSsrcs), MAKE_VECTOR(kReceiverRtxSsrcs));
EXPECT_TRUE(receive_channel_->AddRecvStream(receiver_sp));
@@ -7159,7 +7180,7 @@
}
TEST_F(WebRtcVideoChannelTest, MapsReceivedPayloadTypeToCodecName) {
- FakeVideoReceiveStream* stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStreamInterface::Stats stats;
// Report no codec name before receiving.
@@ -7566,7 +7587,7 @@
// Test BaseMinimumPlayoutDelayMs on unsignaled receive streams.
TEST_F(WebRtcVideoChannelTest, BaseMinimumPlayoutDelayMsUnsignaledRecvStream) {
std::optional<int> delay_ms;
- const FakeVideoReceiveStream* recv_stream;
+ const webrtc::FakeVideoReceiveStream* recv_stream;
// Set default stream with SSRC 0
EXPECT_TRUE(receive_channel_->SetBaseMinimumPlayoutDelayMs(0, 200));
@@ -7752,7 +7773,7 @@
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
// No receive streams yet.
ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
- cricket::FakeVideoRenderer renderer;
+ webrtc::FakeVideoRenderer renderer;
receive_channel_->SetDefaultSink(&renderer);
// Receive VP8 packet on first SSRC.
@@ -7762,7 +7783,8 @@
ReceivePacketAndAdvanceTime(rtp_packet);
// VP8 packet should create default receive stream.
ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
- FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
+ webrtc::FakeVideoReceiveStream* recv_stream =
+ fake_call_->GetVideoReceiveStreams()[0];
EXPECT_EQ(rtp_packet.Ssrc(), recv_stream->GetConfig().rtp.remote_ssrc);
// Verify that the receive stream sinks to a renderer.
webrtc::VideoFrame video_frame =
@@ -7836,7 +7858,7 @@
ReceivePacketAndAdvanceTime(rtp_packet);
// Default receive stream should be created.
ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
- FakeVideoReceiveStream* recv_stream0 =
+ webrtc::FakeVideoReceiveStream* recv_stream0 =
fake_call_->GetVideoReceiveStreams()[0];
EXPECT_EQ(kSsrcs3[0], recv_stream0->GetConfig().rtp.remote_ssrc);
@@ -7853,7 +7875,7 @@
// New default receive stream should be created, but old stream should remain.
ASSERT_EQ(2u, fake_call_->GetVideoReceiveStreams().size());
EXPECT_EQ(recv_stream0, fake_call_->GetVideoReceiveStreams()[0]);
- FakeVideoReceiveStream* recv_stream1 =
+ webrtc::FakeVideoReceiveStream* recv_stream1 =
fake_call_->GetVideoReceiveStreams()[1];
EXPECT_EQ(kSsrcs3[1], recv_stream1->GetConfig().rtp.remote_ssrc);
}
@@ -7899,7 +7921,7 @@
TEST_F(WebRtcVideoChannelTest,
SetLowMaxBitrateOverwritesVideoStreamMinBitrate) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(last_ssrc_);
@@ -7929,7 +7951,7 @@
TEST_F(WebRtcVideoChannelTest,
SetHighMinBitrateOverwritesVideoStreamMaxBitrate) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
// Note that this is testing the behavior of the FakeVideoSendStream, which
// also calls to CreateEncoderStreams to get the VideoStreams, so essentially
@@ -7953,7 +7975,7 @@
TEST_F(WebRtcVideoChannelTest,
SetMinBitrateAboveMaxBitrateLimitAdjustsMinBitrateDown) {
send_parameters_.max_bandwidth_bps = 99999;
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
ASSERT_EQ(1UL, stream->GetVideoStreams().size());
@@ -7977,7 +7999,7 @@
}
TEST_F(WebRtcVideoChannelTest, SetMaxFramerateOneStream) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(last_ssrc_);
@@ -8004,7 +8026,7 @@
}
TEST_F(WebRtcVideoChannelTest, SetNumTemporalLayersForSingleStream) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(last_ssrc_);
@@ -8046,7 +8068,7 @@
TEST_F(WebRtcVideoChannelTest,
CannotSetSimulcastRtpSendParametersWithIncorrectNumberOfEncodings) {
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- StreamParams sp = CreateSimStreamParams("cname", ssrcs);
+ StreamParams sp = webrtc::CreateSimStreamParams("cname", ssrcs);
AddSendStream(sp);
webrtc::RtpParameters parameters =
@@ -8112,10 +8134,10 @@
EXPECT_EQ(new_bitrate_priority, parameters.encodings[0].bitrate_priority);
// Verify that the new value propagated down to the encoder.
- std::vector<FakeVideoSendStream*> video_send_streams =
+ std::vector<webrtc::FakeVideoSendStream*> video_send_streams =
fake_call_->GetVideoSendStreams();
EXPECT_EQ(1UL, video_send_streams.size());
- FakeVideoSendStream* video_send_stream = video_send_streams.front();
+ webrtc::FakeVideoSendStream* video_send_stream = video_send_streams.front();
// Check that the WebRtcVideoSendStream updated the VideoEncoderConfig
// appropriately.
EXPECT_EQ(new_bitrate_priority,
@@ -8134,7 +8156,7 @@
// Create the stream params with multiple ssrcs for simulcast.
const size_t kNumSimulcastStreams = 3;
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- StreamParams stream_params = CreateSimStreamParams("cname", ssrcs);
+ StreamParams stream_params = webrtc::CreateSimStreamParams("cname", ssrcs);
AddSendStream(stream_params);
uint32_t primary_ssrc = stream_params.first_ssrc();
@@ -8168,10 +8190,10 @@
EXPECT_EQ(new_bitrate_priority, parameters.encodings[0].bitrate_priority);
// Verify that the new value propagated down to the encoder.
- std::vector<FakeVideoSendStream*> video_send_streams =
+ std::vector<webrtc::FakeVideoSendStream*> video_send_streams =
fake_call_->GetVideoSendStreams();
EXPECT_EQ(1UL, video_send_streams.size());
- FakeVideoSendStream* video_send_stream = video_send_streams.front();
+ webrtc::FakeVideoSendStream* video_send_stream = video_send_streams.front();
// Check that the WebRtcVideoSendStream updated the VideoEncoderConfig
// appropriately.
EXPECT_EQ(kNumSimulcastStreams,
@@ -8219,7 +8241,8 @@
codec.id = 123;
parameters.codecs.push_back(codec);
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
webrtc::test::FrameForwarder frame_forwarder;
EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, /*options=*/nullptr,
&frame_forwarder));
@@ -8240,9 +8263,9 @@
// Use a capture resolution whose width and height are not divisible by 2^3.
// (See field trial set at the top of the test.)
- FakeFrameSource frame_source(test_params.resolution.width,
- test_params.resolution.height,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(test_params.resolution.width,
+ test_params.resolution.height,
+ rtc::kNumMicrosecsPerSec / 30);
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
// Ensure the scaling is correct.
@@ -8378,7 +8401,8 @@
}
TEST_F(WebRtcVideoChannelTest, NumTemporalLayersPropagatedToEncoder) {
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -8425,7 +8449,8 @@
TEST_F(WebRtcVideoChannelTest,
DefaultValuePropagatedToEncoderForUnsetNumTemporalLayers) {
const size_t kDefaultNumTemporalLayers = 3;
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -8465,7 +8490,8 @@
TEST_F(WebRtcVideoChannelTest,
DefaultValuePropagatedToEncoderForUnsetFramerate) {
const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -8513,7 +8539,8 @@
encoder_factory_->AddSupportedVideoCodec(webrtc::SdpVideoFormat(
"VP8", webrtc::CodecParameterMap(), kSupportedModes));
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -8588,7 +8615,8 @@
send_parameters.codecs.push_back(GetEngineCodec("H265"));
EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters));
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -8668,7 +8696,7 @@
}
EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
ASSERT_TRUE(stream);
webrtc::test::FrameForwarder frame_forwarder;
@@ -8689,7 +8717,8 @@
}
}
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
ASSERT_TRUE(send_stream);
webrtc::VideoEncoderConfig encoder_config =
send_stream->GetEncoderConfig().Copy();
@@ -8710,7 +8739,8 @@
}
}
- FakeVideoSendStream* send_stream2 = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream2 =
+ fake_call_->GetVideoSendStreams().front();
ASSERT_TRUE(send_stream2);
webrtc::VideoEncoderConfig encoder_config2 =
send_stream2->GetEncoderConfig().Copy();
@@ -8737,7 +8767,7 @@
}
EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
ASSERT_TRUE(stream);
webrtc::test::FrameForwarder frame_forwarder;
@@ -8758,7 +8788,8 @@
}
}
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
ASSERT_TRUE(send_stream);
webrtc::VideoEncoderConfig encoder_config =
send_stream->GetEncoderConfig().Copy();
@@ -8781,7 +8812,8 @@
}
}
- FakeVideoSendStream* send_stream2 = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream2 =
+ fake_call_->GetVideoSendStreams().front();
ASSERT_TRUE(send_stream2);
webrtc::VideoEncoderConfig encoder_config2 =
send_stream2->GetEncoderConfig().Copy();
@@ -8808,7 +8840,7 @@
}
EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
ASSERT_TRUE(stream);
webrtc::test::FrameForwarder frame_forwarder;
@@ -8829,7 +8861,8 @@
}
}
- FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream =
+ fake_call_->GetVideoSendStreams().front();
ASSERT_TRUE(send_stream);
webrtc::VideoEncoderConfig encoder_config =
send_stream->GetEncoderConfig().Copy();
@@ -8850,7 +8883,8 @@
EXPECT_EQ(codec.parameters.at("level-id"), "156");
}
}
- FakeVideoSendStream* send_stream2 = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* send_stream2 =
+ fake_call_->GetVideoSendStreams().front();
ASSERT_TRUE(send_stream2);
webrtc::VideoEncoderConfig encoder_config2 =
send_stream2->GetEncoderConfig().Copy();
@@ -8873,7 +8907,8 @@
send_parameters.codecs.push_back(GetEngineCodec("VP9"));
EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters));
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -8929,7 +8964,7 @@
frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
// The stream should be recreated due to codec change.
- std::vector<FakeVideoSendStream*> new_streams = GetFakeSendStreams();
+ std::vector<webrtc::FakeVideoSendStream*> new_streams = GetFakeSendStreams();
EXPECT_EQ(1u, new_streams.size());
EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
@@ -9007,7 +9042,8 @@
// the maximum (3/4 was chosen because it's similar to the simulcast defaults
// that are used if no min/max are specified).
TEST_F(WebRtcVideoChannelTest, MinAndMaxSimulcastBitratePropagatedToEncoder) {
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -9071,7 +9107,8 @@
// simulcast default that is used if no min/max are specified.
TEST_F(WebRtcVideoChannelTest, MinOrMaxSimulcastBitratePropagatedToEncoder) {
const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -9141,7 +9178,8 @@
// unspecified values accordingly.
TEST_F(WebRtcVideoChannelTest, SetMinAndMaxSimulcastBitrateAboveBelowDefault) {
const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -9190,7 +9228,8 @@
TEST_F(WebRtcVideoChannelTest, BandwidthAboveTotalMaxBitrateGivenToMaxLayer) {
const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -9240,7 +9279,8 @@
BandwidthAboveTotalMaxBitrateNotGivenToMaxLayerIfMaxBitrateSet) {
const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
EXPECT_EQ(kNumSimulcastStreams, kDefault.size());
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
// Send a full size frame so all simulcast layers are used when reconfiguring.
webrtc::test::FrameForwarder frame_forwarder;
@@ -9276,7 +9316,7 @@
webrtc::test::ScopedKeyValueConfig field_trials(
field_trials_, "WebRTC-MixedCodecSimulcast/Enabled/");
- StreamParams sp = CreateSimStreamParams("cname", {123, 456, 789});
+ StreamParams sp = webrtc::CreateSimStreamParams("cname", {123, 456, 789});
std::vector<cricket::RidDescription> rid_descriptions;
rid_descriptions.emplace_back("f", cricket::RidDirection::kSend);
@@ -9350,7 +9390,7 @@
// Test that min and max bitrate values set via RtpParameters are correctly
// propagated to the underlying encoder for a single stream.
TEST_F(WebRtcVideoChannelTest, MinAndMaxBitratePropagatedToEncoder) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
EXPECT_TRUE(send_channel_->SetSend(true));
EXPECT_TRUE(stream->IsSending());
@@ -9381,7 +9421,7 @@
// underlying encoder for a single stream (when the values are not set via
// RtpParameters).
TEST_F(WebRtcVideoChannelTest, DefaultMinAndMaxBitratePropagatedToEncoder) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
EXPECT_TRUE(send_channel_->SetSend(true));
EXPECT_TRUE(stream->IsSending());
@@ -9410,8 +9450,9 @@
// Create the stream params with multiple ssrcs for simulcast.
const size_t kNumSimulcastStreams = 3;
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
- StreamParams stream_params = CreateSimStreamParams("cname", ssrcs);
- FakeVideoSendStream* fake_video_send_stream = AddSendStream(stream_params);
+ StreamParams stream_params = webrtc::CreateSimStreamParams("cname", ssrcs);
+ webrtc::FakeVideoSendStream* fake_video_send_stream =
+ AddSendStream(stream_params);
uint32_t primary_ssrc = stream_params.first_ssrc();
// Using the FrameForwarder, we manually send a full size
@@ -9586,7 +9627,7 @@
parameters.codecs.push_back(kH264sprop2);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
- FakeVideoReceiveStream* recv_stream = AddRecvStream();
+ webrtc::FakeVideoReceiveStream* recv_stream = AddRecvStream();
const webrtc::VideoReceiveStreamInterface::Config& cfg =
recv_stream->GetConfig();
webrtc::RtpParameters rtp_parameters =
@@ -9656,7 +9697,7 @@
receive_channel_->GetDefaultRtpReceiveParameters());
// Set a sink for an unsignaled stream.
- cricket::FakeVideoRenderer renderer;
+ webrtc::FakeVideoRenderer renderer;
receive_channel_->SetDefaultSink(&renderer);
// Call GetDefaultRtpReceiveParameters before the SSRC is known.
@@ -9706,7 +9747,7 @@
if (receiver_first) {
AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
- std::vector<FakeVideoReceiveStream*> receive_streams =
+ std::vector<webrtc::FakeVideoReceiveStream*> receive_streams =
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1u, receive_streams.size());
// Default local SSRC when we have no sender.
@@ -9716,7 +9757,7 @@
AddSendStream(StreamParams::CreateLegacy(kSenderSsrc));
if (!receiver_first)
AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
- std::vector<FakeVideoReceiveStream*> receive_streams =
+ std::vector<webrtc::FakeVideoReceiveStream*> receive_streams =
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1u, receive_streams.size());
EXPECT_EQ(kSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
@@ -9746,12 +9787,13 @@
}
TEST_F(WebRtcVideoChannelTest, Simulcast_QualityScalingNotAllowed) {
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/true);
+ webrtc::FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/true);
EXPECT_FALSE(stream->GetEncoderConfig().is_quality_scaling_allowed);
}
TEST_F(WebRtcVideoChannelTest, Singlecast_QualityScalingAllowed) {
- FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/true);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(false, /*with_rtx=*/true);
EXPECT_TRUE(stream->GetEncoderConfig().is_quality_scaling_allowed);
}
@@ -9766,7 +9808,8 @@
send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
// Fetch the latest stream since SetVideoSend() may recreate it if the
// screen content setting is changed.
- FakeVideoSendStream* stream = fake_call_->GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* stream =
+ fake_call_->GetVideoSendStreams().front();
EXPECT_FALSE(stream->GetEncoderConfig().is_quality_scaling_allowed);
EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
@@ -9774,7 +9817,8 @@
TEST_F(WebRtcVideoChannelTest,
SimulcastSingleActiveStream_QualityScalingAllowed) {
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(last_ssrc_);
@@ -9790,7 +9834,7 @@
}
TEST_F(WebRtcVideoChannelTest, GenerateKeyFrameSinglecast) {
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(last_ssrc_);
@@ -9811,7 +9855,8 @@
}
TEST_F(WebRtcVideoChannelTest, GenerateKeyFrameSimulcast) {
- StreamParams stream_params = CreateSimStreamParams("cname", {123, 456, 789});
+ StreamParams stream_params =
+ webrtc::CreateSimStreamParams("cname", {123, 456, 789});
std::vector<std::string> rids = {"f", "h", "q"};
std::vector<cricket::RidDescription> rid_descriptions;
@@ -9819,7 +9864,7 @@
rid_descriptions.emplace_back(rid, cricket::RidDirection::kSend);
}
stream_params.set_rids(rid_descriptions);
- FakeVideoSendStream* stream = AddSendStream(stream_params);
+ webrtc::FakeVideoSendStream* stream = AddSendStream(stream_params);
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(last_ssrc_);
@@ -9871,13 +9916,13 @@
public:
WebRtcVideoChannelSimulcastTest()
: fake_call_(CreateEnvironment(&field_trials_)),
- encoder_factory_(new cricket::FakeWebRtcVideoEncoderFactory),
- decoder_factory_(new cricket::FakeWebRtcVideoDecoderFactory),
+ encoder_factory_(new webrtc::FakeWebRtcVideoEncoderFactory),
+ decoder_factory_(new webrtc::FakeWebRtcVideoDecoderFactory),
mock_rate_allocator_factory_(
std::make_unique<webrtc::MockVideoBitrateAllocatorFactory>()),
- engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
+ engine_(std::unique_ptr<webrtc::FakeWebRtcVideoEncoderFactory>(
encoder_factory_),
- std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
+ std::unique_ptr<webrtc::FakeWebRtcVideoDecoderFactory>(
decoder_factory_),
field_trials_),
last_ssrc_(0) {}
@@ -9915,12 +9960,12 @@
RTC_DCHECK(num_configured_streams <= ssrcs.size());
ssrcs.resize(num_configured_streams);
- AddSendStream(CreateSimStreamParams("cname", ssrcs));
+ AddSendStream(webrtc::CreateSimStreamParams("cname", ssrcs));
// Send a full-size frame to trigger a stream reconfiguration to use all
// expected simulcast layers.
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(capture_width, capture_height,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(capture_width, capture_height,
+ rtc::kNumMicrosecsPerSec / 30);
VideoOptions options;
if (screenshare)
@@ -9929,7 +9974,8 @@
send_channel_->SetVideoSend(ssrcs.front(), &options, &frame_forwarder));
// Fetch the latest stream since SetVideoSend() may recreate it if the
// screen content setting is changed.
- FakeVideoSendStream* stream = fake_call_.GetVideoSendStreams().front();
+ webrtc::FakeVideoSendStream* stream =
+ fake_call_.GetVideoSendStreams().front();
send_channel_->SetSend(true);
frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
@@ -10006,40 +10052,40 @@
EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs.front(), nullptr, nullptr));
}
- FakeVideoSendStream* AddSendStream() {
+ webrtc::FakeVideoSendStream* AddSendStream() {
return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
}
- FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
+ webrtc::FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
size_t num_streams = fake_call_.GetVideoSendStreams().size();
EXPECT_TRUE(send_channel_->AddSendStream(sp));
- std::vector<FakeVideoSendStream*> streams =
+ std::vector<webrtc::FakeVideoSendStream*> streams =
fake_call_.GetVideoSendStreams();
EXPECT_EQ(num_streams + 1, streams.size());
return streams[streams.size() - 1];
}
- std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
+ std::vector<webrtc::FakeVideoSendStream*> GetFakeSendStreams() {
return fake_call_.GetVideoSendStreams();
}
- FakeVideoReceiveStream* AddRecvStream() {
+ webrtc::FakeVideoReceiveStream* AddRecvStream() {
return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
}
- FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
+ webrtc::FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
size_t num_streams = fake_call_.GetVideoReceiveStreams().size();
EXPECT_TRUE(receive_channel_->AddRecvStream(sp));
- std::vector<FakeVideoReceiveStream*> streams =
+ std::vector<webrtc::FakeVideoReceiveStream*> streams =
fake_call_.GetVideoReceiveStreams();
EXPECT_EQ(num_streams + 1, streams.size());
return streams[streams.size() - 1];
}
webrtc::test::ScopedKeyValueConfig field_trials_;
- FakeCall fake_call_;
- cricket::FakeWebRtcVideoEncoderFactory* encoder_factory_;
- cricket::FakeWebRtcVideoDecoderFactory* decoder_factory_;
+ webrtc::FakeCall fake_call_;
+ webrtc::FakeWebRtcVideoEncoderFactory* encoder_factory_;
+ webrtc::FakeWebRtcVideoDecoderFactory* decoder_factory_;
std::unique_ptr<webrtc::MockVideoBitrateAllocatorFactory>
mock_rate_allocator_factory_;
WebRtcVideoEngine engine_;
@@ -10120,7 +10166,7 @@
}
TEST_F(WebRtcVideoChannelTest, SetsRidsOnSendStream) {
- StreamParams sp = CreateSimStreamParams("cname", {123, 456, 789});
+ StreamParams sp = webrtc::CreateSimStreamParams("cname", {123, 456, 789});
std::vector<std::string> rids = {"f", "h", "q"};
std::vector<cricket::RidDescription> rid_descriptions;
@@ -10171,10 +10217,10 @@
parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(
send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
@@ -10230,10 +10276,10 @@
parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = AddSendStream();
+ webrtc::FakeVideoSendStream* stream = AddSendStream();
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(
send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
@@ -10307,10 +10353,11 @@
parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
- FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false);
+ webrtc::FakeVideoSendStream* stream =
+ SetUpSimulcast(true, /*with_rtx=*/false);
webrtc::test::FrameForwarder frame_forwarder;
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ webrtc::FakeFrameSource frame_source(1280, 720,
+ rtc::kNumMicrosecsPerSec / 30);
EXPECT_TRUE(
send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
diff --git a/media/engine/webrtc_voice_engine_unittest.cc b/media/engine/webrtc_voice_engine_unittest.cc
index cb903f1..a529a3d 100644
--- a/media/engine/webrtc_voice_engine_unittest.cc
+++ b/media/engine/webrtc_voice_engine_unittest.cc
@@ -357,13 +357,13 @@
rtc::Thread::Current()->ProcessMessages(0);
}
- const cricket::FakeAudioSendStream& GetSendStream(uint32_t ssrc) {
+ const webrtc::FakeAudioSendStream& GetSendStream(uint32_t ssrc) {
const auto* send_stream = call_.GetAudioSendStream(ssrc);
EXPECT_TRUE(send_stream);
return *send_stream;
}
- const cricket::FakeAudioReceiveStream& GetRecvStream(uint32_t ssrc) {
+ const webrtc::FakeAudioReceiveStream& GetRecvStream(uint32_t ssrc) {
const auto* recv_stream = call_.GetAudioReceiveStream(ssrc);
EXPECT_TRUE(recv_stream);
return *recv_stream;
@@ -448,7 +448,7 @@
EXPECT_FALSE(send_channel_->InsertDtmf(-1, 1, 111));
// Test send.
- cricket::FakeAudioSendStream::TelephoneEvent telephone_event =
+ webrtc::FakeAudioSendStream::TelephoneEvent telephone_event =
GetSendStream(kSsrcX).GetLatestTelephoneEvent();
EXPECT_EQ(-1, telephone_event.payload_type);
EXPECT_TRUE(send_channel_->InsertDtmf(ssrc, 2, 123));
@@ -918,7 +918,7 @@
const Environment env_;
rtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm_;
rtc::scoped_refptr<StrictMock<webrtc::test::MockAudioProcessing>> apm_;
- cricket::FakeCall call_;
+ webrtc::FakeCall call_;
FakeAudioSource fake_source_;
std::unique_ptr<cricket::WebRtcVoiceEngine> engine_;
std::unique_ptr<cricket::VoiceMediaSendChannelInterface> send_channel_;
@@ -2820,9 +2820,9 @@
webrtc::SetBE32(packets[i] + 8, static_cast<uint32_t>(i));
}
- const cricket::FakeAudioReceiveStream& s1 = GetRecvStream(ssrc1);
- const cricket::FakeAudioReceiveStream& s2 = GetRecvStream(ssrc2);
- const cricket::FakeAudioReceiveStream& s3 = GetRecvStream(ssrc3);
+ const webrtc::FakeAudioReceiveStream& s1 = GetRecvStream(ssrc1);
+ const webrtc::FakeAudioReceiveStream& s2 = GetRecvStream(ssrc2);
+ const webrtc::FakeAudioReceiveStream& s3 = GetRecvStream(ssrc3);
EXPECT_EQ(s1.received_packets(), 0);
EXPECT_EQ(s2.received_packets(), 0);
@@ -3394,7 +3394,7 @@
// This test verifies DSCP settings are properly applied on voice media channel.
TEST_P(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
EXPECT_TRUE(SetupSendStream());
- cricket::FakeNetworkInterface network_interface;
+ webrtc::FakeNetworkInterface network_interface;
cricket::MediaConfig config;
std::unique_ptr<cricket::VoiceMediaSendChannelInterface> channel;
webrtc::RtpParameters parameters;
@@ -3650,7 +3650,7 @@
cricket::StreamParams::CreateLegacy(kAudioSsrc)));
EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
- const cricket::FakeAudioReceiveStream* s =
+ const webrtc::FakeAudioReceiveStream* s =
call_.GetAudioReceiveStream(kAudioSsrc);
EXPECT_EQ(0, s->received_packets());
webrtc::RtpPacketReceived parsed_packet;
diff --git a/media/sctp/dcsctp_transport_unittest.cc b/media/sctp/dcsctp_transport_unittest.cc
index a609e0f..ab17e51 100644
--- a/media/sctp/dcsctp_transport_unittest.cc
+++ b/media/sctp/dcsctp_transport_unittest.cc
@@ -89,7 +89,7 @@
sctp_transport_->SetOnConnectedCallback([this]() { sink_.OnConnected(); });
}
- cricket::FakeDtlsTransport fake_dtls_transport_;
+ FakeDtlsTransport fake_dtls_transport_;
webrtc::SimulatedClock simulated_clock_;
Environment env_;
dcsctp::MockDcSctpSocket* socket_;
diff --git a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
index 60b4db1..59c5eb8 100644
--- a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
@@ -176,7 +176,7 @@
DumpEncoderRuntimeConfigIsCalledOnGetEncoderRuntimeConfig) {
test::ScopedFieldTrials override_field_trials(
"WebRTC-Audio-FecAdaptation/Enabled/");
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.AdvanceTime(TimeDelta::Millis(kClockInitialTimeMs));
auto states = CreateAudioNetworkAdaptor();
AudioEncoderRuntimeConfig config;
@@ -194,7 +194,7 @@
TEST(AudioNetworkAdaptorImplTest,
DumpNetworkMetricsIsCalledOnSetNetworkMetrics) {
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.AdvanceTime(TimeDelta::Millis(kClockInitialTimeMs));
auto states = CreateAudioNetworkAdaptor();
diff --git a/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc b/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
index dfc3d6f..866a04c 100644
--- a/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
@@ -140,7 +140,7 @@
}
TEST(ControllerManagerTest, DoNotReorderBeforeMinReordingTime) {
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
auto states = CreateControllerManager();
CheckControllersOrder(&states, kChracteristicBandwithBps[0],
kChracteristicPacketLossFraction[0],
@@ -155,7 +155,7 @@
}
TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
auto states = CreateControllerManager();
constexpr int kBandwidthBps =
(kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2;
@@ -174,7 +174,7 @@
}
TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) {
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
auto states = CreateControllerManager();
constexpr int kBandwidthBps =
(kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2;
@@ -354,7 +354,7 @@
const std::vector<int> encoder_frame_lengths_ms = {20, 60};
constexpr int64_t kClockInitialTimeMs = 12345678;
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
fake_clock.AdvanceTime(TimeDelta::Millis(kClockInitialTimeMs));
auto debug_dump_writer =
std::unique_ptr<MockDebugDumpWriter>(new NiceMock<MockDebugDumpWriter>());
@@ -417,7 +417,7 @@
}
TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
audio_network_adaptor::config::ControllerManager config;
config.set_min_reordering_time_ms(kMinReorderingTimeMs);
config.set_min_reordering_squared_distance(kMinReorderingSquareDistance);
diff --git a/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc b/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
index 12ff7b5..a7a5057 100644
--- a/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
+++ b/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
@@ -49,7 +49,7 @@
MockAudioNetworkAdaptor* mock_audio_network_adaptor;
MockSmoothingFilter* mock_bitrate_smoother;
std::unique_ptr<AudioEncoderOpusImpl> encoder;
- std::unique_ptr<rtc::ScopedFakeClock> fake_clock;
+ std::unique_ptr<ScopedFakeClock> fake_clock;
AudioEncoderOpusConfig config;
};
@@ -60,7 +60,7 @@
std::unique_ptr<AudioEncoderOpusStates> states =
std::make_unique<AudioEncoderOpusStates>();
states->mock_audio_network_adaptor = nullptr;
- states->fake_clock.reset(new rtc::ScopedFakeClock());
+ states->fake_clock.reset(new ScopedFakeClock());
states->fake_clock->SetTime(Timestamp::Micros(kInitialTimeUs));
MockAudioNetworkAdaptor** mock_ptr = &states->mock_audio_network_adaptor;
diff --git a/modules/audio_processing/audio_processing_unittest.cc b/modules/audio_processing/audio_processing_unittest.cc
index 38bd180..751f634 100644
--- a/modules/audio_processing/audio_processing_unittest.cc
+++ b/modules/audio_processing/audio_processing_unittest.cc
@@ -1500,7 +1500,7 @@
}
void ApmTest::VerifyDebugDumpTest(Format format) {
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
const std::string in_filename = test::ResourcePath("ref03", "aecdump");
std::string format_string;
switch (format) {
diff --git a/modules/pacing/packet_router_unittest.cc b/modules/pacing/packet_router_unittest.cc
index 33ba74f..7b9467e 100644
--- a/modules/pacing/packet_router_unittest.cc
+++ b/modules/pacing/packet_router_unittest.cc
@@ -673,7 +673,7 @@
}
TEST(PacketRouterRembTest, ChangeSendRtpModuleChangeRembSender) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
NiceMock<MockRtpRtcpInterface> rtp_send;
NiceMock<MockRtpRtcpInterface> rtp_recv;
PacketRouter packet_router;
@@ -698,7 +698,7 @@
// Only register receiving modules and make sure we fallback to trigger a REMB
// packet on this one.
TEST(PacketRouterRembTest, NoSendingRtpModule) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
NiceMock<MockRtpRtcpInterface> rtp;
PacketRouter packet_router;
@@ -719,7 +719,7 @@
}
TEST(PacketRouterRembTest, NonCandidateSendRtpModuleNotUsedForRemb) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
PacketRouter packet_router;
NiceMock<MockRtpRtcpInterface> module;
@@ -737,7 +737,7 @@
}
TEST(PacketRouterRembTest, CandidateSendRtpModuleUsedForRemb) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
PacketRouter packet_router;
NiceMock<MockRtpRtcpInterface> module;
@@ -755,7 +755,7 @@
}
TEST(PacketRouterRembTest, NonCandidateReceiveRtpModuleNotUsedForRemb) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
PacketRouter packet_router;
NiceMock<MockRtpRtcpInterface> module;
@@ -773,7 +773,7 @@
}
TEST(PacketRouterRembTest, CandidateReceiveRtpModuleUsedForRemb) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
PacketRouter packet_router;
NiceMock<MockRtpRtcpInterface> module;
@@ -792,7 +792,7 @@
TEST(PacketRouterRembTest,
SendCandidatePreferredOverReceiveCandidate_SendModuleAddedFirst) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
PacketRouter packet_router;
NiceMock<MockRtpRtcpInterface> send_module;
NiceMock<MockRtpRtcpInterface> receive_module;
@@ -819,7 +819,7 @@
TEST(PacketRouterRembTest,
SendCandidatePreferredOverReceiveCandidate_ReceiveModuleAddedFirst) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
PacketRouter packet_router;
NiceMock<MockRtpRtcpInterface> send_module;
NiceMock<MockRtpRtcpInterface> receive_module;
@@ -846,7 +846,7 @@
}
TEST(PacketRouterRembTest, ReceiveModuleTakesOverWhenLastSendModuleRemoved) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
PacketRouter packet_router;
NiceMock<MockRtpRtcpInterface> send_module;
NiceMock<MockRtpRtcpInterface> receive_module;
diff --git a/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc b/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
index fbcb7d8..2ba7b89 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
+++ b/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
@@ -192,7 +192,7 @@
int min_qp_;
uint32_t max_qp_;
int frame_size_;
- rtc::ScopedFakeClock clock_;
+ ScopedFakeClock clock_;
std::unique_ptr<ScreenshareLayers> layers_;
uint32_t timestamp_;
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index 7d89744..c7693af 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -435,7 +435,7 @@
return ice_regathering_counter_[reason];
}
- rtc::FakeNetworkManager network_manager_;
+ webrtc::FakeNetworkManager network_manager_;
std::unique_ptr<BasicPortAllocator> allocator_;
webrtc::AsyncDnsResolverFactoryInterface* async_dns_resolver_factory_ =
nullptr;
@@ -710,7 +710,7 @@
}
void Test(const Environment& env, const Result& expected) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
int64_t connect_start = rtc::TimeMillis();
int64_t connect_time;
@@ -769,7 +769,7 @@
DestroyChannels();
}
- void TestSendRecv(rtc::ThreadProcessingFakeClock* clock) {
+ void TestSendRecv(webrtc::ThreadProcessingFakeClock* clock) {
for (int i = 0; i < 10; ++i) {
const char* data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
int len = static_cast<int>(strlen(data));
@@ -805,7 +805,7 @@
// new connection using the newly generated ice candidates.
// Before calling this function the end points must be configured.
void TestHandleIceUfragPasswordChanged() {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
ep1_ch1()->SetRemoteIceParameters(kIceParams[1]);
ep2_ch1()->SetRemoteIceParameters(kIceParams[0]);
EXPECT_THAT(
@@ -1347,7 +1347,7 @@
// Test the operation of GetStats.
TEST_F(P2PTransportChannelTest, GetStats) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
@@ -1402,7 +1402,7 @@
}
TEST_F(P2PTransportChannelTest, GetStatsSwitchConnection) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
IceConfig continual_gathering_config =
CreateIceConfig(1000, GATHER_CONTINUALLY);
@@ -1484,7 +1484,7 @@
// change if and only if continual gathering is enabled.
TEST_F(P2PTransportChannelTest,
TestIceRegatheringReasonContinualGatheringByNetworkChange) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
@@ -1530,7 +1530,7 @@
// failure if and only if continual gathering is enabled.
TEST_F(P2PTransportChannelTest,
TestIceRegatheringReasonContinualGatheringByNetworkFailure) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
@@ -1832,7 +1832,7 @@
// Test that if remote candidates don't have ufrag and pwd, we still work.
TEST_F(P2PTransportChannelTest, RemoteCandidatesWithoutUfragPwd) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
@@ -1859,7 +1859,7 @@
// Test that a host behind NAT cannot be reached when incoming_only
// is set to true.
TEST_F(P2PTransportChannelTest, IncomingOnlyBlocked) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, NAT_FULL_CONE, OPEN, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
@@ -1882,7 +1882,7 @@
// Test that a peer behind NAT can connect to a peer that has
// incoming_only flag set.
TEST_F(P2PTransportChannelTest, IncomingOnlyOpen) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, NAT_FULL_CONE, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
@@ -1929,7 +1929,7 @@
}
TEST_F(P2PTransportChannelTest, TestTcpConnectionsFromActiveToPassive) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0]);
@@ -1982,7 +1982,7 @@
// Test that tcptype is set on all candidates for a connection running over TCP.
TEST_F(P2PTransportChannelTest, TestTcpConnectionTcptypeSet) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, BLOCK_UDP_AND_INCOMING_TCP, OPEN,
PORTALLOCATOR_ENABLE_SHARED_SOCKET,
@@ -2009,7 +2009,7 @@
}
TEST_F(P2PTransportChannelTest, TestIceRoleConflict) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0]);
@@ -2052,7 +2052,7 @@
// Tests that the ice configs (protocol and role) can be passed down to ports.
TEST_F(P2PTransportChannelTest, TestIceConfigWillPassDownToPort) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0]);
@@ -2120,7 +2120,7 @@
// Verify IPv6 connection is preferred over IPv4.
TEST_F(P2PTransportChannelTest, TestIPv6Connections) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kIPv6PublicAddrs[0]);
@@ -2156,7 +2156,7 @@
// Testing forceful TURN connections.
TEST_F(P2PTransportChannelTest, TestForceTurn) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(
env, NAT_PORT_RESTRICTED, NAT_SYMMETRIC,
@@ -2191,7 +2191,7 @@
// Test that if continual gathering is set to true, ICE gathering state will
// not change to "Complete", and vice versa.
TEST_F(P2PTransportChannelTest, TestContinualGathering) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
@@ -2224,7 +2224,7 @@
// Test that a connection succeeds when the P2PTransportChannel uses a pooled
// PortAllocatorSession that has not yet finished gathering candidates.
TEST_F(P2PTransportChannelTest, TestUsingPooledSessionBeforeDoneGathering) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
@@ -2272,7 +2272,7 @@
// Test that a connection succeeds when the P2PTransportChannel uses a pooled
// PortAllocatorSession that already finished gathering candidates.
TEST_F(P2PTransportChannelTest, TestUsingPooledSessionAfterDoneGathering) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
@@ -2374,7 +2374,7 @@
// Test that a TURN/peer reflexive candidate pair is also presumed writable.
TEST_F(P2PTransportChannelTest, TurnToPrflxPresumedWritable) {
- rtc::ScopedFakeClock fake_clock;
+ webrtc::ScopedFakeClock fake_clock;
const Environment env = CreateEnvironment();
// We need to add artificial network delay to verify that the connection
@@ -2433,7 +2433,7 @@
// Test that a presumed-writable TURN<->TURN connection is preferred above an
// unreliable connection (one that has failed to be pinged for some time).
TEST_F(P2PTransportChannelTest, PresumedWritablePreferredOverUnreliable) {
- rtc::ScopedFakeClock fake_clock;
+ webrtc::ScopedFakeClock fake_clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, NAT_SYMMETRIC, NAT_SYMMETRIC,
@@ -2527,7 +2527,7 @@
// crbug.com/webrtc/9034.
TEST_F(P2PTransportChannelTest,
TurnToPrflxSelectedAfterResolvingIceControllingRoleConflict) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
// Gather only relay candidates.
ConfigureEndpoints(env, NAT_SYMMETRIC, NAT_SYMMETRIC,
@@ -2574,7 +2574,7 @@
// acknowledgement in the connectivity check from the remote peer.
TEST_F(P2PTransportChannelTest,
CanConnectWithPiggybackCheckAcknowledgementWhenCheckResponseBlocked) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment(FieldTrials::CreateNoGlobal(
"WebRTC-PiggybackIceCheckAcknowledgement/Enabled/"));
ConfigureEndpoints(env, OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
@@ -2755,7 +2755,7 @@
// Test that we can quickly switch links if an interface goes down.
// The controlled side has two interfaces and one will die.
TEST_F(P2PTransportChannelMultihomedTest, TestFailoverControlledSide) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0]);
@@ -2817,7 +2817,7 @@
// Test that we can quickly switch links if an interface goes down.
// The controlling side has two interfaces and one will die.
TEST_F(P2PTransportChannelMultihomedTest, TestFailoverControllingSide) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
// Simulate failing over from Wi-Fi to cell interface.
@@ -2867,7 +2867,7 @@
// Tests that we can quickly switch links if an interface goes down when
// there are many connections.
TEST_F(P2PTransportChannelMultihomedTest, TestFailoverWithManyConnections) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
test_turn_server()->AddInternalSocket(kTurnTcpIntAddr, webrtc::PROTO_TCP);
@@ -2980,7 +2980,7 @@
// the nomination of the selected connection on the controlled side will
// increase.
TEST_F(P2PTransportChannelMultihomedTest, TestIceRenomination) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
// Simulate failing over from Wi-Fi to cell interface.
@@ -3055,7 +3055,7 @@
// TestFailoverControlledSide and TestFailoverControllingSide.
TEST_F(P2PTransportChannelMultihomedTest,
TestConnectionSwitchDampeningControlledSide) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0]);
@@ -3124,7 +3124,7 @@
// the selected connection will not switch.
TEST_F(P2PTransportChannelMultihomedTest,
TestConnectionSwitchDampeningControllingSide) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
// Simulate failing over from Wi-Fi to cell interface.
@@ -3187,7 +3187,7 @@
// Tests that if the remote side's network failed, it won't cause the local
// side to switch connections and networks.
TEST_F(P2PTransportChannelMultihomedTest, TestRemoteFailover) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
// The interface names are chosen so that `cellular` would have higher
@@ -3418,7 +3418,7 @@
}
TEST_F(P2PTransportChannelMultihomedTest, TestGetState) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kAlternateAddrs[0]);
@@ -3448,7 +3448,7 @@
// will be removed from the port list of the channel, and the respective
// remote candidates on the other participant will be removed eventually.
TEST_F(P2PTransportChannelMultihomedTest, TestNetworkBecomesInactive) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0]);
@@ -3582,7 +3582,7 @@
// Tests that we can switch links via continual gathering.
TEST_F(P2PTransportChannelMultihomedTest,
TestSwitchLinksViaContinualGathering) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0]);
@@ -3642,7 +3642,7 @@
// Tests that the backup connection will be restored after it is destroyed.
TEST_F(P2PTransportChannelMultihomedTest, TestRestoreBackupConnection) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
auto& wifi = kAlternateAddrs;
@@ -3696,7 +3696,7 @@
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnDefault) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0], "eth0", rtc::ADAPTER_TYPE_ETHERNET);
@@ -3718,7 +3718,7 @@
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnPreferVpn) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0], "eth0", rtc::ADAPTER_TYPE_ETHERNET);
@@ -3757,7 +3757,7 @@
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnAvoidVpn) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0], "eth0", rtc::ADAPTER_TYPE_CELLULAR);
@@ -3795,7 +3795,7 @@
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnNeverVpn) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0], "eth0", rtc::ADAPTER_TYPE_CELLULAR);
@@ -3831,7 +3831,7 @@
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnOnlyVpn) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0], "eth0", rtc::ADAPTER_TYPE_CELLULAR);
@@ -3866,7 +3866,7 @@
}
TEST_F(P2PTransportChannelMultihomedTest, StunDictionaryPerformsSync) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
CreatePortAllocators(env);
AddAddress(0, kPublicAddrs[0], "eth0", rtc::ADAPTER_TYPE_CELLULAR);
@@ -3935,7 +3935,7 @@
P2PTransportChannel* ch,
absl::string_view ip,
int port_num,
- rtc::ThreadProcessingFakeClock* clock = nullptr) {
+ webrtc::ThreadProcessingFakeClock* clock = nullptr) {
if (clock == nullptr) {
EXPECT_THAT(
webrtc::WaitUntil(
@@ -3995,7 +3995,7 @@
}
Connection* CreateConnectionWithCandidate(P2PTransportChannel* channel,
- rtc::ScopedFakeClock* clock,
+ webrtc::ScopedFakeClock* clock,
absl::string_view ip_addr,
int port,
int priority,
@@ -4201,7 +4201,7 @@
// Verify that the connections are pinged at the right time.
TEST_F(P2PTransportChannelPingTest, TestStunPingIntervals) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
int RTT_RATIO = 4;
int SCHEDULING_RANGE = 200;
@@ -4298,7 +4298,7 @@
// Test that we start pinging as soon as we have a connection and remote ICE
// parameters.
TEST_F(P2PTransportChannelPingTest, PingingStartedAsSoonAsPossible) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory(),
@@ -4540,7 +4540,7 @@
}
TEST_F(P2PTransportChannelPingTest, TestReceivingStateChange) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory(),
&env.field_trials());
@@ -4967,7 +4967,7 @@
TEST_F(P2PTransportChannelPingTest,
TestControlledAgentDataReceivingTakesHigherPrecedenceThanPriority) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory(),
@@ -5022,7 +5022,7 @@
TEST_F(P2PTransportChannelPingTest,
TestControlledAgentNominationTakesHigherPrecedenceThanDataReceiving) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment();
@@ -5067,7 +5067,7 @@
TEST_F(P2PTransportChannelPingTest,
TestControlledAgentSelectsConnectionWithHigherNomination) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment();
@@ -5118,7 +5118,7 @@
}
TEST_F(P2PTransportChannelPingTest, TestEstimatedDisconnectedTime) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment();
@@ -5183,7 +5183,7 @@
TEST_F(P2PTransportChannelPingTest,
TestControlledAgentIgnoresSmallerNomination) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment();
@@ -5204,7 +5204,7 @@
TEST_F(P2PTransportChannelPingTest,
TestControlledAgentWriteStateTakesHigherPrecedenceThanNomination) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory(),
@@ -5304,7 +5304,7 @@
// When the current selected connection is strong, lower-priority connections
// will be pruned. Otherwise, lower-priority connections are kept.
TEST_F(P2PTransportChannelPingTest, TestDontPruneWhenWeak) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment();
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory(),
@@ -5354,7 +5354,7 @@
}
TEST_F(P2PTransportChannelPingTest, TestDontPruneHighPriorityConnections) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory(),
&env.field_trials());
@@ -5380,7 +5380,7 @@
// Test that GetState returns the state correctly.
TEST_F(P2PTransportChannelPingTest, TestGetState) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment();
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory(),
@@ -5432,7 +5432,7 @@
// Test that when a low-priority connection is pruned, it is not deleted
// right away, and it can become active and be pruned again.
TEST_F(P2PTransportChannelPingTest, TestConnectionPrunedAgain) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment();
@@ -5513,7 +5513,7 @@
// Test that if all connections in a channel has timed out on writing, they
// will all be deleted. We use Prune to simulate write_time_out.
TEST_F(P2PTransportChannelPingTest, TestDeleteConnectionsIfAllWriteTimedout) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory(),
&env.field_trials());
@@ -5651,7 +5651,7 @@
// will be destroyed. The port will only be destroyed after it is marked as
// "pruned."
TEST_F(P2PTransportChannelPingTest, TestPortDestroyedAfterTimeoutAndPruned) {
- rtc::ScopedFakeClock fake_clock;
+ webrtc::ScopedFakeClock fake_clock;
const Environment env = CreateEnvironment();
FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory(),
@@ -5777,7 +5777,7 @@
private:
std::unique_ptr<BasicPortAllocator> port_allocator_;
- rtc::FakeNetworkManager network_manager_;
+ webrtc::FakeNetworkManager network_manager_;
webrtc::TestTurnServer turn_server_;
std::unique_ptr<P2PTransportChannel> channel_;
};
@@ -6372,7 +6372,7 @@
TEST_F(P2PTransportChannelTest,
ConnectingIncreasesSelectedCandidatePairChanges) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
@@ -6397,7 +6397,7 @@
TEST_F(P2PTransportChannelTest,
DisconnectedIncreasesSelectedCandidatePairChanges) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
@@ -6435,7 +6435,7 @@
TEST_F(P2PTransportChannelTest,
NewSelectionIncreasesSelectedCandidatePairChanges) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
@@ -6658,7 +6658,7 @@
// removed and are still usable for necessary route switching.
TEST_F(P2PTransportChannelTest,
SurfaceHostCandidateOnCandidateFilterChangeFromRelayToAll) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(
@@ -6747,7 +6747,7 @@
// changing the candidate filter.
TEST_F(P2PTransportChannelTest,
SurfaceSrflxCandidateOnCandidateFilterChangeFromRelayToNoHost) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
// We need an actual NAT so that the host candidate is not equivalent to the
// srflx candidate; otherwise, the host candidate would still surface even
@@ -6841,7 +6841,7 @@
// gathering stopped.
TEST_F(P2PTransportChannelTest,
CannotSurfaceTheNewlyAllowedOnFilterChangeIfNotGatheringContinually) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(
@@ -6883,7 +6883,7 @@
// match the filter, are not removed.
TEST_F(P2PTransportChannelTest,
RestrictingCandidateFilterDoesNotRemoveRegatheredCandidates) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
ConfigureEndpoints(
@@ -6968,7 +6968,7 @@
// i.e surface_ice_candidates_on_ice_transport_type_changed requires
// coordination outside of webrtc to function properly.
TEST_F(P2PTransportChannelTest, SurfaceRequiresCoordination) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment(FieldTrials::CreateNoGlobal(
"WebRTC-IceFieldTrials/skip_relay_to_non_relay_connections:true/"));
@@ -7049,7 +7049,7 @@
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampening0) {
constexpr int kMargin = 10;
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment(FieldTrials::CreateNoGlobal(
"WebRTC-IceFieldTrials/initial_select_dampening:0/"));
@@ -7078,7 +7078,7 @@
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampening) {
constexpr int kMargin = 10;
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment(FieldTrials::CreateNoGlobal(
"WebRTC-IceFieldTrials/initial_select_dampening:100/"));
@@ -7107,7 +7107,7 @@
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampeningPingReceived) {
constexpr int kMargin = 10;
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment(FieldTrials::CreateNoGlobal(
"WebRTC-IceFieldTrials/initial_select_dampening_ping_received:100/"));
@@ -7137,7 +7137,7 @@
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampeningBoth) {
constexpr int kMargin = 10;
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
const Environment env = CreateEnvironment(FieldTrials::CreateNoGlobal(
"WebRTC-IceFieldTrials/"
@@ -7389,7 +7389,7 @@
std::string("WebRTC-IceFieldTrials/stop_gather_on_strongly_connected:") +
(stop_gather_on_strongly_connected ? "true/" : "false/");
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env =
CreateEnvironment(FieldTrials::CreateNoGlobal(field_trial));
// Use local + relay
@@ -7469,7 +7469,7 @@
std::string("WebRTC-IceFieldTrials/stop_gather_on_strongly_connected:") +
(stop_gather_on_strongly_connected ? "true/" : "false/");
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env =
CreateEnvironment(FieldTrials::CreateNoGlobal(field_trial));
@@ -7548,7 +7548,7 @@
// Tests no candidates are generated with old ice ufrag/passwd after an ice
// restart even if continual gathering is enabled.
TEST_F(P2PTransportChannelTest, TestIceNoOldCandidatesAfterIceRestart) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
const Environment env = CreateEnvironment();
AddAddress(0, kAlternateAddrs[0]);
ConfigureEndpoints(env, OPEN, OPEN, kDefaultPortAllocatorFlags,
@@ -7632,7 +7632,7 @@
void piggyback_data_received(const StunByteStringAttribute* data,
const StunByteStringAttribute* ack) {}
- rtc::ScopedFakeClock clock_;
+ webrtc::ScopedFakeClock clock_;
rtc::Buffer pending_packet_;
};
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index 1e2bf99..246778a 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -268,7 +268,7 @@
TestPort* lport,
Connection* rconn,
TestPort* rport,
- rtc::ScopedFakeClock* clock,
+ webrtc::ScopedFakeClock* clock,
int64_t ms) {
lconn->Ping(rtc::TimeMillis());
ASSERT_THAT(webrtc::WaitUntil(
@@ -970,7 +970,7 @@
bool same_addr1,
bool same_addr2,
bool possible) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
RTC_LOG(LS_INFO) << "Test: " << name1 << " to " << name2 << ": ";
port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
port2->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
@@ -1739,7 +1739,7 @@
}
TEST_F(PortTest, TestTcpNoDelay) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
auto port1 = CreateTcpPort(kLocalAddr1);
port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
int option_value = -1;
@@ -2253,7 +2253,7 @@
}
TEST_F(PortTest, TestRoundTripTime) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
@@ -3145,7 +3145,7 @@
// the default setup where the RTT is deterministically one, which generates an
// estimate given by `MINIMUM_RTT` = 100.
TEST_F(PortTest, TestWritableState) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
auto port1 = CreateUdpPort(kLocalAddr1);
port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
auto port2 = CreateUdpPort(kLocalAddr2);
@@ -3242,7 +3242,7 @@
// the default value given by `CONNECTION_WRITE_CONNECT_TIMEOUT` and
// `CONNECTION_WRITE_CONNECT_FAILURES`.
TEST_F(PortTest, TestWritableStateWithConfiguredThreshold) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
auto port1 = CreateUdpPort(kLocalAddr1);
port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
auto port2 = CreateUdpPort(kLocalAddr2);
@@ -3952,7 +3952,7 @@
// port will time out after connectivity is lost, if they are not marked as
// "keep alive until pruned."
TEST_F(PortTest, TestPortTimeoutIfNotKeptAlive) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
int timeout_delay = 100;
auto port1 = CreateUdpPort(kLocalAddr1);
ConnectToSignalDestroyed(port1.get());
@@ -3983,7 +3983,7 @@
// and destroyed again, ports won't be destroyed until a timeout period passes
// after the last set of connections are all destroyed.
TEST_F(PortTest, TestPortTimeoutAfterNewConnectionCreatedAndDestroyed) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
int timeout_delay = 100;
auto port1 = CreateUdpPort(kLocalAddr1);
ConnectToSignalDestroyed(port1.get());
@@ -4026,7 +4026,7 @@
// port will time out after connectivity is lost if they are marked as "keep
// alive until pruned". They will time out after they are pruned.
TEST_F(PortTest, TestPortNotTimeoutUntilPruned) {
- rtc::ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
int timeout_delay = 100;
auto port1 = CreateUdpPort(kLocalAddr1);
ConnectToSignalDestroyed(port1.get());
@@ -4148,7 +4148,7 @@
rport_->PrepareAddress();
}
- rtc::ScopedFakeClock clock_;
+ webrtc::ScopedFakeClock clock_;
int num_state_changes_ = 0;
Connection* CreateConnection(IceRole role) {
diff --git a/p2p/base/regathering_controller_unittest.cc b/p2p/base/regathering_controller_unittest.cc
index 79773e7..6b66b90 100644
--- a/p2p/base/regathering_controller_unittest.cc
+++ b/p2p/base/regathering_controller_unittest.cc
@@ -125,7 +125,7 @@
// still in progress or the continual gathering is not enabled.
TEST_F(RegatheringControllerTest,
IceRegatheringDoesNotOccurIfSessionNotCleared) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
InitializeAndGatherOnce(); // Session not cleared.
BasicRegatheringController::Config config;
@@ -139,7 +139,7 @@
}
TEST_F(RegatheringControllerTest, IceRegatheringRepeatsAsScheduled) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
InitializeAndGatherOnceWithSessionCleared();
BasicRegatheringController::Config config;
@@ -165,7 +165,7 @@
// and replaced by a new recurring schedule.
TEST_F(RegatheringControllerTest,
ScheduleOfIceRegatheringOnFailedNetworksCanBeReplaced) {
- rtc::ScopedFakeClock clock;
+ ScopedFakeClock clock;
InitializeAndGatherOnceWithSessionCleared();
BasicRegatheringController::Config config;
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc
index ee1662f..3a65d2f 100644
--- a/p2p/base/stun_port_unittest.cc
+++ b/p2p/base/stun_port_unittest.cc
@@ -323,7 +323,7 @@
class FakeClockBase {
public:
- rtc::ScopedFakeClock fake_clock;
+ webrtc::ScopedFakeClock fake_clock;
};
class StunPortTest : public FakeClockBase, public StunPortTestBase {};
diff --git a/p2p/base/stun_request_unittest.cc b/p2p/base/stun_request_unittest.cc
index 8cb8bbe..770d514 100644
--- a/p2p/base/stun_request_unittest.cc
+++ b/p2p/base/stun_request_unittest.cc
@@ -151,7 +151,7 @@
// Test that requests are sent at the right times.
TEST_F(StunRequestTest, TestBackoff) {
- rtc::ScopedFakeClock fake_clock;
+ webrtc::ScopedFakeClock fake_clock;
auto* request = new StunRequestThunker(manager_, this);
std::unique_ptr<StunMessage> res =
request->CreateResponseMessage(STUN_BINDING_RESPONSE);
@@ -179,7 +179,7 @@
// Test that we timeout properly if no response is received.
TEST_F(StunRequestTest, TestTimeout) {
- rtc::ScopedFakeClock fake_clock;
+ webrtc::ScopedFakeClock fake_clock;
auto* request = new StunRequestThunker(manager_, this);
std::unique_ptr<StunMessage> res =
request->CreateResponseMessage(STUN_BINDING_RESPONSE);
diff --git a/p2p/base/transport_description_factory_unittest.cc b/p2p/base/transport_description_factory_unittest.cc
index ad994eb..a706a88 100644
--- a/p2p/base/transport_description_factory_unittest.cc
+++ b/p2p/base/transport_description_factory_unittest.cc
@@ -42,9 +42,9 @@
f1_(field_trials_),
f2_(field_trials_),
cert1_(webrtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
- new rtc::FakeSSLIdentity("User1")))),
+ new webrtc::FakeSSLIdentity("User1")))),
cert2_(webrtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
- new rtc::FakeSSLIdentity("User2")))) {
+ new webrtc::FakeSSLIdentity("User2")))) {
// By default, certificates are supplied.
f1_.set_certificate(cert1_);
f2_.set_certificate(cert2_);
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index c9235e5..fcdfd80 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -945,7 +945,7 @@
}
webrtc::test::ScopedKeyValueConfig field_trials_;
- rtc::ScopedFakeClock fake_clock_;
+ webrtc::ScopedFakeClock fake_clock_;
// When a "create port" helper method is called with an IP, we create a
// Network with that IP and add it to this list. Using a list instead of a
// vector so that when it grows, pointers aren't invalidated.
diff --git a/p2p/base/wrapping_active_ice_controller_unittest.cc b/p2p/base/wrapping_active_ice_controller_unittest.cc
index 433e4c3..a7902b6 100644
--- a/p2p/base/wrapping_active_ice_controller_unittest.cc
+++ b/p2p/base/wrapping_active_ice_controller_unittest.cc
@@ -46,7 +46,7 @@
using ::rtc::AutoThread;
using ::rtc::Event;
-using ::rtc::ScopedFakeClock;
+using ::webrtc::ScopedFakeClock;
using ::webrtc::TimeDelta;
using NiceMockIceController = NiceMock<MockIceController>;
diff --git a/p2p/client/basic_port_allocator_unittest.cc b/p2p/client/basic_port_allocator_unittest.cc
index 1a08137..aa5edf8 100644
--- a/p2p/client/basic_port_allocator_unittest.cc
+++ b/p2p/client/basic_port_allocator_unittest.cc
@@ -512,7 +512,7 @@
std::unique_ptr<rtc::BasicPacketSocketFactory> nat_socket_factory_;
webrtc::TestStunServer::StunServerPtr stun_server_;
webrtc::TestTurnServer turn_server_;
- rtc::FakeNetworkManager network_manager_;
+ webrtc::FakeNetworkManager network_manager_;
std::unique_ptr<BasicPortAllocator> allocator_;
std::unique_ptr<PortAllocatorSession> session_;
std::vector<webrtc::PortInterface*> ports_;
@@ -526,7 +526,7 @@
class FakeClockBase {
public:
- rtc::ScopedFakeClock fake_clock;
+ webrtc::ScopedFakeClock fake_clock;
};
class BasicPortAllocatorTest : public FakeClockBase,
diff --git a/p2p/dtls/dtls_ice_integrationtest.cc b/p2p/dtls/dtls_ice_integrationtest.cc
index a185fa9..efd54d3 100644
--- a/p2p/dtls/dtls_ice_integrationtest.cc
+++ b/p2p/dtls/dtls_ice_integrationtest.cc
@@ -315,8 +315,8 @@
ep.dtls->SetLocalCertificate(certificate);
}
- rtc::ScopedFakeClock fake_clock_;
- rtc::FakeNetworkManager network_manager_;
+ webrtc::ScopedFakeClock fake_clock_;
+ webrtc::FakeNetworkManager network_manager_;
std::unique_ptr<rtc::VirtualSocketServer> ss_;
std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory_;
std::unique_ptr<webrtc::NetworkEmulationManager> network_emulation_manager_;
diff --git a/p2p/dtls/dtls_transport_unittest.cc b/p2p/dtls/dtls_transport_unittest.cc
index e2d95f4..ae69627 100644
--- a/p2p/dtls/dtls_transport_unittest.cc
+++ b/p2p/dtls/dtls_transport_unittest.cc
@@ -539,7 +539,7 @@
protected:
rtc::AutoThread main_thread_;
- rtc::ScopedFakeClock fake_clock_;
+ webrtc::ScopedFakeClock fake_clock_;
DtlsTestClient client1_;
DtlsTestClient client2_;
bool use_dtls_;
diff --git a/p2p/dtls/fake_dtls_transport.h b/p2p/dtls/fake_dtls_transport.h
index 70b95d0..ece74ed 100644
--- a/p2p/dtls/fake_dtls_transport.h
+++ b/p2p/dtls/fake_dtls_transport.h
@@ -40,14 +40,14 @@
#include "rtc_base/ssl_stream_adapter.h"
#include "rtc_base/thread.h"
-namespace cricket {
+namespace webrtc {
// Fake DTLS transport which is implemented by wrapping a fake ICE transport.
// Doesn't interact directly with fake ICE transport for anything other than
// sending packets.
-class FakeDtlsTransport : public DtlsTransportInternal {
+class FakeDtlsTransport : public cricket::DtlsTransportInternal {
public:
- explicit FakeDtlsTransport(FakeIceTransport* ice_transport)
+ explicit FakeDtlsTransport(cricket::FakeIceTransport* ice_transport)
: ice_transport_(ice_transport),
transport_name_(ice_transport->transport_name()),
component_(ice_transport->component()),
@@ -62,7 +62,7 @@
this, &FakeDtlsTransport::OnNetworkRouteChanged);
}
- explicit FakeDtlsTransport(std::unique_ptr<FakeIceTransport> ice)
+ explicit FakeDtlsTransport(std::unique_ptr<cricket::FakeIceTransport> ice)
: owned_ice_transport_(std::move(ice)),
transport_name_(owned_ice_transport_->transport_name()),
component_(owned_ice_transport_->component()),
@@ -80,14 +80,15 @@
// If this constructor is called, a new fake ICE transport will be created,
// and this FakeDtlsTransport will take the ownership.
FakeDtlsTransport(const std::string& name, int component)
- : FakeDtlsTransport(std::make_unique<FakeIceTransport>(name, component)) {
- }
+ : FakeDtlsTransport(
+ std::make_unique<cricket::FakeIceTransport>(name, component)) {}
FakeDtlsTransport(const std::string& name,
int component,
rtc::Thread* network_thread)
- : FakeDtlsTransport(std::make_unique<FakeIceTransport>(name,
- component,
- network_thread)) {}
+ : FakeDtlsTransport(
+ std::make_unique<cricket::FakeIceTransport>(name,
+ component,
+ network_thread)) {}
~FakeDtlsTransport() override {
if (dest_ && dest_->dest_ == this) {
@@ -97,7 +98,7 @@
}
// Get inner fake ICE transport.
- FakeIceTransport* fake_ice_transport() { return ice_transport_; }
+ cricket::FakeIceTransport* fake_ice_transport() { return ice_transport_; }
// If async, will send packets by "Post"-ing to message queue instead of
// synchronously "Send"-ing.
@@ -114,7 +115,7 @@
ice_transport_->SetReceiving(receiving);
set_receiving(receiving);
}
- void SetDtlsState(webrtc::DtlsTransportState state) {
+ void SetDtlsState(DtlsTransportState state) {
dtls_state_ = state;
SendDtlsState(this, dtls_state_);
}
@@ -146,9 +147,10 @@
if (!dtls_role_) {
dtls_role_ = std::move(webrtc::SSL_CLIENT);
}
- SetDtlsState(webrtc::DtlsTransportState::kConnected);
+ SetDtlsState(DtlsTransportState::kConnected);
ice_transport_->SetDestination(
- static_cast<FakeIceTransport*>(dest->ice_transport()), asymmetric);
+ static_cast<cricket::FakeIceTransport*>(dest->ice_transport()),
+ asymmetric);
} else {
// Simulates loss of connectivity, by asymmetrically forgetting dest_.
dest_ = nullptr;
@@ -158,21 +160,21 @@
}
// Fake DtlsTransportInternal implementation.
- webrtc::DtlsTransportState dtls_state() const override { return dtls_state_; }
+ DtlsTransportState dtls_state() const override { return dtls_state_; }
const std::string& transport_name() const override { return transport_name_; }
int component() const override { return component_; }
const rtc::SSLFingerprint& dtls_fingerprint() const {
return dtls_fingerprint_;
}
- webrtc::RTCError SetRemoteParameters(absl::string_view alg,
- const uint8_t* digest,
- size_t digest_len,
- std::optional<webrtc::SSLRole> role) {
+ RTCError SetRemoteParameters(absl::string_view alg,
+ const uint8_t* digest,
+ size_t digest_len,
+ std::optional<SSLRole> role) {
if (role) {
SetDtlsRole(*role);
}
SetRemoteFingerprint(alg, digest, digest_len);
- return webrtc::RTCError::OK();
+ return RTCError::OK();
}
bool SetRemoteFingerprint(absl::string_view alg,
const uint8_t* digest,
@@ -181,11 +183,11 @@
rtc::SSLFingerprint(alg, rtc::MakeArrayView(digest, digest_len));
return true;
}
- bool SetDtlsRole(webrtc::SSLRole role) override {
+ bool SetDtlsRole(SSLRole role) override {
dtls_role_ = std::move(role);
return true;
}
- bool GetDtlsRole(webrtc::SSLRole* role) const override {
+ bool GetDtlsRole(SSLRole* role) const override {
if (!dtls_role_) {
return false;
}
@@ -193,12 +195,12 @@
return true;
}
bool SetLocalCertificate(
- const rtc::scoped_refptr<webrtc::RTCCertificate>& certificate) override {
+ const scoped_refptr<RTCCertificate>& certificate) override {
do_dtls_ = true;
local_cert_ = certificate;
return true;
}
- void SetRemoteSSLCertificate(rtc::FakeSSLCertificate* cert) {
+ void SetRemoteSSLCertificate(FakeSSLCertificate* cert) {
remote_cert_ = cert;
}
bool IsDtlsActive() const override { return do_dtls_; }
@@ -233,8 +235,7 @@
return "FakeTlsCipherSuite";
}
uint16_t GetSslPeerSignatureAlgorithm() const override { return 0; }
- rtc::scoped_refptr<webrtc::RTCCertificate> GetLocalCertificate()
- const override {
+ scoped_refptr<RTCCertificate> GetLocalCertificate() const override {
return local_cert_;
}
std::unique_ptr<rtc::SSLCertChain> GetRemoteSSLCertChain() const override {
@@ -250,14 +251,16 @@
}
return do_dtls_;
}
- void set_ssl_max_protocol_version(webrtc::SSLProtocolVersion version) {
+ void set_ssl_max_protocol_version(SSLProtocolVersion version) {
ssl_max_version_ = version;
}
- webrtc::SSLProtocolVersion ssl_max_protocol_version() const {
+ SSLProtocolVersion ssl_max_protocol_version() const {
return ssl_max_version_;
}
- IceTransportInternal* ice_transport() override { return ice_transport_; }
+ cricket::IceTransportInternal* ice_transport() override {
+ return ice_transport_;
+ }
// PacketTransportInternal implementation, which passes through to fake ICE
// transport for sending actual packets.
@@ -268,7 +271,7 @@
const rtc::PacketOptions& options,
int flags) override {
// We expect only SRTP packets to be sent through this interface.
- if (flags != PF_SRTP_BYPASS && flags != 0) {
+ if (flags != cricket::PF_SRTP_BYPASS && flags != 0) {
return -1;
}
return ice_transport_->SendPacket(data, len, options, flags);
@@ -314,26 +317,32 @@
SignalNetworkRouteChanged(network_route);
}
- FakeIceTransport* ice_transport_;
- std::unique_ptr<FakeIceTransport> owned_ice_transport_;
+ cricket::FakeIceTransport* ice_transport_;
+ std::unique_ptr<cricket::FakeIceTransport> owned_ice_transport_;
std::string transport_name_;
int component_;
FakeDtlsTransport* dest_ = nullptr;
- rtc::scoped_refptr<webrtc::RTCCertificate> local_cert_;
- rtc::FakeSSLCertificate* remote_cert_ = nullptr;
+ scoped_refptr<RTCCertificate> local_cert_;
+ FakeSSLCertificate* remote_cert_ = nullptr;
bool do_dtls_ = false;
- webrtc::SSLProtocolVersion ssl_max_version_ = webrtc::SSL_PROTOCOL_DTLS_12;
+ SSLProtocolVersion ssl_max_version_ = webrtc::SSL_PROTOCOL_DTLS_12;
rtc::SSLFingerprint dtls_fingerprint_;
- std::optional<webrtc::SSLRole> dtls_role_;
+ std::optional<SSLRole> dtls_role_;
int crypto_suite_ = webrtc::kSrtpAes128CmSha1_80;
std::optional<int> ssl_cipher_suite_;
- webrtc::DtlsTransportState dtls_state_ = webrtc::DtlsTransportState::kNew;
+ DtlsTransportState dtls_state_ = DtlsTransportState::kNew;
bool receiving_ = false;
bool writable_ = false;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::FakeDtlsTransport;
} // namespace cricket
#endif // P2P_DTLS_FAKE_DTLS_TRANSPORT_H_
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index e480a03..b907848 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -229,10 +229,10 @@
}
} else {
// Confirmed to work with KT_RSA and KT_ECDSA.
- fake_rtp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
+ fake_rtp_dtls_transport1_.reset(new webrtc::FakeDtlsTransport(
"channel1", cricket::ICE_CANDIDATE_COMPONENT_RTP, network_thread_));
if (!(flags1 & RTCP_MUX)) {
- fake_rtcp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
+ fake_rtcp_dtls_transport1_.reset(new webrtc::FakeDtlsTransport(
"channel1", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
network_thread_));
}
@@ -255,10 +255,10 @@
}
} else {
// Confirmed to work with KT_RSA and KT_ECDSA.
- fake_rtp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
+ fake_rtp_dtls_transport2_.reset(new webrtc::FakeDtlsTransport(
"channel2", cricket::ICE_CANDIDATE_COMPONENT_RTP, network_thread_));
if (!(flags2 & RTCP_MUX)) {
- fake_rtcp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
+ fake_rtcp_dtls_transport2_.reset(new webrtc::FakeDtlsTransport(
"channel2", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
network_thread_));
}
@@ -1567,10 +1567,10 @@
webrtc::PendingTaskSafetyFlag::CreateDetached();
std::unique_ptr<rtc::Thread> network_thread_keeper_;
rtc::Thread* network_thread_;
- std::unique_ptr<cricket::FakeDtlsTransport> fake_rtp_dtls_transport1_;
- std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport1_;
- std::unique_ptr<cricket::FakeDtlsTransport> fake_rtp_dtls_transport2_;
- std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport2_;
+ std::unique_ptr<webrtc::FakeDtlsTransport> fake_rtp_dtls_transport1_;
+ std::unique_ptr<webrtc::FakeDtlsTransport> fake_rtcp_dtls_transport1_;
+ std::unique_ptr<webrtc::FakeDtlsTransport> fake_rtp_dtls_transport2_;
+ std::unique_ptr<webrtc::FakeDtlsTransport> fake_rtcp_dtls_transport2_;
std::unique_ptr<webrtc::FakePacketTransport> fake_rtp_packet_transport1_;
std::unique_ptr<webrtc::FakePacketTransport> fake_rtcp_packet_transport1_;
std::unique_ptr<webrtc::FakePacketTransport> fake_rtp_packet_transport2_;
diff --git a/pc/data_channel_integrationtest.cc b/pc/data_channel_integrationtest.cc
index b2e60bf..5ceb6b7 100644
--- a/pc/data_channel_integrationtest.cc
+++ b/pc/data_channel_integrationtest.cc
@@ -99,7 +99,7 @@
// where order of construction is finely controlled.
// This also ensures peerconnection is closed before switching back to non-fake
// clock, avoiding other races and DCHECK failures such as in rtp_sender.cc.
-class FakeClockForTest : public rtc::ScopedFakeClock {
+class FakeClockForTest : public ScopedFakeClock {
protected:
FakeClockForTest() {
// Some things use a time of "0" as a special value, so we need to start out
diff --git a/pc/dtls_srtp_transport_integrationtest.cc b/pc/dtls_srtp_transport_integrationtest.cc
index 16108c8..86163f8 100644
--- a/pc/dtls_srtp_transport_integrationtest.cc
+++ b/pc/dtls_srtp_transport_integrationtest.cc
@@ -218,7 +218,7 @@
private:
rtc::AutoThread main_thread_;
- rtc::ScopedFakeClock fake_clock_;
+ webrtc::ScopedFakeClock fake_clock_;
webrtc::test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<cricket::FakeIceTransport> client_ice_transport_;
diff --git a/pc/dtls_srtp_transport_unittest.cc b/pc/dtls_srtp_transport_unittest.cc
index 679ddfe..6f9625b 100644
--- a/pc/dtls_srtp_transport_unittest.cc
+++ b/pc/dtls_srtp_transport_unittest.cc
@@ -37,9 +37,9 @@
#include "test/gtest.h"
#include "test/scoped_key_value_config.h"
-using cricket::FakeDtlsTransport;
using cricket::FakeIceTransport;
using webrtc::DtlsSrtpTransport;
+using ::webrtc::FakeDtlsTransport;
using webrtc::RtpTransport;
using webrtc::SrtpTransport;
diff --git a/pc/dtls_transport_unittest.cc b/pc/dtls_transport_unittest.cc
index 0eb5a20..7a4cc9c 100644
--- a/pc/dtls_transport_unittest.cc
+++ b/pc/dtls_transport_unittest.cc
@@ -34,7 +34,6 @@
constexpr int kNonsenseCipherSuite = 1234;
-using cricket::FakeDtlsTransport;
using ::testing::ElementsAre;
class TestDtlsTransportObserver : public DtlsTransportObserverInterface {
@@ -65,7 +64,7 @@
DtlsTransport* transport() { return transport_.get(); }
DtlsTransportObserverInterface* observer() { return &observer_; }
- void CreateTransport(rtc::FakeSSLCertificate* certificate = nullptr) {
+ void CreateTransport(FakeSSLCertificate* certificate = nullptr) {
auto cricket_transport = std::make_unique<FakeDtlsTransport>(
"audio", cricket::ICE_CANDIDATE_COMPONENT_RTP);
if (certificate) {
@@ -136,7 +135,7 @@
}
TEST_F(DtlsTransportTest, RoleAppearsOnConnect) {
- rtc::FakeSSLCertificate fake_certificate("fake data");
+ FakeSSLCertificate fake_certificate("fake data");
CreateTransport(&fake_certificate);
transport()->RegisterObserver(observer());
EXPECT_FALSE(transport()->Information().role());
@@ -150,7 +149,7 @@
}
TEST_F(DtlsTransportTest, CertificateAppearsOnConnect) {
- rtc::FakeSSLCertificate fake_certificate("fake data");
+ FakeSSLCertificate fake_certificate("fake data");
CreateTransport(&fake_certificate);
transport()->RegisterObserver(observer());
CompleteDtlsHandshake();
@@ -161,7 +160,7 @@
}
TEST_F(DtlsTransportTest, CertificateDisappearsOnClose) {
- rtc::FakeSSLCertificate fake_certificate("fake data");
+ FakeSSLCertificate fake_certificate("fake data");
CreateTransport(&fake_certificate);
transport()->RegisterObserver(observer());
CompleteDtlsHandshake();
diff --git a/pc/dtmf_sender_unittest.cc b/pc/dtmf_sender_unittest.cc
index 9c981cb..ba7560d 100644
--- a/pc/dtmf_sender_unittest.cc
+++ b/pc/dtmf_sender_unittest.cc
@@ -218,7 +218,7 @@
std::unique_ptr<FakeDtmfObserver> observer_;
std::unique_ptr<FakeDtmfProvider> provider_;
rtc::scoped_refptr<DtmfSender> dtmf_;
- rtc::ScopedFakeClock fake_clock_;
+ webrtc::ScopedFakeClock fake_clock_;
};
TEST_F(DtmfSenderTest, CanInsertDtmf) {
diff --git a/pc/jsep_transport_controller_unittest.cc b/pc/jsep_transport_controller_unittest.cc
index 045c6e8..a6837dc 100644
--- a/pc/jsep_transport_controller_unittest.cc
+++ b/pc/jsep_transport_controller_unittest.cc
@@ -65,7 +65,7 @@
using cricket::Candidate;
using cricket::Candidates;
-using cricket::FakeDtlsTransport;
+using ::webrtc::FakeDtlsTransport;
static const int kTimeout = 100;
static const char kIceUfrag1[] = "u0001";
@@ -634,7 +634,7 @@
transport_controller_
->SetLocalDescription(SdpType::kOffer, description.get(), nullptr)
.ok());
- rtc::FakeSSLCertificate fake_certificate("fake_data");
+ FakeSSLCertificate fake_certificate("fake_data");
auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
transport_controller_->GetDtlsTransport(kAudioMid1));
diff --git a/pc/jsep_transport_unittest.cc b/pc/jsep_transport_unittest.cc
index 18966b6..12da957 100644
--- a/pc/jsep_transport_unittest.cc
+++ b/pc/jsep_transport_unittest.cc
@@ -128,16 +128,16 @@
auto ice_internal = std::make_unique<FakeIceTransport>(
kTransportName, ICE_CANDIDATE_COMPONENT_RTP);
auto rtp_dtls_transport =
- std::make_unique<FakeDtlsTransport>(ice_internal.get());
+ std::make_unique<webrtc::FakeDtlsTransport>(ice_internal.get());
auto ice = CreateIceTransport(std::move(ice_internal));
std::unique_ptr<FakeIceTransport> rtcp_ice_internal;
- std::unique_ptr<FakeDtlsTransport> rtcp_dtls_transport;
+ std::unique_ptr<webrtc::FakeDtlsTransport> rtcp_dtls_transport;
if (!rtcp_mux_enabled) {
rtcp_ice_internal = std::make_unique<FakeIceTransport>(
kTransportName, ICE_CANDIDATE_COMPONENT_RTCP);
rtcp_dtls_transport =
- std::make_unique<FakeDtlsTransport>(rtcp_ice_internal.get());
+ std::make_unique<webrtc::FakeDtlsTransport>(rtcp_ice_internal.get());
}
auto rtcp_ice = CreateIceTransport(std::move(rtcp_ice_internal));
@@ -289,14 +289,14 @@
ASSERT_TRUE(role);
EXPECT_EQ(webrtc::SSL_SERVER,
role); // Because remote description was "active".
- auto fake_dtls =
- static_cast<FakeDtlsTransport*>(jsep_transport_->rtp_dtls_transport());
+ auto fake_dtls = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport_->rtp_dtls_transport());
EXPECT_EQ(remote_description.transport_desc.identity_fingerprint->ToString(),
fake_dtls->dtls_fingerprint().ToString());
if (!rtcp_mux_enabled) {
- auto fake_rtcp_dtls =
- static_cast<FakeDtlsTransport*>(jsep_transport_->rtcp_dtls_transport());
+ auto fake_rtcp_dtls = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport_->rtcp_dtls_transport());
EXPECT_EQ(
remote_description.transport_desc.identity_fingerprint->ToString(),
fake_rtcp_dtls->dtls_fingerprint().ToString());
@@ -341,14 +341,14 @@
ASSERT_TRUE(role);
EXPECT_EQ(webrtc::SSL_CLIENT,
role); // Because remote description was "passive".
- auto fake_dtls =
- static_cast<FakeDtlsTransport*>(jsep_transport_->rtp_dtls_transport());
+ auto fake_dtls = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport_->rtp_dtls_transport());
EXPECT_EQ(remote_description.transport_desc.identity_fingerprint->ToString(),
fake_dtls->dtls_fingerprint().ToString());
if (!rtcp_mux_enabled) {
- auto fake_rtcp_dtls =
- static_cast<FakeDtlsTransport*>(jsep_transport_->rtcp_dtls_transport());
+ auto fake_rtcp_dtls = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport_->rtcp_dtls_transport());
EXPECT_EQ(
remote_description.transport_desc.identity_fingerprint->ToString(),
fake_rtcp_dtls->dtls_fingerprint().ToString());
@@ -1056,10 +1056,10 @@
jsep_transport1_ = CreateJsepTransport2(/*rtcp_mux_enabled=*/true);
jsep_transport2_ = CreateJsepTransport2(/*rtcp_mux_enabled=*/true);
- auto fake_dtls1 =
- static_cast<FakeDtlsTransport*>(jsep_transport1_->rtp_dtls_transport());
- auto fake_dtls2 =
- static_cast<FakeDtlsTransport*>(jsep_transport2_->rtp_dtls_transport());
+ auto fake_dtls1 = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport1_->rtp_dtls_transport());
+ auto fake_dtls2 = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport2_->rtp_dtls_transport());
fake_dtls1->fake_ice_transport()->RegisterReceivedPacketCallback(
this, [&](rtc::PacketTransportInternal* transport,
@@ -1103,10 +1103,10 @@
}
void ConnectTransport() {
- auto rtp_dtls_transport1 =
- static_cast<FakeDtlsTransport*>(jsep_transport1_->rtp_dtls_transport());
- auto rtp_dtls_transport2 =
- static_cast<FakeDtlsTransport*>(jsep_transport2_->rtp_dtls_transport());
+ auto rtp_dtls_transport1 = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport1_->rtp_dtls_transport());
+ auto rtp_dtls_transport2 = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport2_->rtp_dtls_transport());
rtp_dtls_transport1->SetDestination(rtp_dtls_transport2);
}
@@ -1165,10 +1165,10 @@
recv_encrypted_headers2_.push_back(kHeaderExtensionIDs[1]);
if (use_gcm) {
- auto fake_dtls1 =
- static_cast<FakeDtlsTransport*>(jsep_transport1_->rtp_dtls_transport());
- auto fake_dtls2 =
- static_cast<FakeDtlsTransport*>(jsep_transport2_->rtp_dtls_transport());
+ auto fake_dtls1 = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport1_->rtp_dtls_transport());
+ auto fake_dtls2 = static_cast<webrtc::FakeDtlsTransport*>(
+ jsep_transport2_->rtp_dtls_transport());
fake_dtls1->SetSrtpCryptoSuite(webrtc::kSrtpAeadAes256Gcm);
fake_dtls2->SetSrtpCryptoSuite(webrtc::kSrtpAeadAes256Gcm);
diff --git a/pc/legacy_stats_collector_unittest.cc b/pc/legacy_stats_collector_unittest.cc
index bd427dc..96dba2e 100644
--- a/pc/legacy_stats_collector_unittest.cc
+++ b/pc/legacy_stats_collector_unittest.cc
@@ -654,9 +654,9 @@
}
}
- void TestCertificateReports(const rtc::FakeSSLIdentity& local_identity,
+ void TestCertificateReports(const FakeSSLIdentity& local_identity,
const std::vector<std::string>& local_ders,
- const rtc::FakeSSLIdentity& remote_identity,
+ const FakeSSLIdentity& remote_identity,
const std::vector<std::string>& remote_ders) {
const std::string kTransportName = "transport";
@@ -1431,7 +1431,7 @@
local_ders[2] = "some";
local_ders[3] = "der";
local_ders[4] = "values";
- rtc::FakeSSLIdentity local_identity(DersToPems(local_ders));
+ FakeSSLIdentity local_identity(DersToPems(local_ders));
// Build remote certificate chain
std::vector<std::string> remote_ders(4);
@@ -1439,7 +1439,7 @@
remote_ders[1] = "non-";
remote_ders[2] = "intersecting";
remote_ders[3] = "set";
- rtc::FakeSSLIdentity remote_identity(DersToPems(remote_ders));
+ FakeSSLIdentity remote_identity(DersToPems(remote_ders));
TestCertificateReports(local_identity, local_ders, remote_identity,
remote_ders);
@@ -1450,11 +1450,11 @@
TEST_F(LegacyStatsCollectorTest, ChainlessCertificateReportsCreated) {
// Build local certificate.
std::string local_der = "This is the local der.";
- rtc::FakeSSLIdentity local_identity(DerToPem(local_der));
+ FakeSSLIdentity local_identity(DerToPem(local_der));
// Build remote certificate.
std::string remote_der = "This is somebody else's der.";
- rtc::FakeSSLIdentity remote_identity(DerToPem(remote_der));
+ FakeSSLIdentity remote_identity(DerToPem(remote_der));
TestCertificateReports(local_identity, std::vector<std::string>(1, local_der),
remote_identity,
@@ -1503,13 +1503,13 @@
TEST_F(LegacyStatsCollectorTest, UnsupportedDigestIgnored) {
// Build a local certificate.
std::string local_der = "This is the local der.";
- rtc::FakeSSLIdentity local_identity(DerToPem(local_der));
+ FakeSSLIdentity local_identity(DerToPem(local_der));
// Build a remote certificate with an unsupported digest algorithm.
std::string remote_der = "This is somebody else's der.";
- rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
+ FakeSSLCertificate remote_cert(DerToPem(remote_der));
remote_cert.set_digest_algorithm("foobar");
- rtc::FakeSSLIdentity remote_identity(remote_cert);
+ FakeSSLIdentity remote_identity(remote_cert);
TestCertificateReports(local_identity, std::vector<std::string>(1, local_der),
remote_identity, std::vector<std::string>());
diff --git a/pc/media_session_unittest.cc b/pc/media_session_unittest.cc
index ab11d66..3bbd875 100644
--- a/pc/media_session_unittest.cc
+++ b/pc/media_session_unittest.cc
@@ -543,9 +543,9 @@
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(
MAKE_VECTOR(kVideoCodecs2), MAKE_VECTOR(kVideoCodecs2));
tdf1_.set_certificate(webrtc::RTCCertificate::Create(
- std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id1"))));
+ std::unique_ptr<rtc::SSLIdentity>(new webrtc::FakeSSLIdentity("id1"))));
tdf2_.set_certificate(webrtc::RTCCertificate::Create(
- std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id2"))));
+ std::unique_ptr<rtc::SSLIdentity>(new webrtc::FakeSSLIdentity("id2"))));
}
// Create a video StreamParamsVec object with:
@@ -4680,9 +4680,9 @@
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(
MAKE_VECTOR(kVideoCodecs2), MAKE_VECTOR(kVideoCodecs2));
tdf1_.set_certificate(webrtc::RTCCertificate::Create(
- std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id1"))));
+ std::unique_ptr<rtc::SSLIdentity>(new webrtc::FakeSSLIdentity("id1"))));
tdf2_.set_certificate(webrtc::RTCCertificate::Create(
- std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id2"))));
+ std::unique_ptr<rtc::SSLIdentity>(new webrtc::FakeSSLIdentity("id2"))));
}
protected:
@@ -4747,7 +4747,7 @@
webrtc::test::ScopedKeyValueConfig field_trials;
TransportDescriptionFactory tdf(field_trials);
tdf.set_certificate(webrtc::RTCCertificate::Create(
- std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id"))));
+ std::unique_ptr<rtc::SSLIdentity>(new webrtc::FakeSSLIdentity("id"))));
rtc::UniqueRandomIdGenerator ssrc_generator;
CodecLookupHelperForTesting codec_lookup_helper(field_trials);
@@ -4852,11 +4852,12 @@
webrtc::test::ScopedKeyValueConfig field_trials;
TransportDescriptionFactory offer_tdf(field_trials);
TransportDescriptionFactory answer_tdf(field_trials);
- offer_tdf.set_certificate(webrtc::RTCCertificate::Create(
- std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("offer_id"))));
+ offer_tdf.set_certificate(
+ webrtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
+ new webrtc::FakeSSLIdentity("offer_id"))));
answer_tdf.set_certificate(
webrtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
- new rtc::FakeSSLIdentity("answer_id"))));
+ new webrtc::FakeSSLIdentity("answer_id"))));
rtc::UniqueRandomIdGenerator ssrc_generator1, ssrc_generator2;
CodecLookupHelperForTesting offer_codec_lookup_helper(field_trials);
MediaSessionDescriptionFactory offer_factory(
@@ -5022,10 +5023,10 @@
codec_lookup_helper_answerer_(field_trials_) {
tdf_offerer_.set_certificate(
webrtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
- new rtc::FakeSSLIdentity("offer_id"))));
+ new webrtc::FakeSSLIdentity("offer_id"))));
tdf_answerer_.set_certificate(
webrtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
- new rtc::FakeSSLIdentity("answer_id"))));
+ new webrtc::FakeSSLIdentity("answer_id"))));
}
void CheckH265Level(const std::vector<Codec>& codecs,
diff --git a/pc/peer_connection_bundle_unittest.cc b/pc/peer_connection_bundle_unittest.cc
index d80b524..4bc41c1 100644
--- a/pc/peer_connection_bundle_unittest.cc
+++ b/pc/peer_connection_bundle_unittest.cc
@@ -86,7 +86,7 @@
// will use: https://www.w3.org/TR/webrtc/#dom-rtcrtpsender-transport
// Should also be able to remove GetTransceiversForTesting at that point.
-class FakeNetworkManagerWithNoAnyNetwork : public rtc::FakeNetworkManager {
+class FakeNetworkManagerWithNoAnyNetwork : public FakeNetworkManager {
public:
std::vector<const rtc::Network*> GetAnyAddressNetworks() override {
// This function allocates networks that are owned by the
@@ -180,12 +180,12 @@
return false;
}
- rtc::FakeNetworkManager* network() { return network_; }
+ FakeNetworkManager* network() { return network_; }
- void set_network(rtc::FakeNetworkManager* network) { network_ = network; }
+ void set_network(FakeNetworkManager* network) { network_ = network; }
private:
- rtc::FakeNetworkManager* network_;
+ FakeNetworkManager* network_;
};
class PeerConnectionBundleBaseTest : public ::testing::Test {
diff --git a/pc/peer_connection_encodings_integrationtest.cc b/pc/peer_connection_encodings_integrationtest.cc
index f42ca15..22b8a01 100644
--- a/pc/peer_connection_encodings_integrationtest.cc
+++ b/pc/peer_connection_encodings_integrationtest.cc
@@ -3078,9 +3078,8 @@
#ifdef RTC_ENABLE_H265
scoped_refptr<PeerConnectionTestWrapper> CreatePcWithFakeH265(
std::unique_ptr<FieldTrialsView> field_trials = nullptr) {
- std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>
- video_encoder_factory =
- std::make_unique<cricket::FakeWebRtcVideoEncoderFactory>();
+ std::unique_ptr<FakeWebRtcVideoEncoderFactory> video_encoder_factory =
+ std::make_unique<FakeWebRtcVideoEncoderFactory>();
video_encoder_factory->AddSupportedVideoCodec(
SdpVideoFormat("H265",
{{"profile-id", "1"},
@@ -3088,9 +3087,8 @@
{"level-id", "156"},
{"tx-mode", "SRST"}},
{ScalabilityMode::kL1T1}));
- std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>
- video_decoder_factory =
- std::make_unique<cricket::FakeWebRtcVideoDecoderFactory>();
+ std::unique_ptr<FakeWebRtcVideoDecoderFactory> video_decoder_factory =
+ std::make_unique<FakeWebRtcVideoDecoderFactory>();
video_decoder_factory->AddSupportedVideoCodecType("H265");
auto pc_wrapper = make_ref_counted<PeerConnectionTestWrapper>(
"pc", &pss_, background_thread_.get(), background_thread_.get());
@@ -3106,9 +3104,8 @@
// sendrecv "profile-level-id". The sendrecv one is constrained baseline.
scoped_refptr<PeerConnectionTestWrapper> CreatePcWithUnidirectionalH264(
std::unique_ptr<FieldTrialsView> field_trials = nullptr) {
- std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>
- video_encoder_factory =
- std::make_unique<cricket::FakeWebRtcVideoEncoderFactory>();
+ std::unique_ptr<FakeWebRtcVideoEncoderFactory> video_encoder_factory =
+ std::make_unique<FakeWebRtcVideoEncoderFactory>();
SdpVideoFormat h264_constrained_baseline =
SdpVideoFormat("H264",
{{"level-asymmetry-allowed", "1"},
@@ -3122,9 +3119,8 @@
{"packetization-mode", "1"},
{"profile-level-id", "640034"}}, // sendonly
{ScalabilityMode::kL1T1}));
- std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>
- video_decoder_factory =
- std::make_unique<cricket::FakeWebRtcVideoDecoderFactory>();
+ std::unique_ptr<FakeWebRtcVideoDecoderFactory> video_decoder_factory =
+ std::make_unique<FakeWebRtcVideoDecoderFactory>();
video_decoder_factory->AddSupportedVideoCodec(h264_constrained_baseline);
video_decoder_factory->AddSupportedVideoCodec(
SdpVideoFormat("H264",
diff --git a/pc/peer_connection_factory_unittest.cc b/pc/peer_connection_factory_unittest.cc
index aaa0417..72d71a8 100644
--- a/pc/peer_connection_factory_unittest.cc
+++ b/pc/peer_connection_factory_unittest.cc
@@ -653,8 +653,7 @@
rtc::scoped_refptr<FakeVideoTrackSource> source =
FakeVideoTrackSource::Create(/*is_screencast=*/false);
- cricket::FakeFrameSource frame_source(1280, 720,
- rtc::kNumMicrosecsPerSec / 30);
+ FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30);
ASSERT_TRUE(source.get() != NULL);
rtc::scoped_refptr<VideoTrackInterface> track(
@@ -706,7 +705,7 @@
TEST(PeerConnectionFactoryDependenciesTest, UsesPacketSocketFactory) {
constexpr TimeDelta kWaitTimeout = TimeDelta::Seconds(10);
auto mock_socket_factory =
- std::make_unique<NiceMock<rtc::MockPacketSocketFactory>>();
+ std::make_unique<NiceMock<MockPacketSocketFactory>>();
rtc::Event called;
EXPECT_CALL(*mock_socket_factory, CreateUdpSocket(_, _, _))
diff --git a/pc/peer_connection_histogram_unittest.cc b/pc/peer_connection_histogram_unittest.cc
index 5702a12..de67d8e 100644
--- a/pc/peer_connection_histogram_unittest.cc
+++ b/pc/peer_connection_histogram_unittest.cc
@@ -228,7 +228,7 @@
deps.async_dns_resolver_factory =
std::make_unique<NiceMock<MockAsyncDnsResolverFactory>>();
- auto fake_network = std::make_unique<rtc::FakeNetworkManager>();
+ auto fake_network = std::make_unique<FakeNetworkManager>();
fake_network->set_mdns_responder(
std::make_unique<FakeMdnsResponder>(rtc::Thread::Current()));
fake_network->AddInterface(NextLocalAddress());
@@ -246,7 +246,7 @@
}
WrapperPtr CreatePeerConnectionWithPrivateLocalAddresses() {
- auto fake_network = std::make_unique<rtc::FakeNetworkManager>();
+ auto fake_network = std::make_unique<FakeNetworkManager>();
fake_network->AddInterface(NextLocalAddress());
fake_network->AddInterface(kPrivateLocalAddress);
@@ -258,7 +258,7 @@
}
WrapperPtr CreatePeerConnectionWithPrivateIpv6LocalAddresses() {
- auto fake_network = std::make_unique<rtc::FakeNetworkManager>();
+ auto fake_network = std::make_unique<FakeNetworkManager>();
fake_network->AddInterface(NextLocalAddress());
fake_network->AddInterface(kPrivateIpv6LocalAddress);
@@ -284,7 +284,7 @@
} else {
// If no network manager is provided, one will be created that uses the
// host network. This doesn't work on all trybots.
- auto fake_network = std::make_unique<rtc::FakeNetworkManager>();
+ auto fake_network = std::make_unique<FakeNetworkManager>();
fake_network->AddInterface(NextLocalAddress());
pcf_deps.network_manager = std::move(fake_network);
}
diff --git a/pc/peer_connection_ice_unittest.cc b/pc/peer_connection_ice_unittest.cc
index 261d423..74d2e7d 100644
--- a/pc/peer_connection_ice_unittest.cc
+++ b/pc/peer_connection_ice_unittest.cc
@@ -131,12 +131,12 @@
return candidates;
}
- rtc::FakeNetworkManager* network() { return network_; }
+ FakeNetworkManager* network() { return network_; }
- void set_network(rtc::FakeNetworkManager* network) { network_ = network; }
+ void set_network(FakeNetworkManager* network) { network_ = network; }
private:
- rtc::FakeNetworkManager* network_;
+ FakeNetworkManager* network_;
};
class PeerConnectionIceBaseTest : public ::testing::Test {
@@ -160,7 +160,7 @@
pcf_deps.worker_thread = rtc::Thread::Current();
pcf_deps.signaling_thread = rtc::Thread::Current();
pcf_deps.socket_factory = &vss_;
- auto network_manager = std::make_unique<rtc::FakeNetworkManager>();
+ auto network_manager = std::make_unique<FakeNetworkManager>();
auto* fake_network = network_manager.get();
pcf_deps.network_manager = std::move(network_manager);
pcf_deps.adm = FakeAudioCaptureModule::Create();
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index d3a945b..0de455e 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -125,7 +125,7 @@
// where order of construction is finely controlled.
// This also ensures peerconnection is closed before switching back to non-fake
// clock, avoiding other races and DCHECK failures such as in rtp_sender.cc.
-class FakeClockForTest : public rtc::ScopedFakeClock {
+class FakeClockForTest : public ScopedFakeClock {
protected:
FakeClockForTest() {
// Some things use a time of "0" as a special value, so we need to start out
diff --git a/pc/peer_connection_rampup_tests.cc b/pc/peer_connection_rampup_tests.cc
index cda8dcb..428ca8c 100644
--- a/pc/peer_connection_rampup_tests.cc
+++ b/pc/peer_connection_rampup_tests.cc
@@ -181,7 +181,7 @@
pcf_deps.worker_thread = worker_thread_.get();
pcf_deps.signaling_thread = rtc::Thread::Current();
pcf_deps.socket_factory = &firewall_socket_server_;
- auto network_manager = std::make_unique<rtc::FakeNetworkManager>();
+ auto network_manager = std::make_unique<FakeNetworkManager>();
network_manager->AddInterface(kDefaultLocalAddress);
pcf_deps.network_manager = std::move(network_manager);
pcf_deps.adm = FakeAudioCaptureModule::Create();
diff --git a/pc/rtc_stats_collector_unittest.cc b/pc/rtc_stats_collector_unittest.cc
index c0d20e3..2aa66e7 100644
--- a/pc/rtc_stats_collector_unittest.cc
+++ b/pc/rtc_stats_collector_unittest.cc
@@ -147,9 +147,8 @@
"CERTIFICATE", reinterpret_cast<const unsigned char*>(der.c_str()),
der.length()));
}
- info->certificate =
- RTCCertificate::Create(std::unique_ptr<rtc::FakeSSLIdentity>(
- new rtc::FakeSSLIdentity(info->pems)));
+ info->certificate = RTCCertificate::Create(
+ std::unique_ptr<FakeSSLIdentity>(new FakeSSLIdentity(info->pems)));
// Strip header/footer and newline characters of PEM strings.
for (size_t i = 0; i < info->pems.size(); ++i) {
absl::StrReplaceAll({{"-----BEGIN CERTIFICATE-----", ""},
@@ -879,7 +878,7 @@
}
protected:
- rtc::ScopedFakeClock fake_clock_;
+ ScopedFakeClock fake_clock_;
rtc::AutoThread main_thread_;
rtc::scoped_refptr<FakePeerConnectionForStats> pc_;
std::unique_ptr<RTCStatsCollectorWrapper> stats_;
@@ -1431,7 +1430,7 @@
TEST_F(RTCStatsCollectorTest, CertificateStatsCache) {
const char kTransportName[] = "transport";
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
pc_->AddVoiceChannel("audio", kTransportName);
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index 2b67265..75e9f54 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -108,7 +108,7 @@
media_engine_(std::make_unique<cricket::FakeMediaEngine>()),
fake_call_(env_, worker_thread_, network_thread_),
local_stream_(MediaStream::Create(kStreamId1)) {
- rtp_dtls_transport_ = std::make_unique<cricket::FakeDtlsTransport>(
+ rtp_dtls_transport_ = std::make_unique<FakeDtlsTransport>(
"fake_dtls_transport", cricket::ICE_CANDIDATE_COMPONENT_RTP);
rtp_transport_ = CreateDtlsSrtpTransport();
@@ -223,7 +223,7 @@
for (int i = 0; i < num_layers; ++i) {
ssrcs.push_back(kVideoSsrcSimulcast + i);
}
- return cricket::CreateSimStreamParams("cname", ssrcs);
+ return CreateSimStreamParams("cname", ssrcs);
}
uint32_t CreateVideoRtpSender(const cricket::StreamParams& stream_params) {
@@ -309,8 +309,7 @@
ssrcs.reserve(num_layers);
for (int i = 0; i < num_layers; ++i)
ssrcs.push_back(kVideoSsrcSimulcast + i);
- cricket::StreamParams stream_params =
- cricket::CreateSimStreamParams("cname", ssrcs);
+ cricket::StreamParams stream_params = CreateSimStreamParams("cname", ssrcs);
video_media_receive_channel_->AddRecvStream(stream_params);
uint32_t primary_ssrc = stream_params.first_ssrc();
@@ -523,7 +522,7 @@
video_bitrate_allocator_factory_;
std::unique_ptr<cricket::FakeMediaEngine> media_engine_;
UniqueRandomIdGenerator ssrc_generator_;
- cricket::FakeCall fake_call_;
+ FakeCall fake_call_;
std::unique_ptr<cricket::VoiceMediaSendChannelInterface>
voice_media_send_channel_;
std::unique_ptr<cricket::VideoMediaSendChannelInterface>
@@ -958,8 +957,7 @@
// Simulate the setLocalDescription call
std::vector<uint32_t> ssrcs(1, 1);
- cricket::StreamParams stream_params =
- cricket::CreateSimStreamParams("cname", ssrcs);
+ cricket::StreamParams stream_params = CreateSimStreamParams("cname", ssrcs);
voice_media_send_channel()->AddSendStream(stream_params);
audio_rtp_sender_->SetMediaChannel(
voice_media_send_channel()->AsVoiceSendChannel());
@@ -1212,8 +1210,7 @@
ssrcs.reserve(2);
for (int i = 0; i < 2; ++i)
ssrcs.push_back(kVideoSsrcSimulcast + i);
- cricket::StreamParams stream_params =
- cricket::CreateSimStreamParams("cname", ssrcs);
+ cricket::StreamParams stream_params = CreateSimStreamParams("cname", ssrcs);
video_media_send_channel()->AddSendStream(stream_params);
video_rtp_sender_->SetMediaChannel(
video_media_send_channel()->AsVideoSendChannel());
@@ -1254,8 +1251,7 @@
ssrcs.reserve(2);
for (int i = 0; i < 2; ++i)
ssrcs.push_back(kVideoSsrcSimulcast + i);
- cricket::StreamParams stream_params =
- cricket::CreateSimStreamParams("cname", ssrcs);
+ cricket::StreamParams stream_params = CreateSimStreamParams("cname", ssrcs);
video_media_send_channel()->AddSendStream(stream_params);
video_rtp_sender_->SetMediaChannel(
video_media_send_channel()->AsVideoSendChannel());
diff --git a/pc/rtp_transceiver_unittest.cc b/pc/rtp_transceiver_unittest.cc
index 2d6efa6..cacd34a 100644
--- a/pc/rtp_transceiver_unittest.cc
+++ b/pc/rtp_transceiver_unittest.cc
@@ -99,7 +99,7 @@
const std::string content_name("my_mid");
auto transceiver = rtc::make_ref_counted<RtpTransceiver>(
cricket::MediaType::MEDIA_TYPE_AUDIO, context());
- auto channel1 = std::make_unique<NiceMock<cricket::MockChannelInterface>>();
+ auto channel1 = std::make_unique<NiceMock<MockChannelInterface>>();
EXPECT_CALL(*channel1, media_type())
.WillRepeatedly(Return(cricket::MediaType::MEDIA_TYPE_AUDIO));
EXPECT_CALL(*channel1, mid()).WillRepeatedly(ReturnRef(content_name));
@@ -116,7 +116,7 @@
transceiver->StopInternal();
EXPECT_EQ(channel1_ptr, transceiver->channel());
- auto channel2 = std::make_unique<NiceMock<cricket::MockChannelInterface>>();
+ auto channel2 = std::make_unique<NiceMock<MockChannelInterface>>();
EXPECT_CALL(*channel2, media_type())
.WillRepeatedly(Return(cricket::MediaType::MEDIA_TYPE_AUDIO));
@@ -135,7 +135,7 @@
const std::string content_name("my_mid");
auto transceiver = rtc::make_ref_counted<RtpTransceiver>(
cricket::MediaType::MEDIA_TYPE_VIDEO, context());
- auto channel = std::make_unique<NiceMock<cricket::MockChannelInterface>>();
+ auto channel = std::make_unique<NiceMock<MockChannelInterface>>();
EXPECT_CALL(*channel, media_type())
.WillRepeatedly(Return(cricket::MediaType::MEDIA_TYPE_VIDEO));
EXPECT_CALL(*channel, mid()).WillRepeatedly(ReturnRef(content_name));
@@ -731,8 +731,7 @@
EXPECT_CALL(*sender_.get(), SetMediaChannel(_));
EXPECT_CALL(*sender_.get(), SetTransceiverAsStopped());
EXPECT_CALL(*sender_.get(), Stop());
- auto mock_channel =
- std::make_unique<NiceMock<cricket::MockChannelInterface>>();
+ auto mock_channel = std::make_unique<NiceMock<MockChannelInterface>>();
auto mock_channel_ptr = mock_channel.get();
EXPECT_CALL(*mock_channel, SetFirstPacketReceivedCallback(_));
EXPECT_CALL(*mock_channel, media_type())
@@ -765,8 +764,7 @@
EXPECT_CALL(*sender_.get(), SetTransceiverAsStopped());
EXPECT_CALL(*sender_.get(), Stop());
- auto mock_channel =
- std::make_unique<NiceMock<cricket::MockChannelInterface>>();
+ auto mock_channel = std::make_unique<NiceMock<MockChannelInterface>>();
auto mock_channel_ptr = mock_channel.get();
EXPECT_CALL(*mock_channel, SetFirstPacketReceivedCallback(_));
EXPECT_CALL(*mock_channel, media_type())
diff --git a/pc/sctp_transport_unittest.cc b/pc/sctp_transport_unittest.cc
index 0631e35..b7f318a 100644
--- a/pc/sctp_transport_unittest.cc
+++ b/pc/sctp_transport_unittest.cc
@@ -41,7 +41,6 @@
constexpr int kTestMaxSctpStreams = 1234;
-using cricket::FakeDtlsTransport;
using ::testing::ElementsAre;
namespace {
@@ -221,7 +220,7 @@
ASSERT_THAT(WaitUntil([&] { return observer_.State(); },
::testing::Eq(SctpTransportState::kConnected)),
IsRtcOk());
- static_cast<cricket::FakeDtlsTransport*>(dtls_transport_->internal())
+ static_cast<FakeDtlsTransport*>(dtls_transport_->internal())
->SetDtlsState(DtlsTransportState::kClosed);
ASSERT_THAT(WaitUntil([&] { return observer_.State(); },
::testing::Eq(SctpTransportState::kClosed)),
diff --git a/pc/slow_peer_connection_integration_test.cc b/pc/slow_peer_connection_integration_test.cc
index 28a858f..06716cb 100644
--- a/pc/slow_peer_connection_integration_test.cc
+++ b/pc/slow_peer_connection_integration_test.cc
@@ -62,7 +62,7 @@
// where order of construction is finely controlled.
// This also ensures peerconnection is closed before switching back to non-fake
// clock, avoiding other races and DCHECK failures such as in rtp_sender.cc.
-class FakeClockForTest : public rtc::ScopedFakeClock {
+class FakeClockForTest : public ScopedFakeClock {
protected:
FakeClockForTest() {
// Some things use a time of "0" as a special value, so we need to start out
diff --git a/pc/srtp_session_unittest.cc b/pc/srtp_session_unittest.cc
index 88c92fb..148a0a8 100644
--- a/pc/srtp_session_unittest.cc
+++ b/pc/srtp_session_unittest.cc
@@ -53,7 +53,8 @@
}
void TestProtectRtp(int crypto_suite) {
EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_));
- EXPECT_EQ(rtp_packet_.size(), rtp_len_ + rtp_auth_tag_len(crypto_suite));
+ EXPECT_EQ(rtp_packet_.size(),
+ rtp_len_ + webrtc::rtp_auth_tag_len(crypto_suite));
// Check that Protect changed the content (up to the original length).
EXPECT_NE(0, std::memcmp(kPcmuFrame, rtp_packet_.data(), rtp_len_));
rtp_len_ = rtp_packet_.size();
@@ -61,7 +62,7 @@
void TestProtectRtcp(int crypto_suite) {
EXPECT_TRUE(s1_.ProtectRtcp(rtcp_packet_));
EXPECT_EQ(rtcp_packet_.size(),
- rtcp_len_ + 4 + rtcp_auth_tag_len(crypto_suite));
+ rtcp_len_ + 4 + webrtc::rtcp_auth_tag_len(crypto_suite));
// Check that Protect changed the content (up to the original length).
EXPECT_NE(0, std::memcmp(kRtcpReport, rtcp_packet_.data(), rtcp_len_));
rtcp_len_ = rtcp_packet_.size();
@@ -89,40 +90,41 @@
// Test that we can set up the session and keys properly.
TEST_F(SrtpSessionTest, TestGoodSetup) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
}
// Test that we can't change the keys once set.
TEST_F(SrtpSessionTest, TestBadSetup) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_FALSE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey2,
+ EXPECT_FALSE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey2,
kEncryptedHeaderExtensionIds));
- EXPECT_FALSE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey2,
+ EXPECT_FALSE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey2,
kEncryptedHeaderExtensionIds));
}
// Test that we fail keys of the wrong length.
TEST_F(SrtpSessionTest, TestKeysTooShort) {
- EXPECT_FALSE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80,
- rtc::ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), 1),
- kEncryptedHeaderExtensionIds));
EXPECT_FALSE(
- s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80,
- rtc::ZeroOnFreeBuffer<uint8_t>(kTestKey1.data(), 1),
- kEncryptedHeaderExtensionIds));
+ s1_.SetSend(webrtc::kSrtpAes128CmSha1_80,
+ rtc::ZeroOnFreeBuffer<uint8_t>(webrtc::kTestKey1.data(), 1),
+ kEncryptedHeaderExtensionIds));
+ EXPECT_FALSE(s2_.SetReceive(
+ webrtc::kSrtpAes128CmSha1_80,
+ rtc::ZeroOnFreeBuffer<uint8_t>(webrtc::kTestKey1.data(), 1),
+ kEncryptedHeaderExtensionIds));
}
// Test that we can encrypt and decrypt RTP/RTCP using AES_CM_128_HMAC_SHA1_80.
TEST_F(SrtpSessionTest, TestProtect_AES_CM_128_HMAC_SHA1_80) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
TestProtectRtp(webrtc::kSrtpAes128CmSha1_80);
TestProtectRtcp(webrtc::kSrtpAes128CmSha1_80);
@@ -132,9 +134,9 @@
// Test that we can encrypt and decrypt RTP/RTCP using AES_CM_128_HMAC_SHA1_32.
TEST_F(SrtpSessionTest, TestProtect_AES_CM_128_HMAC_SHA1_32) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_32, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_32, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_32, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_32, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
TestProtectRtp(webrtc::kSrtpAes128CmSha1_32);
TestProtectRtcp(webrtc::kSrtpAes128CmSha1_32);
@@ -143,7 +145,7 @@
}
TEST_F(SrtpSessionTest, TestGetSendStreamPacketIndex) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_32, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_32, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
int64_t index;
EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, &index));
@@ -154,9 +156,9 @@
// Test that we fail to unprotect if someone tampers with the RTP/RTCP paylaods.
TEST_F(SrtpSessionTest, TestTamperReject) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
TestProtectRtp(webrtc::kSrtpAes128CmSha1_80);
rtp_packet_.MutableData<uint8_t>()[0] = 0x12;
@@ -175,9 +177,9 @@
// Test that we fail to unprotect if the payloads are not authenticated.
TEST_F(SrtpSessionTest, TestUnencryptReject) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
EXPECT_FALSE(s2_.UnprotectRtp(rtp_packet_));
EXPECT_METRIC_THAT(
@@ -191,7 +193,7 @@
// Test that we fail when using buffers that are too small.
TEST_F(SrtpSessionTest, TestBuffersTooSmall) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
// This buffer does not have extra capacity which we treat as an error.
rtc::CopyOnWriteBuffer rtp_packet(rtp_packet_.data(), rtp_packet_.size(),
@@ -209,9 +211,9 @@
static const uint16_t seqnum_small = 10;
static const uint16_t replay_window = 1024;
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
// Initial sequence number.
@@ -258,9 +260,9 @@
}
TEST_F(SrtpSessionTest, RemoveSsrc) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
// Encrypt and decrypt the packet once.
EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_));
@@ -292,9 +294,9 @@
// failures when it wraps around with packet loss. Pick your starting
// sequence number in the lower half of the range for robustness reasons,
// see packet_sequencer.cc for the code doing so.
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
// Buffers include enough room for the 10 byte SRTP auth tag so we can
// encrypt in place.
@@ -349,9 +351,9 @@
}
TEST_F(SrtpSessionTest, ProtectGetPacketIndex) {
- EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s1_.SetSend(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
- EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, kTestKey1,
+ EXPECT_TRUE(s2_.SetReceive(webrtc::kSrtpAes128CmSha1_80, webrtc::kTestKey1,
kEncryptedHeaderExtensionIds));
// Buffers include enough room for the 10 byte SRTP auth tag so we can
// encrypt in place.
diff --git a/pc/srtp_transport_unittest.cc b/pc/srtp_transport_unittest.cc
index a742fb9..77b0a65 100644
--- a/pc/srtp_transport_unittest.cc
+++ b/pc/srtp_transport_unittest.cc
@@ -33,9 +33,9 @@
#include "test/gtest.h"
#include "test/scoped_key_value_config.h"
-using rtc::kTestKey1;
-using rtc::kTestKey2;
using ::webrtc::kSrtpAeadAes128Gcm;
+using ::webrtc::kTestKey1;
+using ::webrtc::kTestKey2;
namespace webrtc {
// 128 bits key + 96 bits salt.
@@ -129,7 +129,7 @@
void TestSendRecvRtpPacket(int crypto_suite) {
size_t rtp_len = sizeof(kPcmuFrame);
- size_t packet_size = rtp_len + rtc::rtp_auth_tag_len(crypto_suite);
+ size_t packet_size = rtp_len + rtp_auth_tag_len(crypto_suite);
rtc::Buffer rtp_packet_buffer(packet_size);
char* rtp_packet_data = rtp_packet_buffer.data<char>();
memcpy(rtp_packet_data, kPcmuFrame, rtp_len);
@@ -182,7 +182,7 @@
void TestSendRecvRtcpPacket(int crypto_suite) {
size_t rtcp_len = sizeof(::kRtcpReport);
- size_t packet_size = rtcp_len + 4 + rtc::rtcp_auth_tag_len(crypto_suite);
+ size_t packet_size = rtcp_len + 4 + rtcp_auth_tag_len(crypto_suite);
rtc::Buffer rtcp_packet_buffer(packet_size);
char* rtcp_packet_data = rtcp_packet_buffer.data<char>();
memcpy(rtcp_packet_data, ::kRtcpReport, rtcp_len);
@@ -254,7 +254,7 @@
int crypto_suite,
const std::vector<int>& encrypted_header_ids) {
size_t rtp_len = sizeof(kPcmuFrameWithExtensions);
- size_t packet_size = rtp_len + rtc::rtp_auth_tag_len(crypto_suite);
+ size_t packet_size = rtp_len + rtp_auth_tag_len(crypto_suite);
rtc::Buffer rtp_packet_buffer(packet_size);
char* rtp_packet_data = rtp_packet_buffer.data<char>();
memcpy(rtp_packet_data, kPcmuFrameWithExtensions, rtp_len);
@@ -448,7 +448,7 @@
// Create a packet and try to send it three times.
size_t rtp_len = sizeof(kPcmuFrame);
- size_t packet_size = rtp_len + rtc::rtp_auth_tag_len(kSrtpAeadAes128Gcm);
+ size_t packet_size = rtp_len + rtp_auth_tag_len(kSrtpAeadAes128Gcm);
rtc::Buffer rtp_packet_buffer(packet_size);
char* rtp_packet_data = rtp_packet_buffer.data<char>();
memcpy(rtp_packet_data, kPcmuFrame, rtp_len);
diff --git a/pc/test/integration_test_helpers.cc b/pc/test/integration_test_helpers.cc
index 6aed9b0..04dd26f 100644
--- a/pc/test/integration_test_helpers.cc
+++ b/pc/test/integration_test_helpers.cc
@@ -229,7 +229,7 @@
RTC_DCHECK(!peer_connection_);
RTC_DCHECK(!peer_connection_factory_);
- auto network_manager = std::make_unique<rtc::FakeNetworkManager>();
+ auto network_manager = std::make_unique<FakeNetworkManager>();
fake_network_manager_ = network_manager.get();
fake_network_manager_->AddInterface(kDefaultLocalAddress);
diff --git a/pc/test/integration_test_helpers.h b/pc/test/integration_test_helpers.h
index 6b5828e..968c572 100644
--- a/pc/test/integration_test_helpers.h
+++ b/pc/test/integration_test_helpers.h
@@ -643,9 +643,7 @@
}
}
- rtc::FakeNetworkManager* network_manager() const {
- return fake_network_manager_;
- }
+ FakeNetworkManager* network_manager() const { return fake_network_manager_; }
FakeRtcEventLogFactory* event_log_factory() const {
return event_log_factory_;
@@ -1145,7 +1143,7 @@
std::string debug_name_;
// Network manager is owned by the `peer_connection_factory_`.
- rtc::FakeNetworkManager* fake_network_manager_ = nullptr;
+ FakeNetworkManager* fake_network_manager_ = nullptr;
rtc::Thread* network_thread_;
// Reference to the mDNS responder owned by `fake_network_manager_` after set.
diff --git a/pc/test/mock_channel_interface.h b/pc/test/mock_channel_interface.h
index 96dc223..d379f9e 100644
--- a/pc/test/mock_channel_interface.h
+++ b/pc/test/mock_channel_interface.h
@@ -24,7 +24,7 @@
#include "pc/rtp_transport_internal.h"
#include "test/gmock.h"
-namespace cricket {
+namespace webrtc {
// Mock class for BaseChannel.
// Use this class in unit tests to avoid dependecy on a specific
@@ -32,26 +32,29 @@
class MockChannelInterface : public cricket::ChannelInterface {
public:
MOCK_METHOD(cricket::MediaType, media_type, (), (const, override));
- MOCK_METHOD(VideoChannel*, AsVideoChannel, (), (override));
- MOCK_METHOD(VoiceChannel*, AsVoiceChannel, (), (override));
- MOCK_METHOD(MediaSendChannelInterface*, media_send_channel, (), (override));
- MOCK_METHOD(VoiceMediaSendChannelInterface*,
+ MOCK_METHOD(cricket::VideoChannel*, AsVideoChannel, (), (override));
+ MOCK_METHOD(cricket::VoiceChannel*, AsVoiceChannel, (), (override));
+ MOCK_METHOD(cricket::MediaSendChannelInterface*,
+ media_send_channel,
+ (),
+ (override));
+ MOCK_METHOD(cricket::VoiceMediaSendChannelInterface*,
voice_media_send_channel,
(),
(override));
- MOCK_METHOD(VideoMediaSendChannelInterface*,
+ MOCK_METHOD(cricket::VideoMediaSendChannelInterface*,
video_media_send_channel,
(),
(override));
- MOCK_METHOD(MediaReceiveChannelInterface*,
+ MOCK_METHOD(cricket::MediaReceiveChannelInterface*,
media_receive_channel,
(),
(override));
- MOCK_METHOD(VoiceMediaReceiveChannelInterface*,
+ MOCK_METHOD(cricket::VoiceMediaReceiveChannelInterface*,
voice_media_receive_channel,
(),
(override));
- MOCK_METHOD(VideoMediaReceiveChannelInterface*,
+ MOCK_METHOD(cricket::VideoMediaReceiveChannelInterface*,
video_media_receive_channel,
(),
(override));
@@ -68,31 +71,30 @@
(override));
MOCK_METHOD(bool,
SetLocalContent,
- (const cricket::MediaContentDescription*,
- webrtc::SdpType,
- std::string&),
+ (const cricket::MediaContentDescription*, SdpType, std::string&),
(override));
MOCK_METHOD(bool,
SetRemoteContent,
- (const cricket::MediaContentDescription*,
- webrtc::SdpType,
- std::string&),
+ (const cricket::MediaContentDescription*, SdpType, std::string&),
(override));
MOCK_METHOD(bool, SetPayloadTypeDemuxingEnabled, (bool), (override));
- MOCK_METHOD(const std::vector<StreamParams>&,
+ MOCK_METHOD(const std::vector<cricket::StreamParams>&,
local_streams,
(),
(const, override));
- MOCK_METHOD(const std::vector<StreamParams>&,
+ MOCK_METHOD(const std::vector<cricket::StreamParams>&,
remote_streams,
(),
(const, override));
- MOCK_METHOD(bool,
- SetRtpTransport,
- (webrtc::RtpTransportInternal*),
- (override));
+ MOCK_METHOD(bool, SetRtpTransport, (RtpTransportInternal*), (override));
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::MockChannelInterface;
} // namespace cricket
#endif // PC_TEST_MOCK_CHANNEL_INTERFACE_H_
diff --git a/pc/test/srtp_test_util.h b/pc/test/srtp_test_util.h
index ccf455d..ba0c355 100644
--- a/pc/test/srtp_test_util.h
+++ b/pc/test/srtp_test_util.h
@@ -17,7 +17,7 @@
#include "rtc_base/checks.h"
#include "rtc_base/ssl_stream_adapter.h"
-namespace rtc {
+namespace webrtc {
static const rtc::ZeroOnFreeBuffer<uint8_t> kTestKey1{
"ABCDEFGHIJKLMNOPQRSTUVWXYZ1234", 30};
@@ -51,6 +51,15 @@
}
}
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::kTestKey1;
+using ::webrtc::kTestKey2;
+using ::webrtc::rtcp_auth_tag_len;
+using ::webrtc::rtp_auth_tag_len;
} // namespace rtc
#endif // PC_TEST_SRTP_TEST_UTIL_H_
diff --git a/pc/video_track_unittest.cc b/pc/video_track_unittest.cc
index e75fd03..545a8e0 100644
--- a/pc/video_track_unittest.cc
+++ b/pc/video_track_unittest.cc
@@ -41,7 +41,7 @@
rtc::AutoThread main_thread_;
rtc::scoped_refptr<FakeVideoTrackSource> video_track_source_;
rtc::scoped_refptr<VideoTrack> video_track_;
- cricket::FakeFrameSource frame_source_;
+ webrtc::FakeFrameSource frame_source_;
};
// VideoTrack::Create will create an API proxy around the source object.
diff --git a/rtc_base/fake_clock.cc b/rtc_base/fake_clock.cc
index 652a5af..30c6fac 100644
--- a/rtc_base/fake_clock.cc
+++ b/rtc_base/fake_clock.cc
@@ -13,50 +13,50 @@
#include "rtc_base/checks.h"
#include "rtc_base/thread.h"
-namespace rtc {
+namespace webrtc {
int64_t FakeClock::TimeNanos() const {
- webrtc::MutexLock lock(&lock_);
+ MutexLock lock(&lock_);
return time_ns_;
}
-void FakeClock::SetTime(webrtc::Timestamp new_time) {
- webrtc::MutexLock lock(&lock_);
+void FakeClock::SetTime(Timestamp new_time) {
+ MutexLock lock(&lock_);
RTC_DCHECK(new_time.us() * 1000 >= time_ns_);
time_ns_ = new_time.us() * 1000;
}
-void FakeClock::AdvanceTime(webrtc::TimeDelta delta) {
- webrtc::MutexLock lock(&lock_);
+void FakeClock::AdvanceTime(TimeDelta delta) {
+ MutexLock lock(&lock_);
time_ns_ += delta.ns();
}
-void ThreadProcessingFakeClock::SetTime(webrtc::Timestamp time) {
+void ThreadProcessingFakeClock::SetTime(Timestamp time) {
clock_.SetTime(time);
// If message queues are waiting in a socket select() with a timeout provided
// by the OS, they should wake up and dispatch all messages that are ready.
- ThreadManager::ProcessAllMessageQueuesForTesting();
+ rtc::ThreadManager::ProcessAllMessageQueuesForTesting();
}
-void ThreadProcessingFakeClock::AdvanceTime(webrtc::TimeDelta delta) {
+void ThreadProcessingFakeClock::AdvanceTime(TimeDelta delta) {
clock_.AdvanceTime(delta);
- ThreadManager::ProcessAllMessageQueuesForTesting();
+ rtc::ThreadManager::ProcessAllMessageQueuesForTesting();
}
ScopedBaseFakeClock::ScopedBaseFakeClock() {
- prev_clock_ = SetClockForTesting(this);
+ prev_clock_ = rtc::SetClockForTesting(this);
}
ScopedBaseFakeClock::~ScopedBaseFakeClock() {
- SetClockForTesting(prev_clock_);
+ rtc::SetClockForTesting(prev_clock_);
}
ScopedFakeClock::ScopedFakeClock() {
- prev_clock_ = SetClockForTesting(this);
+ prev_clock_ = rtc::SetClockForTesting(this);
}
ScopedFakeClock::~ScopedFakeClock() {
- SetClockForTesting(prev_clock_);
+ rtc::SetClockForTesting(prev_clock_);
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/fake_clock.h b/rtc_base/fake_clock.h
index edb507b..e5c5a79 100644
--- a/rtc_base/fake_clock.h
+++ b/rtc_base/fake_clock.h
@@ -19,13 +19,13 @@
#include "rtc_base/thread_annotations.h"
#include "rtc_base/time_utils.h"
-namespace rtc {
+namespace webrtc {
// Fake clock for use with unit tests, which does not tick on its own.
// Starts at time 0.
//
// TODO(deadbeef): Unify with webrtc::SimulatedClock.
-class FakeClock : public ClockInterface {
+class FakeClock : public rtc::ClockInterface {
public:
FakeClock() = default;
FakeClock(const FakeClock&) = delete;
@@ -38,20 +38,20 @@
// Methods that can be used by the test to control the time.
// Should only be used to set a time in the future.
- void SetTime(webrtc::Timestamp new_time);
+ void SetTime(Timestamp new_time);
- void AdvanceTime(webrtc::TimeDelta delta);
+ void AdvanceTime(TimeDelta delta);
private:
- mutable webrtc::Mutex lock_;
+ mutable Mutex lock_;
int64_t time_ns_ RTC_GUARDED_BY(lock_) = 0;
};
-class ThreadProcessingFakeClock : public ClockInterface {
+class ThreadProcessingFakeClock : public rtc::ClockInterface {
public:
int64_t TimeNanos() const override { return clock_.TimeNanos(); }
- void SetTime(webrtc::Timestamp time);
- void AdvanceTime(webrtc::TimeDelta delta);
+ void SetTime(Timestamp time);
+ void AdvanceTime(TimeDelta delta);
private:
FakeClock clock_;
@@ -65,7 +65,7 @@
~ScopedBaseFakeClock() override;
private:
- ClockInterface* prev_clock_;
+ rtc::ClockInterface* prev_clock_;
};
// TODO(srte): Rename this to reflect that it also does thread processing.
@@ -75,9 +75,18 @@
~ScopedFakeClock() override;
private:
- ClockInterface* prev_clock_;
+ rtc::ClockInterface* prev_clock_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::FakeClock;
+using ::webrtc::ScopedBaseFakeClock;
+using ::webrtc::ScopedFakeClock;
+using ::webrtc::ThreadProcessingFakeClock;
} // namespace rtc
#endif // RTC_BASE_FAKE_CLOCK_H_
diff --git a/rtc_base/fake_clock_unittest.cc b/rtc_base/fake_clock_unittest.cc
index fc1d510..6597042 100644
--- a/rtc_base/fake_clock_unittest.cc
+++ b/rtc_base/fake_clock_unittest.cc
@@ -12,7 +12,7 @@
#include "test/gtest.h"
-namespace rtc {
+namespace webrtc {
TEST(ScopedFakeClockTest, OverridesGlobalClock) {
const int64_t kFixedTimeUs = 100000;
int64_t real_time_us = rtc::TimeMicros();
@@ -21,17 +21,17 @@
ScopedFakeClock scoped;
EXPECT_EQ(rtc::TimeMicros(), 0);
- scoped.AdvanceTime(webrtc::TimeDelta::Millis(1));
+ scoped.AdvanceTime(TimeDelta::Millis(1));
EXPECT_EQ(rtc::TimeMicros(), 1000);
- scoped.SetTime(webrtc::Timestamp::Micros(kFixedTimeUs));
+ scoped.SetTime(Timestamp::Micros(kFixedTimeUs));
EXPECT_EQ(rtc::TimeMicros(), kFixedTimeUs);
- scoped.AdvanceTime(webrtc::TimeDelta::Millis(1));
+ scoped.AdvanceTime(TimeDelta::Millis(1));
EXPECT_EQ(rtc::TimeMicros(), kFixedTimeUs + 1000);
}
EXPECT_NE(rtc::TimeMicros(), kFixedTimeUs + 1000);
EXPECT_GE(rtc::TimeMicros(), real_time_us);
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/fake_network.h b/rtc_base/fake_network.h
index 8ccc881..bb9cef7 100644
--- a/rtc_base/fake_network.h
+++ b/rtc_base/fake_network.h
@@ -23,45 +23,44 @@
#include "rtc_base/string_encode.h"
#include "rtc_base/thread.h"
-namespace rtc {
+namespace webrtc {
const int kFakeIPv4NetworkPrefixLength = 24;
const int kFakeIPv6NetworkPrefixLength = 64;
// Fake network manager that allows us to manually specify the IPs to use.
-class FakeNetworkManager : public NetworkManagerBase {
+class FakeNetworkManager : public rtc::NetworkManagerBase {
public:
FakeNetworkManager() {}
struct Iface {
- webrtc::SocketAddress socket_address;
- AdapterType adapter_type;
- std::optional<AdapterType> underlying_vpn_adapter_type;
+ SocketAddress socket_address;
+ rtc::AdapterType adapter_type;
+ std::optional<rtc::AdapterType> underlying_vpn_adapter_type;
};
typedef std::vector<Iface> IfaceList;
- void AddInterface(const webrtc::SocketAddress& iface) {
+ void AddInterface(const SocketAddress& iface) {
// Ensure a unique name for the interface if its name is not given.
AddInterface(iface, "test" + rtc::ToString(next_index_++));
}
- void AddInterface(const webrtc::SocketAddress& iface,
- absl::string_view if_name) {
- AddInterface(iface, if_name, ADAPTER_TYPE_UNKNOWN);
+ void AddInterface(const SocketAddress& iface, absl::string_view if_name) {
+ AddInterface(iface, if_name, rtc::ADAPTER_TYPE_UNKNOWN);
}
- void AddInterface(
- const webrtc::SocketAddress& iface,
- absl::string_view if_name,
- AdapterType type,
- std::optional<AdapterType> underlying_vpn_adapter_type = std::nullopt) {
- webrtc::SocketAddress address(if_name, 0);
+ void AddInterface(const SocketAddress& iface,
+ absl::string_view if_name,
+ rtc::AdapterType type,
+ std::optional<rtc::AdapterType>
+ underlying_vpn_adapter_type = std::nullopt) {
+ SocketAddress address(if_name, 0);
address.SetResolvedIP(iface.ipaddr());
ifaces_.push_back({address, type, underlying_vpn_adapter_type});
DoUpdateNetworks();
}
- void RemoveInterface(const webrtc::SocketAddress& iface) {
+ void RemoveInterface(const SocketAddress& iface) {
for (IfaceList::iterator it = ifaces_.begin(); it != ifaces_.end(); ++it) {
if (it->socket_address.EqualIPs(iface)) {
ifaces_.erase(it);
@@ -75,24 +74,24 @@
++start_count_;
if (start_count_ == 1) {
sent_first_update_ = false;
- Thread::Current()->PostTask([this] { DoUpdateNetworks(); });
+ rtc::Thread::Current()->PostTask([this] { DoUpdateNetworks(); });
} else if (sent_first_update_) {
- Thread::Current()->PostTask([this] { SignalNetworksChanged(); });
+ rtc::Thread::Current()->PostTask([this] { SignalNetworksChanged(); });
}
}
void StopUpdating() override { --start_count_; }
- using NetworkManagerBase::set_default_local_addresses;
- using NetworkManagerBase::set_enumeration_permission;
+ using rtc::NetworkManagerBase::set_default_local_addresses;
+ using rtc::NetworkManagerBase::set_enumeration_permission;
// rtc::NetworkManager override.
- webrtc::MdnsResponderInterface* GetMdnsResponder() const override {
+ MdnsResponderInterface* GetMdnsResponder() const override {
return mdns_responder_.get();
}
void set_mdns_responder(
- std::unique_ptr<webrtc::MdnsResponderInterface> mdns_responder) {
+ std::unique_ptr<MdnsResponderInterface> mdns_responder) {
mdns_responder_ = std::move(mdns_responder);
}
@@ -100,7 +99,7 @@
void DoUpdateNetworks() {
if (start_count_ == 0)
return;
- std::vector<std::unique_ptr<Network>> networks;
+ std::vector<std::unique_ptr<rtc::Network>> networks;
for (IfaceList::iterator it = ifaces_.begin(); it != ifaces_.end(); ++it) {
int prefix_length = 0;
if (it->socket_address.ipaddr().family() == AF_INET) {
@@ -108,9 +107,9 @@
} else if (it->socket_address.ipaddr().family() == AF_INET6) {
prefix_length = kFakeIPv6NetworkPrefixLength;
}
- webrtc::IPAddress prefix =
+ IPAddress prefix =
webrtc::TruncateIP(it->socket_address.ipaddr(), prefix_length);
- auto net = std::make_unique<Network>(
+ auto net = std::make_unique<rtc::Network>(
it->socket_address.hostname(), it->socket_address.hostname(), prefix,
prefix_length, it->adapter_type);
if (it->underlying_vpn_adapter_type.has_value()) {
@@ -133,9 +132,17 @@
int start_count_ = 0;
bool sent_first_update_ = false;
- std::unique_ptr<webrtc::MdnsResponderInterface> mdns_responder_;
+ std::unique_ptr<MdnsResponderInterface> mdns_responder_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::FakeNetworkManager;
+using ::webrtc::kFakeIPv4NetworkPrefixLength;
+using ::webrtc::kFakeIPv6NetworkPrefixLength;
} // namespace rtc
#endif // RTC_BASE_FAKE_NETWORK_H_
diff --git a/rtc_base/fake_ssl_identity.cc b/rtc_base/fake_ssl_identity.cc
index 73c843a..4685915 100644
--- a/rtc_base/fake_ssl_identity.cc
+++ b/rtc_base/fake_ssl_identity.cc
@@ -18,18 +18,18 @@
#include "rtc_base/checks.h"
#include "rtc_base/message_digest.h"
-namespace rtc {
+namespace webrtc {
FakeSSLCertificate::FakeSSLCertificate(absl::string_view pem_string)
: pem_string_(pem_string),
- digest_algorithm_(DIGEST_SHA_1),
+ digest_algorithm_(rtc::DIGEST_SHA_1),
expiration_time_(-1) {}
FakeSSLCertificate::FakeSSLCertificate(const FakeSSLCertificate&) = default;
FakeSSLCertificate::~FakeSSLCertificate() = default;
-std::unique_ptr<SSLCertificate> FakeSSLCertificate::Clone() const {
+std::unique_ptr<rtc::SSLCertificate> FakeSSLCertificate::Clone() const {
return std::make_unique<FakeSSLCertificate>(*this);
}
@@ -39,8 +39,8 @@
void FakeSSLCertificate::ToDER(Buffer* der_buffer) const {
std::string der_string;
- RTC_CHECK(
- SSLIdentity::PemToDer(kPemTypeCertificate, pem_string_, &der_string));
+ RTC_CHECK(rtc::SSLIdentity::PemToDer(rtc::kPemTypeCertificate, pem_string_,
+ &der_string));
der_buffer->SetData(der_string.c_str(), der_string.size());
}
@@ -75,31 +75,31 @@
: FakeSSLIdentity(FakeSSLCertificate(pem_string)) {}
FakeSSLIdentity::FakeSSLIdentity(const std::vector<std::string>& pem_strings) {
- std::vector<std::unique_ptr<SSLCertificate>> certs;
+ std::vector<std::unique_ptr<rtc::SSLCertificate>> certs;
certs.reserve(pem_strings.size());
for (const std::string& pem_string : pem_strings) {
certs.push_back(std::make_unique<FakeSSLCertificate>(pem_string));
}
- cert_chain_ = std::make_unique<SSLCertChain>(std::move(certs));
+ cert_chain_ = std::make_unique<rtc::SSLCertChain>(std::move(certs));
}
FakeSSLIdentity::FakeSSLIdentity(const FakeSSLCertificate& cert)
- : cert_chain_(std::make_unique<SSLCertChain>(cert.Clone())) {}
+ : cert_chain_(std::make_unique<rtc::SSLCertChain>(cert.Clone())) {}
FakeSSLIdentity::FakeSSLIdentity(const FakeSSLIdentity& o)
: cert_chain_(o.cert_chain_->Clone()) {}
FakeSSLIdentity::~FakeSSLIdentity() = default;
-std::unique_ptr<SSLIdentity> FakeSSLIdentity::CloneInternal() const {
+std::unique_ptr<rtc::SSLIdentity> FakeSSLIdentity::CloneInternal() const {
return std::make_unique<FakeSSLIdentity>(*this);
}
-const SSLCertificate& FakeSSLIdentity::certificate() const {
+const rtc::SSLCertificate& FakeSSLIdentity::certificate() const {
return cert_chain_->Get(0);
}
-const SSLCertChain& FakeSSLIdentity::cert_chain() const {
+const rtc::SSLCertChain& FakeSSLIdentity::cert_chain() const {
return *cert_chain_.get();
}
@@ -113,9 +113,9 @@
return "";
}
-bool FakeSSLIdentity::operator==(const SSLIdentity& other) const {
+bool FakeSSLIdentity::operator==(const rtc::SSLIdentity& other) const {
RTC_DCHECK_NOTREACHED(); // Not implemented.
return false;
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/fake_ssl_identity.h b/rtc_base/fake_ssl_identity.h
index 2b4ae2e..856b6dc 100644
--- a/rtc_base/fake_ssl_identity.h
+++ b/rtc_base/fake_ssl_identity.h
@@ -18,9 +18,9 @@
#include "rtc_base/ssl_certificate.h"
#include "rtc_base/ssl_identity.h"
-namespace rtc {
+namespace webrtc {
-class FakeSSLCertificate : public SSLCertificate {
+class FakeSSLCertificate : public rtc::SSLCertificate {
public:
// SHA-1 is the default digest algorithm because it is available in all build
// configurations used for unit testing.
@@ -30,7 +30,7 @@
~FakeSSLCertificate() override;
// SSLCertificate implementation.
- std::unique_ptr<SSLCertificate> Clone() const override;
+ std::unique_ptr<rtc::SSLCertificate> Clone() const override;
std::string ToPEMString() const override;
void ToDER(Buffer* der_buffer) const override;
int64_t CertificateExpirationTime() const override;
@@ -51,7 +51,7 @@
int64_t expiration_time_;
};
-class FakeSSLIdentity : public SSLIdentity {
+class FakeSSLIdentity : public rtc::SSLIdentity {
public:
explicit FakeSSLIdentity(absl::string_view pem_string);
// For a certificate chain.
@@ -63,21 +63,28 @@
~FakeSSLIdentity() override;
// SSLIdentity implementation.
- const SSLCertificate& certificate() const override;
- const SSLCertChain& cert_chain() const override;
+ const rtc::SSLCertificate& certificate() const override;
+ const rtc::SSLCertChain& cert_chain() const override;
// Not implemented.
std::string PrivateKeyToPEMString() const override;
// Not implemented.
std::string PublicKeyToPEMString() const override;
// Not implemented.
- virtual bool operator==(const SSLIdentity& other) const;
+ virtual bool operator==(const rtc::SSLIdentity& other) const;
private:
- std::unique_ptr<SSLIdentity> CloneInternal() const override;
+ std::unique_ptr<rtc::SSLIdentity> CloneInternal() const override;
- std::unique_ptr<SSLCertChain> cert_chain_;
+ std::unique_ptr<rtc::SSLCertChain> cert_chain_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::FakeSSLCertificate;
+using ::webrtc::FakeSSLIdentity;
} // namespace rtc
#endif // RTC_BASE_FAKE_SSL_IDENTITY_H_
diff --git a/rtc_base/ssl_identity_unittest.cc b/rtc_base/ssl_identity_unittest.cc
index 19b3957..3923619 100644
--- a/rtc_base/ssl_identity_unittest.cc
+++ b/rtc_base/ssl_identity_unittest.cc
@@ -177,7 +177,7 @@
"CERTIFICATE", reinterpret_cast<const unsigned char*>(der.c_str()),
der.length()));
}
- info.identity.reset(new rtc::FakeSSLIdentity(info.pems));
+ info.identity.reset(new webrtc::FakeSSLIdentity(info.pems));
// Strip header/footer and newline characters of PEM strings.
for (size_t i = 0; i < info.pems.size(); ++i) {
absl::StrReplaceAll({{"-----BEGIN CERTIFICATE-----", ""},
diff --git a/rtc_base/ssl_stream_adapter_unittest.cc b/rtc_base/ssl_stream_adapter_unittest.cc
index 255615e..e020095 100644
--- a/rtc_base/ssl_stream_adapter_unittest.cc
+++ b/rtc_base/ssl_stream_adapter_unittest.cc
@@ -878,7 +878,7 @@
}
rtc::AutoThread main_thread_;
- rtc::ScopedFakeClock clock_;
+ webrtc::ScopedFakeClock clock_;
std::string client_cert_pem_;
std::string client_private_key_pem_;
rtc::KeyParams client_key_type_;
diff --git a/rtc_base/test_client.cc b/rtc_base/test_client.cc
index a003599..99acf19 100644
--- a/rtc_base/test_client.cc
+++ b/rtc_base/test_client.cc
@@ -38,7 +38,7 @@
: TestClient(std::move(socket), nullptr) {}
TestClient::TestClient(std::unique_ptr<rtc::AsyncPacketSocket> socket,
- rtc::ThreadProcessingFakeClock* fake_clock)
+ ThreadProcessingFakeClock* fake_clock)
: fake_clock_(fake_clock), socket_(std::move(socket)) {
socket_->RegisterReceivedPacketCallback(
[&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
diff --git a/rtc_base/test_client.h b/rtc_base/test_client.h
index 5adc108..8f2f25e 100644
--- a/rtc_base/test_client.h
+++ b/rtc_base/test_client.h
@@ -47,7 +47,7 @@
// for a packet to be received, and thus it needs to advance the fake clock
// if the test is using one, rather than just sleeping.
TestClient(std::unique_ptr<rtc::AsyncPacketSocket> socket,
- rtc::ThreadProcessingFakeClock* fake_clock);
+ ThreadProcessingFakeClock* fake_clock);
~TestClient() override;
TestClient(const TestClient&) = delete;
@@ -101,7 +101,7 @@
bool CheckTimestamp(std::optional<Timestamp> packet_timestamp);
void AdvanceTime(int ms);
- rtc::ThreadProcessingFakeClock* fake_clock_ = nullptr;
+ ThreadProcessingFakeClock* fake_clock_ = nullptr;
Mutex mutex_;
std::unique_ptr<rtc::AsyncPacketSocket> socket_;
std::vector<std::unique_ptr<Packet>> packets_;
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index 3184061..ee885b5 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -492,7 +492,7 @@
}
static void DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(
- FakeClock& clock,
+ webrtc::FakeClock& clock,
Thread& q) {
std::vector<int> run_order;
@@ -515,7 +515,7 @@
}
TEST(ThreadTest, DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder) {
- ScopedBaseFakeClock clock;
+ webrtc::ScopedBaseFakeClock clock;
Thread q(CreateDefaultSocketServer(), true);
q.Start();
DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(clock, q);
@@ -804,7 +804,7 @@
}
TEST(ThreadPostDelayedTaskTest, InvokesInDelayOrder) {
- ScopedFakeClock clock;
+ webrtc::ScopedFakeClock clock;
std::unique_ptr<rtc::Thread> background_thread(rtc::Thread::Create());
background_thread->Start();
diff --git a/rtc_base/time_utils_unittest.cc b/rtc_base/time_utils_unittest.cc
index c60c333..6771f03 100644
--- a/rtc_base/time_utils_unittest.cc
+++ b/rtc_base/time_utils_unittest.cc
@@ -160,7 +160,7 @@
// Test that all the time functions exposed by TimeUtils get time from the
// fake clock when it's set.
TEST(FakeClock, TimeFunctionsUseFakeClock) {
- FakeClock clock;
+ webrtc::FakeClock clock;
SetClockForTesting(&clock);
clock.SetTime(webrtc::Timestamp::Micros(987654));
@@ -176,12 +176,12 @@
}
TEST(FakeClock, InitialTime) {
- FakeClock clock;
+ webrtc::FakeClock clock;
EXPECT_EQ(0, clock.TimeNanos());
}
TEST(FakeClock, SetTime) {
- FakeClock clock;
+ webrtc::FakeClock clock;
clock.SetTime(webrtc::Timestamp::Micros(123));
EXPECT_EQ(123000, clock.TimeNanos());
clock.SetTime(webrtc::Timestamp::Micros(456));
@@ -189,7 +189,7 @@
}
TEST(FakeClock, AdvanceTime) {
- FakeClock clock;
+ webrtc::FakeClock clock;
clock.AdvanceTime(webrtc::TimeDelta::Micros(1u));
EXPECT_EQ(1000, clock.TimeNanos());
clock.AdvanceTime(webrtc::TimeDelta::Micros(2222u));
@@ -207,7 +207,7 @@
TEST(FakeClock, SettingTimeWakesThreads) {
int64_t real_start_time_ms = TimeMillis();
- ThreadProcessingFakeClock clock;
+ webrtc::ThreadProcessingFakeClock clock;
SetClockForTesting(&clock);
std::unique_ptr<Thread> worker(Thread::CreateWithSocketServer());
diff --git a/rtc_base/virtual_socket_server.cc b/rtc_base/virtual_socket_server.cc
index ebac6b0..3305be7 100644
--- a/rtc_base/virtual_socket_server.cc
+++ b/rtc_base/virtual_socket_server.cc
@@ -657,7 +657,8 @@
VirtualSocketServer::VirtualSocketServer() : VirtualSocketServer(nullptr) {}
-VirtualSocketServer::VirtualSocketServer(ThreadProcessingFakeClock* fake_clock)
+VirtualSocketServer::VirtualSocketServer(
+ webrtc::ThreadProcessingFakeClock* fake_clock)
: fake_clock_(fake_clock),
msg_queue_(nullptr),
stop_on_idle_(false),
diff --git a/rtc_base/virtual_socket_server.h b/rtc_base/virtual_socket_server.h
index 9c7f2c3..5e86e2a 100644
--- a/rtc_base/virtual_socket_server.h
+++ b/rtc_base/virtual_socket_server.h
@@ -226,7 +226,7 @@
// This constructor needs to be used if the test uses a fake clock and
// ProcessMessagesUntilIdle, since ProcessMessagesUntilIdle needs a way of
// advancing time.
- explicit VirtualSocketServer(ThreadProcessingFakeClock* fake_clock);
+ explicit VirtualSocketServer(webrtc::ThreadProcessingFakeClock* fake_clock);
~VirtualSocketServer() override;
VirtualSocketServer(const VirtualSocketServer&) = delete;
@@ -443,7 +443,7 @@
// May be null if the test doesn't use a fake clock, or it does but doesn't
// use ProcessMessagesUntilIdle.
- ThreadProcessingFakeClock* fake_clock_ = nullptr;
+ webrtc::ThreadProcessingFakeClock* fake_clock_ = nullptr;
// Used to implement Wait/WakeUp.
Event wakeup_;
diff --git a/rtc_base/virtual_socket_unittest.cc b/rtc_base/virtual_socket_unittest.cc
index fd8186d..8d24fbc 100644
--- a/rtc_base/virtual_socket_unittest.cc
+++ b/rtc_base/virtual_socket_unittest.cc
@@ -839,7 +839,7 @@
}
protected:
- rtc::ScopedFakeClock fake_clock_;
+ webrtc::ScopedFakeClock fake_clock_;
VirtualSocketServer ss_;
AutoSocketServerThread thread_;
const webrtc::SocketAddress kIPv4AnyAddress;
diff --git a/test/fuzzers/utils/rtp_replayer.cc b/test/fuzzers/utils/rtp_replayer.cc
index e5d26f2..2e11936 100644
--- a/test/fuzzers/utils/rtp_replayer.cc
+++ b/test/fuzzers/utils/rtp_replayer.cc
@@ -47,7 +47,7 @@
const uint8_t* rtp_dump_data,
size_t rtp_dump_size) {
RunLoop loop;
- rtc::ScopedBaseFakeClock fake_clock;
+ ScopedBaseFakeClock fake_clock;
// Work around: webrtc calls webrtc::Random(clock.TimeInMicroseconds())
// everywhere and Random expects non-zero seed. Let's set the clock non-zero
@@ -149,7 +149,7 @@
}
void RtpReplayer::ReplayPackets(
- rtc::FakeClock* clock,
+ FakeClock* clock,
Call* call,
test::RtpFileReader* rtp_reader,
const RtpPacketReceived::ExtensionManager& extensions) {
diff --git a/test/fuzzers/utils/rtp_replayer.h b/test/fuzzers/utils/rtp_replayer.h
index 73220ee..f13b7b7 100644
--- a/test/fuzzers/utils/rtp_replayer.h
+++ b/test/fuzzers/utils/rtp_replayer.h
@@ -79,7 +79,7 @@
size_t rtp_dump_size);
// Replays each packet to from the RtpDump.
- static void ReplayPackets(rtc::FakeClock* clock,
+ static void ReplayPackets(FakeClock* clock,
Call* call,
test::RtpFileReader* rtp_reader,
const RtpHeaderExtensionMap& extensions);
diff --git a/test/time_controller/simulated_time_controller.h b/test/time_controller/simulated_time_controller.h
index bd76331..c070146 100644
--- a/test/time_controller/simulated_time_controller.h
+++ b/test/time_controller/simulated_time_controller.h
@@ -154,7 +154,7 @@
void Unregister(sim_time_impl::SimulatedSequenceRunner* runner);
private:
- rtc::ScopedBaseFakeClock global_clock_;
+ ScopedBaseFakeClock global_clock_;
// Provides simulated CurrentNtpInMilliseconds()
SimulatedClock sim_clock_;
sim_time_impl::SimulatedTimeControllerImpl impl_;
diff --git a/test/wait_until.h b/test/wait_until.h
index f6d5729..ea2a437 100644
--- a/test/wait_until.h
+++ b/test/wait_until.h
@@ -29,8 +29,8 @@
using ClockVariant = absl::variant<absl::monostate,
SimulatedClock*,
- rtc::FakeClock*,
- rtc::ThreadProcessingFakeClock*,
+ FakeClock*,
+ ThreadProcessingFakeClock*,
TimeController*>;
namespace wait_until_internal {
diff --git a/test/wait_until_unittest.cc b/test/wait_until_unittest.cc
index fffce70..b6c5bad 100644
--- a/test/wait_until_unittest.cc
+++ b/test/wait_until_unittest.cc
@@ -89,7 +89,7 @@
}
TEST(WaitUntilTest, ReturnsWhenConditionIsMetWithThreadProcessingFakeClock) {
- rtc::ScopedFakeClock fake_clock;
+ ScopedFakeClock fake_clock;
int counter = 0;
RTCErrorOr<int> result =
@@ -101,7 +101,7 @@
}
TEST(WaitUntilTest, ReturnsWhenConditionIsMetWithFakeClock) {
- rtc::FakeClock fake_clock;
+ FakeClock fake_clock;
int counter = 0;
RTCErrorOr<int> result =
diff --git a/video/adaptation/overuse_frame_detector_unittest.cc b/video/adaptation/overuse_frame_detector_unittest.cc
index b1abdd3..92554db 100644
--- a/video/adaptation/overuse_frame_detector_unittest.cc
+++ b/video/adaptation/overuse_frame_detector_unittest.cc
@@ -231,7 +231,7 @@
}
CpuOveruseOptions options_;
- rtc::ScopedFakeClock clock_;
+ ScopedFakeClock clock_;
MockCpuOveruseObserver mock_observer_;
OveruseFrameDetectorObserverInterface* observer_;
std::unique_ptr<OveruseFrameDetectorUnderTest> overuse_detector_;
diff --git a/video/encoder_overshoot_detector_unittest.cc b/video/encoder_overshoot_detector_unittest.cc
index 95d0fd1..c85a379 100644
--- a/video/encoder_overshoot_detector_unittest.cc
+++ b/video/encoder_overshoot_detector_unittest.cc
@@ -100,7 +100,7 @@
static constexpr int64_t kWindowSizeMs = 3000;
EncoderOvershootDetector detector_;
- rtc::ScopedFakeClock clock_;
+ ScopedFakeClock clock_;
DataRate target_bitrate_;
double target_framerate_fps_;
};
diff --git a/video/send_statistics_proxy_unittest.cc b/video/send_statistics_proxy_unittest.cc
index 5a1147b..d70074f 100644
--- a/video/send_statistics_proxy_unittest.cc
+++ b/video/send_statistics_proxy_unittest.cc
@@ -458,7 +458,7 @@
// This test relies on rtc::ScopedFakeClock to synchronize these two clocks.
// TODO(https://crbug.com/webrtc/10640): When the RateTracker uses a Clock
// this test can stop relying on rtc::ScopedFakeClock.
- rtc::ScopedFakeClock fake_global_clock;
+ ScopedFakeClock fake_global_clock;
fake_global_clock.SetTime(
Timestamp::Millis(fake_clock_.TimeInMilliseconds()));
@@ -489,7 +489,7 @@
TEST_F(SendStatisticsProxyTest, EncodeFrameRateInSubStream) {
const int kInterframeDelayMs = 100;
const auto ssrc = config_.rtp.ssrcs[0];
- rtc::ScopedFakeClock fake_global_clock;
+ ScopedFakeClock fake_global_clock;
fake_global_clock.SetTime(
Timestamp::Millis(fake_clock_.TimeInMilliseconds()));
@@ -513,7 +513,7 @@
TEST_F(SendStatisticsProxyTest, EncodeFrameRateInSubStreamsVp8Simulcast) {
const int kInterframeDelayMs = 100;
- rtc::ScopedFakeClock fake_global_clock;
+ ScopedFakeClock fake_global_clock;
fake_global_clock.SetTime(
Timestamp::Millis(fake_clock_.TimeInMilliseconds()));
EncodedImage encoded_image;
@@ -574,7 +574,7 @@
TEST_F(SendStatisticsProxyTest, EncodeFrameRateInSubStreamsVp9Svc) {
const int kInterframeDelayMs = 100;
- rtc::ScopedFakeClock fake_global_clock;
+ ScopedFakeClock fake_global_clock;
fake_global_clock.SetTime(
Timestamp::Millis(fake_clock_.TimeInMilliseconds()));
EncodedImage encoded_image;
diff --git a/video/video_receive_stream2_unittest.cc b/video/video_receive_stream2_unittest.cc
index 0331699..1583323 100644
--- a/video/video_receive_stream2_unittest.cc
+++ b/video/video_receive_stream2_unittest.cc
@@ -268,7 +268,7 @@
internal::CallStats call_stats_;
testing::NiceMock<MockVideoDecoder> mock_decoder_;
FakeVideoRenderer fake_renderer_;
- cricket::FakeCall fake_call_;
+ FakeCall fake_call_;
MockTransport mock_transport_;
test::RtcpPacketParser rtcp_packet_parser_;
PacketRouter packet_router_;
