Replace EventWrapper in video/, test/ and call/.

webrtc/video/end_to_end_tests.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include <algorithm>
 #include <map>
 #include <sstream>
 #include <string>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/call.h"
 #include "webrtc/call/transport_adapter.h"
 #include "webrtc/frame_callback.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
-#include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/call_test.h"
 #include "webrtc/test/direct_transport.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_audio_device.h"
 #include "webrtc/test/fake_decoder.h"
 #include "webrtc/test/fake_encoder.h"
 #include "webrtc/test/frame_generator.h"
 #include "webrtc/test/frame_generator_capturer.h"
 #include "webrtc/test/histogram.h"
 #include "webrtc/test/null_transport.h"
 #include "webrtc/test/rtcp_packet_parser.h"
 #include "webrtc/test/rtp_rtcp_observer.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/gtest_disable.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #include "webrtc/video_encoder.h"
 
 namespace webrtc {
 
-static const uint32_t kSilenceTimeoutMs = 2000;
+static const int kSilenceTimeoutMs = 2000;
 
 class EndToEndTest : public test::CallTest {
  public:
   EndToEndTest() {}
 
   virtual ~EndToEndTest() {
     EXPECT_EQ(nullptr, send_stream_);
     EXPECT_TRUE(receive_streams_.empty());
   }
 
@@ skipping 55 matching lines @@
 TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
   static const int kWidth = 320;
   static const int kHeight = 240;
   // This constant is chosen to be higher than the timeout in the video_render
   // module. This makes sure that frames aren't dropped if there are no other
   // frames in the queue.
   static const int kDelayRenderCallbackMs = 1000;
 
   class Renderer : public VideoRenderer {
    public:
-    Renderer() : event_(EventWrapper::Create()) {}
+    Renderer() : event_(false, false) {}
 
     void RenderFrame(const VideoFrame& video_frame,
                      int /*time_to_render_ms*/) override {
-      event_->Set();
+      event_.Set();
     }
 
     bool IsTextureSupported() const override { return false; }
 
-    EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
+    bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
-    rtc::scoped_ptr<EventWrapper> event_;
+    rtc::Event event_;
   } renderer;
 
   class TestFrameCallback : public I420FrameCallback {
    public:
-    TestFrameCallback() : event_(EventWrapper::Create()) {}
+    TestFrameCallback() : event_(false, false) {}
 
-    EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
+    bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
    private:
     void FrameCallback(VideoFrame* frame) override {
       SleepMs(kDelayRenderCallbackMs);
-      event_->Set();
+      event_.Set();
     }
 
-    rtc::scoped_ptr<EventWrapper> event_;
+    rtc::Event event_;
   };
 
   CreateCalls(Call::Config(), Call::Config());
 
   test::DirectTransport sender_transport(sender_call_.get());
   test::DirectTransport receiver_transport(receiver_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
 
   TestFrameCallback pre_render_callback;
   receive_configs_[0].pre_render_callback = &pre_render_callback;
   receive_configs_[0].renderer = &renderer;
 
   CreateStreams();
   Start();
 
   // Create frames that are smaller than the send width/height, this is done to
   // check that the callbacks are done after processing video.
   rtc::scoped_ptr<test::FrameGenerator> frame_generator(
       test::FrameGenerator::CreateChromaGenerator(kWidth, kHeight));
   send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
-  EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
+  EXPECT_TRUE(pre_render_callback.Wait())
       << "Timed out while waiting for pre-render callback.";
-  EXPECT_EQ(kEventSignaled, renderer.Wait())
+  EXPECT_TRUE(renderer.Wait())
       << "Timed out while waiting for the frame to render.";
 
   Stop();
 
   sender_transport.StopSending();
   receiver_transport.StopSending();
 
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, TransmitsFirstFrame) {
   class Renderer : public VideoRenderer {
    public:
-    Renderer() : event_(EventWrapper::Create()) {}
+    Renderer() : event_(false, false) {}
 
     void RenderFrame(const VideoFrame& video_frame,
                      int /*time_to_render_ms*/) override {
-      event_->Set();
+      event_.Set();
     }
     bool IsTextureSupported() const override { return false; }
 
-    EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
+    bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
-    rtc::scoped_ptr<EventWrapper> event_;
+    rtc::Event event_;
   } renderer;
 
   CreateCalls(Call::Config(), Call::Config());
 
   test::DirectTransport sender_transport(sender_call_.get());
   test::DirectTransport receiver_transport(receiver_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
   receive_configs_[0].renderer = &renderer;
 
   CreateStreams();
   Start();
 
   rtc::scoped_ptr<test::FrameGenerator> frame_generator(
       test::FrameGenerator::CreateChromaGenerator(
           encoder_config_.streams[0].width, encoder_config_.streams[0].height));
   send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
 
-  EXPECT_EQ(kEventSignaled, renderer.Wait())
+  EXPECT_TRUE(renderer.Wait())
       << "Timed out while waiting for the frame to render.";
 
   Stop();
 
   sender_transport.StopSending();
   receiver_transport.StopSending();
 
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, SendsAndReceivesVP9) {
   class VP9Observer : public test::EndToEndTest, public VideoRenderer {
    public:
     VP9Observer()
         : EndToEndTest(2 * kDefaultTimeoutMs),
           encoder_(VideoEncoder::Create(VideoEncoder::kVp9)),
           decoder_(VP9Decoder::Create()),
           frame_counter_(0) {}
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for enough frames to be decoded.";
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = encoder_.get();
       send_config->encoder_settings.payload_name = "VP9";
       send_config->encoder_settings.payload_type = 124;
       encoder_config->streams[0].min_bitrate_bps = 50000;
       encoder_config->streams[0].target_bitrate_bps =
           encoder_config->streams[0].max_bitrate_bps = 2000000;
 
       (*receive_configs)[0].renderer = this;
       (*receive_configs)[0].decoders.resize(1);
       (*receive_configs)[0].decoders[0].payload_type =
           send_config->encoder_settings.payload_type;
       (*receive_configs)[0].decoders[0].payload_name =
           send_config->encoder_settings.payload_name;
       (*receive_configs)[0].decoders[0].decoder = decoder_.get();
     }
 
     void RenderFrame(const VideoFrame& video_frame,
                      int time_to_render_ms) override {
       const int kRequiredFrames = 500;
       if (++frame_counter_ == kRequiredFrames)
-        observation_complete_->Set();
+        observation_complete_.Set();
     }
 
     bool IsTextureSupported() const override { return false; }
 
    private:
     rtc::scoped_ptr<webrtc::VideoEncoder> encoder_;
     rtc::scoped_ptr<webrtc::VideoDecoder> decoder_;
     int frame_counter_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, SendsAndReceivesH264) {
   class H264Observer : public test::EndToEndTest, public VideoRenderer {
    public:
     H264Observer()
         : EndToEndTest(2 * kDefaultTimeoutMs),
           fake_encoder_(Clock::GetRealTimeClock()),
           frame_counter_(0) {}
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for enough frames to be decoded.";
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms =
           (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       send_config->encoder_settings.encoder = &fake_encoder_;
       send_config->encoder_settings.payload_name = "H264";
       send_config->encoder_settings.payload_type = kFakeSendPayloadType;
       encoder_config->streams[0].min_bitrate_bps = 50000;
       encoder_config->streams[0].target_bitrate_bps =
           encoder_config->streams[0].max_bitrate_bps = 2000000;
 
       (*receive_configs)[0].renderer = this;
       (*receive_configs)[0].decoders.resize(1);
       (*receive_configs)[0].decoders[0].payload_type =
           send_config->encoder_settings.payload_type;
       (*receive_configs)[0].decoders[0].payload_name =
           send_config->encoder_settings.payload_name;
       (*receive_configs)[0].decoders[0].decoder = &fake_decoder_;
     }
 
     void RenderFrame(const VideoFrame& video_frame,
                      int time_to_render_ms) override {
       const int kRequiredFrames = 500;
       if (++frame_counter_ == kRequiredFrames)
-        observation_complete_->Set();
+        observation_complete_.Set();
     }
 
     bool IsTextureSupported() const override { return false; }
 
    private:
     test::FakeH264Decoder fake_decoder_;
     test::FakeH264Encoder fake_encoder_;
     int frame_counter_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
   class SyncRtcpObserver : public test::EndToEndTest {
    public:
     SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {}
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
       RTCPUtility::RTCPParserV2 parser(packet, length, true);
       EXPECT_TRUE(parser.IsValid());
       uint32_t ssrc = 0;
       ssrc |= static_cast<uint32_t>(packet[4]) << 24;
       ssrc |= static_cast<uint32_t>(packet[5]) << 16;
       ssrc |= static_cast<uint32_t>(packet[6]) << 8;
       ssrc |= static_cast<uint32_t>(packet[7]) << 0;
       EXPECT_EQ(kReceiverLocalSsrc, ssrc);
-      observation_complete_->Set();
+      observation_complete_.Set();
 
       return SEND_PACKET;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for a receiver RTCP packet to be sent.";
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
   static const int kNumberOfNacksToObserve = 2;
   static const int kLossBurstSize = 2;
@@ skipping 11 matching lines @@
       rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       // Never drop retransmitted packets.
       if (dropped_packets_.find(header.sequenceNumber) !=
           dropped_packets_.end()) {
         retransmitted_packets_.insert(header.sequenceNumber);
         if (nacks_left_ <= 0 &&
             retransmitted_packets_.size() == dropped_packets_.size()) {
-          observation_complete_->Set();
+          observation_complete_.Set();
         }
         return SEND_PACKET;
       }
 
       ++sent_rtp_packets_;
 
       // Enough NACKs received, stop dropping packets.
       if (nacks_left_ <= 0)
         return SEND_PACKET;
 
@@ skipping 28 matching lines @@
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out waiting for packets to be NACKed, retransmitted and "
              "rendered.";
     }
 
     rtc::CriticalSection crit_;
     std::set<uint16_t> dropped_packets_;
     std::set<uint16_t> retransmitted_packets_;
     uint64_t sent_rtp_packets_;
     int packets_left_to_drop_;
     int nacks_left_ GUARDED_BY(&crit_);
@@ skipping 56 matching lines @@
 
       return SEND_PACKET;
     }
 
     void RenderFrame(const VideoFrame& video_frame,
                      int time_to_render_ms) override {
       rtc::CritScope lock(&crit_);
       // Rendering frame with timestamp of packet that was dropped -> FEC
       // protection worked.
       if (protected_timestamps_.count(video_frame.timestamp()) != 0)
-        observation_complete_->Set();
+        observation_complete_.Set();
     }
 
     bool IsTextureSupported() const override { return false; }
 
     enum {
       kFirstPacket,
       kDropEveryOtherPacketUntilFec,
       kDropNextMediaPacket,
     } state_;
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       // TODO(pbos): Run this test with combined NACK/FEC enabled as well.
       // int rtp_history_ms = 1000;
       // (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms;
       // send_config->rtp.nack.rtp_history_ms = rtp_history_ms;
       send_config->rtp.fec.red_payload_type = kRedPayloadType;
       send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
 
       (*receive_configs)[0].rtp.fec.red_payload_type = kRedPayloadType;
       (*receive_configs)[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
       (*receive_configs)[0].renderer = this;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out waiting for dropped frames frames to be rendered.";
     }
 
     rtc::CriticalSection crit_;
     std::set<uint32_t> protected_sequence_numbers_ GUARDED_BY(crit_);
     std::set<uint32_t> protected_timestamps_ GUARDED_BY(crit_);
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
@@ skipping 64 matching lines @@
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock_(&crit_);
       if (state_ == kVerifyFecPacketNotInNackList) {
         test::RtcpPacketParser rtcp_parser;
         rtcp_parser.Parse(packet, length);
         std::vector<uint16_t> nacks = rtcp_parser.nack_item()->last_nack_list();
         if (!nacks.empty() &&
             IsNewerSequenceNumber(nacks.back(), fec_sequence_number_)) {
           EXPECT_TRUE(std::find(
               nacks.begin(), nacks.end(), fec_sequence_number_) == nacks.end());
-          observation_complete_->Set();
+          observation_complete_.Set();
         }
       }
       return SEND_PACKET;
     }
 
     // TODO(holmer): Investigate why we don't send FEC packets when the bitrate
     // is 10 kbps.
     Call::Config GetSenderCallConfig() override {
       Call::Config config;
       const int kMinBitrateBps = 30000;
       config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
       return config;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       // Configure hybrid NACK/FEC.
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       send_config->rtp.fec.red_payload_type = kRedPayloadType;
       send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.fec.red_payload_type = kRedPayloadType;
       (*receive_configs)[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for FEC packets to be received.";
     }
 
     enum {
       kFirstPacket,
       kDropEveryOtherPacketUntilFec,
       kDropAllMediaPacketsUntilFec,
       kVerifyFecPacketNotInNackList,
     } state_;
 
@@ skipping 61 matching lines @@
         return DROP_PACKET;
       }
 
       return SEND_PACKET;
     }
 
     void FrameCallback(VideoFrame* frame) override {
       rtc::CritScope lock(&crit_);
       if (frame->timestamp() == retransmitted_timestamp_) {
         EXPECT_TRUE(frame_retransmitted_);
-        observation_complete_->Set();
+        observation_complete_.Set();
       }
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].pre_render_callback = this;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 
       if (payload_type_ == kRedPayloadType) {
         send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
         send_config->rtp.fec.red_payload_type = kRedPayloadType;
         (*receive_configs)[0].rtp.fec.red_payload_type = kRedPayloadType;
         (*receive_configs)[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
       }
 
       if (retransmission_ssrc_ == kSendRtxSsrcs[0]) {
         send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
         send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
         (*receive_configs)[0].rtp.rtx[kFakeSendPayloadType].ssrc =
             kSendRtxSsrcs[0];
         (*receive_configs)[0].rtp.rtx[kFakeSendPayloadType].payload_type =
             kSendRtxPayloadType;
       }
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for retransmission to render.";
     }
 
     int GetPayloadType(bool use_rtx, bool use_red) {
       return use_rtx ? kSendRtxPayloadType
                      : (use_red ? kRedPayloadType : kFakeSendPayloadType);
     }
 
     rtc::CriticalSection crit_;
     const int payload_type_;
@@ skipping 23 matching lines @@
 TEST_F(EndToEndTest, DecodesRetransmittedFrameByRedOverRtx) {
   DecodesRetransmittedFrame(true, true);
 }
 
 TEST_F(EndToEndTest, UsesFrameCallbacks) {
   static const int kWidth = 320;
   static const int kHeight = 240;
 
   class Renderer : public VideoRenderer {
    public:
-    Renderer() : event_(EventWrapper::Create()) {}
+    Renderer() : event_(false, false) {}
 
     void RenderFrame(const VideoFrame& video_frame,
                      int /*time_to_render_ms*/) override {
       EXPECT_EQ(0, *video_frame.buffer(kYPlane))
           << "Rendered frame should have zero luma which is applied by the "
              "pre-render callback.";
-      event_->Set();
+      event_.Set();
     }
 
     bool IsTextureSupported() const override { return false; }
 
-    EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
-    rtc::scoped_ptr<EventWrapper> event_;
+    bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
+    rtc::Event event_;
   } renderer;
 
   class TestFrameCallback : public I420FrameCallback {
    public:
     TestFrameCallback(int expected_luma_byte, int next_luma_byte)
-        : event_(EventWrapper::Create()),
+        : event_(false, false),
           expected_luma_byte_(expected_luma_byte),
           next_luma_byte_(next_luma_byte) {}
 
-    EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
+    bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
    private:
     virtual void FrameCallback(VideoFrame* frame) {
       EXPECT_EQ(kWidth, frame->width())
           << "Width not as expected, callback done before resize?";
       EXPECT_EQ(kHeight, frame->height())
           << "Height not as expected, callback done before resize?";
 
       // Previous luma specified, observed luma should be fairly close.
       if (expected_luma_byte_ != -1) {
         EXPECT_NEAR(expected_luma_byte_, *frame->buffer(kYPlane), 10);
       }
 
       memset(frame->buffer(kYPlane),
              next_luma_byte_,
              frame->allocated_size(kYPlane));
 
-      event_->Set();
+      event_.Set();
     }
 
-    rtc::scoped_ptr<EventWrapper> event_;
+    rtc::Event event_;
     int expected_luma_byte_;
     int next_luma_byte_;
   };
 
   TestFrameCallback pre_encode_callback(-1, 255);  // Changes luma to 255.
   TestFrameCallback pre_render_callback(255, 0);  // Changes luma from 255 to 0.
 
   CreateCalls(Call::Config(), Call::Config());
 
   test::DirectTransport sender_transport(sender_call_.get());
@@ skipping 17 matching lines @@
 
   CreateStreams();
   Start();
 
   // Create frames that are smaller than the send width/height, this is done to
   // check that the callbacks are done after processing video.
   rtc::scoped_ptr<test::FrameGenerator> frame_generator(
       test::FrameGenerator::CreateChromaGenerator(kWidth / 2, kHeight / 2));
   send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
 
-  EXPECT_EQ(kEventSignaled, pre_encode_callback.Wait())
+  EXPECT_TRUE(pre_encode_callback.Wait())
       << "Timed out while waiting for pre-encode callback.";
-  EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
+  EXPECT_TRUE(pre_render_callback.Wait())
       << "Timed out while waiting for pre-render callback.";
-  EXPECT_EQ(kEventSignaled, renderer.Wait())
+  EXPECT_TRUE(renderer.Wait())
       << "Timed out while waiting for the frame to render.";
 
   Stop();
 
   sender_transport.StopSending();
   receiver_transport.StopSending();
 
   DestroyStreams();
 }
 
@@ skipping 46 matching lines @@
         }
       }
       return SEND_PACKET;
     }
 
     void RenderFrame(const VideoFrame& video_frame,
                      int time_to_render_ms) override {
       rtc::CritScope lock(&crit_);
       if (received_pli_ &&
           video_frame.timestamp() > highest_dropped_timestamp_) {
-        observation_complete_->Set();
+        observation_complete_.Set();
       }
       if (!received_pli_)
         frames_to_drop_ = kPacketsToDrop;
     }
 
     bool IsTextureSupported() const override { return false; }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = rtp_history_ms_;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
       (*receive_configs)[0].renderer = this;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait()) << "Timed out waiting for PLI to be "
