admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add default constructor for rtc::Event

Browse Source 
Bug: webrtc:9962
Change-Id: Icaa91e657e6881fcb1553f354c07866109a0ea68
Reviewed-on: https://webrtc-review.googlesource.com/c/109500
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25535}
This commit is contained in:
Niels Möller 2018-11-07 08:43:50 +01:00 committed by Commit Bot
parent 3ea7b83fa3
commit c572ff3c71
64 changed files with 147 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/proxy.cc
View File

@ -23,7 +23,7 @@ void SynchronousMethodCall::Invoke(const rtc::Location& posted_from,
if (t->IsCurrent()) {
proxy_->OnMessage(nullptr);
} else {
e_.reset(new rtc::Event(false, false));
e_ = absl::make_unique<rtc::Event>();
t->Post(posted_from, this, 0);
e_->Wait(rtc::Event::kForever);
}

4
audio/audio_send_stream.cc
View File

@ -803,7 +803,7 @@ void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps,
bool has_packet_feedback) {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
RTC_DCHECK_GE(max_bitrate_bps, min_bitrate_bps);
rtc::Event thread_sync_event(false /* manual_reset */, false);
rtc::Event thread_sync_event;
worker_queue_->PostTask([&] {
// We may get a callback immediately as the observer is registered, so make
// sure the bitrate limits in config_ are up-to-date.
@ -823,7 +823,7 @@ void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps,
void AudioSendStream::RemoveBitrateObserver() {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
rtc::Event thread_sync_event(false /* manual_reset */, false);
rtc::Event thread_sync_event;
worker_queue_->PostTask([this, &thread_sync_event] {
bitrate_allocator_->RemoveObserver(this);
thread_sync_event.Set();

2
audio/channel_send.cc
View File

@ -595,7 +595,7 @@ void ChannelSend::StopSend() {
// to acccess and invalid channel object.
RTC_DCHECK(encoder_queue_);
rtc::Event flush(false, false);
rtc::Event flush;
{
// Clear |encoder_queue_is_active_| under lock to prevent any other tasks
// than this final "flush task" to be posted on the queue.

2
call/bitrate_estimator_tests.cc
View File

@ -46,8 +46,6 @@ class LogObserver {
private:
class Callback : public rtc::LogSink {
public:
Callback() : done_(false, false) {}
void OnLogMessage(const std::string& message) override {
rtc::CritScope lock(&crit_sect_);
// Ignore log lines that are due to missing AST extensions, these are

1
call/call_perf_tests.cc
View File

@ -725,7 +725,6 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
BitrateObserver()
: EndToEndTest(kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
time_to_reconfigure_(false, false),
encoder_inits_(0),
last_set_bitrate_kbps_(0),
send_stream_(nullptr),

1
call/rampup_tests.cc
View File

@ -54,7 +54,6 @@ RampUpTester::RampUpTester(size_t num_video_streams,
bool red,
bool report_perf_stats)
: EndToEndTest(test::CallTest::kLongTimeoutMs),
stop_event_(false, false),
clock_(Clock::GetRealTimeClock()),
num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams),

2
logging/rtc_event_log/rtc_event_log_impl.cc
View File

@ -202,7 +202,7 @@ void RtcEventLogImpl::StopLogging() {
RTC_LOG(LS_INFO) << "Stopping WebRTC event log.";
rtc::Event output_stopped(true, false);
rtc::Event output_stopped;
// Binding to |this| is safe because |this| outlives the |task_queue_|.
task_queue_->PostTask([this, &output_stopped]() {

7
media/engine/fakewebrtcvideoengine.cc
View File

@ -129,9 +129,7 @@ FakeWebRtcVideoDecoderFactory::decoders() {
// Encoder.
FakeWebRtcVideoEncoder::FakeWebRtcVideoEncoder(
FakeWebRtcVideoEncoderFactory* factory)
: init_encode_event_(false, false),
num_frames_encoded_(0),
factory_(factory) {}
: num_frames_encoded_(0), factory_(factory) {}
FakeWebRtcVideoEncoder::~FakeWebRtcVideoEncoder() {
if (factory_) {
@ -190,8 +188,7 @@ int FakeWebRtcVideoEncoder::GetNumEncodedFrames() {
// Video encoder factory.
FakeWebRtcVideoEncoderFactory::FakeWebRtcVideoEncoderFactory()
: created_video_encoder_event_(false, false),
num_created_encoders_(0),
: num_created_encoders_(0),
encoders_have_internal_sources_(false),
vp8_factory_mode_(false) {}

2
media/engine/webrtcvideoengine_unittest.cc
View File

@ -1086,7 +1086,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
EXPECT_CALL(*encoder_factory, QueryVideoEncoder(format))
.WillRepeatedly(testing::Return(codec_info));
FakeWebRtcVideoEncoder* const encoder = new FakeWebRtcVideoEncoder(nullptr);
rtc::Event encoder_created(false, false);
rtc::Event encoder_created;
EXPECT_CALL(*encoder_factory, CreateVideoEncoderProxy(format))
.WillOnce(
::testing::DoAll(::testing::InvokeWithoutArgs(

2
modules/audio_coding/acm2/audio_coding_module_unittest.cc
View File

@ -481,7 +481,6 @@ class AudioCodingModuleMtTestOldApi : public AudioCodingModuleTestOldApi {
send_thread_(CbSendThread, this, "send"),
insert_packet_thread_(CbInsertPacketThread, this, "insert_packet"),
pull_audio_thread_(CbPullAudioThread, this, "pull_audio"),
test_complete_(false, false),
send_count_(0),
insert_packet_count_(0),
pull_audio_count_(0),
@ -734,7 +733,6 @@ class AcmReRegisterIsacMtTestOldApi : public AudioCodingModuleTestOldApi {
codec_registration_thread_(CbCodecRegistrationThread,
this,
"codec_registration"),
test_complete_(false, false),
codec_registered_(false),
receive_packet_count_(0),
next_insert_packet_time_ms_(0),

2
modules/audio_device/audio_device_unittest.cc
View File

@ -509,7 +509,7 @@ class MockAudioTransport : public test::MockAudioTransport {
class AudioDeviceTest
: public ::testing::TestWithParam<webrtc::AudioDeviceModule::AudioLayer> {
protected:
AudioDeviceTest() : audio_layer_(GetParam()), event_(false, false) {
AudioDeviceTest() : audio_layer_(GetParam()) {
// TODO(webrtc:9778): Re-enable on THREAD_SANITIZER?
#if !defined(ADDRESS_SANITIZER) && !defined(MEMORY_SANITIZER) && \
!defined(WEBRTC_DUMMY_AUDIO_BUILD) && !defined(THREAD_SANITIZER)

2
modules/audio_device/include/test_audio_device.cc
View File

@ -62,8 +62,6 @@ class TestAudioDeviceModuleImpl
audio_callback_(nullptr),
rendering_(false),
capturing_(false),
done_rendering_(false, false),
done_capturing_(false, false),
stop_thread_(false) {
auto good_sample_rate = [](int sr) {
return sr == 8000 || sr == 16000 || sr == 32000 || sr == 44100 ||

4
modules/audio_device/linux/audio_device_pulse_linux.cc
View File

@ -32,10 +32,6 @@ namespace webrtc {
AudioDeviceLinuxPulse::AudioDeviceLinuxPulse()
: _ptrAudioBuffer(NULL),
_timeEventRec(false, false),
_timeEventPlay(false, false),
_recStartEvent(false, false),
_playStartEvent(false, false),
_inputDeviceIndex(0),
_outputDeviceIndex(0),
_inputDeviceIsSpecified(false),

2
modules/audio_processing/aec_dump/aec_dump_impl.cc
View File

@ -65,7 +65,7 @@ AecDumpImpl::AecDumpImpl(std::unique_ptr<FileWrapper> debug_file,
AecDumpImpl::~AecDumpImpl() {
// Block until all tasks have finished running.
rtc::Event thread_sync_event(false /* manual_reset */, false);
rtc::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.

5
modules/audio_processing/audio_processing_impl_locking_unittest.cc
View File

@ -487,10 +487,7 @@ void PopulateAudioFrame(AudioFrame* frame,
}
AudioProcessingImplLockTest::AudioProcessingImplLockTest()
: test_complete_(false, false),
render_call_event_(false, false),
capture_call_event_(false, false),
render_thread_(RenderProcessorThreadFunc, this, "render"),
: render_thread_(RenderProcessorThreadFunc, this, "render"),
capture_thread_(CaptureProcessorThreadFunc, this, "capture"),
stats_thread_(StatsProcessorThreadFunc, this, "stats"),
apm_(AudioProcessingBuilder().Create()),

3
modules/audio_processing/audio_processing_performance_unittest.cc
View File

@ -391,8 +391,7 @@ class TimedThreadApiProcessor {
class CallSimulator : public ::testing::TestWithParam<SimulationConfig> {
public:
CallSimulator()
: test_complete_(false, false),
render_thread_(
: render_thread_(
new rtc::PlatformThread(RenderProcessorThreadFunc, this, "render")),
capture_thread_(new rtc::PlatformThread(CaptureProcessorThreadFunc,
this,

2
modules/congestion_controller/rtp/send_side_congestion_controller.cc
View File

@ -482,7 +482,7 @@ void SendSideCongestionController::PostPeriodicTasksForTest() {
}
void SendSideCongestionController::WaitOnTasksForTest() {
rtc::Event event(false, false);
rtc::Event event;
task_queue_->PostTask([&event]() { event.Set(); });
event.Wait(rtc::Event::kForever);
}

13
modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc
View File

@ -77,7 +77,6 @@ constexpr int kAlmostForeverMs = 1000;
// Helper to wait for an rtcp packet produced on a different thread/task queue.
class FakeRtcpTransport : public webrtc::Transport {
public:
FakeRtcpTransport() : sent_rtcp_(false, false) {}
bool SendRtcp(const uint8_t* data, size_t size) override {
sent_rtcp_.Set();
return true;
@ -148,7 +147,7 @@ TEST(RtcpTransceiverImplTest, CanDestroyOnTaskQueue) {
// Wait for a periodic packet.
EXPECT_TRUE(transport.WaitPacket());
rtc::Event done(false, false);
rtc::Event done;
queue.PostTask([rtcp_transceiver, &done] {
delete rtcp_transceiver;
done.Set();
@ -187,7 +186,7 @@ TEST(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
EXPECT_GE(rtc::TimeMillis() - started_ms, config.initial_report_delay_ms);
// Cleanup.
rtc::Event done(false, false);
rtc::Event done;
queue.PostTask([&] {
rtcp_transceiver.reset();
done.Set();
@ -220,7 +219,7 @@ TEST(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
config.report_period_ms - 1);
// Cleanup.
rtc::Event done(false, false);
rtc::Event done;
queue.PostTask([&] {
rtcp_transceiver.reset();
done.Set();
@ -242,7 +241,7 @@ TEST(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
// Wait for first packet.
EXPECT_TRUE(transport.WaitPacket());
// Send non periodic one after half period.
rtc::Event non_periodic(false, false);
rtc::Event non_periodic;
int64_t time_of_non_periodic_packet_ms = 0;
queue.PostDelayedTask(
[&] {
@ -265,7 +264,7 @@ TEST(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
config.report_period_ms - 1);
// Cleanup.
rtc::Event done(false, false);
rtc::Event done;
queue.PostTask([&] {
rtcp_transceiver.reset();
done.Set();
@ -329,7 +328,7 @@ TEST(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
EXPECT_TRUE(transport.WaitPacket());
// Cleanup.
rtc::Event done(false, false);
rtc::Event done;
queue.PostTask([&] {
rtcp_transceiver.reset();
done.Set();

16
modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
View File

@ -41,7 +41,7 @@ class MockMediaReceiverRtcpObserver : public webrtc::MediaReceiverRtcpObserver {
constexpr int kTimeoutMs = 1000;
void WaitPostedTasks(rtc::TaskQueue* queue) {
rtc::Event done(false, false);
rtc::Event done;
queue->PostTask([&done] { done.Set(); });
ASSERT_TRUE(done.Wait(kTimeoutMs));
}
@ -108,8 +108,8 @@ TEST(RtcpTransceiverTest, CanBeDestroyedWithoutBlocking) {
auto* rtcp_transceiver = new RtcpTransceiver(config);
rtcp_transceiver->SendCompoundPacket();
rtc::Event done(false, false);
rtc::Event heavy_task(false, false);
rtc::Event done;
rtc::Event heavy_task;
queue.PostTask([&] {
EXPECT_TRUE(heavy_task.Wait(kTimeoutMs));
done.Set();
@ -128,7 +128,7 @@ TEST(RtcpTransceiverTest, MaySendPacketsAfterDestructor) { // i.e. Be careful!
config.task_queue = &queue;
auto* rtcp_transceiver = new RtcpTransceiver(config);
rtc::Event heavy_task(false, false);
rtc::Event heavy_task;
queue.PostTask([&] { EXPECT_TRUE(heavy_task.Wait(kTimeoutMs)); });
rtcp_transceiver->SendCompoundPacket();
delete rtcp_transceiver;
@ -158,7 +158,7 @@ TEST(RtcpTransceiverTest, DoesntPostToRtcpObserverAfterCallToRemove) {
config.outgoing_transport = &null_transport;
config.task_queue = &queue;
RtcpTransceiver rtcp_transceiver(config);
rtc::Event observer_deleted(false, false);
rtc::Event observer_deleted;
auto observer = absl::make_unique<MockMediaReceiverRtcpObserver>();
EXPECT_CALL(*observer, OnSenderReport(kRemoteSsrc, _, 1));
@ -188,8 +188,8 @@ TEST(RtcpTransceiverTest, RemoveMediaReceiverRtcpObserverIsNonBlocking) {
auto observer = absl::make_unique<MockMediaReceiverRtcpObserver>();
rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, observer.get());
rtc::Event queue_blocker(false, false);
rtc::Event observer_deleted(false, false);
rtc::Event queue_blocker;
rtc::Event observer_deleted;
queue.PostTask([&] { EXPECT_TRUE(queue_blocker.Wait(kTimeoutMs)); });
rtcp_transceiver.RemoveMediaReceiverRtcpObserver(kRemoteSsrc, observer.get(),
/*on_removed=*/[&] {
@ -240,7 +240,7 @@ TEST(RtcpTransceiverTest, DoesntSendPacketsAfterStopCallback) {
config.schedule_periodic_compound_packets = true;
auto rtcp_transceiver = absl::make_unique<RtcpTransceiver>(config);
rtc::Event done(false, false);
rtc::Event done;
rtcp_transceiver->SendCompoundPacket();
rtcp_transceiver->Stop([&] {
EXPECT_CALL(outgoing_transport, SendRtcp).Times(0);

4
modules/utility/source/process_thread_impl.cc
View File

@ -44,9 +44,7 @@ std::unique_ptr<ProcessThread> ProcessThread::Create(const char* thread_name) {
}
ProcessThreadImpl::ProcessThreadImpl(const char* thread_name)
: wake_up_(/*manual_reset=*/false, /*initially_signaled=*/false),
stop_(false),
thread_name_(thread_name) {}
: stop_(false), thread_name_(thread_name) {}
ProcessThreadImpl::~ProcessThreadImpl() {
RTC_DCHECK(thread_checker_.CalledOnValidThread());

16
modules/utility/source/process_thread_impl_unittest.cc
View File

@ -83,7 +83,7 @@ TEST(ProcessThreadImpl, ProcessCall) {
ProcessThreadImpl thread("ProcessThread");
thread.Start();
rtc::Event event(false, false);
rtc::Event event;
MockModule module;
EXPECT_CALL(module, TimeUntilNextProcess())
@ -105,7 +105,7 @@ TEST(ProcessThreadImpl, ProcessCall) {
// call to Start().
TEST(ProcessThreadImpl, ProcessCall2) {
ProcessThreadImpl thread("ProcessThread");
rtc::Event event(false, false);
rtc::Event event;
MockModule module;
EXPECT_CALL(module, TimeUntilNextProcess())
@ -129,7 +129,7 @@ TEST(ProcessThreadImpl, ProcessCall2) {
// After unregistration, we should not receive any further callbacks.
TEST(ProcessThreadImpl, Deregister) {
ProcessThreadImpl thread("ProcessThread");
rtc::Event event(false, false);
rtc::Event event;
int process_count = 0;
MockModule module;
@ -166,7 +166,7 @@ void ProcessCallAfterAFewMs(int64_t milliseconds) {
ProcessThreadImpl thread("ProcessThread");
thread.Start();
rtc::Event event(false, false);
rtc::Event event;
MockModule module;
int64_t start_time = 0;
@ -228,7 +228,7 @@ TEST(ProcessThreadImpl, DISABLED_Process50Times) {
ProcessThreadImpl thread("ProcessThread");
thread.Start();
rtc::Event event(false, false);
rtc::Event event;
MockModule module;
int callback_count = 0;
@ -259,8 +259,8 @@ TEST(ProcessThreadImpl, WakeUp) {
ProcessThreadImpl thread("ProcessThread");
thread.Start();
rtc::Event started(false, false);
rtc::Event called(false, false);
rtc::Event started;
rtc::Event called;
MockModule module;
int64_t start_time;
@ -301,7 +301,7 @@ TEST(ProcessThreadImpl, WakeUp) {
// thread.
TEST(ProcessThreadImpl, PostTask) {
ProcessThreadImpl thread("ProcessThread");
rtc::Event task_ran(false, false);
rtc::Event task_ran;
std::unique_ptr<RaiseEventTask> task(new RaiseEventTask(&task_ran));
thread.Start();
thread.PostTask(std::move(task));

4
modules/video_coding/codecs/test/video_codec_unittest.h
View File

@ -32,11 +32,7 @@ class VideoCodecUnitTest : public ::testing::Test {
VideoCodecUnitTest()
: encode_complete_callback_(this),
decode_complete_callback_(this),
encoded_frame_event_(false /* manual reset */,
false /* initially signaled */),
wait_for_encoded_frames_threshold_(1),
decoded_frame_event_(false /* manual reset */,
false /* initially signaled */),
last_input_frame_timestamp_(0) {}
protected:

2
modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
View File

@ -444,7 +444,7 @@ void VideoCodecTestFixtureImpl::ProcessAllFrames(
}
// Wait until we know that the last frame has been sent for encode.
rtc::Event sync_event(false, false);
rtc::Event sync_event;
task_queue->PostTask([&sync_event] { sync_event.Set(); });
sync_event.Wait(rtc::Event::kForever);

1
modules/video_coding/frame_buffer2.cc
View File

@ -46,7 +46,6 @@ FrameBuffer::FrameBuffer(Clock* clock,
VCMTiming* timing,
VCMReceiveStatisticsCallback* stats_callback)
: clock_(clock),
new_continuous_frame_event_(false, false),
jitter_estimator_(jitter_estimator),
timing_(timing),
inter_frame_delay_(clock_->TimeInMilliseconds()),

4
modules/video_coding/frame_buffer2_unittest.cc
View File

@ -137,9 +137,7 @@ class TestFrameBuffer2 : public ::testing::Test {
&stats_callback_)),
rand_(0x34678213),
tear_down_(false),
extract_thread_(&ExtractLoop, this, "Extract Thread"),
trigger_extract_event_(false, false),
crit_acquired_event_(false, false) {}
extract_thread_(&ExtractLoop, this, "Extract Thread") {}
void SetUp() override { extract_thread_.Start(); }

17
modules/video_coding/utility/quality_scaler_unittest.cc
View File

@ -28,19 +28,18 @@ static const int kMinFramesNeededToScale = 60; // From quality_scaler.cc.
static const size_t kDefaultTimeoutMs = 150;
} // namespace
#define DO_SYNC(q, block) \
do { \
rtc::Event event(false, false); \
q->PostTask([this, &event] { \
block; \
event.Set(); \
}); \
RTC_CHECK(event.Wait(1000)); \
#define DO_SYNC(q, block) \
do { \
rtc::Event event; \
q->PostTask([this, &event] { \
block; \
event.Set(); \
}); \
RTC_CHECK(event.Wait(1000)); \
} while (0)
class MockAdaptationObserver : public AdaptationObserverInterface {
public:
MockAdaptationObserver() : event(false, false) {}
virtual ~MockAdaptationObserver() {}
void AdaptUp(AdaptReason r) override {

2
pc/videocapturertracksource_unittest.cc
View File

@ -126,7 +126,7 @@ class VideoCapturerTrackSourceTest : public testing::Test {
}
void CaptureSingleFrame() {
rtc::Event event(false, false);
rtc::Event event;
task_queue_.PostTask([this, &event]() {
ASSERT_TRUE(capturer_->CaptureFrame());
event.Set();

1
rtc_base/BUILD.gn
View File

@ -263,7 +263,6 @@ rtc_source_set("platform_thread") {
rtc_source_set("rtc_event") {
deps = [
":checks",
":macromagic",
]
if (build_with_chromium) {

2
rtc_base/asyncinvoker.cc
View File

@ -17,7 +17,7 @@ namespace rtc {
AsyncInvoker::AsyncInvoker()
: pending_invocations_(0),
invocation_complete_(new RefCountedObject<Event>(false, false)),
invocation_complete_(new RefCountedObject<Event>()),
destroying_(false) {}
AsyncInvoker::~AsyncInvoker() {

14
rtc_base/cancelable_periodic_task_unittest.cc
View File

@ -68,7 +68,7 @@ TEST(CancelablePeriodicTaskTest, CanCallCancelOnEmptyHandle) {
}
TEST(CancelablePeriodicTaskTest, CancelTaskBeforeItRuns) {
rtc::Event done(false, false);
rtc::Event done;
MockClosure mock;
EXPECT_CALL(mock, Call).Times(0);
EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
@ -84,7 +84,7 @@ TEST(CancelablePeriodicTaskTest, CancelTaskBeforeItRuns) {
}
TEST(CancelablePeriodicTaskTest, CancelDelayedTaskBeforeItRuns) {
rtc::Event done(false, false);
rtc::Event done;
MockClosure mock;
EXPECT_CALL(mock, Call).Times(0);
EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
@ -100,7 +100,7 @@ TEST(CancelablePeriodicTaskTest, CancelDelayedTaskBeforeItRuns) {
}
TEST(CancelablePeriodicTaskTest, CancelTaskAfterItRuns) {
rtc::Event done(false, false);
rtc::Event done;
MockClosure mock;
EXPECT_CALL(mock, Call).WillOnce(Return(100));
EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
@ -117,7 +117,7 @@ TEST(CancelablePeriodicTaskTest, CancelTaskAfterItRuns) {
TEST(CancelablePeriodicTaskTest, ZeroReturnValueRepostsTheTask) {
NiceMock<MockClosure> closure;
rtc::Event done(false, false);
rtc::Event done;
EXPECT_CALL(closure, Call()).WillOnce(Return(0)).WillOnce(Invoke([&done] {
done.Set();
return kTimeoutMs;
@ -130,7 +130,7 @@ TEST(CancelablePeriodicTaskTest, ZeroReturnValueRepostsTheTask) {
TEST(CancelablePeriodicTaskTest, StartPeriodicTask) {
MockFunction<int()> closure;
rtc::Event done(false, false);
rtc::Event done;
EXPECT_CALL(closure, Call())
.WillOnce(Return(20))
.WillOnce(Return(20))
@ -146,7 +146,7 @@ TEST(CancelablePeriodicTaskTest, StartPeriodicTask) {
// Validates perfect forwarding doesn't keep reference to deleted copy.
TEST(CancelablePeriodicTaskTest, CreateWithCopyOfAClosure) {
rtc::Event done(false, false);
rtc::Event done;
MockClosure mock;
EXPECT_CALL(mock, Call).WillOnce(Invoke([&done] {
done.Set();
@ -166,7 +166,7 @@ TEST(CancelablePeriodicTaskTest, CreateWithCopyOfAClosure) {
}
TEST(CancelablePeriodicTaskTest, DeletingHandleDoesntStopTheTask) {
rtc::Event run(false, false);
rtc::Event run;
rtc::TaskQueue task_queue("queue");
auto task = rtc::CreateCancelablePeriodicTask(([&] {
run.Set();

2
rtc_base/criticalsection_unittest.cc
View File

@ -389,7 +389,7 @@ class PerfTestThread {
// The test is disabled by default to avoid unecessarily loading the bots.
TEST(CriticalSectionTest, DISABLED_Performance) {
PerfTestThread threads[8];
Event event(false, false);
Event event;
static const int kThreadRepeats = 10000000;
static const int kExpectedCount = kThreadRepeats * arraysize(threads);

2
rtc_base/event.cc
View File

@ -24,6 +24,8 @@
namespace rtc {
Event::Event() : Event(false, false) {}
#if defined(WEBRTC_WIN)
Event::Event(bool manual_reset, bool initially_signaled) {

6
rtc_base/event.h
View File

@ -11,7 +11,6 @@
#ifndef RTC_BASE_EVENT_H_
#define RTC_BASE_EVENT_H_
#include "rtc_base/constructormagic.h"
#if defined(WEBRTC_WIN)
#include <windows.h>
#elif defined(WEBRTC_POSIX)
@ -26,7 +25,10 @@ class Event {
public:
static const int kForever = -1;
Event();
Event(bool manual_reset, bool initially_signaled);
Event(const Event&) = delete;
Event& operator=(const Event&) = delete;
~Event();
void Set();
@ -45,8 +47,6 @@ class Event {
const bool is_manual_reset_;
bool event_status_;
#endif
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Event);
};
// This class is provided for compatibility with Chromium.

3
rtc_base/event_tracer.cc
View File

@ -90,8 +90,7 @@ class EventLogger final {
: logging_thread_(EventTracingThreadFunc,
this,
"EventTracingThread",
kLowPriority),
shutdown_event_(false, false) {}
kLowPriority) {}
~EventLogger() { RTC_DCHECK(thread_checker_.CalledOnValidThread()); }
void AddTraceEvent(const char* name,

10
rtc_base/event_unittest.cc
View File

@ -32,7 +32,7 @@ TEST(EventTest, ManualReset) {
}
TEST(EventTest, AutoReset) {
Event event(false, false);
Event event;
ASSERT_FALSE(event.Wait(0));
event.Set();
@ -59,7 +59,7 @@ class SignalerThread {
me->reader_->Wait(Event::kForever);
}
}
Event stop_event_{false, false};
Event stop_event_;
Event* writer_;
Event* reader_;
PlatformThread thread_;
@ -68,7 +68,7 @@ class SignalerThread {
// These tests are disabled by default and only intended to be run manually.
TEST(EventTest, DISABLED_PerformanceSingleThread) {
static const int kNumIterations = 10000000;
Event event(false, false);
Event event;
for (int i = 0; i < kNumIterations; ++i) {
event.Set();
event.Wait(0);
@ -77,8 +77,8 @@ TEST(EventTest, DISABLED_PerformanceSingleThread) {
TEST(EventTest, DISABLED_PerformanceMultiThread) {
static const int kNumIterations = 10000;
Event read(false, false);
Event write(false, false);
Event read;
Event write;
SignalerThread thread;
thread.Start(&read, &write);

2
rtc_base/logging_unittest.cc
View File

@ -292,7 +292,7 @@ class LogThread {
static void ThreadEntry(void* p) { static_cast<LogThread*>(p)->Run(); }
PlatformThread thread_;
Event event_{false, false};
Event event_;
};
// Ensure we don't crash when adding/removing streams while threads are going.

2
rtc_base/nullsocketserver.cc
View File

@ -13,7 +13,7 @@
namespace rtc {
NullSocketServer::NullSocketServer() : event_(false, false) {}
NullSocketServer::NullSocketServer() = default;
NullSocketServer::~NullSocketServer() {}
bool NullSocketServer::Wait(int cms, bool process_io) {

4
rtc_base/rate_limiter_unittest.cc
View File

@ -112,9 +112,7 @@ static const int64_t kMaxTimeoutMs = 30000;
class ThreadTask {
public:
explicit ThreadTask(RateLimiter* rate_limiter)
: rate_limiter_(rate_limiter),
start_signal_(false, false),
end_signal_(false, false) {}
: rate_limiter_(rate_limiter) {}
virtual ~ThreadTask() {}
void Run() {

12
rtc_base/sequenced_task_checker_unittest.cc
View File

@ -44,7 +44,6 @@ class CallCalledSequentiallyOnThread {
CallCalledSequentiallyOnThread(bool expect_true,
SequencedTaskChecker* sequenced_task_checker)
: expect_true_(expect_true),
thread_has_run_event_(false, false),
thread_(&Run, this, "call_do_stuff_on_thread"),
sequenced_task_checker_(sequenced_task_checker) {
thread_.Start();
@ -78,7 +77,6 @@ class DeleteSequencedCheckerOnThread {
explicit DeleteSequencedCheckerOnThread(
std::unique_ptr<SequencedTaskChecker> sequenced_task_checker)
: thread_(&Run, this, "delete_sequenced_task_checker_on_thread"),
thread_has_run_event_(false, false),
sequenced_task_checker_(std::move(sequenced_task_checker)) {
thread_.Start();
}
@ -119,7 +117,7 @@ void RunMethodOnDifferentTaskQueue(bool expect_true) {
static const char kQueueName[] = "MethodNotAllowedOnDifferentTq";
TaskQueue queue(kQueueName);
Event done_event(false, false);
Event done_event;
queue.PostTask([&sequenced_task_checker, &done_event, expect_true] {
if (expect_true)
EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
@ -136,7 +134,7 @@ void DetachThenCallFromDifferentTaskQueue(bool expect_true) {
sequenced_task_checker->Detach();
Event done_event(false, false);
Event done_event;
TaskQueue queue1("DetachThenCallFromDifferentTaskQueueImpl1");
queue1.PostTask([&sequenced_task_checker, &done_event] {
EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
@ -194,7 +192,7 @@ TEST(SequencedTaskCheckerTest, DetachFromThreadAndUseOnTaskQueue) {
sequenced_task_checker->Detach();
static const char kQueueName[] = "DetachFromThreadAndUseOnTaskQueue";
TaskQueue queue(kQueueName);
Event done_event(false, false);
Event done_event;
queue.PostTask([&sequenced_task_checker, &done_event] {
EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
done_event.Set();
@ -204,7 +202,7 @@ TEST(SequencedTaskCheckerTest, DetachFromThreadAndUseOnTaskQueue) {
TEST(SequencedTaskCheckerTest, DetachFromTaskQueueAndUseOnThread) {
TaskQueue queue("DetachFromTaskQueueAndUseOnThread");
Event done_event(false, false);
Event done_event;
queue.PostTask([&done_event] {
std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
new SequencedTaskChecker());
@ -272,7 +270,7 @@ void TestAnnotationsOnWrongQueue() {
TestAnnotations annotations;
static const char kQueueName[] = "TestAnnotationsOnWrongQueueDebug";
TaskQueue queue(kQueueName);
Event done_event(false, false);
Event done_event;
queue.PostTask([&annotations, &done_event] {
annotations.ModifyTestVar();
done_event.Set();

4
rtc_base/task_queue_for_test.h
View File

@ -33,7 +33,7 @@ class RTC_LOCKABLE TaskQueueForTest : public TaskQueue {
template <class Closure>
void SendTask(Closure* task) {
RTC_DCHECK(!IsCurrent());
rtc::Event event(false, false);
rtc::Event event;
PostTask(rtc::NewClosure(
[&task]() {
RTC_CHECK_EQ(false, static_cast<QueuedTask*>(task)->Run());
@ -47,7 +47,7 @@ class RTC_LOCKABLE TaskQueueForTest : public TaskQueue {
template <class Closure>
void SendTask(Closure&& task) {
RTC_DCHECK(!IsCurrent());
rtc::Event event(false, false);
rtc::Event event;
PostTask(rtc::NewClosure(std::move(task), [&event]() { event.Set(); }));
event.Wait(rtc::Event::kForever);
}

40
rtc_base/task_queue_unittest.cc
View File

@ -64,7 +64,7 @@ TEST(TaskQueueTest, Construct) {
TEST(TaskQueueTest, PostAndCheckCurrent) {
static const char kQueueName[] = "PostAndCheckCurrent";
Event event(false, false);
Event event;
TaskQueue queue(kQueueName);
// We're not running a task, so there shouldn't be a current queue.
@ -106,7 +106,7 @@ TEST(TaskQueueTest, PostLambda) {
TEST(TaskQueueTest, PostDelayedZero) {
static const char kQueueName[] = "PostDelayedZero";
Event event(false, false);
Event event;
TaskQueue queue(kQueueName);
queue.PostDelayedTask([&event]() { event.Set(); }, 0);
@ -115,7 +115,7 @@ TEST(TaskQueueTest, PostDelayedZero) {
TEST(TaskQueueTest, PostFromQueue) {
static const char kQueueName[] = "PostFromQueue";
Event event(false, false);
Event event;
TaskQueue queue(kQueueName);
queue.PostTask(
@ -125,7 +125,7 @@ TEST(TaskQueueTest, PostFromQueue) {
TEST(TaskQueueTest, PostDelayed) {
static const char kQueueName[] = "PostDelayed";
Event event(false, false);
Event event;
TaskQueue queue(kQueueName, TaskQueue::Priority::HIGH);
uint32_t start = Time();
@ -145,7 +145,7 @@ TEST(TaskQueueTest, DISABLED_PostDelayedHighRes) {
EnableHighResTimers high_res_scope;
static const char kQueueName[] = "PostDelayedHighRes";
Event event(false, false);
Event event;
TaskQueue queue(kQueueName, TaskQueue::Priority::HIGH);
uint32_t start = Time();
@ -165,7 +165,7 @@ TEST(TaskQueueTest, PostMultipleDelayed) {
std::vector<std::unique_ptr<Event>> events;
for (int i = 0; i < 100; ++i) {
events.push_back(std::unique_ptr<Event>(new Event(false, false)));
events.push_back(absl::make_unique<Event>());
queue.PostDelayedTask(Bind(&CheckCurrent, events.back().get(), &queue), i);
}
@ -175,8 +175,8 @@ TEST(TaskQueueTest, PostMultipleDelayed) {
TEST(TaskQueueTest, PostDelayedAfterDestruct) {
static const char kQueueName[] = "PostDelayedAfterDestruct";
Event run(false, false);
Event deleted(false, false);
Event run;
Event deleted;
{
TaskQueue queue(kQueueName);
queue.PostDelayedTask(
@ -191,7 +191,7 @@ TEST(TaskQueueTest, PostDelayedAfterDestruct) {
TEST(TaskQueueTest, PostAndReply) {
static const char kPostQueue[] = "PostQueue";
static const char kReplyQueue[] = "ReplyQueue";
Event event(false, false);
Event event;
TaskQueue post_queue(kPostQueue);
TaskQueue reply_queue(kReplyQueue);
@ -204,7 +204,7 @@ TEST(TaskQueueTest, PostAndReply) {
TEST(TaskQueueTest, PostAndReuse) {
static const char kPostQueue[] = "PostQueue";
static const char kReplyQueue[] = "ReplyQueue";
Event event(false, false);
Event event;
TaskQueue post_queue(kPostQueue);
TaskQueue reply_queue(kReplyQueue);
@ -251,7 +251,7 @@ TEST(TaskQueueTest, PostAndReuse) {
TEST(TaskQueueTest, PostAndReplyLambda) {
static const char kPostQueue[] = "PostQueue";
static const char kReplyQueue[] = "ReplyQueue";
Event event(false, false);
Event event;
TaskQueue post_queue(kPostQueue);
TaskQueue reply_queue(kReplyQueue);
@ -287,7 +287,7 @@ TEST(TaskQueueTest, PostCopyableClosure) {
int num_copies = 0;
int num_moves = 0;
Event event(false, false);
Event event;
static const char kPostQueue[] = "PostCopyableClosure";
TaskQueue post_queue(kPostQueue);
@ -323,7 +323,7 @@ TEST(TaskQueueTest, PostMoveOnlyClosure) {
};
int num_moves = 0;
Event event(false, false);
Event event;
std::unique_ptr<SomeState> state(new SomeState(&event));
static const char kPostQueue[] = "PostMoveOnlyClosure";
@ -346,8 +346,8 @@ TEST(TaskQueueTest, PostMoveOnlyCleanup) {
std::unique_ptr<SomeState> state;
};
Event event_run(false, false);
Event event_cleanup(false, false);
Event event_run;
Event event_cleanup;
std::unique_ptr<SomeState> state_run(new SomeState(&event_run));
std::unique_ptr<SomeState> state_cleanup(new SomeState(&event_cleanup));
@ -367,7 +367,7 @@ TEST(TaskQueueTest, PostMoveOnlyCleanup) {
// written in a way that makes it likely and by running with --gtest_repeat=1000
// the bug would occur. Alas, now it should be fixed.
TEST(TaskQueueTest, PostAndReplyDeadlock) {
Event event(false, false);
Event event;
TaskQueue post_queue("PostQueue");
TaskQueue reply_queue("ReplyQueue");
@ -384,8 +384,8 @@ TEST(TaskQueueTest, PostAndReplyDeadlock) {
#define MAYBE_DeleteTaskQueueAfterPostAndReply DeleteTaskQueueAfterPostAndReply
#endif
TEST(TaskQueueTest, MAYBE_DeleteTaskQueueAfterPostAndReply) {
Event task_deleted(false, false);
Event reply_deleted(false, false);
Event task_deleted;
Event reply_deleted;
auto* task_queue = new TaskQueue("Queue");
task_queue->PostTaskAndReply(
@ -413,7 +413,7 @@ void TestPostTaskAndReply(TaskQueue* work_queue, Event* event) {
TEST(TaskQueueTest, PostAndReply2) {
static const char kQueueName[] = "PostAndReply2";
static const char kWorkQueueName[] = "PostAndReply2_Worker";
Event event(false, false);
Event event;
TaskQueue queue(kQueueName);
TaskQueue work_queue(kWorkQueueName);
@ -425,7 +425,7 @@ TEST(TaskQueueTest, PostAndReply2) {
// In situations like that, tasks will get dropped.
TEST(TaskQueueTest, PostALot) {
// To destruct the event after the queue has gone out of scope.
Event event(false, false);
Event event;
int tasks_executed = 0;
int tasks_cleaned_up = 0;

8
rtc_base/thread_unittest.cc
View File

@ -470,9 +470,9 @@ TEST_F(AsyncInvokeTest, KillInvokerDuringExecute) {
// Use these events to get in a state where the functor is in the middle of
// executing, and then to wait for it to finish, ensuring the "EXPECT_FALSE"
// is run.
Event functor_started(false, false);
Event functor_continue(false, false);
Event functor_finished(false, false);
Event functor_started;
Event functor_continue;
Event functor_finished;
auto thread = Thread::CreateWithSocketServer();
thread->Start();
@ -507,7 +507,7 @@ TEST_F(AsyncInvokeTest, KillInvokerDuringExecute) {
// destroyed. This shouldn't deadlock or crash; this second invocation should
// just be ignored.
TEST_F(AsyncInvokeTest, KillInvokerDuringExecuteWithReentrantInvoke) {
Event functor_started(false, false);
Event functor_started;
// Flag used to verify that the recursively invoked task never actually runs.
bool reentrant_functor_run = false;

2
rtc_base/timeutils_unittest.cc
View File

@ -262,7 +262,7 @@ TEST(FakeClock, SettingTimeWakesThreads) {
worker->Start();
// Post an event that won't be executed for 10 seconds.
Event message_handler_dispatched(false, false);
Event message_handler_dispatched;
auto functor = [&message_handler_dispatched] {
message_handler_dispatched.Set();
};

1
rtc_base/virtualsocketserver.cc
View File

@ -525,7 +525,6 @@ VirtualSocketServer::VirtualSocketServer() : VirtualSocketServer(nullptr) {}
VirtualSocketServer::VirtualSocketServer(FakeClock* fake_clock)
: fake_clock_(fake_clock),
wakeup_(/*manual_reset=*/false, /*initially_signaled=*/false),
msg_queue_(nullptr),
stop_on_idle_(false),
next_ipv4_(kInitialNextIPv4),

4
rtc_base/weak_ptr_unittest.cc
View File

@ -202,7 +202,7 @@ template <class T>
std::unique_ptr<T> NewObjectCreatedOnTaskQueue() {
std::unique_ptr<T> obj;
TaskQueue queue("NewObjectCreatedOnTaskQueue");
Event event(false, false);
Event event;
queue.PostTask([&event, &obj] {
obj.reset(new T());
event.Set();
@ -229,7 +229,7 @@ TEST(WeakPtrTest, WeakPtrInitiateAndUseOnDifferentThreads) {
// Create weak ptr on main thread
WeakPtr<Target> weak_ptr = target->factory.GetWeakPtr();
rtc::TaskQueue queue("queue");
rtc::Event done(false, false);
rtc::Event done;
queue.PostTask([&] {
// Dereference and invalide weak_ptr on another thread.
EXPECT_EQ(weak_ptr.get(), target.get());

1
system_wrappers/source/event.cc
View File

@ -22,7 +22,6 @@ namespace webrtc {
class EventWrapperImpl : public EventWrapper {
public:
EventWrapperImpl() : event_(false, false) {}
~EventWrapperImpl() override {}
bool Set() override {

4
test/rtp_rtcp_observer.h
View File

@ -71,9 +71,7 @@ class RtpRtcpObserver {
protected:
RtpRtcpObserver() : RtpRtcpObserver(0) {}
explicit RtpRtcpObserver(int event_timeout_ms)
: observation_complete_(false, false),
parser_(RtpHeaderParser::Create()),
timeout_ms_(event_timeout_ms) {
: parser_(RtpHeaderParser::Create()), timeout_ms_(event_timeout_ms) {
parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
kTOffsetExtensionId);
parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,

2
test/scenario/scenario.cc
View File

@ -335,7 +335,7 @@ void Scenario::RunUntil(TimeDelta max_duration,
call->call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
}
rtc::Event done_(false, false);
rtc::Event done_;
while (!exit_function() && Duration() < max_duration) {
Timestamp current_time = Now();
TimeDelta duration = current_time - start_time_;

7
test/single_threaded_task_queue.cc
View File

@ -32,10 +32,7 @@ SingleThreadedTaskQueueForTesting::QueuedTask::~QueuedTask() = default;
SingleThreadedTaskQueueForTesting::SingleThreadedTaskQueueForTesting(
const char* name)
: thread_(Run, this, name),
running_(true),
next_task_id_(0),
wake_up_(false, false) {
: thread_(Run, this, name), running_(true), next_task_id_(0) {
thread_.Start();
}
@ -83,7 +80,7 @@ SingleThreadedTaskQueueForTesting::PostDelayedTask(Task task,
}
void SingleThreadedTaskQueueForTesting::SendTask(Task task) {
rtc::Event done(true, false);
rtc::Event done;
PostTask([&task, &done]() {
task();
done.Set();

32
test/single_threaded_task_queue_unittest.cc
View File

@ -37,7 +37,7 @@ TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedTasks) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> executed(false);
rtc::Event done(true, false);
rtc::Event done;
task_queue.PostTask([&executed, &done]() {
executed.store(true);
@ -60,14 +60,14 @@ TEST(SingleThreadedTaskQueueForTestingTest,
std::vector<std::unique_ptr<rtc::Event>> done_events;
for (size_t i = 0; i < kCount; i++) {
done_events.emplace_back(absl::make_unique<rtc::Event>(false, false));
done_events.emplace_back(absl::make_unique<rtc::Event>());
}
// To avoid the tasks which comprise the actual test from running before they
// have all be posted, which could result in only one task ever being in the
// queue at any given time, post one waiting task that would block the
// task-queue, and unblock only after all tasks have been posted.
rtc::Event rendezvous(true, false);
rtc::Event rendezvous;
task_queue.PostTask(
[&rendezvous]() { ASSERT_TRUE(rendezvous.Wait(kMaxWaitTimeMs)); });
@ -95,7 +95,7 @@ TEST(SingleThreadedTaskQueueForTestingTest, PostToTaskQueueFromOwnThread) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> executed(false);
rtc::Event done(true, false);
rtc::Event done;
auto internally_posted_task = [&executed, &done]() {
executed.store(true);
@ -124,7 +124,7 @@ TEST(SingleThreadedTaskQueueForTestingTest, TasksExecutedInSequence) {
// Prevent the chain from being set in motion before we've had time to
// schedule it all, lest the queue only contain one task at a time.
rtc::Event rendezvous(true, false);
rtc::Event rendezvous;
task_queue.PostTask(
[&rendezvous]() { ASSERT_TRUE(rendezvous.Wait(kMaxWaitTimeMs)); });
@ -136,7 +136,7 @@ TEST(SingleThreadedTaskQueueForTestingTest, TasksExecutedInSequence) {
}
// The test will wait for the task-queue to finish.
rtc::Event done(true, false);
rtc::Event done;
task_queue.PostTask([&done]() { done.Set(); });
rendezvous.Set(); // Set the chain in motion.
@ -150,7 +150,7 @@ TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedDelayedTask) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> executed(false);
rtc::Event done(true, false);
rtc::Event done;
constexpr int64_t delay_ms = 20;
static_assert(delay_ms < kMaxWaitTimeMs / 2, "Delay too long for tests.");
@ -177,7 +177,7 @@ TEST(SingleThreadedTaskQueueForTestingTest, DoesNotExecuteDelayedTaskTooSoon) {
task_queue.PostDelayedTask([&executed]() { executed.store(true); }, delay_ms);
// Wait less than is enough, make sure the task was not yet executed.
rtc::Event not_done(true, false);
rtc::Event not_done;
ASSERT_FALSE(not_done.Wait(delay_ms / 2));
EXPECT_FALSE(executed.load());
}
@ -195,7 +195,7 @@ TEST(SingleThreadedTaskQueueForTestingTest,
static_assert(earlier_delay_ms + later_delay_ms < kMaxWaitTimeMs / 2,
"Delay too long for tests.");
rtc::Event done(true, false);
rtc::Event done;
auto earlier_task = [&earlier_executed, &later_executed]() {
EXPECT_FALSE(later_executed.load());
@ -229,7 +229,7 @@ TEST(SingleThreadedTaskQueueForTestingTest,
static_assert(earlier_delay_ms + later_delay_ms < kMaxWaitTimeMs / 2,
"Delay too long for tests.");
rtc::Event done(true, false);
rtc::Event done;
auto earlier_task = [&earlier_executed, &later_executed]() {
EXPECT_FALSE(later_executed.load());
@ -253,11 +253,11 @@ TEST(SingleThreadedTaskQueueForTestingTest,
TEST(SingleThreadedTaskQueueForTestingTest, ExternalThreadCancelsTask) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
rtc::Event done(true, false);
rtc::Event done;
// Prevent the to-be-cancelled task from being executed before we've had
// time to cancel it.
rtc::Event rendezvous(true, false);
rtc::Event rendezvous;
task_queue.PostTask(
[&rendezvous]() { ASSERT_TRUE(rendezvous.Wait(kMaxWaitTimeMs)); });
@ -279,10 +279,10 @@ TEST(SingleThreadedTaskQueueForTestingTest, ExternalThreadCancelsTask) {
TEST(SingleThreadedTaskQueueForTestingTest, InternalThreadCancelsTask) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
rtc::Event done(true, false);
rtc::Event done;
// Prevent the chain from being set-off before we've set everything up.
rtc::Event rendezvous(true, false);
rtc::Event rendezvous;
task_queue.PostTask(
[&rendezvous]() { ASSERT_TRUE(rendezvous.Wait(kMaxWaitTimeMs)); });
@ -316,7 +316,7 @@ TEST(SingleThreadedTaskQueueForTestingTest, SendTask) {
task_queue.SendTask([&executed]() {
// Intentionally delay, so that if SendTask didn't block, the sender thread
// would have time to read |executed|.
rtc::Event delay(true, false);
rtc::Event delay;
ASSERT_FALSE(delay.Wait(1000));
executed.store(true);
});
@ -335,7 +335,7 @@ TEST(SingleThreadedTaskQueueForTestingTest,
for (size_t i = 0; i < tasks; i++) {
task_queue->PostTask([&counter]() {
std::atomic_fetch_add(&counter, static_cast<size_t>(1));
rtc::Event delay(true, false);
rtc::Event delay;
ASSERT_FALSE(delay.Wait(500));
});
}

16
video/call_stats_unittest.cc
View File

@ -55,7 +55,7 @@ class CallStatsTest : public ::testing::Test {
};
TEST_F(CallStatsTest, AddAndTriggerCallback) {
rtc::Event event(false, false);
rtc::Event event;
static constexpr const int64_t kRtt = 25;
@ -77,7 +77,7 @@ TEST_F(CallStatsTest, AddAndTriggerCallback) {
}
TEST_F(CallStatsTest, ProcessTime) {
rtc::Event event(false, false);
rtc::Event event;
static constexpr const int64_t kRtt = 100;
static constexpr const int64_t kRtt2 = 80;
@ -128,8 +128,8 @@ TEST_F(CallStatsTest, MultipleObservers) {
static constexpr const int64_t kRtt = 100;
// Verify both observers are updated.
rtc::Event ev1(false, false);
rtc::Event ev2(false, false);
rtc::Event ev1;
rtc::Event ev2;
EXPECT_CALL(stats_observer_1, OnRttUpdate(kRtt, kRtt))
.Times(AnyNumber())
.WillOnce(InvokeWithoutArgs([&ev1] { ev1.Set(); }))
@ -167,7 +167,7 @@ TEST_F(CallStatsTest, MultipleObservers) {
// Flush the queue on the process thread to make sure we return after
// Process() has been called.
rtc::Event event(false, false);
rtc::Event event;
process_thread_->PostTask(rtc::NewClosure([&event]() { event.Set(); }));
event.Wait(rtc::Event::kForever);
}
@ -183,7 +183,7 @@ TEST_F(CallStatsTest, ChangeRtt) {
call_stats_.RegisterStatsObserver(&stats_observer);
RtcpRttStats* rtcp_rtt_stats = &call_stats_;
rtc::Event event(false, false);
rtc::Event event;
static constexpr const int64_t kFirstRtt = 100;
static constexpr const int64_t kLowRtt = kFirstRtt - 20;
@ -240,7 +240,7 @@ TEST_F(CallStatsTest, ChangeRtt) {
}
TEST_F(CallStatsTest, LastProcessedRtt) {
rtc::Event event(false, false);
rtc::Event event;
MockStatsObserver stats_observer;
call_stats_.RegisterStatsObserver(&stats_observer);
RtcpRttStats* rtcp_rtt_stats = &call_stats_;
@ -289,7 +289,7 @@ TEST_F(CallStatsTest, LastProcessedRtt) {
TEST_F(CallStatsTest, ProducesHistogramMetrics) {
metrics::Reset();
rtc::Event event(false, false);
rtc::Event event;
static constexpr const int64_t kRtt = 123;
RtcpRttStats* rtcp_rtt_stats = &call_stats_;
MockStatsObserver stats_observer;

1
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -145,7 +145,6 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
sender_ssrc_(0),
remb_bitrate_bps_(1000000),
receive_transport_(nullptr),
stop_event_(false, false),
poller_thread_(&BitrateStatsPollingThread,
this,
"BitrateStatsPollingThread"),

4
video/end_to_end_tests/call_operation_tests.cc
View File

@ -92,8 +92,6 @@ TEST_P(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
public:
Renderer() : event_(false, false) {}
void OnFrame(const VideoFrame& video_frame) override {
SleepMs(kRenderDelayMs);
event_.Set();
@ -161,8 +159,6 @@ TEST_P(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
TEST_P(CallOperationEndToEndTest, TransmitsFirstFrame) {
class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
public:
Renderer() : event_(false, false) {}
void OnFrame(const VideoFrame& video_frame) override { event_.Set(); }
bool Wait() { return event_.Wait(kDefaultTimeoutMs); }

5
video/end_to_end_tests/multi_stream_tests.cc
View File

@ -30,10 +30,7 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
VideoOutputObserver(const MultiStreamTester::CodecSettings& settings,
uint32_t ssrc,
test::FrameGeneratorCapturer** frame_generator)
: settings_(settings),
ssrc_(ssrc),
frame_generator_(frame_generator),
done_(false, false) {}
: settings_(settings), ssrc_(ssrc), frame_generator_(frame_generator) {}
void OnFrame(const VideoFrame& video_frame) override {
EXPECT_EQ(settings_.width, video_frame.width());

2
video/end_to_end_tests/network_state_tests.cc
View File

@ -158,8 +158,6 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
: EndToEndTest(kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
encoded_frames_(false, false),
packet_event_(false, false),
sender_call_(nullptr),
receiver_call_(nullptr),
encoder_factory_(this),

2
video/end_to_end_tests/ssrc_tests.cc
View File

@ -48,7 +48,7 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
class PacketInputObserver : public PacketReceiver {
public:
explicit PacketInputObserver(PacketReceiver* receiver)
: receiver_(receiver), delivered_packet_(false, false) {}
: receiver_(receiver) {}
bool Wait() { return delivered_packet_.Wait(kDefaultTimeoutMs); }

3
video/end_to_end_tests/stats_tests.cc
View File

@ -47,8 +47,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
Clock::GetRealTimeClock(), 10);
}),
send_stream_(nullptr),
expected_send_ssrcs_(),
check_stats_event_(false, false) {}
expected_send_ssrcs_() {}
private:
Action OnSendRtp(const uint8_t* packet, size_t length) override {

1
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -58,7 +58,6 @@ TEST_P(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
BuiltInNetworkBehaviorConfig())),
sender_call,
payload_type_map),
done_(false, false),
parser_(RtpHeaderParser::Create()),
first_media_ssrc_(first_media_ssrc),
rtx_to_media_ssrcs_(ssrc_map),

4
video/overuse_frame_detector_unittest.cc
View File

@ -406,7 +406,7 @@ TEST_F(OveruseFrameDetectorTest, UpdatesExistingSamples) {
TEST_F(OveruseFrameDetectorTest, RunOnTqNormalUsage) {
rtc::TaskQueue queue("OveruseFrameDetectorTestQueue");
rtc::Event event(false, false);
rtc::Event event;
queue.PostTask([this, &event] {
overuse_detector_->StartCheckForOveruse(options_, observer_);
event.Set();
@ -870,7 +870,7 @@ TEST_F(OveruseFrameDetectorTest2, UpdatesExistingSamples) {
TEST_F(OveruseFrameDetectorTest2, RunOnTqNormalUsage) {
rtc::TaskQueue queue("OveruseFrameDetectorTestQueue");
rtc::Event event(false, false);
rtc::Event event;
queue.PostTask([this, &event] {
overuse_detector_->StartCheckForOveruse(options_, observer_);
event.Set();

1
video/video_analyzer.cc
View File

@ -91,7 +91,6 @@ VideoAnalyzer::VideoAnalyzer(test::LayerFilteringTransport* transport,
avg_ssim_threshold_(avg_ssim_threshold),
is_quick_test_enabled_(is_quick_test_enabled),
stats_polling_thread_(&PollStatsThread, this, "StatsPoller"),
comparison_available_event_(false, false),
done_(true, false),
clock_(clock),
start_ms_(clock->TimeInMilliseconds()) {

2
video/video_receive_stream_unittest.cc
View File

@ -118,7 +118,7 @@ TEST_F(VideoReceiveStreamTest, CreateFrameFromH264FmtpSpropAndIdr) {
rtppacket.SetPayloadType(99);
rtppacket.SetSequenceNumber(1);
rtppacket.SetTimestamp(0);
rtc::Event init_decode_event_(false, false);
rtc::Event init_decode_event_;
EXPECT_CALL(mock_h264_video_decoder_, InitDecode(_, _))
.WillOnce(Invoke([&init_decode_event_](const VideoCodec* config,
int32_t number_of_cores) {

1
video/video_send_stream.cc
View File

@ -71,7 +71,6 @@ VideoSendStream::VideoSendStream(
const std::map<uint32_t, RtpPayloadState>& suspended_payload_states,
std::unique_ptr<FecController> fec_controller)
: worker_queue_(worker_queue),
thread_sync_event_(false /* manual_reset */, false),
stats_proxy_(Clock::GetRealTimeClock(),
config,
encoder_config.content_type),

18
video/video_send_stream_tests.cc
View File

@ -1782,7 +1782,6 @@ class MaxPaddingSetTest : public test::SendTest {
explicit MaxPaddingSetTest(bool test_switch_content_type, T* stream_reset_fun)
: SendTest(test::CallTest::kDefaultTimeoutMs),
content_switch_event_(false, false),
call_(nullptr),
send_stream_(nullptr),
send_stream_config_(nullptr),
@ -1912,7 +1911,6 @@ TEST_P(VideoSendStreamTest,
public:
EncoderObserver()
: FakeEncoder(Clock::GetRealTimeClock()),
init_encode_called_(false, false),
number_of_initializations_(0),
last_initialized_frame_width_(0),
last_initialized_frame_height_(0) {}
@ -1995,7 +1993,6 @@ TEST_P(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
public:
StartBitrateObserver()
: FakeEncoder(Clock::GetRealTimeClock()),
start_bitrate_changed_(false, false),
start_bitrate_kbps_(0) {}
int32_t InitEncode(const VideoCodec* config,
int32_t number_of_cores,
@ -2070,10 +2067,7 @@ TEST_P(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
class StartStopBitrateObserver : public test::FakeEncoder {
public:
StartStopBitrateObserver()
: FakeEncoder(Clock::GetRealTimeClock()),
encoder_init_(false, false),
bitrate_changed_(false, false) {}
StartStopBitrateObserver() : FakeEncoder(Clock::GetRealTimeClock()) {}
int32_t InitEncode(const VideoCodec* config,
int32_t number_of_cores,
size_t max_payload_size) override {
@ -2230,8 +2224,6 @@ TEST_P(VideoSendStreamTest, VideoSendStreamUpdateActiveSimulcastLayers) {
TEST_P(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
class FrameObserver : public rtc::VideoSinkInterface<VideoFrame> {
public:
FrameObserver() : output_frame_event_(false, false) {}
void OnFrame(const VideoFrame& video_frame) override {
output_frames_.push_back(video_frame);
output_frame_event_.Set();
@ -2455,7 +2447,6 @@ TEST_P(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
VideoCodecConfigObserver()
: SendTest(kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
init_encode_event_(false, false),
num_initializations_(0),
stream_(nullptr),
encoder_factory_(this) {}
@ -2527,7 +2518,6 @@ class VideoCodecConfigObserver : public test::SendTest,
FakeEncoder(Clock::GetRealTimeClock()),
video_codec_type_(video_codec_type),
codec_name_(codec_name),
init_encode_event_(false, false),
num_initializations_(0),
stream_(nullptr),
encoder_factory_(this) {
@ -2841,8 +2831,6 @@ TEST_P(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
: SendTest(kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
init_encode_event_(false, false),
bitrate_changed_event_(false, false),
target_bitrate_(0),
num_initializations_(0),
call_(nullptr),
@ -3671,8 +3659,7 @@ TEST_P(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
encoder_factory_(this),
call_(nullptr),
max_bitrate_bps_(0),
first_packet_sent_(false),
bitrate_changed_event_(false, false) {}
first_packet_sent_(false) {}
int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate,
uint32_t frameRate) override {
@ -3885,7 +3872,6 @@ class ContentSwitchTest : public test::SendTest {
explicit ContentSwitchTest(T* stream_reset_fun)
: SendTest(test::CallTest::kDefaultTimeoutMs),
content_switch_event_(false, false),
call_(nullptr),
state_(StreamState::kBeforeSwitch),
send_stream_(nullptr),

16
video/video_stream_encoder_unittest.cc
View File

@ -104,7 +104,7 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
new CpuOveruseDetectorProxy(stats_proxy))) {}
void PostTaskAndWait(bool down, AdaptReason reason) {
rtc::Event event(false, false);
rtc::Event event;
encoder_queue()->PostTask([this, &event, reason, down] {
down ? AdaptDown(reason) : AdaptUp(reason);
event.Set();
@ -115,7 +115,7 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
// This is used as a synchronisation mechanism, to make sure that the
// encoder queue is not blocked before we start sending it frames.
void WaitUntilTaskQueueIsIdle() {
rtc::Event event(false, false);
rtc::Event event;
encoder_queue()->PostTask([&event] { event.Set(); });
ASSERT_TRUE(event.Wait(5000));
}
@ -494,9 +494,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
class TestEncoder : public test::FakeEncoder {
public:
TestEncoder()
: FakeEncoder(Clock::GetRealTimeClock()),
continue_encode_event_(false, false) {}
TestEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {}
VideoCodec codec_config() const {
rtc::CritScope lock(&crit_sect_);
@ -599,7 +597,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
class TestSink : public VideoStreamEncoder::EncoderSink {
public:
explicit TestSink(TestEncoder* test_encoder)
: test_encoder_(test_encoder), encoded_frame_event_(false, false) {}
: test_encoder_(test_encoder) {}
void WaitForEncodedFrame(int64_t expected_ntp_time) {
EXPECT_TRUE(
@ -707,7 +705,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
TEST_F(VideoStreamEncoderTest, EncodeOneFrame) {
video_stream_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
rtc::Event frame_destroyed_event(false, false);
rtc::Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
WaitForEncodedFrame(1);
EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
@ -716,7 +714,7 @@ TEST_F(VideoStreamEncoderTest, EncodeOneFrame) {
TEST_F(VideoStreamEncoderTest, DropsFramesBeforeFirstOnBitrateUpdated) {
// Dropped since no target bitrate has been set.
rtc::Event frame_destroyed_event(false, false);
rtc::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.
@ -774,7 +772,7 @@ TEST_F(VideoStreamEncoderTest, DropsFrameAfterStop) {
video_stream_encoder_->Stop();
sink_.SetExpectNoFrames();
rtc::Event frame_destroyed_event(false, false);
rtc::Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFrame(2, &frame_destroyed_event));
EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
}