Move event.h to webrtc namespace
Bug: webrtc:42232595
Change-Id: I062f383fdcde2a5458c99e649e80f531b4676da0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/381941
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44173}
diff --git a/api/sequence_checker_unittest.cc b/api/sequence_checker_unittest.cc
index adf5bd0..2174698 100644
--- a/api/sequence_checker_unittest.cc
+++ b/api/sequence_checker_unittest.cc
@@ -48,7 +48,7 @@
};
void RunOnDifferentThread(FunctionView<void()> run) {
- rtc::Event thread_has_run_event;
+ Event thread_has_run_event;
rtc::PlatformThread::SpawnJoinable(
[&] {
run();
@@ -148,13 +148,13 @@
SequenceChecker sequence_checker(SequenceChecker::kDetached);
- rtc::Event blocker;
+ Event blocker;
queue1.PostTask([&blocker, &sequence_checker]() {
(void)sequence_checker.IsCurrent();
blocker.Set();
});
- blocker.Wait(rtc::Event::kForever);
+ blocker.Wait(Event::kForever);
#if RTC_DCHECK_IS_ON
@@ -177,13 +177,13 @@
SequenceChecker sequence_checker(SequenceChecker::kDetached);
- rtc::Event blocker;
+ Event blocker;
queue1.PostTask([&blocker, &sequence_checker]() {
EXPECT_TRUE(sequence_checker.IsCurrent());
blocker.Set();
});
- blocker.Wait(rtc::Event::kForever);
+ blocker.Wait(Event::kForever);
#if RTC_DCHECK_IS_ON
EXPECT_FALSE(sequence_checker.IsCurrent());
diff --git a/api/task_queue/pending_task_safety_flag_unittest.cc b/api/task_queue/pending_task_safety_flag_unittest.cc
index 41f6d7f..672883f 100644
--- a/api/task_queue/pending_task_safety_flag_unittest.cc
+++ b/api/task_queue/pending_task_safety_flag_unittest.cc
@@ -133,9 +133,9 @@
ASSERT_TRUE(owner);
// Queue up a task on tq1 that will execute before the 'DoStuff' task
// can, and delete the `owner` before the 'stuff' task can execute.
- rtc::Event blocker;
+ Event blocker;
tq1.PostTask([&blocker, &owner]() {
- blocker.Wait(rtc::Event::kForever);
+ blocker.Wait(Event::kForever);
owner.reset();
});
diff --git a/api/task_queue/task_queue_test.cc b/api/task_queue/task_queue_test.cc
index 2491fe4..bcdbd0c 100644
--- a/api/task_queue/task_queue_test.cc
+++ b/api/task_queue/task_queue_test.cc
@@ -30,8 +30,8 @@
// Avoids a dependency to system_wrappers.
void SleepFor(TimeDelta duration) {
- rtc::ScopedAllowBaseSyncPrimitivesForTesting allow;
- rtc::Event event;
+ ScopedAllowBaseSyncPrimitivesForTesting allow;
+ Event event;
event.Wait(duration);
}
@@ -50,7 +50,7 @@
TEST_P(TaskQueueTest, PostAndCheckCurrent) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
- rtc::Event event;
+ Event event;
auto queue = CreateTaskQueue(factory, "PostAndCheckCurrent");
// We're not running a task, so `queue` shouldn't be current.
@@ -68,17 +68,17 @@
TEST_P(TaskQueueTest, PostCustomTask) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
- rtc::Event ran;
+ Event ran;
auto queue = CreateTaskQueue(factory, "PostCustomImplementation");
class CustomTask {
public:
- explicit CustomTask(rtc::Event* ran) : ran_(ran) {}
+ explicit CustomTask(Event* ran) : ran_(ran) {}
void operator()() { ran_->Set(); }
private:
- rtc::Event* const ran_;
+ Event* const ran_;
} my_task(&ran);
queue->PostTask(my_task);
@@ -87,7 +87,7 @@
TEST_P(TaskQueueTest, PostDelayedZero) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
- rtc::Event event;
+ Event event;
auto queue = CreateTaskQueue(factory, "PostDelayedZero");
queue->PostDelayedTask([&event] { event.Set(); }, TimeDelta::Zero());
@@ -96,7 +96,7 @@
TEST_P(TaskQueueTest, PostFromQueue) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
- rtc::Event event;
+ Event event;
auto queue = CreateTaskQueue(factory, "PostFromQueue");
queue->PostTask(
@@ -106,7 +106,7 @@
TEST_P(TaskQueueTest, PostDelayed) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
- rtc::Event event;
+ Event event;
auto queue =
CreateTaskQueue(factory, "PostDelayed", TaskQueueFactory::Priority::HIGH);
@@ -130,9 +130,9 @@
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
auto queue = CreateTaskQueue(factory, "PostMultipleDelayed");
- std::vector<rtc::Event> events(100);
+ std::vector<Event> events(100);
for (int i = 0; i < 100; ++i) {
- rtc::Event* event = &events[i];
+ Event* event = &events[i];
queue->PostDelayedTask(
[event, &queue] {
EXPECT_TRUE(queue->IsCurrent());
@@ -147,8 +147,8 @@
TEST_P(TaskQueueTest, PostDelayedAfterDestruct) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
- rtc::Event run;
- rtc::Event deleted;
+ Event run;
+ Event deleted;
auto queue = CreateTaskQueue(factory, "PostDelayedAfterDestruct");
absl::Cleanup cleanup = [&deleted] { deleted.Set(); };
queue->PostDelayedTask([&run, cleanup = std::move(cleanup)] { run.Set(); },
@@ -162,8 +162,8 @@
TEST_P(TaskQueueTest, PostDelayedHighPrecisionAfterDestruct) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
- rtc::Event run;
- rtc::Event deleted;
+ Event run;
+ Event deleted;
auto queue =
CreateTaskQueue(factory, "PostDelayedHighPrecisionAfterDestruct");
absl::Cleanup cleanup = [&deleted] { deleted.Set(); };
@@ -185,7 +185,7 @@
queue->PostTask([] { SleepFor(TimeDelta::Millis(100)); });
// Give the task queue a chance to start executing the first lambda.
SleepFor(TimeDelta::Millis(10));
- rtc::Event finished;
+ Event finished;
// Then ensure the next lambda (which is likely not executing yet) is
// destroyed in the task queue context when the queue is deleted.
auto cleanup = absl::Cleanup([queue_ptr, &finished] {
@@ -201,7 +201,7 @@
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
auto queue = CreateTaskQueue(factory, "PostedClosureDestroyedOnTaskQueue");
TaskQueueBase* queue_ptr = queue.get();
- rtc::Event finished;
+ Event finished;
auto cleanup = absl::Cleanup([queue_ptr, &finished] {
EXPECT_EQ(queue_ptr, TaskQueueBase::Current());
finished.Set();
@@ -220,7 +220,7 @@
CreateTaskQueue(factory, "PostedExecutedClosureDestroyedOnTaskQueue");
TaskQueueBase* queue_ptr = queue.get();
// Ensure an executed lambda is destroyed on the task queue.
- rtc::Event finished;
+ Event finished;
queue->PostTask([cleanup = absl::Cleanup([queue_ptr, &finished] {
EXPECT_EQ(queue_ptr, TaskQueueBase::Current());
finished.Set();
@@ -230,7 +230,7 @@
TEST_P(TaskQueueTest, PostAndReuse) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
- rtc::Event event;
+ Event event;
auto post_queue = CreateTaskQueue(factory, "PostQueue");
auto reply_queue = CreateTaskQueue(factory, "ReplyQueue");
@@ -238,7 +238,7 @@
class ReusedTask {
public:
- ReusedTask(int* counter, TaskQueueBase* reply_queue, rtc::Event* event)
+ ReusedTask(int* counter, TaskQueueBase* reply_queue, Event* event)
: counter_(*counter), reply_queue_(reply_queue), event_(*event) {
EXPECT_EQ(counter_, 0);
}
@@ -259,7 +259,7 @@
private:
int& counter_;
TaskQueueBase* const reply_queue_;
- rtc::Event& event_;
+ Event& event_;
};
ReusedTask task(&call_count, reply_queue.get(), &event);
@@ -282,12 +282,12 @@
private:
webrtc_impl::RefCounter count_;
- rtc::Event event_;
+ Event event_;
};
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
static constexpr int kTaskCount = 0xffff;
- rtc::Event posting_done;
+ Event posting_done;
BlockingCounter all_destroyed(kTaskCount);
int tasks_executed = 0;
@@ -307,7 +307,7 @@
});
// Before destroying the task queue wait until all child tasks are posted.
- posting_done.Wait(rtc::Event::kForever);
+ posting_done.Wait(Event::kForever);
// Destroy the task queue.
task_queue = nullptr;
@@ -336,7 +336,7 @@
} state;
auto queue = CreateTaskQueue(factory, "PostTwoWithSharedUnprotectedState");
- rtc::Event done;
+ Event done;
queue->PostTask([&state, &queue, &done] {
// Post tasks from queue to guarantee, that 1st task won't be
// executed before the second one will be posted.
diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 75f512f..a971cae 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -580,13 +580,13 @@
// Wait until all pending encode tasks are executed and clear any remaining
// buffers in the encoder.
- rtc::Event flush;
+ Event flush;
encoder_queue_->PostTask([this, &flush]() {
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
audio_coding_->Reset();
flush.Set();
});
- flush.Wait(rtc::Event::kForever);
+ flush.Wait(Event::kForever);
// Reset sending SSRC and sequence number and triggers direct transmission
// of RTCP BYE
diff --git a/audio/voip/test/audio_egress_unittest.cc b/audio/voip/test/audio_egress_unittest.cc
index de1984d..a7cb3b7 100644
--- a/audio/voip/test/audio_egress_unittest.cc
+++ b/audio/voip/test/audio_egress_unittest.cc
@@ -119,7 +119,7 @@
TEST_F(AudioEgressTest, ProcessAudioWithMute) {
constexpr int kExpected = 10;
- rtc::Event event;
+ Event event;
int rtp_count = 0;
RtpPacketReceived rtp;
auto rtp_sent = [&](rtc::ArrayView<const uint8_t> packet, Unused) {
@@ -157,7 +157,7 @@
TEST_F(AudioEgressTest, ProcessAudioWithSineWave) {
constexpr int kExpected = 10;
- rtc::Event event;
+ Event event;
int rtp_count = 0;
RtpPacketReceived rtp;
auto rtp_sent = [&](rtc::ArrayView<const uint8_t> packet, Unused) {
@@ -193,7 +193,7 @@
TEST_F(AudioEgressTest, SkipAudioEncodingAfterStopSend) {
constexpr int kExpected = 10;
- rtc::Event event;
+ Event event;
int rtp_count = 0;
auto rtp_sent = [&](rtc::ArrayView<const uint8_t> /* packet */, Unused) {
if (++rtp_count == kExpected) {
@@ -257,7 +257,7 @@
// 5, 6, 7 @ 100 ms (last one sends 3 dtmf)
egress_->SendTelephoneEvent(kEvent, kDurationMs);
- rtc::Event event;
+ Event event;
int dtmf_count = 0;
auto is_dtmf = [&](RtpPacketReceived& rtp) {
return (rtp.PayloadType() == kPayloadType &&
@@ -294,7 +294,7 @@
// Per audio_level's kUpdateFrequency, we need more than 10 audio samples to
// get audio level from input source.
constexpr int kExpected = 6;
- rtc::Event event;
+ Event event;
int rtp_count = 0;
auto rtp_sent = [&](rtc::ArrayView<const uint8_t> /* packet */, Unused) {
if (++rtp_count == kExpected) {
diff --git a/audio/voip/test/audio_ingress_unittest.cc b/audio/voip/test/audio_ingress_unittest.cc
index 5dc1f62..687b104 100644
--- a/audio/voip/test/audio_ingress_unittest.cc
+++ b/audio/voip/test/audio_ingress_unittest.cc
@@ -114,7 +114,7 @@
}
TEST_F(AudioIngressTest, GetAudioFrameAfterRtpReceived) {
- rtc::Event event;
+ Event event;
auto handle_rtp = [&](rtc::ArrayView<const uint8_t> packet, Unused) {
ingress_->ReceivedRTPPacket(packet);
event.Set();
@@ -144,7 +144,7 @@
// get audio level from output source.
constexpr int kNumRtp = 6;
int rtp_count = 0;
- rtc::Event event;
+ Event event;
auto handle_rtp = [&](rtc::ArrayView<const uint8_t> packet, Unused) {
ingress_->ReceivedRTPPacket(packet);
if (++rtp_count == kNumRtp) {
@@ -175,7 +175,7 @@
}
TEST_F(AudioIngressTest, PreferredSampleRate) {
- rtc::Event event;
+ Event event;
auto handle_rtp = [&](rtc::ArrayView<const uint8_t> packet, Unused) {
ingress_->ReceivedRTPPacket(packet);
event.Set();
@@ -204,7 +204,7 @@
// valid speech level.
constexpr int kNumRtp = 6;
int rtp_count = 0;
- rtc::Event event;
+ Event event;
auto handle_rtp = [&](rtc::ArrayView<const uint8_t> packet, Unused) {
ingress_->ReceivedRTPPacket(packet);
if (++rtp_count == kNumRtp) {
diff --git a/call/adaptation/resource_adaptation_processor_unittest.cc b/call/adaptation/resource_adaptation_processor_unittest.cc
index 77a181b..20696ea 100644
--- a/call/adaptation/resource_adaptation_processor_unittest.cc
+++ b/call/adaptation/resource_adaptation_processor_unittest.cc
@@ -459,7 +459,7 @@
// Wait for `resource_` to signal oversue first so we know that the delegate
// has passed it on to the processor's task queue.
- rtc::Event resource_event;
+ Event resource_event;
TaskQueueForTest resource_task_queue("ResourceTaskQueue");
resource_task_queue.PostTask([&]() {
resource_->SetUsageState(ResourceUsageState::kOveruse);
@@ -481,7 +481,7 @@
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
- rtc::Event overuse_event;
+ Event overuse_event;
TaskQueueForTest resource_task_queue("ResourceTaskQueue");
// Queues task for `resource_` overuse while `processor_` is still listening.
resource_task_queue.PostTask([&]() {
diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc
index fadc0a1..12ca23b 100644
--- a/call/bitrate_estimator_tests.cc
+++ b/call/bitrate_estimator_tests.cc
@@ -104,7 +104,7 @@
Mutex mutex_;
Strings received_log_lines_ RTC_GUARDED_BY(mutex_);
Strings expected_log_lines_ RTC_GUARDED_BY(mutex_);
- rtc::Event done_;
+ Event done_;
};
Callback callback_;
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 58c578d..23e9254 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -771,7 +771,7 @@
}
private:
- rtc::Event time_to_reconfigure_;
+ Event time_to_reconfigure_;
int encoder_inits_;
uint32_t last_set_bitrate_kbps_;
VideoSendStream* send_stream_;
diff --git a/logging/rtc_event_log/rtc_event_log_impl.cc b/logging/rtc_event_log/rtc_event_log_impl.cc
index 63cc0f7..12afd75 100644
--- a/logging/rtc_event_log/rtc_event_log_impl.cc
+++ b/logging/rtc_event_log/rtc_event_log_impl.cc
@@ -147,9 +147,9 @@
// TODO(bugs.webrtc.org/14449): Do not block current thread waiting on the
// task queue. It might work for now, for current callers, but disallows
// caller to share threads with the `task_queue_`.
- rtc::Event output_stopped;
+ Event output_stopped;
StopLogging([&output_stopped]() { output_stopped.Set(); });
- output_stopped.Wait(rtc::Event::kForever);
+ output_stopped.Wait(Event::kForever);
RTC_DLOG(LS_INFO) << "WebRTC event log successfully stopped.";
}
diff --git a/media/engine/fake_webrtc_video_engine.h b/media/engine/fake_webrtc_video_engine.h
index 6fa4edc..226f6f0 100644
--- a/media/engine/fake_webrtc_video_engine.h
+++ b/media/engine/fake_webrtc_video_engine.h
@@ -102,7 +102,7 @@
private:
Mutex mutex_;
- rtc::Event init_encode_event_;
+ Event init_encode_event_;
int num_frames_encoded_ RTC_GUARDED_BY(mutex_);
VideoCodec codec_settings_ RTC_GUARDED_BY(mutex_);
FakeWebRtcVideoEncoderFactory* factory_;
@@ -132,7 +132,7 @@
private:
Mutex mutex_;
- rtc::Event created_video_encoder_event_;
+ Event created_video_encoder_event_;
std::vector<SdpVideoFormat> formats_;
std::vector<FakeWebRtcVideoEncoder*> encoders_ RTC_GUARDED_BY(mutex_);
int num_created_encoders_ RTC_GUARDED_BY(mutex_);
diff --git a/modules/audio_coding/acm2/audio_coding_module_unittest.cc b/modules/audio_coding/acm2/audio_coding_module_unittest.cc
index f027cab..a6f5e36 100644
--- a/modules/audio_coding/acm2/audio_coding_module_unittest.cc
+++ b/modules/audio_coding/acm2/audio_coding_module_unittest.cc
@@ -476,7 +476,7 @@
// Used to force worker threads to stop looping.
std::atomic<bool> quit_;
- rtc::Event test_complete_;
+ Event test_complete_;
int send_count_;
int insert_packet_count_;
int pull_audio_count_ RTC_GUARDED_BY(mutex_);
diff --git a/modules/audio_device/audio_device_unittest.cc b/modules/audio_device/audio_device_unittest.cc
index 6106361..3b42fe6 100644
--- a/modules/audio_device/audio_device_unittest.cc
+++ b/modules/audio_device/audio_device_unittest.cc
@@ -338,7 +338,7 @@
// implementation where the number of callbacks is counted and an event
// is set after a certain number of callbacks. Audio parameters are also
// checked.
- void HandleCallbacks(rtc::Event* event,
+ void HandleCallbacks(Event* event,
AudioStream* audio_stream,
int num_callbacks) {
event_ = event;
@@ -491,7 +491,7 @@
private:
Mutex lock_;
TransportType type_ = TransportType::kInvalid;
- rtc::Event* event_ = nullptr;
+ Event* event_ = nullptr;
AudioStream* audio_stream_ = nullptr;
size_t num_callbacks_ = 0;
size_t play_count_ RTC_GUARDED_BY(lock_) = 0;
@@ -573,7 +573,7 @@
}
bool requirements_satisfied() const { return requirements_satisfied_; }
- rtc::Event* event() { return &event_; }
+ Event* event() { return &event_; }
AudioDeviceModule::AudioLayer audio_layer() const { return audio_layer_; }
// AudioDeviceModuleForTest extends the default ADM interface with some extra
@@ -661,7 +661,7 @@
AudioDeviceModule::AudioLayer audio_layer_;
std::unique_ptr<TaskQueueFactory> task_queue_factory_;
bool requirements_satisfied_ = true;
- rtc::Event event_;
+ Event event_;
rtc::scoped_refptr<AudioDeviceModuleForTest> audio_device_;
bool stereo_playout_ = false;
};
diff --git a/modules/audio_processing/aec_dump/aec_dump_impl.cc b/modules/audio_processing/aec_dump/aec_dump_impl.cc
index 8484fcc..5a0c10f 100644
--- a/modules/audio_processing/aec_dump/aec_dump_impl.cc
+++ b/modules/audio_processing/aec_dump/aec_dump_impl.cc
@@ -67,11 +67,11 @@
AecDumpImpl::~AecDumpImpl() {
// Block until all tasks have finished running.
- rtc::Event thread_sync_event;
+ Event thread_sync_event;
worker_queue_->PostTask([&thread_sync_event] { thread_sync_event.Set(); });
// Wait until the event has been signaled with .Set(). By then all
// pending tasks will have finished.
- thread_sync_event.Wait(rtc::Event::kForever);
+ thread_sync_event.Wait(Event::kForever);
}
void AecDumpImpl::WriteInitMessage(const ProcessingConfig& api_format,
diff --git a/modules/audio_processing/audio_processing_impl_locking_unittest.cc b/modules/audio_processing/audio_processing_impl_locking_unittest.cc
index 5756237..8d5423f 100644
--- a/modules/audio_processing/audio_processing_impl_locking_unittest.cc
+++ b/modules/audio_processing/audio_processing_impl_locking_unittest.cc
@@ -305,8 +305,8 @@
public:
CaptureProcessor(int max_frame_size,
RandomGenerator* rand_gen,
- rtc::Event* render_call_event,
- rtc::Event* capture_call_event,
+ Event* render_call_event,
+ Event* capture_call_event,
FrameCounters* shared_counters_state,
const TestConfig* test_config,
AudioProcessing* apm);
@@ -322,8 +322,8 @@
void ApplyRuntimeSettingScheme();
RandomGenerator* const rand_gen_ = nullptr;
- rtc::Event* const render_call_event_ = nullptr;
- rtc::Event* const capture_call_event_ = nullptr;
+ Event* const render_call_event_ = nullptr;
+ Event* const capture_call_event_ = nullptr;
FrameCounters* const frame_counters_ = nullptr;
const TestConfig* const test_config_ = nullptr;
AudioProcessing* const apm_ = nullptr;
@@ -349,8 +349,8 @@
public:
RenderProcessor(int max_frame_size,
RandomGenerator* rand_gen,
- rtc::Event* render_call_event,
- rtc::Event* capture_call_event,
+ Event* render_call_event,
+ Event* capture_call_event,
FrameCounters* shared_counters_state,
const TestConfig* test_config,
AudioProcessing* apm);
@@ -366,8 +366,8 @@
void ApplyRuntimeSettingScheme();
RandomGenerator* const rand_gen_ = nullptr;
- rtc::Event* const render_call_event_ = nullptr;
- rtc::Event* const capture_call_event_ = nullptr;
+ Event* const render_call_event_ = nullptr;
+ Event* const capture_call_event_ = nullptr;
FrameCounters* const frame_counters_ = nullptr;
const TestConfig* const test_config_ = nullptr;
AudioProcessing* const apm_ = nullptr;
@@ -420,9 +420,9 @@
}
// Event handlers for the test.
- rtc::Event test_complete_;
- rtc::Event render_call_event_;
- rtc::Event capture_call_event_;
+ Event test_complete_;
+ Event render_call_event_;
+ Event capture_call_event_;
// Thread related variables.
mutable RandomGenerator rand_gen_;
@@ -557,8 +557,8 @@
CaptureProcessor::CaptureProcessor(int max_frame_size,
RandomGenerator* rand_gen,
- rtc::Event* render_call_event,
- rtc::Event* capture_call_event,
+ Event* render_call_event,
+ Event* capture_call_event,
FrameCounters* shared_counters_state,
const TestConfig* test_config,
AudioProcessing* apm)
@@ -578,7 +578,7 @@
// Ensure that the number of render and capture calls do not
// differ too much.
if (frame_counters_->CaptureMinusRenderCounters() > kMaxCallDifference) {
- render_call_event_->Wait(rtc::Event::kForever);
+ render_call_event_->Wait(Event::kForever);
}
// Apply any specified capture side APM non-processing runtime calls.
@@ -783,8 +783,8 @@
RenderProcessor::RenderProcessor(int max_frame_size,
RandomGenerator* rand_gen,
- rtc::Event* render_call_event,
- rtc::Event* capture_call_event,
+ Event* render_call_event,
+ Event* capture_call_event,
FrameCounters* shared_counters_state,
const TestConfig* test_config,
AudioProcessing* apm)
@@ -802,7 +802,7 @@
// before the first render call is performed (implicitly
// required by the APM API).
if (first_render_call_) {
- capture_call_event_->Wait(rtc::Event::kForever);
+ capture_call_event_->Wait(Event::kForever);
first_render_call_ = false;
}
@@ -812,7 +812,7 @@
// Ensure that the number of render and capture calls do not
// differ too much.
if (frame_counters_->RenderMinusCaptureCounters() > kMaxCallDifference) {
- capture_call_event_->Wait(rtc::Event::kForever);
+ capture_call_event_->Wait(Event::kForever);
}
// Apply any specified render side APM non-processing runtime calls.
diff --git a/modules/audio_processing/audio_processing_performance_unittest.cc b/modules/audio_processing/audio_processing_performance_unittest.cc
index d69263b..5051ee5 100644
--- a/modules/audio_processing/audio_processing_performance_unittest.cc
+++ b/modules/audio_processing/audio_processing_performance_unittest.cc
@@ -509,7 +509,7 @@
}
// Event handler for the test.
- rtc::Event test_complete_;
+ Event test_complete_;
// Thread related variables.
Random rand_gen_;
diff --git a/modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
index 40930a0..2f3e0b9 100644
--- a/modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
@@ -57,7 +57,7 @@
constexpr webrtc::TimeDelta kTimeout = webrtc::TimeDelta::Seconds(1);
void WaitPostedTasks(TaskQueueForTest* queue) {
- rtc::Event done;
+ webrtc::Event done;
queue->PostTask([&done] { done.Set(); });
ASSERT_TRUE(done.Wait(kTimeout));
}
@@ -128,8 +128,8 @@
auto* rtcp_transceiver = new RtcpTransceiver(config);
rtcp_transceiver->SendCompoundPacket();
- rtc::Event done;
- rtc::Event heavy_task;
+ webrtc::Event done;
+ webrtc::Event heavy_task;
queue.PostTask([&] {
EXPECT_TRUE(heavy_task.Wait(kTimeout));
done.Set();
@@ -151,7 +151,7 @@
config.task_queue = queue.Get();
auto* rtcp_transceiver = new RtcpTransceiver(config);
- rtc::Event heavy_task;
+ webrtc::Event heavy_task;
queue.PostTask([&] { EXPECT_TRUE(heavy_task.Wait(kTimeout)); });
rtcp_transceiver->SendCompoundPacket();
delete rtcp_transceiver;
@@ -181,7 +181,7 @@
config.clock = &clock;
config.task_queue = queue.Get();
RtcpTransceiver rtcp_transceiver(config);
- rtc::Event observer_deleted;
+ webrtc::Event observer_deleted;
auto observer = std::make_unique<MockMediaReceiverRtcpObserver>();
EXPECT_CALL(*observer, OnSenderReport(kRemoteSsrc, _, 1));
@@ -211,8 +211,8 @@
auto observer = std::make_unique<MockMediaReceiverRtcpObserver>();
rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, observer.get());
- rtc::Event queue_blocker;
- rtc::Event observer_deleted;
+ webrtc::Event queue_blocker;
+ webrtc::Event observer_deleted;
queue.PostTask([&] { EXPECT_TRUE(queue_blocker.Wait(kTimeout)); });
rtcp_transceiver.RemoveMediaReceiverRtcpObserver(kRemoteSsrc, observer.get(),
/*on_removed=*/[&] {
@@ -268,7 +268,7 @@
config.schedule_periodic_compound_packets = true;
auto rtcp_transceiver = std::make_unique<RtcpTransceiver>(config);
- rtc::Event done;
+ webrtc::Event done;
rtcp_transceiver->SendCompoundPacket();
rtcp_transceiver->Stop([&] {
EXPECT_CALL(outgoing_transport, Call).Times(0);
diff --git a/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate_unittest.cc
index 472c8cc..08db7c5 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate_unittest.cc
@@ -162,7 +162,7 @@
ASSERT_TRUE(frame);
EXPECT_STRCASEEQ("video/VP8", frame->GetMimeType().c_str());
- rtc::Event event;
+ Event event;
EXPECT_CALL(test_sender_, SendVideo).WillOnce(WithoutArgs([&] {
event.Set();
return true;
@@ -274,7 +274,7 @@
delegate->Init();
ASSERT_TRUE(callback);
- rtc::Event event;
+ Event event;
EXPECT_CALL(
test_sender_,
SendVideo(payload_type, std::make_optional(kVideoCodecVP8), timestamp,
diff --git a/modules/video_coding/codecs/test/video_codec_unittest.h b/modules/video_coding/codecs/test/video_codec_unittest.h
index 2856bf6..534fece 100644
--- a/modules/video_coding/codecs/test/video_codec_unittest.h
+++ b/modules/video_coding/codecs/test/video_codec_unittest.h
@@ -111,7 +111,7 @@
FakeEncodeCompleteCallback encode_complete_callback_;
FakeDecodeCompleteCallback decode_complete_callback_;
- rtc::Event encoded_frame_event_;
+ Event encoded_frame_event_;
Mutex encoded_frame_section_;
size_t wait_for_encoded_frames_threshold_;
std::vector<EncodedImage> encoded_frames_
@@ -119,7 +119,7 @@
std::vector<CodecSpecificInfo> codec_specific_infos_
RTC_GUARDED_BY(encoded_frame_section_);
- rtc::Event decoded_frame_event_;
+ Event decoded_frame_event_;
Mutex decoded_frame_section_;
std::optional<VideoFrame> decoded_frame_
RTC_GUARDED_BY(decoded_frame_section_);
diff --git a/modules/video_coding/deprecated/event_wrapper.cc b/modules/video_coding/deprecated/event_wrapper.cc
index 16321b6..41b236c 100644
--- a/modules/video_coding/deprecated/event_wrapper.cc
+++ b/modules/video_coding/deprecated/event_wrapper.cc
@@ -30,7 +30,7 @@
}
private:
- rtc::Event event_;
+ Event event_;
};
// static
diff --git a/modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc b/modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc
index 7367e04..f4a89c5 100644
--- a/modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc
+++ b/modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc
@@ -46,7 +46,7 @@
event_.Set();
}
- rtc::Event event_;
+ Event event_;
int adapt_up_event_count_ = 0;
int adapt_down_event_count_ = 0;
};
diff --git a/modules/video_coding/utility/quality_scaler_unittest.cc b/modules/video_coding/utility/quality_scaler_unittest.cc
index 1142947..a0d0e58 100644
--- a/modules/video_coding/utility/quality_scaler_unittest.cc
+++ b/modules/video_coding/utility/quality_scaler_unittest.cc
@@ -45,7 +45,7 @@
event.Set();
}
- rtc::Event event;
+ Event event;
int adapt_up_events_ = 0;
int adapt_down_events_ = 0;
};
diff --git a/p2p/base/wrapping_active_ice_controller_unittest.cc b/p2p/base/wrapping_active_ice_controller_unittest.cc
index a7902b6..db0706e 100644
--- a/p2p/base/wrapping_active_ice_controller_unittest.cc
+++ b/p2p/base/wrapping_active_ice_controller_unittest.cc
@@ -45,7 +45,7 @@
using ::testing::Sequence;
using ::rtc::AutoThread;
-using ::rtc::Event;
+using ::webrtc::Event;
using ::webrtc::ScopedFakeClock;
using ::webrtc::TimeDelta;
diff --git a/pc/peer_connection_factory_unittest.cc b/pc/peer_connection_factory_unittest.cc
index d0235cc..ab4ba81 100644
--- a/pc/peer_connection_factory_unittest.cc
+++ b/pc/peer_connection_factory_unittest.cc
@@ -681,7 +681,7 @@
constexpr TimeDelta kWaitTimeout = TimeDelta::Seconds(10);
auto mock_network_manager = std::make_unique<NiceMock<MockNetworkManager>>();
- rtc::Event called;
+ Event called;
EXPECT_CALL(*mock_network_manager, StartUpdating())
.Times(AtLeast(1))
.WillRepeatedly(InvokeWithoutArgs([&] { called.Set(); }));
@@ -707,7 +707,7 @@
auto mock_socket_factory =
std::make_unique<NiceMock<MockPacketSocketFactory>>();
- rtc::Event called;
+ Event called;
EXPECT_CALL(*mock_socket_factory, CreateUdpSocket(_, _, _))
.WillOnce(InvokeWithoutArgs([&] {
called.Set();
diff --git a/pc/proxy.h b/pc/proxy.h
index 160d532..3e6bde4 100644
--- a/pc/proxy.h
+++ b/pc/proxy.h
@@ -121,7 +121,7 @@
Invoke(std::index_sequence_for<Args...>());
event_.Set();
});
- event_.Wait(rtc::Event::kForever);
+ event_.Wait(Event::kForever);
}
return r_.moved_result();
}
@@ -136,7 +136,7 @@
Method m_;
ReturnType<R> r_;
std::tuple<Args&&...> args_;
- rtc::Event event_;
+ Event event_;
};
template <typename C, typename R, typename... Args>
@@ -156,7 +156,7 @@
Invoke(std::index_sequence_for<Args...>());
event_.Set();
});
- event_.Wait(rtc::Event::kForever);
+ event_.Wait(Event::kForever);
}
return r_.moved_result();
}
@@ -171,7 +171,7 @@
Method m_;
ReturnType<R> r_;
std::tuple<Args&&...> args_;
- rtc::Event event_;
+ Event event_;
};
#define PROXY_STRINGIZE_IMPL(x) #x
diff --git a/pc/rtc_stats_collector.cc b/pc/rtc_stats_collector.cc
index 101a5b7..bfeb2ee 100644
--- a/pc/rtc_stats_collector.cc
+++ b/pc/rtc_stats_collector.cc
@@ -1362,7 +1362,7 @@
// `network_report_`. This is normally not blocking, but if
// WaitForPendingRequest() is called while a request is pending, we might have
// to wait until the network thread is done touching `network_report_`.
- network_report_event_.Wait(rtc::Event::kForever);
+ network_report_event_.Wait(Event::kForever);
if (!network_report_) {
// Normally, MergeNetworkReport_s() is executed because it is posted from
// the network thread. But if WaitForPendingRequest() is called while a
diff --git a/pc/rtc_stats_collector.h b/pc/rtc_stats_collector.h
index 3020360..68bb450 100644
--- a/pc/rtc_stats_collector.h
+++ b/pc/rtc_stats_collector.h
@@ -277,7 +277,7 @@
// This is reset before async-invoking ProducePartialResultsOnNetworkThread()
// and set when ProducePartialResultsOnNetworkThread() is complete, after it
// has updated the value of `network_report_`.
- rtc::Event network_report_event_;
+ Event network_report_event_;
// Cleared and set in `PrepareTransceiverStatsInfosAndCallStats_s_w_n`,
// starting out on the signaling thread, then network. Later read on the
diff --git a/pc/rtp_sender.cc b/pc/rtp_sender.cc
index de24df5..f4a72f5 100644
--- a/pc/rtp_sender.cc
+++ b/pc/rtp_sender.cc
@@ -372,7 +372,7 @@
// blocking call is required to keep them working. The encoder configuration
// also involves another thread with an asynchronous task, thus we still do
// need to wait for the callback to be resolved this way.
- std::unique_ptr<rtc::Event> done_event = std::make_unique<rtc::Event>();
+ std::unique_ptr<Event> done_event = std::make_unique<Event>();
SetParametersInternal(
parameters,
[done = done_event.get(), &result](RTCError error) {
@@ -380,7 +380,7 @@
done->Set();
},
true);
- done_event->Wait(rtc::Event::kForever);
+ done_event->Wait(Event::kForever);
last_transaction_id_.reset();
return result;
}
diff --git a/rtc_base/deprecated/recursive_critical_section_unittest.cc b/rtc_base/deprecated/recursive_critical_section_unittest.cc
index 38f003d..1e7d957 100644
--- a/rtc_base/deprecated/recursive_critical_section_unittest.cc
+++ b/rtc_base/deprecated/recursive_critical_section_unittest.cc
@@ -108,8 +108,8 @@
}
std::atomic<int> threads_active_;
- Event start_event_;
- Event done_event_;
+ webrtc::Event start_event_;
+ webrtc::Event done_event_;
int shared_value_;
};
@@ -178,7 +178,7 @@
class PerfTestData {
public:
- PerfTestData(int expected_count, Event* event)
+ PerfTestData(int expected_count, webrtc::Event* event)
: cache_line_barrier_1_(),
cache_line_barrier_2_(),
expected_count_(expected_count),
@@ -206,7 +206,7 @@
uint8_t cache_line_barrier_2_[64];
int64_t my_counter_ = 0;
const int expected_count_;
- Event* const event_;
+ webrtc::Event* const event_;
};
class PerfTestThread {
@@ -270,7 +270,7 @@
// The test is disabled by default to avoid unecessarily loading the bots.
TEST(RecursiveCriticalSectionTest, DISABLED_Performance) {
PerfTestThread threads[8];
- Event event;
+ webrtc::Event event;
static const int kThreadRepeats = 10000000;
static const int kExpectedCount = kThreadRepeats * arraysize(threads);
@@ -279,7 +279,7 @@
for (auto& t : threads)
t.Start(&test_data, kThreadRepeats, 1);
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
for (auto& t : threads)
t.Stop();
diff --git a/rtc_base/event.cc b/rtc_base/event.cc
index f45368c..3a477b9 100644
--- a/rtc_base/event.cc
+++ b/rtc_base/event.cc
@@ -28,7 +28,7 @@
#include "rtc_base/system/warn_current_thread_is_deadlocked.h"
#include "rtc_base/time_utils.h"
-namespace rtc {
+namespace webrtc {
using ::webrtc::TimeDelta;
@@ -125,19 +125,19 @@
timeval tv;
gettimeofday(&tv, nullptr);
ts.tv_sec = tv.tv_sec;
- ts.tv_nsec = tv.tv_usec * kNumNanosecsPerMicrosec;
+ ts.tv_nsec = tv.tv_usec * rtc::kNumNanosecsPerMicrosec;
#endif
// Add the specified number of milliseconds to it.
int64_t microsecs_from_now = duration_from_now.us();
- ts.tv_sec += microsecs_from_now / kNumMicrosecsPerSec;
- ts.tv_nsec +=
- (microsecs_from_now % kNumMicrosecsPerSec) * kNumNanosecsPerMicrosec;
+ ts.tv_sec += microsecs_from_now / rtc::kNumMicrosecsPerSec;
+ ts.tv_nsec += (microsecs_from_now % rtc::kNumMicrosecsPerSec) *
+ rtc::kNumNanosecsPerMicrosec;
// Normalize.
- if (ts.tv_nsec >= kNumNanosecsPerSec) {
+ if (ts.tv_nsec >= rtc::kNumNanosecsPerSec) {
ts.tv_sec++;
- ts.tv_nsec -= kNumNanosecsPerSec;
+ ts.tv_nsec -= rtc::kNumNanosecsPerSec;
}
return ts;
@@ -160,7 +160,7 @@
? std::nullopt
: std::make_optional(GetTimespec(give_up_after));
- webrtc::ScopedYieldPolicy::YieldExecution();
+ ScopedYieldPolicy::YieldExecution();
pthread_mutex_lock(&event_mutex_);
// Wait for `event_cond_` to trigger and `event_status_` to be set, with the
@@ -207,4 +207,4 @@
#endif
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/event.h b/rtc_base/event.h
index 78b3c16..aa68ac5 100644
--- a/rtc_base/event.h
+++ b/rtc_base/event.h
@@ -23,7 +23,7 @@
#include "rtc_base/synchronization/yield_policy.h"
-namespace rtc {
+namespace webrtc {
// RTC_DISALLOW_WAIT() utility
//
@@ -56,10 +56,8 @@
class Event {
public:
// TODO(bugs.webrtc.org/14366): Consider removing this redundant alias.
- static constexpr webrtc::TimeDelta kForever =
- webrtc::TimeDelta::PlusInfinity();
- static constexpr webrtc::TimeDelta kDefaultWarnDuration =
- webrtc::TimeDelta::Seconds(3);
+ static constexpr TimeDelta kForever = TimeDelta::PlusInfinity();
+ static constexpr TimeDelta kDefaultWarnDuration = TimeDelta::Seconds(3);
Event();
Event(bool manual_reset, bool initially_signaled);
@@ -80,10 +78,10 @@
//
// Returns true if the event was signaled, false if there was a timeout or
// some other error.
- bool Wait(webrtc::TimeDelta give_up_after, webrtc::TimeDelta warn_after);
+ bool Wait(TimeDelta give_up_after, TimeDelta warn_after);
// Waits with the given timeout and a reasonable default warning timeout.
- bool Wait(webrtc::TimeDelta give_up_after) {
+ bool Wait(TimeDelta give_up_after) {
return Wait(give_up_after, give_up_after.IsPlusInfinity()
? kDefaultWarnDuration
: kForever);
@@ -134,6 +132,14 @@
};
#endif
+} // 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::Event;
+using ::webrtc::ScopedAllowBaseSyncPrimitives;
+using ::webrtc::ScopedAllowBaseSyncPrimitivesForTesting;
} // namespace rtc
#endif // RTC_BASE_EVENT_H_
diff --git a/rtc_base/event_tracer.cc b/rtc_base/event_tracer.cc
index 5b47193..801c829 100644
--- a/rtc_base/event_tracer.cc
+++ b/rtc_base/event_tracer.cc
@@ -348,7 +348,7 @@
Mutex mutex_;
std::vector<TraceEvent> trace_events_ RTC_GUARDED_BY(mutex_);
rtc::PlatformThread logging_thread_;
- rtc::Event shutdown_event_;
+ Event shutdown_event_;
SequenceChecker thread_checker_;
FILE* output_file_ = nullptr;
bool output_file_owned_ = false;
diff --git a/rtc_base/event_unittest.cc b/rtc_base/event_unittest.cc
index 17f50dc..57dfa17 100644
--- a/rtc_base/event_unittest.cc
+++ b/rtc_base/event_unittest.cc
@@ -15,32 +15,32 @@
#include "system_wrappers/include/clock.h"
#include "test/gtest.h"
-namespace rtc {
+namespace webrtc {
TEST(EventTest, InitiallySignaled) {
Event event(false, true);
- ASSERT_TRUE(event.Wait(webrtc::TimeDelta::Zero()));
+ ASSERT_TRUE(event.Wait(TimeDelta::Zero()));
}
TEST(EventTest, ManualReset) {
Event event(true, false);
- ASSERT_FALSE(event.Wait(webrtc::TimeDelta::Zero()));
+ ASSERT_FALSE(event.Wait(TimeDelta::Zero()));
event.Set();
- ASSERT_TRUE(event.Wait(webrtc::TimeDelta::Zero()));
- ASSERT_TRUE(event.Wait(webrtc::TimeDelta::Zero()));
+ ASSERT_TRUE(event.Wait(TimeDelta::Zero()));
+ ASSERT_TRUE(event.Wait(TimeDelta::Zero()));
event.Reset();
- ASSERT_FALSE(event.Wait(webrtc::TimeDelta::Zero()));
+ ASSERT_FALSE(event.Wait(TimeDelta::Zero()));
}
TEST(EventTest, AutoReset) {
Event event;
- ASSERT_FALSE(event.Wait(webrtc::TimeDelta::Zero()));
+ ASSERT_FALSE(event.Wait(TimeDelta::Zero()));
event.Set();
- ASSERT_TRUE(event.Wait(webrtc::TimeDelta::Zero()));
- ASSERT_FALSE(event.Wait(webrtc::TimeDelta::Zero()));
+ ASSERT_TRUE(event.Wait(TimeDelta::Zero()));
+ ASSERT_FALSE(event.Wait(TimeDelta::Zero()));
}
class SignalerThread {
@@ -48,9 +48,9 @@
void Start(Event* writer, Event* reader) {
writer_ = writer;
reader_ = reader;
- thread_ = PlatformThread::SpawnJoinable(
+ thread_ = rtc::PlatformThread::SpawnJoinable(
[this] {
- while (!stop_event_.Wait(webrtc::TimeDelta::Zero())) {
+ while (!stop_event_.Wait(TimeDelta::Zero())) {
writer_->Set();
reader_->Wait(Event::kForever);
}
@@ -64,16 +64,15 @@
Event stop_event_;
Event* writer_;
Event* reader_;
- PlatformThread thread_;
+ rtc::PlatformThread thread_;
};
TEST(EventTest, UnsignaledWaitDoesNotReturnBeforeTimeout) {
- constexpr webrtc::TimeDelta kDuration = webrtc::TimeDelta::Micros(10'499);
+ constexpr TimeDelta kDuration = TimeDelta::Micros(10'499);
Event event;
- auto begin = webrtc::Clock::GetRealTimeClock()->CurrentTime();
+ auto begin = Clock::GetRealTimeClock()->CurrentTime();
EXPECT_FALSE(event.Wait(kDuration));
- EXPECT_GE(webrtc::Clock::GetRealTimeClock()->CurrentTime(),
- begin + kDuration);
+ EXPECT_GE(Clock::GetRealTimeClock()->CurrentTime(), begin + kDuration);
}
// These tests are disabled by default and only intended to be run manually.
@@ -82,7 +81,7 @@
Event event;
for (int i = 0; i < kNumIterations; ++i) {
event.Set();
- event.Wait(webrtc::TimeDelta::Zero());
+ event.Wait(TimeDelta::Zero());
}
}
@@ -112,4 +111,4 @@
}
#endif // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/null_socket_server.cc b/rtc_base/null_socket_server.cc
index 5783c82..47896a4 100644
--- a/rtc_base/null_socket_server.cc
+++ b/rtc_base/null_socket_server.cc
@@ -25,7 +25,7 @@
// Wait with the given timeout. Do not log a warning if we end up waiting for
// a long time; that just means no one has any work for us, which is perfectly
// legitimate.
- event_.Wait(max_wait_duration, /*warn_after=*/rtc::Event::kForever);
+ event_.Wait(max_wait_duration, /*warn_after=*/Event::kForever);
return true;
}
diff --git a/rtc_base/null_socket_server.h b/rtc_base/null_socket_server.h
index e0e10e7..87e6492 100644
--- a/rtc_base/null_socket_server.h
+++ b/rtc_base/null_socket_server.h
@@ -29,7 +29,7 @@
Socket* CreateSocket(int family, int type) override;
private:
- rtc::Event event_;
+ Event event_;
};
} // namespace webrtc
diff --git a/rtc_base/operations_chain_unittest.cc b/rtc_base/operations_chain_unittest.cc
index 78e02ed..dcd2355 100644
--- a/rtc_base/operations_chain_unittest.cc
+++ b/rtc_base/operations_chain_unittest.cc
@@ -48,7 +48,7 @@
// Creates a binding for the synchronous operation (see
// StartSynchronousOperation() below).
std::function<void(std::function<void()>)> BindSynchronousOperation(
- Event* operation_complete_event) {
+ webrtc::Event* operation_complete_event) {
return [this, operation_complete_event](std::function<void()> callback) {
StartSynchronousOperation(operation_complete_event, std::move(callback));
};
@@ -57,8 +57,8 @@
// Creates a binding for the asynchronous operation (see
// StartAsynchronousOperation() below).
std::function<void(std::function<void()>)> BindAsynchronousOperation(
- Event* unblock_operation_event,
- Event* operation_complete_event) {
+ webrtc::Event* unblock_operation_event,
+ webrtc::Event* operation_complete_event) {
return [this, unblock_operation_event,
operation_complete_event](std::function<void()> callback) {
StartAsynchronousOperation(unblock_operation_event,
@@ -69,14 +69,14 @@
// When an operation is completed, its associated Event* is added to this
// list, in chronological order. This allows you to verify the order that
// operations are executed.
- const std::vector<Event*>& completed_operation_events() const {
+ const std::vector<webrtc::Event*>& completed_operation_events() const {
return completed_operation_events_;
}
private:
// This operation is completed synchronously; the callback is invoked before
// the function returns.
- void StartSynchronousOperation(Event* operation_complete_event,
+ void StartSynchronousOperation(webrtc::Event* operation_complete_event,
std::function<void()> callback) {
completed_operation_events_.push_back(operation_complete_event);
operation_complete_event->Set();
@@ -88,13 +88,13 @@
// completes upon posting back to the thread that the operation started on.
// Note that this requires the starting thread to be executing tasks (handle
// messages), i.e. must not be blocked.
- void StartAsynchronousOperation(Event* unblock_operation_event,
- Event* operation_complete_event,
+ void StartAsynchronousOperation(webrtc::Event* unblock_operation_event,
+ webrtc::Event* operation_complete_event,
std::function<void()> callback) {
Thread* current_thread = Thread::Current();
background_thread_->PostTask([this, current_thread, unblock_operation_event,
operation_complete_event, callback]() {
- unblock_operation_event->Wait(Event::kForever);
+ unblock_operation_event->Wait(webrtc::Event::kForever);
current_thread->PostTask([this, operation_complete_event, callback]() {
completed_operation_events_.push_back(operation_complete_event);
operation_complete_event->Set();
@@ -104,7 +104,7 @@
}
std::unique_ptr<Thread> background_thread_;
- std::vector<Event*> completed_operation_events_;
+ std::vector<webrtc::Event*> completed_operation_events_;
};
// The OperationTrackerProxy ensures all operations are chained on a separate
@@ -119,8 +119,8 @@
operations_chain_thread_->Start();
}
- std::unique_ptr<Event> Initialize() {
- std::unique_ptr<Event> event = std::make_unique<Event>();
+ std::unique_ptr<webrtc::Event> Initialize() {
+ std::unique_ptr<webrtc::Event> event = std::make_unique<webrtc::Event>();
operations_chain_thread_->PostTask([this, event_ptr = event.get()]() {
operation_tracker_ = std::make_unique<OperationTracker>();
operations_chain_ = OperationsChain::Create();
@@ -130,7 +130,7 @@
}
void SetOnChainEmptyCallback(std::function<void()> on_chain_empty_callback) {
- Event event;
+ webrtc::Event event;
operations_chain_thread_->PostTask(
[this, &event,
on_chain_empty_callback = std::move(on_chain_empty_callback)]() {
@@ -138,22 +138,22 @@
std::move(on_chain_empty_callback));
event.Set();
});
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
}
bool IsEmpty() {
- Event event;
+ webrtc::Event event;
bool is_empty = false;
operations_chain_thread_->PostTask([this, &event, &is_empty]() {
is_empty = operations_chain_->IsEmpty();
event.Set();
});
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
return is_empty;
}
- std::unique_ptr<Event> ReleaseOperationChain() {
- std::unique_ptr<Event> event = std::make_unique<Event>();
+ std::unique_ptr<webrtc::Event> ReleaseOperationChain() {
+ std::unique_ptr<webrtc::Event> event = std::make_unique<webrtc::Event>();
operations_chain_thread_->PostTask([this, event_ptr = event.get()]() {
operations_chain_ = nullptr;
event_ptr->Set();
@@ -162,8 +162,9 @@
}
// Chains a synchronous operation on the operation chain's thread.
- std::unique_ptr<Event> PostSynchronousOperation() {
- std::unique_ptr<Event> operation_complete_event = std::make_unique<Event>();
+ std::unique_ptr<webrtc::Event> PostSynchronousOperation() {
+ std::unique_ptr<webrtc::Event> operation_complete_event =
+ std::make_unique<webrtc::Event>();
operations_chain_thread_->PostTask(
[this,
operation_complete_event_ptr = operation_complete_event.get()]() {
@@ -176,9 +177,10 @@
// Chains an asynchronous operation on the operation chain's thread. This
// involves the operation chain thread and an additional background thread.
- std::unique_ptr<Event> PostAsynchronousOperation(
- Event* unblock_operation_event) {
- std::unique_ptr<Event> operation_complete_event = std::make_unique<Event>();
+ std::unique_ptr<webrtc::Event> PostAsynchronousOperation(
+ webrtc::Event* unblock_operation_event) {
+ std::unique_ptr<webrtc::Event> operation_complete_event =
+ std::make_unique<webrtc::Event>();
operations_chain_thread_->PostTask(
[this, unblock_operation_event,
operation_complete_event_ptr = operation_complete_event.get()]() {
@@ -192,7 +194,7 @@
// The order of completed events. Touches the `operation_tracker_` on the
// calling thread, this is only thread safe if all chained operations have
// completed.
- const std::vector<Event*>& completed_operation_events() const {
+ const std::vector<webrtc::Event*>& completed_operation_events() const {
return operation_tracker_->completed_operation_events();
}
@@ -237,16 +239,17 @@
TEST(OperationsChainTest, SynchronousOperation) {
OperationTrackerProxy operation_tracker_proxy;
- operation_tracker_proxy.Initialize()->Wait(Event::kForever);
+ operation_tracker_proxy.Initialize()->Wait(webrtc::Event::kForever);
- operation_tracker_proxy.PostSynchronousOperation()->Wait(Event::kForever);
+ operation_tracker_proxy.PostSynchronousOperation()->Wait(
+ webrtc::Event::kForever);
}
TEST(OperationsChainTest, AsynchronousOperation) {
OperationTrackerProxy operation_tracker_proxy;
- operation_tracker_proxy.Initialize()->Wait(Event::kForever);
+ operation_tracker_proxy.Initialize()->Wait(webrtc::Event::kForever);
- Event unblock_async_operation_event;
+ webrtc::Event unblock_async_operation_event;
auto async_operation_completed_event =
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event);
@@ -255,7 +258,7 @@
async_operation_completed_event->Wait(webrtc::TimeDelta::Zero()));
// Unblock the operation and wait for it to complete.
unblock_async_operation_event.Set();
- async_operation_completed_event->Wait(Event::kForever);
+ async_operation_completed_event->Wait(webrtc::Event::kForever);
}
TEST(OperationsChainTest,
@@ -265,7 +268,7 @@
// threads.
scoped_refptr<OperationsChain> operations_chain = OperationsChain::Create();
OperationTracker operation_tracker;
- Event event0;
+ webrtc::Event event0;
operations_chain->ChainOperation(
operation_tracker.BindSynchronousOperation(&event0));
// This should already be signaled. (If it wasn't, waiting wouldn't help,
@@ -273,7 +276,7 @@
EXPECT_TRUE(event0.Wait(webrtc::TimeDelta::Zero()));
// Chaining another operation should also execute immediately because the
// chain should already be empty.
- Event event1;
+ webrtc::Event event1;
operations_chain->ChainOperation(
operation_tracker.BindSynchronousOperation(&event1));
EXPECT_TRUE(event1.Wait(webrtc::TimeDelta::Zero()));
@@ -281,9 +284,9 @@
TEST(OperationsChainTest, AsynchronousOperationBlocksSynchronousOperation) {
OperationTrackerProxy operation_tracker_proxy;
- operation_tracker_proxy.Initialize()->Wait(Event::kForever);
+ operation_tracker_proxy.Initialize()->Wait(webrtc::Event::kForever);
- Event unblock_async_operation_event;
+ webrtc::Event unblock_async_operation_event;
auto async_operation_completed_event =
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event);
@@ -293,7 +296,7 @@
unblock_async_operation_event.Set();
- sync_operation_completed_event->Wait(Event::kForever);
+ sync_operation_completed_event->Wait(webrtc::Event::kForever);
// The asynchronous avent should have blocked the synchronous event, meaning
// this should already be signaled.
EXPECT_TRUE(async_operation_completed_event->Wait(webrtc::TimeDelta::Zero()));
@@ -301,15 +304,15 @@
TEST(OperationsChainTest, OperationsAreExecutedInOrder) {
OperationTrackerProxy operation_tracker_proxy;
- operation_tracker_proxy.Initialize()->Wait(Event::kForever);
+ operation_tracker_proxy.Initialize()->Wait(webrtc::Event::kForever);
// Chain a mix of asynchronous and synchronous operations.
- Event operation0_unblock_event;
+ webrtc::Event operation0_unblock_event;
auto operation0_completed_event =
operation_tracker_proxy.PostAsynchronousOperation(
&operation0_unblock_event);
- Event operation1_unblock_event;
+ webrtc::Event operation1_unblock_event;
auto operation1_completed_event =
operation_tracker_proxy.PostAsynchronousOperation(
&operation1_unblock_event);
@@ -320,7 +323,7 @@
auto operation3_completed_event =
operation_tracker_proxy.PostSynchronousOperation();
- Event operation4_unblock_event;
+ webrtc::Event operation4_unblock_event;
auto operation4_completed_event =
operation_tracker_proxy.PostAsynchronousOperation(
&operation4_unblock_event);
@@ -328,7 +331,7 @@
auto operation5_completed_event =
operation_tracker_proxy.PostSynchronousOperation();
- Event operation6_unblock_event;
+ webrtc::Event operation6_unblock_event;
auto operation6_completed_event =
operation_tracker_proxy.PostAsynchronousOperation(
&operation6_unblock_event);
@@ -341,13 +344,13 @@
operation0_unblock_event.Set();
// Await all operations. The await-order shouldn't matter since they all get
// executed eventually.
- operation0_completed_event->Wait(Event::kForever);
- operation1_completed_event->Wait(Event::kForever);
- operation2_completed_event->Wait(Event::kForever);
- operation3_completed_event->Wait(Event::kForever);
- operation4_completed_event->Wait(Event::kForever);
- operation5_completed_event->Wait(Event::kForever);
- operation6_completed_event->Wait(Event::kForever);
+ operation0_completed_event->Wait(webrtc::Event::kForever);
+ operation1_completed_event->Wait(webrtc::Event::kForever);
+ operation2_completed_event->Wait(webrtc::Event::kForever);
+ operation3_completed_event->Wait(webrtc::Event::kForever);
+ operation4_completed_event->Wait(webrtc::Event::kForever);
+ operation5_completed_event->Wait(webrtc::Event::kForever);
+ operation6_completed_event->Wait(webrtc::Event::kForever);
EXPECT_THAT(
operation_tracker_proxy.completed_operation_events(),
@@ -360,12 +363,12 @@
TEST(OperationsChainTest, IsEmpty) {
OperationTrackerProxy operation_tracker_proxy;
- operation_tracker_proxy.Initialize()->Wait(Event::kForever);
+ operation_tracker_proxy.Initialize()->Wait(webrtc::Event::kForever);
// The chain is initially empty.
EXPECT_TRUE(operation_tracker_proxy.IsEmpty());
// Chain a single event.
- Event unblock_async_operation_event0;
+ webrtc::Event unblock_async_operation_event0;
auto async_operation_completed_event0 =
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event0);
@@ -373,15 +376,15 @@
EXPECT_FALSE(operation_tracker_proxy.IsEmpty());
// Completing the operation empties the chain.
unblock_async_operation_event0.Set();
- async_operation_completed_event0->Wait(Event::kForever);
+ async_operation_completed_event0->Wait(webrtc::Event::kForever);
EXPECT_TRUE(operation_tracker_proxy.IsEmpty());
// Chain multiple events.
- Event unblock_async_operation_event1;
+ webrtc::Event unblock_async_operation_event1;
auto async_operation_completed_event1 =
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event1);
- Event unblock_async_operation_event2;
+ webrtc::Event unblock_async_operation_event2;
auto async_operation_completed_event2 =
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event2);
@@ -389,25 +392,25 @@
EXPECT_FALSE(operation_tracker_proxy.IsEmpty());
// Upon completing the first event, the chain is still not empty.
unblock_async_operation_event1.Set();
- async_operation_completed_event1->Wait(Event::kForever);
+ async_operation_completed_event1->Wait(webrtc::Event::kForever);
EXPECT_FALSE(operation_tracker_proxy.IsEmpty());
// Completing the last event empties the chain.
unblock_async_operation_event2.Set();
- async_operation_completed_event2->Wait(Event::kForever);
+ async_operation_completed_event2->Wait(webrtc::Event::kForever);
EXPECT_TRUE(operation_tracker_proxy.IsEmpty());
}
TEST(OperationsChainTest, OnChainEmptyCallback) {
rtc::AutoThread main_thread;
OperationTrackerProxy operation_tracker_proxy;
- operation_tracker_proxy.Initialize()->Wait(Event::kForever);
+ operation_tracker_proxy.Initialize()->Wait(webrtc::Event::kForever);
std::atomic<size_t> on_empty_callback_counter(0u);
operation_tracker_proxy.SetOnChainEmptyCallback(
[&on_empty_callback_counter] { ++on_empty_callback_counter; });
// Chain a single event.
- Event unblock_async_operation_event0;
+ webrtc::Event unblock_async_operation_event0;
auto async_operation_completed_event0 =
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event0);
@@ -415,18 +418,18 @@
EXPECT_EQ(0u, on_empty_callback_counter);
// Completing the operation empties the chain, invoking the callback.
unblock_async_operation_event0.Set();
- async_operation_completed_event0->Wait(Event::kForever);
+ async_operation_completed_event0->Wait(webrtc::Event::kForever);
EXPECT_THAT(
webrtc::WaitUntil([&] { return on_empty_callback_counter == 1u; },
::testing::IsTrue(), {.timeout = kDefaultTimeout}),
webrtc::IsRtcOk());
// Chain multiple events.
- Event unblock_async_operation_event1;
+ webrtc::Event unblock_async_operation_event1;
auto async_operation_completed_event1 =
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event1);
- Event unblock_async_operation_event2;
+ webrtc::Event unblock_async_operation_event2;
auto async_operation_completed_event2 =
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event2);
@@ -438,14 +441,14 @@
// Upon completing the first event, the chain is still not empty, so the
// callback must not be invoked yet.
unblock_async_operation_event1.Set();
- async_operation_completed_event1->Wait(Event::kForever);
+ async_operation_completed_event1->Wait(webrtc::Event::kForever);
EXPECT_THAT(
webrtc::WaitUntil([&] { return on_empty_callback_counter == 1u; },
::testing::IsTrue(), {.timeout = kDefaultTimeout}),
webrtc::IsRtcOk());
// Completing the last event empties the chain, invoking the callback.
unblock_async_operation_event2.Set();
- async_operation_completed_event2->Wait(Event::kForever);
+ async_operation_completed_event2->Wait(webrtc::Event::kForever);
EXPECT_THAT(
webrtc::WaitUntil([&] { return on_empty_callback_counter == 2u; },
::testing::IsTrue(), {.timeout = kDefaultTimeout}),
@@ -455,19 +458,20 @@
TEST(OperationsChainTest,
SafeToReleaseReferenceToOperationChainWhileOperationIsPending) {
OperationTrackerProxy operation_tracker_proxy;
- operation_tracker_proxy.Initialize()->Wait(Event::kForever);
+ operation_tracker_proxy.Initialize()->Wait(webrtc::Event::kForever);
- Event unblock_async_operation_event;
+ webrtc::Event unblock_async_operation_event;
auto async_operation_completed_event =
operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event);
// Pending operations keep the OperationChain alive, making it safe for the
// test to release any references before unblocking the async operation.
- operation_tracker_proxy.ReleaseOperationChain()->Wait(Event::kForever);
+ operation_tracker_proxy.ReleaseOperationChain()->Wait(
+ webrtc::Event::kForever);
unblock_async_operation_event.Set();
- async_operation_completed_event->Wait(Event::kForever);
+ async_operation_completed_event->Wait(webrtc::Event::kForever);
}
TEST(OperationsChainTest, FunctorIsNotDestroyedWhileExecuting) {
diff --git a/rtc_base/physical_socket_server.cc b/rtc_base/physical_socket_server.cc
index 81601ef..7c074e1 100644
--- a/rtc_base/physical_socket_server.cc
+++ b/rtc_base/physical_socket_server.cc
@@ -1366,7 +1366,7 @@
}
int PhysicalSocketServer::ToCmsWait(TimeDelta max_wait_duration) {
- return max_wait_duration == rtc::Event::kForever
+ return max_wait_duration == Event::kForever
? kForeverMs
: max_wait_duration.RoundUpTo(TimeDelta::Millis(1)).ms();
}
diff --git a/rtc_base/platform_thread_unittest.cc b/rtc_base/platform_thread_unittest.cc
index be4417a..ba628ad 100644
--- a/rtc_base/platform_thread_unittest.cc
+++ b/rtc_base/platform_thread_unittest.cc
@@ -30,7 +30,7 @@
EXPECT_FALSE(thread.empty());
thread.Finalize();
EXPECT_TRUE(thread.empty());
- rtc::Event done;
+ webrtc::Event done;
thread = PlatformThread::SpawnDetached([&] { done.Set(); }, "2");
EXPECT_FALSE(thread.empty());
thread.Finalize();
@@ -50,7 +50,7 @@
PlatformThread thread2 = std::move(thread1);
EXPECT_TRUE(thread1.empty());
EXPECT_FALSE(thread2.empty());
- rtc::Event done;
+ webrtc::Event done;
thread1 = PlatformThread::SpawnDetached([&] { done.Set(); }, "2");
thread2 = std::move(thread1);
EXPECT_TRUE(thread1.empty());
@@ -80,7 +80,7 @@
TEST(PlatformThreadTest, JoinsThread) {
// This test flakes if there are problems with the join implementation.
- rtc::Event event;
+ webrtc::Event event;
PlatformThread::SpawnJoinable([&] { event.Set(); }, "T");
EXPECT_TRUE(event.Wait(/*give_up_after=*/webrtc::TimeDelta::Zero()));
}
@@ -89,21 +89,21 @@
// This test flakes if there are problems with the detached thread
// implementation.
bool flag = false;
- rtc::Event thread_started;
- rtc::Event thread_continue;
- rtc::Event thread_exiting;
+ webrtc::Event thread_started;
+ webrtc::Event thread_continue;
+ webrtc::Event thread_exiting;
PlatformThread::SpawnDetached(
[&] {
thread_started.Set();
- thread_continue.Wait(Event::kForever);
+ thread_continue.Wait(webrtc::Event::kForever);
flag = true;
thread_exiting.Set();
},
"T");
- thread_started.Wait(Event::kForever);
+ thread_started.Wait(webrtc::Event::kForever);
EXPECT_FALSE(flag);
thread_continue.Set();
- thread_exiting.Wait(Event::kForever);
+ thread_exiting.Wait(webrtc::Event::kForever);
EXPECT_TRUE(flag);
}
diff --git a/rtc_base/rate_limiter_unittest.cc b/rtc_base/rate_limiter_unittest.cc
index 07dda56..9d4caf5 100644
--- a/rtc_base/rate_limiter_unittest.cc
+++ b/rtc_base/rate_limiter_unittest.cc
@@ -123,8 +123,8 @@
virtual void DoRun() = 0;
RateLimiter* const rate_limiter_;
- rtc::Event start_signal_;
- rtc::Event end_signal_;
+ Event start_signal_;
+ Event end_signal_;
};
TEST_F(RateLimitTest, MultiThreadedUsage) {
diff --git a/rtc_base/socket_server.h b/rtc_base/socket_server.h
index a40a77b..bf4664e 100644
--- a/rtc_base/socket_server.h
+++ b/rtc_base/socket_server.h
@@ -34,7 +34,7 @@
// notified of asynchronous I/O from this server's Wait method.
class SocketServer : public SocketFactory {
public:
- static constexpr TimeDelta kForever = rtc::Event::kForever;
+ static constexpr TimeDelta kForever = Event::kForever;
static std::unique_ptr<SocketServer> CreateDefault();
// When the socket server is installed into a Thread, this function is called
diff --git a/rtc_base/task_queue_for_test.h b/rtc_base/task_queue_for_test.h
index c0f7aad..2f1ca08 100644
--- a/rtc_base/task_queue_for_test.h
+++ b/rtc_base/task_queue_for_test.h
@@ -29,10 +29,10 @@
return;
}
- rtc::Event event;
+ Event event;
absl::Cleanup cleanup = [&event] { event.Set(); };
task_queue->PostTask([task, cleanup = std::move(cleanup)] { task(); });
- RTC_CHECK(event.Wait(/*give_up_after=*/rtc::Event::kForever,
+ RTC_CHECK(event.Wait(/*give_up_after=*/Event::kForever,
/*warn_after=*/TimeDelta::Seconds(10)));
}
diff --git a/rtc_base/task_queue_stdlib.cc b/rtc_base/task_queue_stdlib.cc
index e2b89b8..84e5a22 100644
--- a/rtc_base/task_queue_stdlib.cc
+++ b/rtc_base/task_queue_stdlib.cc
@@ -94,7 +94,7 @@
void NotifyWake();
// Signaled whenever a new task is pending.
- rtc::Event flag_notify_;
+ Event flag_notify_;
Mutex pending_lock_;
@@ -136,7 +136,7 @@
TaskQueueStdlib* me,
absl::string_view queue_name,
rtc::ThreadPriority priority) {
- rtc::Event started;
+ Event started;
auto thread = rtc::PlatformThread::SpawnJoinable(
[&started, me] {
CurrentTaskQueueSetter set_current(me);
@@ -144,7 +144,7 @@
me->ProcessTasks();
},
queue_name, rtc::ThreadAttributes().SetPriority(priority));
- started.Wait(rtc::Event::kForever);
+ started.Wait(Event::kForever);
return thread;
}
diff --git a/rtc_base/task_queue_stdlib_unittest.cc b/rtc_base/task_queue_stdlib_unittest.cc
index 68d2aca..509d307 100644
--- a/rtc_base/task_queue_stdlib_unittest.cc
+++ b/rtc_base/task_queue_stdlib_unittest.cc
@@ -53,7 +53,7 @@
LogMessage::AddLogToStream(&stream, rtc::LS_VERBOSE);
auto task_queue = CreateTaskQueueStdlibFactory()->CreateTaskQueue(
"test", TaskQueueFactory::Priority::NORMAL);
- auto wait_duration = rtc::Event::kDefaultWarnDuration + TimeDelta::Seconds(1);
+ auto wait_duration = Event::kDefaultWarnDuration + TimeDelta::Seconds(1);
SleepMs(wait_duration.ms());
EXPECT_EQ(log_output.length(), 0u);
task_queue = nullptr;
diff --git a/rtc_base/task_queue_unittest.cc b/rtc_base/task_queue_unittest.cc
index eb5c5b1..34288b3 100644
--- a/rtc_base/task_queue_unittest.cc
+++ b/rtc_base/task_queue_unittest.cc
@@ -59,7 +59,7 @@
EnableHighResTimers high_res_scope;
static const char kQueueName[] = "PostDelayedHighRes";
- rtc::Event event;
+ Event event;
TaskQueueForTest queue(kQueueName, TaskQueueFactory::Priority::HIGH);
uint32_t start = rtc::TimeMillis();
diff --git a/rtc_base/task_queue_win.cc b/rtc_base/task_queue_win.cc
index 513ccd7..ce151c4 100644
--- a/rtc_base/task_queue_win.cc
+++ b/rtc_base/task_queue_win.cc
@@ -202,10 +202,10 @@
[this] { RunThreadMain(); }, queue_name,
rtc::ThreadAttributes().SetPriority(priority));
- rtc::Event event(false, false);
+ Event event(false, false);
RTC_CHECK(thread_.QueueAPC(&InitializeQueueThread,
reinterpret_cast<ULONG_PTR>(&event)));
- event.Wait(rtc::Event::kForever);
+ event.Wait(Event::kForever);
}
void TaskQueueWin::Delete() {
diff --git a/rtc_base/task_utils/repeating_task_unittest.cc b/rtc_base/task_utils/repeating_task_unittest.cc
index e4fb56f..f85078e 100644
--- a/rtc_base/task_utils/repeating_task_unittest.cc
+++ b/rtc_base/task_utils/repeating_task_unittest.cc
@@ -208,7 +208,7 @@
}
TEST(RepeatingTaskTest, CancelDelayedTaskBeforeItRuns) {
- rtc::Event done;
+ Event done;
MockClosure mock;
EXPECT_CALL(mock, Call).Times(0);
EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
@@ -221,7 +221,7 @@
}
TEST(RepeatingTaskTest, CancelTaskAfterItRuns) {
- rtc::Event done;
+ Event done;
MockClosure mock;
EXPECT_CALL(mock, Call).WillOnce(Return(TimeDelta::Millis(100)));
EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
@@ -264,7 +264,7 @@
TEST(RepeatingTaskTest, ZeroReturnValueRepostsTheTask) {
NiceMock<MockClosure> closure;
- rtc::Event done;
+ Event done;
EXPECT_CALL(closure, Call())
.WillOnce(Return(TimeDelta::Zero()))
.WillOnce(Invoke([&] {
@@ -278,7 +278,7 @@
TEST(RepeatingTaskTest, StartPeriodicTask) {
MockFunction<TimeDelta()> closure;
- rtc::Event done;
+ Event done;
EXPECT_CALL(closure, Call())
.WillOnce(Return(TimeDelta::Millis(20)))
.WillOnce(Return(TimeDelta::Millis(20)))
diff --git a/rtc_base/thread.cc b/rtc_base/thread.cc
index bc42d74..72ea907 100644
--- a/rtc_base/thread.cc
+++ b/rtc_base/thread.cc
@@ -752,10 +752,10 @@
}
#endif
- Event done;
+ webrtc::Event done;
absl::Cleanup cleanup = [&done] { done.Set(); };
PostTask([functor, cleanup = std::move(cleanup)] { functor(); });
- done.Wait(Event::kForever);
+ done.Wait(webrtc::Event::kForever);
}
// Called by the ThreadManager when being set as the current thread.
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index 50c59ea..d405295 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -141,7 +141,7 @@
// when it is destroyed.
class SignalWhenDestroyedThread : public Thread {
public:
- SignalWhenDestroyedThread(Event* event)
+ SignalWhenDestroyedThread(webrtc::Event* event)
: Thread(std::unique_ptr<webrtc::SocketServer>(
new webrtc::NullSocketServer())),
event_(event) {}
@@ -156,7 +156,7 @@
}
private:
- Event* event_;
+ webrtc::Event* event_;
};
// See: https://code.google.com/p/webrtc/issues/detail?id=2409
@@ -500,7 +500,7 @@
Thread& q) {
std::vector<int> run_order;
- Event done;
+ webrtc::Event done;
int64_t now = TimeMillis();
q.PostDelayedTask([&] { run_order.push_back(3); }, TimeDelta::Millis(3));
q.PostDelayedTask([&] { run_order.push_back(0); }, TimeDelta::Millis(1));
@@ -535,7 +535,7 @@
// all registered message queues.
TEST(ThreadManager, ProcessAllMessageQueues) {
rtc::AutoThread main_thread;
- Event entered_process_all_message_queues(true, false);
+ webrtc::Event entered_process_all_message_queues(true, false);
auto a = Thread::CreateWithSocketServer();
auto b = Thread::CreateWithSocketServer();
a->Start();
@@ -548,7 +548,7 @@
// of ProcessAllMessageQueues. The event is set by a message posted to
// the main thread, which is guaranteed to be handled inside
// ProcessAllMessageQueues.
- entered_process_all_message_queues.Wait(Event::kForever);
+ entered_process_all_message_queues.Wait(webrtc::Event::kForever);
messages_processed.fetch_add(1);
};
auto event_signaler = [&entered_process_all_message_queues] {
@@ -574,8 +574,8 @@
ThreadManager::ProcessAllMessageQueuesForTesting();
}
-void WaitAndSetEvent(Event* wait_event, Event* set_event) {
- wait_event->Wait(Event::kForever);
+void WaitAndSetEvent(webrtc::Event* wait_event, webrtc::Event* set_event) {
+ wait_event->Wait(webrtc::Event::kForever);
set_event->Set();
}
@@ -587,7 +587,8 @@
size_t move_count = 0;
};
- LifeCycleFunctor(Stats* stats, Event* event) : stats_(stats), event_(event) {}
+ LifeCycleFunctor(Stats* stats, webrtc::Event* event)
+ : stats_(stats), event_(event) {}
LifeCycleFunctor(const LifeCycleFunctor& other) { *this = other; }
LifeCycleFunctor(LifeCycleFunctor&& other) { *this = std::move(other); }
@@ -609,13 +610,15 @@
private:
Stats* stats_;
- Event* event_;
+ webrtc::Event* event_;
};
// A functor that verifies the thread it was destroyed on.
class DestructionFunctor {
public:
- DestructionFunctor(Thread* thread, bool* thread_was_current, Event* event)
+ DestructionFunctor(Thread* thread,
+ bool* thread_was_current,
+ webrtc::Event* event)
: thread_(thread),
thread_was_current_(thread_was_current),
event_(event) {}
@@ -634,7 +637,7 @@
private:
Thread* thread_;
bool* thread_was_current_;
- Event* event_;
+ webrtc::Event* event_;
bool was_invoked_ = false;
};
@@ -642,9 +645,9 @@
std::unique_ptr<rtc::Thread> background_thread(rtc::Thread::Create());
background_thread->Start();
- Event event;
+ webrtc::Event event;
background_thread->PostTask([&event] { event.Set(); });
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
}
TEST(ThreadPostTaskTest, InvokesWithCopiedFunctor) {
@@ -652,10 +655,10 @@
background_thread->Start();
LifeCycleFunctor::Stats stats;
- Event event;
+ webrtc::Event event;
LifeCycleFunctor functor(&stats, &event);
background_thread->PostTask(functor);
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
EXPECT_EQ(1u, stats.copy_count);
EXPECT_EQ(0u, stats.move_count);
@@ -666,10 +669,10 @@
background_thread->Start();
LifeCycleFunctor::Stats stats;
- Event event;
+ webrtc::Event event;
LifeCycleFunctor functor(&stats, &event);
background_thread->PostTask(std::move(functor));
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
EXPECT_EQ(0u, stats.copy_count);
EXPECT_EQ(1u, stats.move_count);
@@ -680,11 +683,11 @@
background_thread->Start();
LifeCycleFunctor::Stats stats;
- Event event;
+ webrtc::Event event;
LifeCycleFunctor functor(&stats, &event);
LifeCycleFunctor& functor_ref = functor;
background_thread->PostTask(functor_ref);
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
EXPECT_EQ(1u, stats.copy_count);
EXPECT_EQ(0u, stats.move_count);
@@ -694,12 +697,12 @@
std::unique_ptr<rtc::Thread> background_thread(rtc::Thread::Create());
background_thread->Start();
- Event event;
+ webrtc::Event event;
bool was_invoked_on_background_thread = false;
DestructionFunctor functor(background_thread.get(),
&was_invoked_on_background_thread, &event);
background_thread->PostTask(functor);
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
EXPECT_TRUE(was_invoked_on_background_thread);
}
@@ -708,12 +711,12 @@
std::unique_ptr<rtc::Thread> background_thread(rtc::Thread::Create());
background_thread->Start();
- Event event;
+ webrtc::Event event;
bool was_invoked_on_background_thread = false;
DestructionFunctor functor(background_thread.get(),
&was_invoked_on_background_thread, &event);
background_thread->PostTask(std::move(functor));
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
EXPECT_TRUE(was_invoked_on_background_thread);
}
@@ -723,13 +726,13 @@
std::unique_ptr<rtc::Thread> background_thread(rtc::Thread::Create());
background_thread->Start();
- Event event;
+ webrtc::Event event;
bool was_invoked_on_background_thread = false;
DestructionFunctor functor(background_thread.get(),
&was_invoked_on_background_thread, &event);
DestructionFunctor& functor_ref = functor;
background_thread->PostTask(functor_ref);
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
EXPECT_TRUE(was_invoked_on_background_thread);
}
@@ -738,7 +741,7 @@
std::unique_ptr<rtc::Thread> background_thread(rtc::Thread::Create());
background_thread->Start();
- Event event;
+ webrtc::Event event;
bool was_invoked_on_background_thread = false;
Thread* background_thread_ptr = background_thread.get();
background_thread->PostTask(
@@ -746,7 +749,7 @@
was_invoked_on_background_thread = background_thread_ptr->IsCurrent();
event.Set();
});
- event.Wait(Event::kForever);
+ event.Wait(webrtc::Event::kForever);
EXPECT_TRUE(was_invoked_on_background_thread);
}
@@ -757,24 +760,24 @@
// The first event ensures that SendSingleMessage() is not blocking this
// thread. The second event ensures that the message is processed.
- Event event_set_by_test_thread;
- Event event_set_by_background_thread;
+ webrtc::Event event_set_by_test_thread;
+ webrtc::Event event_set_by_background_thread;
background_thread->PostTask([&event_set_by_test_thread,
&event_set_by_background_thread] {
WaitAndSetEvent(&event_set_by_test_thread, &event_set_by_background_thread);
});
event_set_by_test_thread.Set();
- event_set_by_background_thread.Wait(Event::kForever);
+ event_set_by_background_thread.Wait(webrtc::Event::kForever);
}
TEST(ThreadPostTaskTest, InvokesInPostedOrder) {
std::unique_ptr<rtc::Thread> background_thread(rtc::Thread::Create());
background_thread->Start();
- Event first;
- Event second;
- Event third;
- Event fourth;
+ webrtc::Event first;
+ webrtc::Event second;
+ webrtc::Event third;
+ webrtc::Event fourth;
background_thread->PostTask(
[&first, &second] { WaitAndSetEvent(&first, &second); });
@@ -786,7 +789,7 @@
// All tasks have been posted before the first one is unblocked.
first.Set();
// Only if the chain is invoked in posted order will the last event be set.
- fourth.Wait(Event::kForever);
+ fourth.Wait(webrtc::Event::kForever);
}
TEST(ThreadPostDelayedTaskTest, InvokesAsynchronously) {
@@ -795,8 +798,8 @@
// The first event ensures that SendSingleMessage() is not blocking this
// thread. The second event ensures that the message is processed.
- Event event_set_by_test_thread;
- Event event_set_by_background_thread;
+ webrtc::Event event_set_by_test_thread;
+ webrtc::Event event_set_by_background_thread;
background_thread->PostDelayedTask(
[&event_set_by_test_thread, &event_set_by_background_thread] {
WaitAndSetEvent(&event_set_by_test_thread,
@@ -804,7 +807,7 @@
},
TimeDelta::Millis(10));
event_set_by_test_thread.Set();
- event_set_by_background_thread.Wait(Event::kForever);
+ event_set_by_background_thread.Wait(webrtc::Event::kForever);
}
TEST(ThreadPostDelayedTaskTest, InvokesInDelayOrder) {
@@ -812,10 +815,10 @@
std::unique_ptr<rtc::Thread> background_thread(rtc::Thread::Create());
background_thread->Start();
- Event first;
- Event second;
- Event third;
- Event fourth;
+ webrtc::Event first;
+ webrtc::Event second;
+ webrtc::Event third;
+ webrtc::Event fourth;
background_thread->PostDelayedTask(
[&third, &fourth] { WaitAndSetEvent(&third, &fourth); },
diff --git a/rtc_base/time_utils_unittest.cc b/rtc_base/time_utils_unittest.cc
index 6771f03..852ddf3 100644
--- a/rtc_base/time_utils_unittest.cc
+++ b/rtc_base/time_utils_unittest.cc
@@ -214,7 +214,7 @@
worker->Start();
// Post an event that won't be executed for 10 seconds.
- Event message_handler_dispatched;
+ webrtc::Event message_handler_dispatched;
worker->PostDelayedTask(
[&message_handler_dispatched] { message_handler_dispatched.Set(); },
TimeDelta::Seconds(60));
diff --git a/rtc_base/virtual_socket_server.h b/rtc_base/virtual_socket_server.h
index 6700238..d9ca16d 100644
--- a/rtc_base/virtual_socket_server.h
+++ b/rtc_base/virtual_socket_server.h
@@ -440,7 +440,7 @@
ThreadProcessingFakeClock* fake_clock_ = nullptr;
// Used to implement Wait/WakeUp.
- rtc::Event wakeup_;
+ Event wakeup_;
rtc::Thread* msg_queue_;
bool stop_on_idle_;
in_addr next_ipv4_;
diff --git a/rtc_tools/data_channel_benchmark/data_channel_benchmark.cc b/rtc_tools/data_channel_benchmark/data_channel_benchmark.cc
index 306cd91..4847f95 100644
--- a/rtc_tools/data_channel_benchmark/data_channel_benchmark.cc
+++ b/rtc_tools/data_channel_benchmark/data_channel_benchmark.cc
@@ -113,10 +113,12 @@
bool IsOkToCallOnTheNetworkThread() override { return true; }
- bool WaitForClosedState() { return closed_event_.Wait(rtc::Event::kForever); }
+ bool WaitForClosedState() {
+ return closed_event_.Wait(webrtc::Event::kForever);
+ }
bool WaitForSetupMessage() {
- return setup_message_event_.Wait(rtc::Event::kForever);
+ return setup_message_event_.Wait(webrtc::Event::kForever);
}
void StartSending() {
@@ -169,8 +171,8 @@
webrtc::DataChannelInterface* const dc_;
rtc::Thread* const signaling_thread_;
- rtc::Event closed_event_;
- rtc::Event setup_message_event_;
+ webrtc::Event closed_event_;
+ webrtc::Event setup_message_event_;
size_t remaining_data_ = 0u;
size_t total_queued_up_ = 0u;
struct SetupMessage setup_;
@@ -206,17 +208,17 @@
void OnBufferedAmountChange(uint64_t sent_data_size) override {}
bool IsOkToCallOnTheNetworkThread() override { return true; }
- bool WaitForOpenState() { return open_event_.Wait(rtc::Event::kForever); }
+ bool WaitForOpenState() { return open_event_.Wait(webrtc::Event::kForever); }
// Wait until the received byte count reaches the desired value.
bool WaitForBytesReceivedThreshold() {
- return bytes_received_event_.Wait(rtc::Event::kForever);
+ return bytes_received_event_.Wait(webrtc::Event::kForever);
}
private:
webrtc::DataChannelInterface* const dc_;
- rtc::Event open_event_;
- rtc::Event bytes_received_event_;
+ webrtc::Event open_event_;
+ webrtc::Event bytes_received_event_;
const uint64_t bytes_received_threshold_;
uint64_t bytes_received_ = 0u;
};
@@ -309,7 +311,7 @@
// Set up the callback to receive the data channel from the sender.
rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel;
- rtc::Event got_data_channel;
+ webrtc::Event got_data_channel;
client.SetOnDataChannel(
[&](rtc::scoped_refptr<webrtc::DataChannelInterface> channel) {
data_channel = std::move(channel);
@@ -327,7 +329,7 @@
}
// Wait for the data channel to be received
- got_data_channel.Wait(rtc::Event::kForever);
+ got_data_channel.Wait(webrtc::Event::kForever);
absl::Cleanup unregister_observer(
[data_channel] { data_channel->UnregisterObserver(); });
diff --git a/rtc_tools/video_replay.cc b/rtc_tools/video_replay.cc
index b189bef..18719d8 100644
--- a/rtc_tools/video_replay.cc
+++ b/rtc_tools/video_replay.cc
@@ -495,7 +495,7 @@
rtp_reader_(CreateRtpReader(rtp_dump_path_)) {
worker_thread_ = env_.task_queue_factory().CreateTaskQueue(
"worker_thread", TaskQueueFactory::Priority::NORMAL);
- rtc::Event event;
+ Event event;
worker_thread_->PostTask([&]() {
call_ = Call::Create(CallConfig(env_));
@@ -517,7 +517,7 @@
~RtpReplayer() {
// Destruction of streams and the call must happen on the same thread as
// their creation.
- rtc::Event event;
+ Event event;
worker_thread_->PostTask([&]() {
for (const auto& receive_stream : stream_state_->receive_streams) {
call_->DestroyVideoReceiveStream(receive_stream);
@@ -532,7 +532,7 @@
}
void Run() {
- rtc::Event event;
+ Event event;
worker_thread_->PostTask([&]() {
// Start replaying the provided stream now that it has been configured.
// VideoReceiveStreams must be started on the same thread as they were
@@ -582,7 +582,7 @@
int64_t replay_start_ms = -1;
int num_packets = 0;
std::map<uint32_t, int> unknown_packets;
- rtc::Event event(/*manual_reset=*/false, /*initially_signalled=*/false);
+ Event event(/*manual_reset=*/false, /*initially_signalled=*/false);
uint32_t start_timestamp = absl::GetFlag(FLAGS_start_timestamp);
uint32_t stop_timestamp = absl::GetFlag(FLAGS_stop_timestamp);
diff --git a/test/network/fake_network_socket_server.h b/test/network/fake_network_socket_server.h
index dbc6bb1..a07c45d 100644
--- a/test/network/fake_network_socket_server.h
+++ b/test/network/fake_network_socket_server.h
@@ -49,7 +49,7 @@
private:
const EndpointsContainer* endpoints_container_;
- rtc::Event wakeup_;
+ Event wakeup_;
rtc::Thread* thread_ = nullptr;
Mutex lock_;
diff --git a/test/pc/e2e/network_quality_metrics_reporter.cc b/test/pc/e2e/network_quality_metrics_reporter.cc
index 3c4f6ca..9a986a7 100644
--- a/test/pc/e2e/network_quality_metrics_reporter.cc
+++ b/test/pc/e2e/network_quality_metrics_reporter.cc
@@ -110,7 +110,7 @@
EmulatedNetworkStats NetworkQualityMetricsReporter::PopulateStats(
EmulatedNetworkManagerInterface* network) {
- rtc::Event wait;
+ Event wait;
EmulatedNetworkStats stats;
network->GetStats([&](EmulatedNetworkStats s) {
stats = std::move(s);
diff --git a/test/pc/e2e/stats_based_network_quality_metrics_reporter.cc b/test/pc/e2e/stats_based_network_quality_metrics_reporter.cc
index d4af187..1c2fa63 100644
--- a/test/pc/e2e/stats_based_network_quality_metrics_reporter.cc
+++ b/test/pc/e2e/stats_based_network_quality_metrics_reporter.cc
@@ -53,7 +53,7 @@
EmulatedNetworkStats PopulateStats(std::vector<EmulatedEndpoint*> endpoints,
NetworkEmulationManager* network_emulation) {
- rtc::Event stats_loaded;
+ Event stats_loaded;
EmulatedNetworkStats stats;
network_emulation->GetStats(endpoints, [&](EmulatedNetworkStats s) {
stats = std::move(s);
@@ -149,7 +149,7 @@
std::map<std::string, NetworkLayerStats> n_stats_
RTC_GUARDED_BY(sequence_checker_);
- rtc::Event all_stats_collected_;
+ Event all_stats_collected_;
Mutex mutex_;
std::map<std::string, NetworkLayerStats> stats_ RTC_GUARDED_BY(mutex_);
bool stats_released_ = false;
diff --git a/test/rtp_rtcp_observer.h b/test/rtp_rtcp_observer.h
index 14c5ce3..0db14e8 100644
--- a/test/rtp_rtcp_observer.h
+++ b/test/rtp_rtcp_observer.h
@@ -70,7 +70,7 @@
RtpRtcpObserver() : RtpRtcpObserver(TimeDelta::Zero()) {}
explicit RtpRtcpObserver(TimeDelta event_timeout) : timeout_(event_timeout) {}
- rtc::Event observation_complete_;
+ Event observation_complete_;
private:
const TimeDelta timeout_;
diff --git a/test/scenario/call_client.cc b/test/scenario/call_client.cc
index b58ae71..60f0bf3 100644
--- a/test/scenario/call_client.cc
+++ b/test/scenario/call_client.cc
@@ -236,9 +236,9 @@
SendTask([&] {
call_.reset();
fake_audio_setup_ = {};
- rtc::Event done;
+ Event done;
env_.event_log().StopLogging([&done] { done.Set(); });
- done.Wait(rtc::Event::kForever);
+ done.Wait(Event::kForever);
});
}
diff --git a/test/scenario/network_node.cc b/test/scenario/network_node.cc
index 0f174c7..b2b4f00 100644
--- a/test/scenario/network_node.cc
+++ b/test/scenario/network_node.cc
@@ -147,7 +147,7 @@
}
// Must be called from the worker thread.
- rtc::Event event;
+ Event event;
auto cleanup = absl::MakeCleanup([&event] { event.Set(); });
auto&& task = [this, &route, cleanup = std::move(cleanup)] {
sender_call_->GetTransportControllerSend()->OnNetworkRouteChanged(
diff --git a/test/testsupport/ivf_video_frame_generator.h b/test/testsupport/ivf_video_frame_generator.h
index 1423ac8..cb0b97f 100644
--- a/test/testsupport/ivf_video_frame_generator.h
+++ b/test/testsupport/ivf_video_frame_generator.h
@@ -90,7 +90,7 @@
// frame was sent to decoder and decoder callback was invoked.
Mutex frame_decode_lock_;
- rtc::Event next_frame_decoded_;
+ Event next_frame_decoded_;
std::optional<VideoFrame> next_frame_ RTC_GUARDED_BY(frame_decode_lock_);
};
diff --git a/test/testsupport/ivf_video_frame_generator_unittest.cc b/test/testsupport/ivf_video_frame_generator_unittest.cc
index 100b47e..731fc9a 100644
--- a/test/testsupport/ivf_video_frame_generator_unittest.cc
+++ b/test/testsupport/ivf_video_frame_generator_unittest.cc
@@ -95,7 +95,7 @@
Mutex lock_;
int received_frames_count_ RTC_GUARDED_BY(lock_) = 0;
- rtc::Event expected_frames_count_received_;
+ Event expected_frames_count_received_;
};
class IvfVideoFrameGeneratorTest : public ::testing::Test {
diff --git a/test/time_controller/simulated_time_controller_unittest.cc b/test/time_controller/simulated_time_controller_unittest.cc
index c1c0ac2..10d741b 100644
--- a/test/time_controller/simulated_time_controller_unittest.cc
+++ b/test/time_controller/simulated_time_controller_unittest.cc
@@ -134,7 +134,7 @@
// called.
main_thread->PostTask([&] { task_has_run = true; });
SendTask(t2.get(), [] {
- rtc::Event yield_event;
+ Event yield_event;
// Wait() triggers YieldExecution() which will runs message processing on
// all threads that are not in the yielded set.
diff --git a/test/time_controller/time_controller_conformance_test.cc b/test/time_controller/time_controller_conformance_test.cc
index 300dd91..f5734e1 100644
--- a/test/time_controller/time_controller_conformance_test.cc
+++ b/test/time_controller/time_controller_conformance_test.cc
@@ -158,7 +158,7 @@
// Tasks on thread have to be executed in order in which they were
// posted/invoked.
ExecutionOrderKeeper execution_order;
- rtc::Event event;
+ Event event;
task_queue->PostTask([&]() { execution_order.Executed(1); });
task_queue->PostTask([&]() {
execution_order.Executed(2);
diff --git a/test/video_codec_tester.cc b/test/video_codec_tester.cc
index b79031d..295d7f7 100644
--- a/test/video_codec_tester.cc
+++ b/test/video_codec_tester.cc
@@ -263,7 +263,7 @@
private:
TaskQueueForTest task_queue_;
std::atomic_int queue_size_;
- rtc::Event task_executed_;
+ Event task_executed_;
Mutex mutex_;
};
diff --git a/video/adaptation/overuse_frame_detector_unittest.cc b/video/adaptation/overuse_frame_detector_unittest.cc
index 92554db..ca6e318 100644
--- a/video/adaptation/overuse_frame_detector_unittest.cc
+++ b/video/adaptation/overuse_frame_detector_unittest.cc
@@ -435,7 +435,7 @@
overuse_detector_->StartCheckForOveruse(queue.Get(), options_, observer_);
});
- rtc::Event event;
+ Event event;
// Expect NormalUsage(). When called, stop the `overuse_detector_` and then
// set `event` to end the test.
EXPECT_CALL(mock_observer_, AdaptUp())
@@ -917,7 +917,7 @@
overuse_detector_->StartCheckForOveruse(queue.Get(), options_, observer_);
});
- rtc::Event event;
+ Event event;
// Expect NormalUsage(). When called, stop the `overuse_detector_` and then
// set `event` to end the test.
EXPECT_CALL(mock_observer_, AdaptUp())
diff --git a/video/end_to_end_tests/call_operation_tests.cc b/video/end_to_end_tests/call_operation_tests.cc
index f99565d..d728022 100644
--- a/video/end_to_end_tests/call_operation_tests.cc
+++ b/video/end_to_end_tests/call_operation_tests.cc
@@ -93,7 +93,7 @@
return event_.Wait(test::VideoTestConstants::kDefaultTimeout);
}
- rtc::Event event_;
+ Event event_;
} renderer;
test::FrameForwarder frame_forwarder;
@@ -149,7 +149,7 @@
return event_.Wait(test::VideoTestConstants::kDefaultTimeout);
}
- rtc::Event event_;
+ Event event_;
} renderer;
std::unique_ptr<test::FrameGeneratorInterface> frame_generator;
diff --git a/video/end_to_end_tests/multi_stream_tests.cc b/video/end_to_end_tests/multi_stream_tests.cc
index b997538..cdf5269 100644
--- a/video/end_to_end_tests/multi_stream_tests.cc
+++ b/video/end_to_end_tests/multi_stream_tests.cc
@@ -51,7 +51,7 @@
const MultiStreamTester::CodecSettings& settings_;
const uint32_t ssrc_;
test::FrameGeneratorCapturer** const frame_generator_;
- rtc::Event done_;
+ Event done_;
};
class Tester : public MultiStreamTester {
diff --git a/video/end_to_end_tests/network_state_tests.cc b/video/end_to_end_tests/network_state_tests.cc
index c0532a3..579abb6 100644
--- a/video/end_to_end_tests/network_state_tests.cc
+++ b/video/end_to_end_tests/network_state_tests.cc
@@ -348,8 +348,8 @@
TaskQueueBase* const e2e_test_task_queue_;
std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue_;
Mutex test_mutex_;
- rtc::Event encoded_frames_;
- rtc::Event packet_event_;
+ Event encoded_frames_;
+ Event packet_event_;
Call* sender_call_;
Call* receiver_call_;
test::VideoEncoderProxyFactory encoder_factory_;
diff --git a/video/end_to_end_tests/retransmission_tests.cc b/video/end_to_end_tests/retransmission_tests.cc
index afcd8b9..a6bd5ca 100644
--- a/video/end_to_end_tests/retransmission_tests.cc
+++ b/video/end_to_end_tests/retransmission_tests.cc
@@ -233,7 +233,7 @@
void PerformTest() override {
start_time_ = clock_->TimeInMilliseconds();
task_queue_->PostTask([this] { Run(); });
- test_done_.Wait(rtc::Event::kForever);
+ test_done_.Wait(Event::kForever);
}
void Run() {
@@ -261,7 +261,7 @@
VideoSendStream* send_stream_;
VideoReceiveStreamInterface* receive_stream_;
TaskQueueBase* const task_queue_;
- rtc::Event test_done_;
+ Event test_done_;
bool frame_decoded_ = false;
int64_t start_time_ = 0;
} test(task_queue());
diff --git a/video/end_to_end_tests/ssrc_tests.cc b/video/end_to_end_tests/ssrc_tests.cc
index 9ffedd6..eedf5f3 100644
--- a/video/end_to_end_tests/ssrc_tests.cc
+++ b/video/end_to_end_tests/ssrc_tests.cc
@@ -88,7 +88,7 @@
void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override {}
PacketReceiver* receiver_;
- rtc::Event undemuxable_packet_handler_triggered_;
+ Event undemuxable_packet_handler_triggered_;
};
std::unique_ptr<test::DirectTransport> send_transport;
diff --git a/video/end_to_end_tests/stats_tests.cc b/video/end_to_end_tests/stats_tests.cc
index c16bf4f..24a395d 100644
--- a/video/end_to_end_tests/stats_tests.cc
+++ b/video/end_to_end_tests/stats_tests.cc
@@ -356,7 +356,7 @@
std::vector<uint32_t> expected_receive_ssrcs_;
std::set<uint32_t> expected_send_ssrcs_;
- rtc::Event check_stats_event_;
+ Event check_stats_event_;
TaskQueueBase* task_queue_ = nullptr;
} test;
diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc
index 5231af0..11b0c2d 100644
--- a/video/end_to_end_tests/transport_feedback_tests.cc
+++ b/video/end_to_end_tests/transport_feedback_tests.cc
@@ -157,7 +157,7 @@
private:
Mutex lock_;
- rtc::Event done_;
+ Event done_;
RtpHeaderExtensionMap extensions_;
RtpSequenceNumberUnwrapper unwrapper_;
std::set<int64_t> received_packed_ids_;
diff --git a/video/frame_cadence_adapter_unittest.cc b/video/frame_cadence_adapter_unittest.cc
index a8b698d..f3e8354 100644
--- a/video/frame_cadence_adapter_unittest.cc
+++ b/video/frame_cadence_adapter_unittest.cc
@@ -639,12 +639,12 @@
time_controller.AdvanceTime(TimeDelta::Millis(1));
Mock::VerifyAndClearExpectations(&callback);
- rtc::Event finalized;
+ Event finalized;
queue->PostTask([&] {
adapter = nullptr;
finalized.Set();
});
- finalized.Wait(rtc::Event::kForever);
+ finalized.Wait(Event::kForever);
}
TEST(FrameCadenceAdapterTest, ShutdownUnderMetronome) {
@@ -1056,7 +1056,7 @@
int frame_counter = 0;
int64_t original_ntp_time_ms;
int64_t original_timestamp_us;
- rtc::Event event;
+ Event event;
test::ScopedKeyValueConfig no_field_trials;
queue->PostTask([&] {
adapter = CreateAdapter(no_field_trials, clock);
@@ -1087,13 +1087,13 @@
}));
adapter->OnFrame(frame);
});
- event.Wait(rtc::Event::kForever);
- rtc::Event finalized;
+ event.Wait(Event::kForever);
+ Event finalized;
queue->PostTask([&] {
adapter = nullptr;
finalized.Set();
});
- finalized.Wait(rtc::Event::kForever);
+ finalized.Wait(Event::kForever);
}
TEST(FrameCadenceAdapterRealTimeTest, ScheduledRepeatAllowsForSlowEncode) {
@@ -1110,7 +1110,7 @@
Clock* clock = Clock::GetRealTimeClock();
std::unique_ptr<FrameCadenceAdapterInterface> adapter;
int frame_counter = 0;
- rtc::Event event;
+ Event event;
std::optional<Timestamp> start_time;
test::ScopedKeyValueConfig no_field_trials;
queue->PostTask([&] {
@@ -1140,13 +1140,13 @@
}));
adapter->OnFrame(frame);
});
- event.Wait(rtc::Event::kForever);
- rtc::Event finalized;
+ event.Wait(Event::kForever);
+ Event finalized;
queue->PostTask([&] {
adapter = nullptr;
finalized.Set();
});
- finalized.Wait(rtc::Event::kForever);
+ finalized.Wait(Event::kForever);
}
class ZeroHertzQueueOverloadTest : public ::testing::Test {
diff --git a/video/video_analyzer.h b/video/video_analyzer.h
index ee0cda9..cbe1a4f 100644
--- a/video/video_analyzer.h
+++ b/video/video_analyzer.h
@@ -304,10 +304,10 @@
bool is_quick_test_enabled_;
std::vector<rtc::PlatformThread> comparison_thread_pool_;
- rtc::Event comparison_available_event_;
+ Event comparison_available_event_;
std::deque<FrameComparison> comparisons_ RTC_GUARDED_BY(comparison_lock_);
bool quit_ RTC_GUARDED_BY(comparison_lock_);
- rtc::Event done_;
+ Event done_;
std::unique_ptr<VideoRtpDepacketizer> vp8_depacketizer_;
std::unique_ptr<VideoRtpDepacketizer> vp9_depacketizer_;
diff --git a/video/video_receive_stream2.cc b/video/video_receive_stream2.cc
index 9fb2caf..645f3cf 100644
--- a/video/video_receive_stream2.cc
+++ b/video/video_receive_stream2.cc
@@ -410,7 +410,7 @@
call_stats_->DeregisterStatsObserver(this);
if (decoder_running_) {
- rtc::Event done;
+ Event done;
decode_queue_->PostTask([this, &done] {
RTC_DCHECK_RUN_ON(&decode_sequence_checker_);
// Set `decoder_stopped_` before deregistering all decoders. This means
@@ -422,7 +422,7 @@
}
done.Set();
});
- done.Wait(rtc::Event::kForever);
+ done.Wait(Event::kForever);
decoder_running_ = false;
stats_proxy_.DecoderThreadStopped();
@@ -1098,7 +1098,7 @@
VideoReceiveStream2::SetAndGetRecordingState(RecordingState state,
bool generate_key_frame) {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
- rtc::Event event;
+ Event event;
// Save old state, set the new state.
RecordingState old_state;
@@ -1136,7 +1136,7 @@
}
}
- event.Wait(rtc::Event::kForever);
+ event.Wait(Event::kForever);
return old_state;
}
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 63ccdf6..16ca54f 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -2132,7 +2132,7 @@
}
Mutex mutex_;
- rtc::Event init_encode_called_;
+ Event init_encode_called_;
int last_initialized_frame_width_ RTC_GUARDED_BY(&mutex_);
int last_initialized_frame_height_ RTC_GUARDED_BY(&mutex_);
};
@@ -2202,7 +2202,7 @@
private:
mutable Mutex mutex_;
- rtc::Event start_bitrate_changed_;
+ Event start_bitrate_changed_;
int start_bitrate_kbps_ RTC_GUARDED_BY(mutex_);
};
@@ -2468,7 +2468,7 @@
T encoder_settings_;
const VideoCodecType video_codec_type_;
- rtc::Event init_encode_event_;
+ Event init_encode_event_;
VideoSendStream* stream_;
test::VideoEncoderProxyFactory encoder_factory_;
VideoEncoderConfig encoder_config_;
@@ -2910,9 +2910,9 @@
}
TaskQueueBase* const task_queue_;
- rtc::Event create_rate_allocator_event_;
- rtc::Event init_encode_event_;
- rtc::Event bitrate_changed_event_;
+ Event create_rate_allocator_event_;
+ Event init_encode_event_;
+ Event bitrate_changed_event_;
Mutex mutex_;
uint32_t target_bitrate_ RTC_GUARDED_BY(&mutex_);
@@ -3822,7 +3822,7 @@
Mutex mutex_;
uint32_t max_bitrate_bps_ RTC_GUARDED_BY(&mutex_);
bool first_packet_sent_ RTC_GUARDED_BY(&mutex_);
- rtc::Event bitrate_changed_event_;
+ Event bitrate_changed_event_;
} test(env(), task_queue());
RunBaseTest(&test);
}
@@ -4040,7 +4040,7 @@
}
Mutex mutex_;
- rtc::Event content_switch_event_;
+ Event content_switch_event_;
Call* call_;
bool done_ RTC_GUARDED_BY(mutex_) = false;
StreamState state_ RTC_GUARDED_BY(mutex_);
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index c41b486..79514ed 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -762,7 +762,7 @@
RTC_DCHECK_RUN_ON(worker_queue_);
video_source_sink_controller_.SetSource(nullptr);
- rtc::Event shutdown_event;
+ Event shutdown_event;
absl::Cleanup shutdown = [&shutdown_event] { shutdown_event.Set(); };
encoder_queue_->PostTask([this, shutdown = std::move(shutdown)] {
RTC_DCHECK_RUN_ON(encoder_queue_.get());
@@ -792,7 +792,7 @@
frame_cadence_adapter_ = nullptr;
frame_instrumentation_generator_ = nullptr;
});
- shutdown_event.Wait(rtc::Event::kForever);
+ shutdown_event.Wait(Event::kForever);
}
void VideoStreamEncoder::SetFecControllerOverride(
@@ -832,14 +832,14 @@
// run on the encoder queue. So rather than force PostTask() operations to
// be accompanied by an event and a `Wait()`, we'll use PostTask + Wait()
// here.
- rtc::Event event;
+ Event event;
std::vector<rtc::scoped_refptr<Resource>> resources;
encoder_queue_->PostTask([&] {
RTC_DCHECK_RUN_ON(encoder_queue_.get());
resources = resource_adaptation_processor_->GetResources();
event.Set();
});
- event.Wait(rtc::Event::kForever);
+ event.Wait(Event::kForever);
return resources;
}
@@ -2546,7 +2546,7 @@
void VideoStreamEncoder::InjectAdaptationConstraint(
AdaptationConstraint* adaptation_constraint) {
- rtc::Event event;
+ Event event;
encoder_queue_->PostTask([this, adaptation_constraint, &event] {
RTC_DCHECK_RUN_ON(encoder_queue_.get());
if (!resource_adaptation_processor_) {
@@ -2558,31 +2558,31 @@
video_stream_adapter_->AddAdaptationConstraint(adaptation_constraint);
event.Set();
});
- event.Wait(rtc::Event::kForever);
+ event.Wait(Event::kForever);
}
void VideoStreamEncoder::AddRestrictionsListenerForTesting(
VideoSourceRestrictionsListener* restrictions_listener) {
- rtc::Event event;
+ Event event;
encoder_queue_->PostTask([this, restrictions_listener, &event] {
RTC_DCHECK_RUN_ON(encoder_queue_.get());
RTC_DCHECK(resource_adaptation_processor_);
video_stream_adapter_->AddRestrictionsListener(restrictions_listener);
event.Set();
});
- event.Wait(rtc::Event::kForever);
+ event.Wait(Event::kForever);
}
void VideoStreamEncoder::RemoveRestrictionsListenerForTesting(
VideoSourceRestrictionsListener* restrictions_listener) {
- rtc::Event event;
+ Event event;
encoder_queue_->PostTask([this, restrictions_listener, &event] {
RTC_DCHECK_RUN_ON(encoder_queue_.get());
RTC_DCHECK(resource_adaptation_processor_);
video_stream_adapter_->RemoveRestrictionsListener(restrictions_listener);
event.Set();
});
- event.Wait(rtc::Event::kForever);
+ event.Wait(Event::kForever);
}
// RTC_RUN_ON(&encoder_queue_)
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index a070c51..d08d7d8 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -196,7 +196,7 @@
class TestBuffer : public webrtc::I420Buffer {
public:
- TestBuffer(rtc::Event* event, int width, int height)
+ TestBuffer(Event* event, int width, int height)
: I420Buffer(width, height), event_(event) {}
private:
@@ -205,14 +205,14 @@
if (event_)
event_->Set();
}
- rtc::Event* const event_;
+ Event* const event_;
};
// A fake native buffer that can't be converted to I420. Upon scaling, it
// produces another FakeNativeBuffer.
class FakeNativeBuffer : public webrtc::VideoFrameBuffer {
public:
- FakeNativeBuffer(rtc::Event* event, int width, int height)
+ FakeNativeBuffer(Event* event, int width, int height)
: event_(event), width_(width), height_(height) {}
webrtc::VideoFrameBuffer::Type type() const override { return Type::kNative; }
int width() const override { return width_; }
@@ -237,7 +237,7 @@
if (event_)
event_->Set();
}
- rtc::Event* const event_;
+ Event* const event_;
const int width_;
const int height_;
};
@@ -245,7 +245,7 @@
// A fake native buffer that is backed by an NV12 buffer.
class FakeNV12NativeBuffer : public webrtc::VideoFrameBuffer {
public:
- FakeNV12NativeBuffer(rtc::Event* event, int width, int height)
+ FakeNV12NativeBuffer(Event* event, int width, int height)
: nv12_buffer_(NV12Buffer::Create(width, height)), event_(event) {}
webrtc::VideoFrameBuffer::Type type() const override { return Type::kNative; }
@@ -270,7 +270,7 @@
event_->Set();
}
rtc::scoped_refptr<NV12Buffer> nv12_buffer_;
- rtc::Event* const event_;
+ Event* const event_;
};
class CpuOveruseDetectorProxy : public OveruseFrameDetector {
@@ -297,12 +297,12 @@
CpuOveruseOptions GetOptions() { return options_; }
- rtc::Event* framerate_updated_event() { return &framerate_updated_event_; }
+ Event* framerate_updated_event() { return &framerate_updated_event_; }
private:
Mutex lock_;
int last_target_framerate_fps_ RTC_GUARDED_BY(lock_);
- rtc::Event framerate_updated_event_;
+ Event framerate_updated_event_;
};
class FakeVideoSourceRestrictionsListener
@@ -314,9 +314,7 @@
RTC_DCHECK(was_restrictions_updated_);
}
- rtc::Event* restrictions_updated_event() {
- return &restrictions_updated_event_;
- }
+ Event* restrictions_updated_event() { return &restrictions_updated_event_; }
// VideoSourceRestrictionsListener implementation.
void OnVideoSourceRestrictionsUpdated(
@@ -330,7 +328,7 @@
private:
bool was_restrictions_updated_;
- rtc::Event restrictions_updated_event_;
+ Event restrictions_updated_event_;
};
auto WantsFps(Matcher<int> fps_matcher) {
@@ -509,7 +507,7 @@
// Triggers resource usage measurements on the fake CPU resource.
void TriggerCpuOveruse() {
- rtc::Event event;
+ Event event;
encoder_queue()->PostTask([this, &event] {
fake_cpu_resource_->SetUsageState(ResourceUsageState::kOveruse);
event.Set();
@@ -519,7 +517,7 @@
}
void TriggerCpuUnderuse() {
- rtc::Event event;
+ Event event;
encoder_queue()->PostTask([this, &event] {
fake_cpu_resource_->SetUsageState(ResourceUsageState::kUnderuse);
event.Set();
@@ -530,7 +528,7 @@
// Triggers resource usage measurements on the fake quality resource.
void TriggerQualityLow() {
- rtc::Event event;
+ Event event;
encoder_queue()->PostTask([this, &event] {
fake_quality_resource_->SetUsageState(ResourceUsageState::kOveruse);
event.Set();
@@ -539,7 +537,7 @@
time_controller_->AdvanceTime(TimeDelta::Zero());
}
void TriggerQualityHigh() {
- rtc::Event event;
+ Event event;
encoder_queue()->PostTask([this, &event] {
fake_quality_resource_->SetUsageState(ResourceUsageState::kUnderuse);
event.Set();
@@ -1003,8 +1001,7 @@
num_cores);
}
- VideoFrame CreateFrame(int64_t ntp_time_ms,
- rtc::Event* destruction_event) const {
+ VideoFrame CreateFrame(int64_t ntp_time_ms, Event* destruction_event) const {
return VideoFrame::Builder()
.set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>(
destruction_event, codec_width_, codec_height_))
@@ -1015,7 +1012,7 @@
}
VideoFrame CreateFrameWithUpdatedPixel(int64_t ntp_time_ms,
- rtc::Event* destruction_event,
+ Event* destruction_event,
int offset_x) const {
return VideoFrame::Builder()
.set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>(
@@ -1048,7 +1045,7 @@
}
VideoFrame CreateFakeNativeFrame(int64_t ntp_time_ms,
- rtc::Event* destruction_event,
+ Event* destruction_event,
int width,
int height) const {
return VideoFrame::Builder()
@@ -1061,7 +1058,7 @@
}
VideoFrame CreateFakeNV12NativeFrame(int64_t ntp_time_ms,
- rtc::Event* destruction_event,
+ Event* destruction_event,
int width,
int height) const {
return VideoFrame::Builder()
@@ -1074,7 +1071,7 @@
}
VideoFrame CreateFakeNativeFrame(int64_t ntp_time_ms,
- rtc::Event* destruction_event) const {
+ Event* destruction_event) const {
return CreateFakeNativeFrame(ntp_time_ms, destruction_event, codec_width_,
codec_height_);
}
@@ -1406,7 +1403,7 @@
kInitializationFailed,
kInitialized
} initialized_ RTC_GUARDED_BY(local_mutex_) = EncoderState::kUninitialized;
- rtc::Event continue_encode_event_;
+ Event continue_encode_event_;
uint32_t timestamp_ RTC_GUARDED_BY(local_mutex_) = 0;
int64_t ntp_time_ms_ RTC_GUARDED_BY(local_mutex_) = 0;
int last_input_width_ RTC_GUARDED_BY(local_mutex_) = 0;
@@ -1651,7 +1648,7 @@
TimeController* const time_controller_;
mutable Mutex mutex_;
TestEncoder* test_encoder_;
- rtc::Event encoded_frame_event_;
+ Event encoded_frame_event_;
EncodedImage last_encoded_image_;
std::vector<uint8_t> last_encoded_image_data_;
uint32_t last_timestamp_ = 0;
@@ -1731,7 +1728,7 @@
TEST_F(VideoStreamEncoderTest, EncodeOneFrame) {
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
WaitForEncodedFrame(1);
EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeout));
@@ -1770,7 +1767,7 @@
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
kLowRate, kLowRate, kLowRate, 0, 0, 0);
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
// Insert two frames, so that the first one isn't stored in the encoder queue.
video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
video_source_.IncomingCapturedFrame(CreateFrame(34, /*event=*/nullptr));
@@ -1871,7 +1868,7 @@
TEST_F(VideoStreamEncoderTest, DropsFramesBeforeFirstOnBitrateUpdated) {
// Dropped since no target bitrate has been set.
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
// The encoder will cache up to one frame for a short duration. Adding two
// frames means that the first frame will be dropped and the second frame will
// be sent when the encoder is enabled.
@@ -1947,7 +1944,7 @@
video_stream_encoder_->Stop();
sink_.SetExpectNoFrames();
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFrame(2, &frame_destroyed_event));
EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeout));
}
@@ -1976,7 +1973,7 @@
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(
CreateFakeNativeFrame(1, &frame_destroyed_event));
WaitForEncodedFrame(1);
@@ -2008,7 +2005,7 @@
// Now send in a fake frame that needs to be cropped as the width/height
// aren't divisible by 4 (see CreateEncoderStreams above).
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFakeNativeFrame(
2, &frame_destroyed_event, codec_width_ + 1, codec_height_ + 1));
WaitForEncodedFrame(2);
@@ -2037,7 +2034,7 @@
fake_encoder_.SetPreferredPixelFormats({});
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame(
1, &frame_destroyed_event, codec_width_, codec_height_));
WaitForEncodedFrame(1);
@@ -2053,7 +2050,7 @@
fake_encoder_.SetPreferredPixelFormats({VideoFrameBuffer::Type::kNV12});
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame(
1, &frame_destroyed_event, codec_width_, codec_height_));
WaitForEncodedFrame(1);
@@ -2069,7 +2066,7 @@
// Fake NV12 native frame does not allow mapping to I444.
fake_encoder_.SetPreferredPixelFormats({VideoFrameBuffer::Type::kI444});
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame(
1, &frame_destroyed_event, codec_width_, codec_height_));
WaitForEncodedFrame(1);
@@ -2082,7 +2079,7 @@
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame(
1, &frame_destroyed_event, codec_width_, codec_height_));
WaitForEncodedFrame(1);
@@ -8218,7 +8215,7 @@
ON_CALL(encoder_selector, OnEncoderBroken)
.WillByDefault(Return(SdpVideoFormat("AV2")));
- rtc::Event encode_attempted;
+ Event encode_attempted;
EXPECT_CALL(switch_callback,
RequestEncoderSwitch(Field(&SdpVideoFormat::name, "AV2"),
/*allow_default_fallback=*/true))
@@ -8262,7 +8259,7 @@
ON_CALL(encoder_selector, OnEncoderBroken)
.WillByDefault(Return(SdpVideoFormat("AV2")));
- rtc::Event encode_attempted;
+ Event encode_attempted;
EXPECT_CALL(switch_callback,
RequestEncoderSwitch(Field(&SdpVideoFormat::name, "AV2"),
/*allow_default_fallback=*/true))
@@ -8304,7 +8301,7 @@
ON_CALL(video_encoder, InitEncode(_, _))
.WillByDefault(Return(WEBRTC_VIDEO_CODEC_ENCODER_FAILURE));
- rtc::Event encode_attempted;
+ Event encode_attempted;
EXPECT_CALL(switch_callback, RequestEncoderFallback())
.WillOnce([&encode_attempted]() { encode_attempted.Set(); });
@@ -8353,7 +8350,7 @@
/*cwnd_reduce_ratio=*/0);
ON_CALL(encoder_selector, OnEncoderBroken)
.WillByDefault(Return(SdpVideoFormat("AV2")));
- rtc::Event encode_attempted;
+ Event encode_attempted;
EXPECT_CALL(switch_callback,
RequestEncoderSwitch(Field(&SdpVideoFormat::name, "AV2"),
/*allow_default_fallback=*/_))
@@ -9283,7 +9280,7 @@
RequestsRefreshFrameAfterEarlyDroppedNativeFrame) {
// Send a native frame before encoder rates have been set. The encoder is
// seen as paused at this time.
- rtc::Event frame_destroyed_event;
+ Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFakeNativeFrame(
/*ntp_time_ms=*/1, &frame_destroyed_event, codec_width_, codec_height_));