-                                           "received and a frame to be "
-                                           "rendered afterwards.";
+      EXPECT_TRUE(Wait()) << "Timed out waiting for PLI to be "
+                             "received and a frame to be "
+                             "rendered afterwards.";
     }
 
     rtc::CriticalSection crit_;
     int rtp_history_ms_;
     bool nack_enabled_;
     uint32_t highest_dropped_timestamp_ GUARDED_BY(&crit_);
     int frames_to_drop_ GUARDED_BY(&crit_);
     bool received_pli_ GUARDED_BY(&crit_);
   } test(rtp_history_ms);
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, ReceivesPliAndRecoversWithNack) {
   ReceivesPliAndRecovers(1000);
 }
 
 TEST_F(EndToEndTest, ReceivesPliAndRecoversWithoutNack) {
   ReceivesPliAndRecovers(0);
 }
 
 TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
   class PacketInputObserver : public PacketReceiver {
    public:
     explicit PacketInputObserver(PacketReceiver* receiver)
-        : receiver_(receiver), delivered_packet_(EventWrapper::Create()) {}
+        : receiver_(receiver), delivered_packet_(false, false) {}
 
-    EventTypeWrapper Wait() {
-      return delivered_packet_->Wait(kDefaultTimeoutMs);
-    }
+    bool Wait() { return delivered_packet_.Wait(kDefaultTimeoutMs); }
 
    private:
     DeliveryStatus DeliverPacket(MediaType media_type,
                                  const uint8_t* packet,
                                  size_t length,
                                  const PacketTime& packet_time) override {
       if (RtpHeaderParser::IsRtcp(packet, length)) {
         return receiver_->DeliverPacket(media_type, packet, length,
                                         packet_time);
       } else {
         DeliveryStatus delivery_status =
             receiver_->DeliverPacket(media_type, packet, length, packet_time);
         EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status);
-        delivered_packet_->Set();
+        delivered_packet_.Set();
         return delivery_status;
       }
     }
 
     PacketReceiver* receiver_;
-    rtc::scoped_ptr<EventWrapper> delivered_packet_;
+    rtc::Event delivered_packet_;
   };
 
   CreateCalls(Call::Config(), Call::Config());
 
   test::DirectTransport send_transport(sender_call_.get());
   test::DirectTransport receive_transport(receiver_call_.get());
   PacketInputObserver input_observer(receiver_call_->Receiver());
   send_transport.SetReceiver(&input_observer);
   receive_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, &send_transport);
   CreateMatchingReceiveConfigs(&receive_transport);
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
   Start();
 
   receiver_call_->DestroyVideoReceiveStream(receive_streams_[0]);
   receive_streams_.clear();
 
   // Wait() waits for a received packet.
-  EXPECT_EQ(kEventSignaled, input_observer.Wait());
+  EXPECT_TRUE(input_observer.Wait());
 
   Stop();
 
   DestroyStreams();
 
   send_transport.StopSending();
   receive_transport.StopSending();
 }
 
 void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
@@ skipping 28 matching lines @@
           break;
         }
         packet_type = parser.Iterate();
       }
 
       switch (rtcp_mode_) {
         case RtcpMode::kCompound:
           if (!has_report_block) {
             ADD_FAILURE() << "Received RTCP packet without receiver report for "
                              "RtcpMode::kCompound.";
-            observation_complete_->Set();
+            observation_complete_.Set();
           }
 
           if (sent_rtcp_ >= kNumCompoundRtcpPacketsToObserve)
-            observation_complete_->Set();
+            observation_complete_.Set();
 
           break;
         case RtcpMode::kReducedSize:
           if (!has_report_block)
-            observation_complete_->Set();
+            observation_complete_.Set();
           break;
         case RtcpMode::kOff:
           RTC_NOTREACHED();
           break;
       }
 
       return SEND_PACKET;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << (rtcp_mode_ == RtcpMode::kCompound
                   ? "Timed out before observing enough compound packets."
                   : "Timed out before receiving a non-compound RTCP packet.");
     }
 
     RtcpMode rtcp_mode_;
     int sent_rtp_;
     int sent_rtcp_;
   } test(rtcp_mode);
 
@@ skipping 130 matching lines @@
 // as every renderer has received a frame, the test finishes.
 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
   class VideoOutputObserver : public VideoRenderer {
    public:
     VideoOutputObserver(const MultiStreamTest::CodecSettings& settings,
                         uint32_t ssrc,
                         test::FrameGeneratorCapturer** frame_generator)
         : settings_(settings),
           ssrc_(ssrc),
           frame_generator_(frame_generator),
-          done_(EventWrapper::Create()) {}
+          done_(false, false) {}
 
     void RenderFrame(const VideoFrame& video_frame,
                      int time_to_render_ms) override {
       EXPECT_EQ(settings_.width, video_frame.width());
       EXPECT_EQ(settings_.height, video_frame.height());
       (*frame_generator_)->Stop();
-      done_->Set();
+      done_.Set();
     }
 
     uint32_t Ssrc() { return ssrc_; }
 
     bool IsTextureSupported() const override { return false; }
 
-    EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); }
+    bool Wait() { return done_.Wait(kDefaultTimeoutMs); }
 
    private:
     const MultiStreamTest::CodecSettings& settings_;
     const uint32_t ssrc_;
     test::FrameGeneratorCapturer** const frame_generator_;
-    rtc::scoped_ptr<EventWrapper> done_;
+    rtc::Event done_;
   };
 
   class Tester : public MultiStreamTest {
    public:
     Tester() {}
     virtual ~Tester() {}
 
    protected:
     void Wait() override {
       for (const auto& observer : observers_) {
-        EXPECT_EQ(EventTypeWrapper::kEventSignaled, observer->Wait())
-            << "Time out waiting for from on ssrc " << observer->Ssrc();
+        EXPECT_TRUE(observer->Wait()) << "Time out waiting for from on ssrc "
+                                      << observer->Ssrc();
       }
     }
 
     void UpdateSendConfig(
         size_t stream_index,
         VideoSendStream::Config* send_config,
         VideoEncoderConfig* encoder_config,
         test::FrameGeneratorCapturer** frame_generator) override {
       observers_[stream_index].reset(new VideoOutputObserver(
           codec_settings[stream_index], send_config->rtp.ssrcs.front(),
@@ skipping 15 matching lines @@
 
 TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
   static const int kExtensionId = 5;
 
   class RtpExtensionHeaderObserver : public test::DirectTransport {
    public:
     RtpExtensionHeaderObserver(Call* sender_call,
                                const uint32_t& first_media_ssrc,
                                const std::map<uint32_t, uint32_t>& ssrc_map)
         : DirectTransport(sender_call),
-          done_(EventWrapper::Create()),
+          done_(false, false),
           parser_(RtpHeaderParser::Create()),
           first_media_ssrc_(first_media_ssrc),
           rtx_to_media_ssrcs_(ssrc_map),
           padding_observed_(false),
           rtx_padding_observed_(false),
           retransmit_observed_(false),
           started_(false) {
       parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
                                           kExtensionId);
     }
@@ skipping 48 matching lines @@
               retransmit_observed_ = true;
               seq_no_map->erase(it);
             } else {
               rtx_padding_observed_ = true;
             }
           } else {
             streams_observed_.insert(header.ssrc);
           }
 
           if (IsDone())
-            done_->Set();
+            done_.Set();
 
           if (drop_packet)
             return true;
         }
       }
 
       return test::DirectTransport::SendRtp(data, length, options);
     }
 
     bool IsDone() {
       bool observed_types_ok =
           streams_observed_.size() == MultiStreamTest::kNumStreams &&
           padding_observed_ && retransmit_observed_ && rtx_padding_observed_;
       if (!observed_types_ok)
         return false;
       // We should not have any gaps in the sequence number range.
       size_t seqno_range =
           *received_packed_ids_.rbegin() - *received_packed_ids_.begin() + 1;
       return seqno_range == received_packed_ids_.size();
     }
 
-    EventTypeWrapper Wait() {
+    bool Wait() {
       {
         // Can't be sure until this point that rtx_to_media_ssrcs_ etc have
         // been initialized and are OK to read.
         rtc::CritScope cs(&lock_);
         started_ = true;
       }
-      return done_->Wait(kDefaultTimeoutMs);
+      return done_.Wait(kDefaultTimeoutMs);
     }
 
     rtc::CriticalSection lock_;
-    rtc::scoped_ptr<EventWrapper> done_;
+    rtc::Event done_;
     rtc::scoped_ptr<RtpHeaderParser> parser_;
     SequenceNumberUnwrapper unwrapper_;
     std::set<int64_t> received_packed_ids_;
     std::set<uint32_t> streams_observed_;
     std::map<uint32_t, std::set<uint16_t>> dropped_seq_;
     const uint32_t& first_media_ssrc_;
     const std::map<uint32_t, uint32_t>& rtx_to_media_ssrcs_;
     bool padding_observed_;
     bool rtx_padding_observed_;
     bool retransmit_observed_;
     bool started_;
   };
 
   class TransportSequenceNumberTester : public MultiStreamTest {
    public:
     TransportSequenceNumberTester()
         : first_media_ssrc_(0), observer_(nullptr) {}
     virtual ~TransportSequenceNumberTester() {}
 
    protected:
     void Wait() override {
       RTC_DCHECK(observer_ != nullptr);
-      EXPECT_EQ(EventTypeWrapper::kEventSignaled, observer_->Wait());
+      EXPECT_TRUE(observer_->Wait());
     }
 
     void UpdateSendConfig(
         size_t stream_index,
         VideoSendStream::Config* send_config,
         VideoEncoderConfig* encoder_config,
         test::FrameGeneratorCapturer** frame_generator) override {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
@@ skipping 116 matching lines @@
 }
 
 TEST_F(EndToEndTest, TransportFeedbackNotConfigured) {
   TransportFeedbackTest(false);
 }
 
 TEST_F(EndToEndTest, ObserversEncodedFrames) {
   class EncodedFrameTestObserver : public EncodedFrameObserver {
    public:
     EncodedFrameTestObserver()
-        : length_(0),
-          frame_type_(kEmptyFrame),
-          called_(EventWrapper::Create()) {}
+        : length_(0), frame_type_(kEmptyFrame), called_(false, false) {}
     virtual ~EncodedFrameTestObserver() {}
 
     virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
       frame_type_ = encoded_frame.frame_type_;
       length_ = encoded_frame.length_;
       buffer_.reset(new uint8_t[length_]);
       memcpy(buffer_.get(), encoded_frame.data_, length_);
-      called_->Set();
+      called_.Set();
     }
 
-    EventTypeWrapper Wait() { return called_->Wait(kDefaultTimeoutMs); }
+    bool Wait() { return called_.Wait(kDefaultTimeoutMs); }
 
     void ExpectEqualFrames(const EncodedFrameTestObserver& observer) {
       ASSERT_EQ(length_, observer.length_)
           << "Observed frames are of different lengths.";
       EXPECT_EQ(frame_type_, observer.frame_type_)
           << "Observed frames have different frame types.";
       EXPECT_EQ(0, memcmp(buffer_.get(), observer.buffer_.get(), length_))
           << "Observed encoded frames have different content.";
     }
 
    private:
     rtc::scoped_ptr<uint8_t[]> buffer_;
     size_t length_;
     FrameType frame_type_;
-    rtc::scoped_ptr<EventWrapper> called_;
+    rtc::Event called_;
   };
 
   EncodedFrameTestObserver post_encode_observer;
   EncodedFrameTestObserver pre_decode_observer;
 
   CreateCalls(Call::Config(), Call::Config());
 
   test::DirectTransport sender_transport(sender_call_.get());
   test::DirectTransport receiver_transport(receiver_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
   send_config_.post_encode_callback = &post_encode_observer;
   receive_configs_[0].pre_decode_callback = &pre_decode_observer;
 
   CreateStreams();
   Start();
 
   rtc::scoped_ptr<test::FrameGenerator> frame_generator(
       test::FrameGenerator::CreateChromaGenerator(
           encoder_config_.streams[0].width, encoder_config_.streams[0].height));
   send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
 
-  EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
+  EXPECT_TRUE(post_encode_observer.Wait())
       << "Timed out while waiting for send-side encoded-frame callback.";
 
-  EXPECT_EQ(kEventSignaled, pre_decode_observer.Wait())
+  EXPECT_TRUE(pre_decode_observer.Wait())
       << "Timed out while waiting for pre-decode encoded-frame callback.";
 
   post_encode_observer.ExpectEqualFrames(pre_decode_observer);
 
   Stop();
 
   sender_transport.StopSending();
   receiver_transport.StopSending();
 
   DestroyStreams();
@@ skipping 19 matching lines @@
         } else if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbRembItem) {
           const RTCPUtility::RTCPPacket& packet = parser.Packet();
           EXPECT_GT(packet.REMBItem.BitRate, 0u);
           EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u);
           EXPECT_EQ(packet.REMBItem.SSRCs[0], kSendSsrcs[0]);
           received_remb = true;
         }
         packet_type = parser.Iterate();
       }
       if (received_psfb && received_remb)
-        observation_complete_->Set();
+        observation_complete_.Set();
       return SEND_PACKET;
     }
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for a "
-                                           "receiver RTCP REMB packet to be "
-                                           "sent.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for a "
+                             "receiver RTCP REMB packet to be "
+                             "sent.";
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(EndToEndTest, VerifyBandwidthStats) {
   class RtcpObserver : public test::EndToEndTest {
    public:
     RtcpObserver()
         : EndToEndTest(kDefaultTimeoutMs),
           sender_call_(nullptr),
           receiver_call_(nullptr),
           has_seen_pacer_delay_(false) {}
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       Call::Stats sender_stats = sender_call_->GetStats();
       Call::Stats receiver_stats = receiver_call_->GetStats();
       if (!has_seen_pacer_delay_)
         has_seen_pacer_delay_ = sender_stats.pacer_delay_ms > 0;
       if (sender_stats.send_bandwidth_bps > 0 &&
           receiver_stats.recv_bandwidth_bps > 0 && has_seen_pacer_delay_) {
-        observation_complete_->Set();
+        observation_complete_.Set();
       }
       return SEND_PACKET;
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
       sender_call_ = sender_call;
       receiver_call_ = receiver_call;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for "
-                                           "non-zero bandwidth stats.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for "
+                             "non-zero bandwidth stats.";
     }
 
    private:
     Call* sender_call_;
     Call* receiver_call_;
     bool has_seen_pacer_delay_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
@@ skipping 49 matching lines @@
             stream_stats.rtcp_packet_type_counts.nack_packets;
       }
       for (size_t i = 0; i < receive_streams_.size(); ++i) {
         VideoReceiveStream::Stats stats = receive_streams_[i]->GetStats();
         receive_stream_nack_packets +=
             stats.rtcp_packet_type_counts.nack_packets;
       }
       if (send_stream_nack_packets >= 1 && receive_stream_nack_packets >= 1) {
         // NACK packet sent on receive stream and received on sent stream.
         if (MinMetricRunTimePassed())
-          observation_complete_->Set();
+          observation_complete_.Set();
       }
     }
 
     bool MinMetricRunTimePassed() {
       int64_t now = Clock::GetRealTimeClock()->TimeInMilliseconds();
       if (start_runtime_ms_ == -1) {
         start_runtime_ms_ = now;
         return false;
       }
       int64_t elapsed_sec = (now - start_runtime_ms_) / 1000;
       return elapsed_sec > metrics::kMinRunTimeInSeconds;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     }
 
     void OnStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
       receive_streams_ = receive_streams;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out waiting for packet to be NACKed.";
+      EXPECT_TRUE(Wait()) << "Timed out waiting for packet to be NACKed.";
     }
 
     rtc::CriticalSection crit_;
     uint64_t sent_rtp_packets_;
     uint16_t dropped_rtp_packet_ GUARDED_BY(&crit_);
     bool dropped_rtp_packet_requested_ GUARDED_BY(&crit_);
     std::vector<VideoReceiveStream*> receive_streams_;
     VideoSendStream* send_stream_;
     int64_t start_runtime_ms_;
   } test;
@@ skipping 21 matching lines @@
           use_rtx_(use_rtx),
           use_red_(use_red),
           screenshare_(screenshare),
           sender_call_(nullptr),
           receiver_call_(nullptr),
           start_runtime_ms_(-1) {}
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       if (MinMetricRunTimePassed())
-        observation_complete_->Set();
+        observation_complete_.Set();
 
       // GetStats calls GetSendChannelRtcpStatistics
       // (via VideoSendStream::GetRtt) which updates ReportBlockStats used by
       // WebRTC.Video.SentPacketsLostInPercent.
       // TODO(asapersson): Remove dependency on calling GetStats.
       sender_call_->GetStats();
 
       return SEND_PACKET;
     }
 
@@ skipping 33 matching lines @@
           screenshare_ ? VideoEncoderConfig::ContentType::kScreen
                        : VideoEncoderConfig::ContentType::kRealtimeVideo;
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
       sender_call_ = sender_call;
       receiver_call_ = receiver_call;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out waiting for packet to be NACKed.";
+      EXPECT_TRUE(Wait()) << "Timed out waiting for packet to be NACKed.";
     }
 
     const bool use_rtx_;
     const bool use_red_;
     const bool screenshare_;
     Call* sender_call_;
     Call* receiver_call_;
     int64_t start_runtime_ms_;
   } test(use_rtx, use_red, screenshare);
 
@@ skipping 186 matching lines @@
       }
       if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&
           sent_rtcp_rr_ > kNumRtcpReportPacketsToObserve) {
         if (enable_rrtr_) {
           EXPECT_GT(sent_rtcp_rrtr_, 0);
           EXPECT_GT(sent_rtcp_dlrr_, 0);
         } else {
           EXPECT_EQ(0, sent_rtcp_rrtr_);
           EXPECT_EQ(0, sent_rtcp_dlrr_);
         }
-        observation_complete_->Set();
+        observation_complete_.Set();
       }
       return SEND_PACKET;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       (*receive_configs)[0].rtp.rtcp_mode = RtcpMode::kReducedSize;
       (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report =
           enable_rrtr_;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for RTCP SR/RR packets to be sent.";
     }
 
     rtc::CriticalSection crit_;
     bool enable_rrtr_;
     int sent_rtcp_sr_;
     int sent_rtcp_rr_ GUARDED_BY(&crit_);
     int sent_rtcp_rrtr_ GUARDED_BY(&crit_);
     int sent_rtcp_dlrr_;
   } test(enable_rrtr);
@@ skipping 20 matching lines @@
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       EXPECT_TRUE(valid_ssrcs_[header.ssrc])
           << "Received unknown SSRC: " << header.ssrc;
 
       if (!valid_ssrcs_[header.ssrc])
-        observation_complete_->Set();
+        observation_complete_.Set();
 
       if (!is_observed_[header.ssrc]) {
         is_observed_[header.ssrc] = true;
         --ssrcs_to_observe_;
         if (expect_single_ssrc_) {
           expect_single_ssrc_ = false;
-          observation_complete_->Set();
+          observation_complete_.Set();
         }
       }
 
       if (ssrcs_to_observe_ == 0)
-        observation_complete_->Set();
+        observation_complete_.Set();
 
       return SEND_PACKET;
     }
 
     size_t GetNumStreams() const override { return num_ssrcs_; }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       if (num_ssrcs_ > 1) {
@@ skipping 10 matching lines @@
         encoder_config->streams.resize(1);
     }
 
     void OnStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while waiting for "
-          << (send_single_ssrc_first_ ? "first SSRC." : "SSRCs.");
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for "
+                          << (send_single_ssrc_first_ ? "first SSRC."
+                                                      : "SSRCs.");
 
       if (send_single_ssrc_first_) {
         // Set full simulcast and continue with the rest of the SSRCs.
         send_stream_->ReconfigureVideoEncoder(encoder_config_all_streams_);
-        EXPECT_EQ(kEventSignaled, Wait())
-            << "Timed out while waiting on additional SSRCs.";
+        EXPECT_TRUE(Wait()) << "Timed out while waiting on additional SSRCs.";
       }
     }
 
    private:
     std::map<uint32_t, bool> valid_ssrcs_;
     std::map<uint32_t, bool> is_observed_;
 
     const size_t num_ssrcs_;
     const bool send_single_ssrc_first_;
 
@@ skipping 28 matching lines @@
                        VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
     }
 
     int32_t SetRates(uint32_t new_target_bitrate, uint32_t framerate) override {
       // Make sure not to trigger on any default zero bitrates.
       if (new_target_bitrate == 0)
         return 0;
       rtc::CritScope lock(&crit_);
       bitrate_kbps_ = new_target_bitrate;
-      observation_complete_->Set();
+      observation_complete_.Set();
       return 0;
     }
 
     void PerformTest() override {
-      ASSERT_EQ(kEventSignaled, Wait())
+      ASSERT_TRUE(Wait())
           << "Timed out while waiting for encoder SetRates() call.";
       // Wait for GetStats to report a corresponding bitrate.
-      for (unsigned int i = 0; i < kDefaultTimeoutMs; ++i) {
+      for (int i = 0; i < kDefaultTimeoutMs; ++i) {
         VideoSendStream::Stats stats = send_stream_->GetStats();
         {
           rtc::CritScope lock(&crit_);
           if ((stats.target_media_bitrate_bps + 500) / 1000 ==
               static_cast<int>(bitrate_kbps_)) {
             return;
           }
         }
         SleepMs(1);
       }
@@ skipping 12 matching lines @@
 
 TEST_F(EndToEndTest, GetStats) {
   static const int kStartBitrateBps = 3000000;
   static const int kExpectedRenderDelayMs = 20;
   class StatsObserver : public test::EndToEndTest, public I420FrameCallback {
    public:
     StatsObserver()
         : EndToEndTest(kLongTimeoutMs),
           send_stream_(nullptr),
           expected_send_ssrcs_(),
-          check_stats_event_(EventWrapper::Create()) {}
+          check_stats_event_(false, false) {}
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      check_stats_event_->Set();
+      check_stats_event_.Set();
       return SEND_PACKET;
     }
 
     Action OnSendRtcp(const uint8_t* packet, size_t length) override {
-      check_stats_event_->Set();
+      check_stats_event_.Set();
       return SEND_PACKET;
     }
 
     Action OnReceiveRtp(const uint8_t* packet, size_t length) override {
-      check_stats_event_->Set();
+      check_stats_event_.Set();
       return SEND_PACKET;
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
-      check_stats_event_->Set();
+      check_stats_event_.Set();
       return SEND_PACKET;
     }
 
     void FrameCallback(VideoFrame* video_frame) override {
       // Ensure that we have at least 5ms send side delay.
       int64_t render_time = video_frame->render_time_ms();
       if (render_time > 0)
         video_frame->set_render_time_ms(render_time - 5);
     }
 
@@ skipping 169 matching lines @@
         if (!receive_ok)
           receive_ok = CheckReceiveStats();
         if (!send_ok)
           send_ok = CheckSendStats();
 
         if (receive_ok && send_ok)
           return;
 
         int64_t time_until_timout_ = stop_time - now;
         if (time_until_timout_ > 0)
-          check_stats_event_->Wait(time_until_timout_);
+          check_stats_event_.Wait(time_until_timout_);
         now = clock->TimeInMilliseconds();
       }
 
       ADD_FAILURE() << "Timed out waiting for filled stats.";
       for (std::map<std::string, bool>::const_iterator it =
                receive_stats_filled_.begin();
            it != receive_stats_filled_.end();
            ++it) {
         if (!it->second) {
           ADD_FAILURE() << "Missing receive stats: " << it->first;
@@ skipping 13 matching lines @@
     std::vector<VideoReceiveStream*> receive_streams_;
     std::map<std::string, bool> receive_stats_filled_;
 
     VideoSendStream* send_stream_;
     std::map<std::string, bool> send_stats_filled_;
 
     std::vector<uint32_t> expected_receive_ssrcs_;
     std::set<uint32_t> expected_send_ssrcs_;
     std::string expected_cname_;
 
-    rtc::scoped_ptr<EventWrapper> check_stats_event_;
+    rtc::Event check_stats_event_;
   } test;
 
   FakeNetworkPipe::Config network_config;
   network_config.loss_percent = 5;
   RunBaseTest(&test, network_config);
 }
 
 TEST_F(EndToEndTest, ReceiverReferenceTimeReportEnabled) {
   TestXrReceiverReferenceTimeReport(true);
 }
@@ skipping 15 matching lines @@
     void OnStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       receive_stream_ = receive_streams[0];
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       if (sent_rtp_ >= kNumRtpPacketsToSend) {
         VideoReceiveStream::Stats stats = receive_stream_->GetStats();
         if (kNumRtpPacketsToSend == stats.rtp_stats.transmitted.packets) {
-          observation_complete_->Set();
+          observation_complete_.Set();
         }
         return DROP_PACKET;
       }
       ++sent_rtp_;
       return SEND_PACKET;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while verifying number of received RTP packets.";
     }
 
     VideoReceiveStream* receive_stream_;
     uint32_t sent_rtp_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
@@ skipping 28 matching lines @@
       EXPECT_LE(header.headerLength + header.paddingLength, length);
       const bool packet_is_redundant_payload =
           header.headerLength + header.paddingLength < length;
 
       if (!packet_is_redundant_payload)
         return SEND_PACKET;
 
       if (!observed_redundant_retransmission_[header.ssrc]) {
         observed_redundant_retransmission_[header.ssrc] = true;
         if (--ssrcs_to_observe_ == 0)
-          observation_complete_->Set();
+          observation_complete_.Set();
       }
 
       return SEND_PACKET;
     }
 
     size_t GetNumStreams() const override { return kNumSsrcs; }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
       for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
         encoder_config->streams[i].min_bitrate_bps = 10000;
         encoder_config->streams[i].target_bitrate_bps = 15000;
         encoder_config->streams[i].max_bitrate_bps = 20000;
       }
 
       send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
 
       for (size_t i = 0; i < kNumSsrcs; ++i)
         send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
 
       // Significantly higher than max bitrates for all video streams -> forcing
       // padding to trigger redundant padding on all RTX SSRCs.
       encoder_config->min_transmit_bitrate_bps = 100000;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for redundant payloads on all SSRCs.";
     }
 
    private:
     size_t ssrcs_to_observe_;
     std::map<uint32_t, bool> observed_redundant_retransmission_;
     std::map<uint32_t, bool> registered_rtx_ssrc_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
@@ skipping 68 matching lines @@
               << " -> " << timestamp << ") too large for SSRC: " << ssrc << ".";
         }
         last_observed_timestamp_[ssrc] = timestamp;
       }
 
       rtc::CritScope lock(&crit_);
       // Wait for media packets on all ssrcs.
       if (!ssrc_observed_[ssrc] && !only_padding) {
         ssrc_observed_[ssrc] = true;
         if (--ssrcs_to_observe_ == 0)
-          observation_complete_->Set();
+          observation_complete_.Set();
       }
 
       return SEND_PACKET;
     }
 
     std::map<uint32_t, uint16_t> last_observed_sequence_number_;
     std::map<uint32_t, uint32_t> last_observed_timestamp_;
     std::map<uint32_t, bool> configured_ssrcs_;
 
     rtc::CriticalSection crit_;
@@ skipping 40 matching lines @@
     one_stream.streams.front().max_bitrate_bps +=
         encoder_config_.streams[i].max_bitrate_bps;
   }
 
   CreateMatchingReceiveConfigs(&receive_transport);
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
 
   Start();
-  EXPECT_EQ(kEventSignaled, observer.Wait())
+  EXPECT_TRUE(observer.Wait())
       << "Timed out waiting for all SSRCs to send packets.";
 
   // Test stream resetting more than once to make sure that the state doesn't
   // get set once (this could be due to using std::map::insert for instance).
   for (size_t i = 0; i < 3; ++i) {
     frame_generator_capturer_->Stop();
     sender_call_->DestroyVideoSendStream(send_stream_);
 
     // Re-create VideoSendStream with only one stream.
     send_stream_ =
         sender_call_->CreateVideoSendStream(send_config_, one_stream);
     send_stream_->Start();
     CreateFrameGeneratorCapturer();
     frame_generator_capturer_->Start();
 
     observer.ResetExpectedSsrcs(1);
-    EXPECT_EQ(kEventSignaled, observer.Wait())
-        << "Timed out waiting for single RTP packet.";
+    EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
 
     // Reconfigure back to use all streams.
     send_stream_->ReconfigureVideoEncoder(encoder_config_);
     observer.ResetExpectedSsrcs(kNumSsrcs);
-    EXPECT_EQ(kEventSignaled, observer.Wait())
+    EXPECT_TRUE(observer.Wait())
         << "Timed out waiting for all SSRCs to send packets.";
 
     // Reconfigure down to one stream.
     send_stream_->ReconfigureVideoEncoder(one_stream);
     observer.ResetExpectedSsrcs(1);
-    EXPECT_EQ(kEventSignaled, observer.Wait())
-        << "Timed out waiting for single RTP packet.";
+    EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
 
     // Reconfigure back to use all streams.
     send_stream_->ReconfigureVideoEncoder(encoder_config_);
     observer.ResetExpectedSsrcs(kNumSsrcs);
-    EXPECT_EQ(kEventSignaled, observer.Wait())
+    EXPECT_TRUE(observer.Wait())
         << "Timed out waiting for all SSRCs to send packets.";
   }
 
   send_transport.StopSending();
   receive_transport.StopSending();
 
   Stop();
   DestroyStreams();
 }
 
@@ skipping 13 matching lines @@
   // checking paused_ again. This should be enough for one round of pacing,
   // otherwise increase.
   static const int kNumAcceptedDowntimeRtp = 5;
   // A single RTCP may be in the pipeline.
   static const int kNumAcceptedDowntimeRtcp = 1;
   class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder {
    public:
     NetworkStateTest()
         : EndToEndTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
-          encoded_frames_(EventWrapper::Create()),
-          packet_event_(EventWrapper::Create()),
+          encoded_frames_(false, false),
+          packet_event_(false, false),
           sender_call_(nullptr),
           receiver_call_(nullptr),
           sender_state_(kNetworkUp),
           sender_rtp_(0),
           sender_rtcp_(0),
           receiver_rtcp_(0),
           down_frames_(0) {}
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&test_crit_);
       ++sender_rtp_;
-      packet_event_->Set();
+      packet_event_.Set();
       return SEND_PACKET;
     }
 
     Action OnSendRtcp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&test_crit_);
       ++sender_rtcp_;
-      packet_event_->Set();
+      packet_event_.Set();
       return SEND_PACKET;
     }
 
     Action OnReceiveRtp(const uint8_t* packet, size_t length) override {
       ADD_FAILURE() << "Unexpected receiver RTP, should not be sending.";
       return SEND_PACKET;
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&test_crit_);
       ++receiver_rtcp_;
-      packet_event_->Set();
+      packet_event_.Set();
       return SEND_PACKET;
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
       sender_call_ = sender_call;
       receiver_call_ = receiver_call;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, encoded_frames_->Wait(kDefaultTimeoutMs))
+      EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs))
           << "No frames received by the encoder.";
       // Wait for packets from both sender/receiver.
       WaitForPacketsOrSilence(false, false);
 
       // Sender-side network down.
       sender_call_->SignalNetworkState(kNetworkDown);
       {
         rtc::CritScope lock(&test_crit_);
         // After network goes down we shouldn't be encoding more frames.
         sender_state_ = kNetworkDown;
@@ skipping 20 matching lines @@
     int32_t Encode(const VideoFrame& input_image,
                    const CodecSpecificInfo* codec_specific_info,
                    const std::vector<FrameType>* frame_types) override {
       {
         rtc::CritScope lock(&test_crit_);
         if (sender_state_ == kNetworkDown) {
           ++down_frames_;
           EXPECT_LE(down_frames_, 1)
               << "Encoding more than one frame while network is down.";
           if (down_frames_ > 1)
-            encoded_frames_->Set();
+            encoded_frames_.Set();
         } else {
-          encoded_frames_->Set();
+          encoded_frames_.Set();
         }
       }
       return test::FakeEncoder::Encode(
           input_image, codec_specific_info, frame_types);
     }
 
    private:
     void WaitForPacketsOrSilence(bool sender_down, bool receiver_down) {
       int64_t initial_time_ms = clock_->TimeInMilliseconds();
       int initial_sender_rtp;
       int initial_sender_rtcp;
       int initial_receiver_rtcp;
       {
         rtc::CritScope lock(&test_crit_);
         initial_sender_rtp = sender_rtp_;
         initial_sender_rtcp = sender_rtcp_;
         initial_receiver_rtcp = receiver_rtcp_;
       }
       bool sender_done = false;
       bool receiver_done = false;
       while (!sender_done || !receiver_done) {
-        packet_event_->Wait(kSilenceTimeoutMs);
+        packet_event_.Wait(kSilenceTimeoutMs);
         int64_t time_now_ms = clock_->TimeInMilliseconds();
         rtc::CritScope lock(&test_crit_);
         if (sender_down) {
           ASSERT_LE(sender_rtp_ - initial_sender_rtp, kNumAcceptedDowntimeRtp)
               << "RTP sent during sender-side downtime.";
           ASSERT_LE(sender_rtcp_ - initial_sender_rtcp,
                     kNumAcceptedDowntimeRtcp)
               << "RTCP sent during sender-side downtime.";
           if (time_now_ms - initial_time_ms >=
               static_cast<int64_t>(kSilenceTimeoutMs)) {
@@ skipping 12 matching lines @@
             receiver_done = true;
           }
         } else {
           if (receiver_rtcp_ > initial_receiver_rtcp)
             receiver_done = true;
         }
       }
     }
 
     rtc::CriticalSection test_crit_;
-    const rtc::scoped_ptr<EventWrapper> encoded_frames_;
-    const rtc::scoped_ptr<EventWrapper> packet_event_;
+    rtc::Event encoded_frames_;
+    rtc::Event packet_event_;
     Call* sender_call_;
     Call* receiver_call_;
     NetworkState sender_state_ GUARDED_BY(test_crit_);
     int sender_rtp_ GUARDED_BY(test_crit_);
     int sender_rtcp_ GUARDED_BY(test_crit_);
     int receiver_rtcp_ GUARDED_BY(test_crit_);
     int down_frames_ GUARDED_BY(test_crit_);
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
@@ skipping 127 matching lines @@
   EXPECT_TRUE(default_receive_config.rtp.rtx.empty())
       << "Enabling RTX requires rtpmap: rtx negotiation.";
   EXPECT_TRUE(default_receive_config.rtp.extensions.empty())
       << "Enabling RTP extensions require negotiation.";
 
   VerifyEmptyNackConfig(default_receive_config.rtp.nack);
   VerifyEmptyFecConfig(default_receive_config.rtp.fec);
 }
 
 }  // namespace webrtc