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

webrtc/video/video_send_stream_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>  // max
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
+#include "webrtc/base/event.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/platform_thread.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/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"

[mflodman, 2015/12/10 08:11:34]

Remove.

[pbos-webrtc, 2015/12/10 11:44:55]

Done.

 #include "webrtc/system_wrappers/include/ref_count.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/call_test.h"
 #include "webrtc/test/configurable_frame_size_encoder.h"
 #include "webrtc/test/fake_texture_frame.h"
 #include "webrtc/test/null_transport.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video_frame.h"
 #include "webrtc/video_send_stream.h"
@@ skipping 50 matching lines @@
 
    private:
     Action OnSendRtcp(const uint8_t* packet, size_t length) override {
       RTCPUtility::RTCPParserV2 parser(packet, length, true);
       EXPECT_TRUE(parser.IsValid());
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
       while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
         if (packet_type == RTCPUtility::RTCPPacketTypes::kSdesChunk) {
           EXPECT_EQ(parser.Packet().CName.CName, kCName);
-          observation_complete_->Set();
+          observation_complete_.Set();
         }
 
         packet_type = parser.Iterate();
       }
 
       return SEND_PACKET;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->rtp.c_name = kCName;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while waiting for RTCP with CNAME.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP with CNAME.";
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
   static const uint8_t kAbsSendTimeExtensionId = 13;
   class AbsoluteSendTimeObserver : public test::SendTest {
    public:
     AbsoluteSendTimeObserver() : SendTest(kDefaultTimeoutMs) {
       EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
           kRtpExtensionAbsoluteSendTime, kAbsSendTimeExtensionId));
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
       EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
       EXPECT_EQ(header.extension.transmissionTimeOffset, 0);
       EXPECT_GT(header.extension.absoluteSendTime, 0u);
-      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 {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while waiting for single RTP packet.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for single RTP packet.";
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
   static const int kEncodeDelayMs = 5;
   class TransmissionTimeOffsetObserver : public test::SendTest {
    public:
     TransmissionTimeOffsetObserver()
         : SendTest(kDefaultTimeoutMs),
           encoder_(Clock::GetRealTimeClock(), kEncodeDelayMs) {
       EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
           kRtpExtensionTransmissionTimeOffset, test::kTOffsetExtensionId));
     }
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       EXPECT_TRUE(header.extension.hasTransmissionTimeOffset);
       EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
       EXPECT_GT(header.extension.transmissionTimeOffset, 0);
       EXPECT_EQ(header.extension.absoluteSendTime, 0u);
-      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 {
       send_config->encoder_settings.encoder = &encoder_;
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTOffset, test::kTOffsetExtensionId));
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while waiting for a single RTP packet.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
     }
 
     test::DelayedEncoder encoder_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
   static const uint8_t kExtensionId = 13;
   class TransportWideSequenceNumberObserver : public test::SendTest {
    public:
     TransportWideSequenceNumberObserver()
         : SendTest(kDefaultTimeoutMs), encoder_(Clock::GetRealTimeClock()) {
       EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
           kRtpExtensionTransportSequenceNumber, kExtensionId));
     }
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
       EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
       EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
 
-      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 {
       send_config->encoder_settings.encoder = &encoder_;
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while waiting for a single RTP packet.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
     }
 
     test::FakeEncoder encoder_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 class FakeReceiveStatistics : public NullReceiveStatistics {
  public:
@@ skipping 95 matching lines @@
 
       if (encapsulated_payload_type != -1) {
         if (encapsulated_payload_type == kUlpfecPayloadType) {
           received_fec_ = true;
         } else {
           received_media_ = true;
         }
       }
 
       if (received_media_ && received_fec_)
-        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 {
       transport_adapter_.reset(
           new internal::TransportAdapter(send_config->send_transport));
       transport_adapter_->Enable();
@@ skipping 57 matching lines @@
           retransmit_ssrc_ != kSendSsrcs[0]) {
         // Not kSendSsrcs[0], assume correct RTX packet. Extract sequence
         // number.
         const uint8_t* rtx_header = packet + header.headerLength;
         sequence_number = (rtx_header[0] << 8) + rtx_header[1];
       }
 
       if (sequence_number == nacked_sequence_number_) {
         EXPECT_EQ(retransmit_ssrc_, header.ssrc);
         EXPECT_EQ(retransmit_payload_type_, header.payloadType);
-        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 {
       transport_adapter_.reset(
           new internal::TransportAdapter(send_config->send_transport));
       transport_adapter_->Enable();
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       send_config->rtp.rtx.payload_type = retransmit_payload_type_;
       if (retransmit_ssrc_ != kSendSsrcs[0])
         send_config->rtp.rtx.ssrcs.push_back(retransmit_ssrc_);
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while waiting for NACK retransmission.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for NACK retransmission.";
     }
 
     rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
     int send_count_;
     uint32_t retransmit_ssrc_;
     uint8_t retransmit_payload_type_;
     int nacked_sequence_number_;
   } test(retransmit_ssrc, retransmit_payload_type);
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
@@ skipping 95 matching lines @@
         EXPECT_GE(accumulated_size_, current_size_rtp_);
         if (test_generic_packetization_) {
           EXPECT_EQ(current_size_rtp_, accumulated_payload_);
         }
 
         // Last packet of frame; reset counters.
         accumulated_size_ = 0;
         accumulated_payload_ = 0;
         if (current_size_rtp_ == stop_size_) {
           // Done! (Don't increase size again, might arrive more @ stop_size).
-          observation_complete_->Set();
+          observation_complete_.Set();
         } else {
           // Increase next expected frame size. If testing with FEC, make sure
           // a FEC packet has been received for this frame size before
           // proceeding, to make sure that redundancy packets don't exceed
           // size limit.
           if (!use_fec_) {
             ++current_size_rtp_;
           } else if (fec_packet_received_) {
             fec_packet_received_ = false;
             ++current_size_rtp_;
@@ skipping 58 matching lines @@
       send_config->encoder_settings.encoder = &encoder_;
       send_config->rtp.max_packet_size = kMaxPacketSize;
       send_config->post_encode_callback = this;
 
       // Make sure there is at least one extension header, to make the RTP
       // header larger than the base length of 12 bytes.
       EXPECT_FALSE(send_config->rtp.extensions.empty());
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while observing incoming RTP packets.";
+      EXPECT_TRUE(Wait()) << "Timed out while observing incoming RTP packets.";
     }
 
     rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
     test::ConfigurableFrameSizeEncoder encoder_;
 
     const size_t max_packet_size_;
     const size_t stop_size_;
     const bool test_generic_packetization_;
     const bool use_fec_;
 
@@ skipping 79 matching lines @@
         if (header.paddingLength == 0) {
           // Non-padding packet observed. Test is almost complete. Will just
           // have to wait for the stats to change.
           test_state_ = kWaitingForStats;
         }
         SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
       } else if (test_state_ == kWaitingForStats) {
         VideoSendStream::Stats stats = stream_->GetStats();
         if (stats.suspended == false) {
           // Stats flipped to false. Test is complete.
-          observation_complete_->Set();
+          observation_complete_.Set();
         }
         SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
       }
 
       return SEND_PACKET;
     }
 
     // This method implements the I420FrameCallback.
     void FrameCallback(VideoFrame* video_frame) override {
       rtc::CritScope lock(&crit_);
@@ skipping 33 matching lines @@
       send_config->suspend_below_min_bitrate = true;
       int min_bitrate_bps = encoder_config->streams[0].min_bitrate_bps;
       set_low_remb_bps(min_bitrate_bps - 10000);
       int threshold_window = std::max(min_bitrate_bps / 10, 10000);
       ASSERT_GT(encoder_config->streams[0].max_bitrate_bps,
                 min_bitrate_bps + threshold_window + 5000);
       set_high_remb_bps(min_bitrate_bps + threshold_window + 5000);
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out during suspend-below-min-bitrate test.";
+      EXPECT_TRUE(Wait()) << "Timed out during suspend-below-min-bitrate test.";
     }
 
     enum TestState {
       kBeforeSuspend,
       kDuringSuspend,
       kWaitingForPacket,
       kWaitingForStats
     };
 
     virtual void SendRtcpFeedback(int remb_value)
@@ skipping 46 matching lines @@
       capturer_->Stop();
       return SEND_PACKET;
     }
 
     Action OnSendRtcp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&crit_);
       const int kVideoMutedThresholdMs = 10000;
       if (last_packet_time_ms_ > 0 &&
           clock_->TimeInMilliseconds() - last_packet_time_ms_ >
               kVideoMutedThresholdMs)
-        observation_complete_->Set();
+        observation_complete_.Set();
       // Receive statistics reporting having lost 50% of the packets.
       FakeReceiveStatistics receive_stats(kSendSsrcs[0], 1, 1, 0);
       RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &receive_stats,
                              nullptr, transport_adapter_.get());
 
       rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
       rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
 
       RTCPSender::FeedbackState feedback_state;
 
@@ skipping 11 matching lines @@
 
     size_t GetNumStreams() const override { return 3; }
 
     virtual void OnFrameGeneratorCapturerCreated(
         test::FrameGeneratorCapturer* frame_generator_capturer) {
       rtc::CritScope lock(&crit_);
       capturer_ = frame_generator_capturer;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for RTP packets to stop being sent.";
     }
 
     Clock* const clock_;
     rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
     rtc::CriticalSection crit_;
     int64_t last_packet_time_ms_ GUARDED_BY(crit_);
     test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_);
   } test;
 
@@ skipping 39 matching lines @@
                           static_cast<size_t>(total_bitrate_bps),
                           "bps",
                           false);
         if (total_bitrate_bps > kHighBitrateBps) {
           rtp_rtcp_->SetREMBData(kRembBitrateBps,
                                  std::vector<uint32_t>(1, header.ssrc));
           rtp_rtcp_->Process();
           bitrate_capped_ = true;
         } else if (bitrate_capped_ &&
                    total_bitrate_bps < kRembRespectedBitrateBps) {
-          observation_complete_->Set();
+          observation_complete_.Set();
         }
       }
       // Packets don't have to be delivered since the test is the receiver.
       return DROP_PACKET;
     }
 
     void OnStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       stream_ = send_stream;
       RtpRtcp::Configuration config;
       config.outgoing_transport = feedback_transport_.get();
       rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
       rtp_rtcp_->SetREMBStatus(true);
       rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       feedback_transport_.reset(
           new internal::TransportAdapter(send_config->send_transport));
       feedback_transport_->Enable();
       encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timeout while waiting for low bitrate stats after REMB.";
     }
 
     rtc::scoped_ptr<RtpRtcp> rtp_rtcp_;
     rtc::scoped_ptr<internal::TransportAdapter> feedback_transport_;
     VideoSendStream* stream_;
     bool bitrate_capped_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
@@ skipping 55 matching lines @@
   // reported in between.
   EXPECT_EQ(bitrate_config.start_bitrate_bps / 1000,
             encoder.GetStartBitrateKbps());
 
   DestroyStreams();
 }
 
 TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
   class FrameObserver : public I420FrameCallback {
    public:
-    FrameObserver() : output_frame_event_(EventWrapper::Create()) {}
+    FrameObserver() : output_frame_event_(false, false) {}
 
     void FrameCallback(VideoFrame* video_frame) override {
       output_frames_.push_back(*video_frame);
-      output_frame_event_->Set();
+      output_frame_event_.Set();
     }
 
     void WaitOutputFrame() {
-      const unsigned long kWaitFrameTimeoutMs = 3000;
-      EXPECT_EQ(kEventSignaled, output_frame_event_->Wait(kWaitFrameTimeoutMs))
+      const int kWaitFrameTimeoutMs = 3000;
+      EXPECT_TRUE(output_frame_event_.Wait(kWaitFrameTimeoutMs))
           << "Timeout while waiting for output frames.";
     }
 
     const std::vector<VideoFrame>& output_frames() const {
       return output_frames_;
     }
 
    private:
     // Delivered output frames.
     std::vector<VideoFrame> output_frames_;
 
     // Indicate an output frame has arrived.
-    rtc::scoped_ptr<EventWrapper> output_frame_event_;
+    rtc::Event output_frame_event_;
   };
 
   // Initialize send stream.
   CreateSenderCall(Call::Config());
 
   test::NullTransport transport;
   CreateSendConfig(1, &transport);
   FrameObserver observer;
   send_config_.pre_encode_callback = &observer;
   CreateStreams();
@@ skipping 127 matching lines @@
       initialized_ = true;
       released_ = false;
       return 0;
     }
 
     int32_t Encode(const VideoFrame& inputImage,
                    const CodecSpecificInfo* codecSpecificInfo,
                    const std::vector<FrameType>* frame_types) override {
       EXPECT_TRUE(IsReadyForEncode());
 
-      observation_complete_->Set();
+      observation_complete_.Set();
       return 0;
     }
 
     int32_t RegisterEncodeCompleteCallback(
         EncodedImageCallback* callback) override {
       rtc::CritScope lock(&crit_);
       EXPECT_TRUE(initialized_);
       callback_registered_ = true;
       return 0;
     }
@@ skipping 29 matching lines @@
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
       encoder_config_ = *encoder_config;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while waiting for Encode.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
       EXPECT_EQ(0u, num_releases());
       stream_->ReconfigureVideoEncoder(encoder_config_);
       EXPECT_EQ(0u, num_releases());
       stream_->Stop();
       // Encoder should not be released before destroying the VideoSendStream.
       EXPECT_FALSE(IsReleased());
       EXPECT_TRUE(IsReadyForEncode());
       stream_->Start();
       // Sanity check, make sure we still encode frames with this encoder.
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while waiting for Encode.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
     }
 
     rtc::CriticalSection crit_;
     VideoSendStream* stream_;
     bool initialized_ GUARDED_BY(crit_);
     bool callback_registered_ GUARDED_BY(crit_);
     size_t num_releases_ GUARDED_BY(crit_);
     bool released_ GUARDED_BY(crit_);
     VideoEncoderConfig encoder_config_;
   } test_encoder;
@@ skipping 221 matching lines @@
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
       while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
         if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
           // Only compare sent media bytes if SenderPacketCount matches the
           // number of sent rtp packets (a new rtp packet could be sent before
           // the rtcp packet).
           if (parser.Packet().SR.SenderOctetCount > 0 &&
               parser.Packet().SR.SenderPacketCount == rtp_packets_sent_) {
             EXPECT_EQ(media_bytes_sent_, parser.Packet().SR.SenderOctetCount);
-            observation_complete_->Set();
+            observation_complete_.Set();
           }
         }
         packet_type = parser.Iterate();
       }
 
       return SEND_PACKET;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out while waiting for RTCP sender report.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP sender report.";
     }
 
     rtc::CriticalSection crit_;
     size_t rtp_packets_sent_ GUARDED_BY(&crit_);
     size_t media_bytes_sent_ GUARDED_BY(&crit_);
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
   static const int kScreencastTargetBitrateKbps = 200;
   class ScreencastTargetBitrateTest : public test::SendTest,
                                       public test::FakeEncoder {
    public:
     ScreencastTargetBitrateTest()
         : SendTest(kDefaultTimeoutMs),
           test::FakeEncoder(Clock::GetRealTimeClock()) {}
 
    private:
     int32_t InitEncode(const VideoCodec* config,
                        int32_t number_of_cores,
                        size_t max_payload_size) override {
       EXPECT_EQ(static_cast<unsigned int>(kScreencastTargetBitrateKbps),
                 config->targetBitrate);
-      observation_complete_->Set();
+      observation_complete_.Set();
       return test::FakeEncoder::InitEncode(
           config, number_of_cores, max_payload_size);
     }
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
       EXPECT_EQ(1u, encoder_config->streams.size());
       EXPECT_TRUE(
           encoder_config->streams[0].temporal_layer_thresholds_bps.empty());
       encoder_config->streams[0].temporal_layer_thresholds_bps.push_back(
           kScreencastTargetBitrateKbps * 1000);
       encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for the encoder to be initialized.";
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
   // These are chosen to be "kind of odd" to not be accidentally checked against
   // default values.
@@ skipping 15 matching lines @@
     int32_t InitEncode(const VideoCodec* codecSettings,
                        int32_t numberOfCores,
                        size_t maxPayloadSize) override {
       if (num_initializations_ == 0) {
         EXPECT_EQ(static_cast<unsigned int>(kMinBitrateKbps),
                   codecSettings->minBitrate);
         EXPECT_EQ(static_cast<unsigned int>(kStartBitrateKbps),
                   codecSettings->startBitrate);
         EXPECT_EQ(static_cast<unsigned int>(kMaxBitrateKbps),
                   codecSettings->maxBitrate);
-        observation_complete_->Set();
+        observation_complete_.Set();
       } else if (num_initializations_ == 1) {
         EXPECT_EQ(static_cast<unsigned int>(kLowerMaxBitrateKbps),
                   codecSettings->maxBitrate);
         // The start bitrate should be kept (-1) and capped to the max bitrate.
         // Since this is not an end-to-end call no receiver should have been
         // returning a REMB that could lower this estimate.
         EXPECT_EQ(codecSettings->startBitrate, codecSettings->maxBitrate);
       } else if (num_initializations_ == 2) {
         EXPECT_EQ(static_cast<unsigned int>(kIncreasedMaxBitrateKbps),
                   codecSettings->maxBitrate);
@@ skipping 32 matching lines @@
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
     }
 
     void PerformTest() override {
       Call::Config::BitrateConfig bitrate_config;
       bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000;
       bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000;
       call_->SetBitrateConfig(bitrate_config);
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting encoder to be configured.";
       encoder_config_.streams[0].min_bitrate_bps = 0;
       encoder_config_.streams[0].max_bitrate_bps = kLowerMaxBitrateKbps * 1000;
       send_stream_->ReconfigureVideoEncoder(encoder_config_);
       EXPECT_EQ(2, num_initializations_)
           << "Encoder should have been reconfigured with the new value.";
       encoder_config_.streams[0].target_bitrate_bps =
           encoder_config_.streams[0].min_bitrate_bps;
       encoder_config_.streams[0].max_bitrate_bps =
           kIncreasedMaxBitrateKbps * 1000;
@@ skipping 42 matching lines @@
       for (size_t i = 0; i < kNumStreams; ++i) {
         specifics.codecSpecific.generic.simulcast_idx = static_cast<uint8_t>(i);
         encoded._frameType = (*frame_types)[i];
         encoded._encodedWidth = kEncodedResolution[i].width;
         encoded._encodedHeight = kEncodedResolution[i].height;
         RTC_DCHECK(callback_ != nullptr);
         if (callback_->Encoded(encoded, &specifics, nullptr) != 0)
           return -1;
       }
 
-      observation_complete_->Set();
+      observation_complete_.Set();
       return 0;
     }
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
       EXPECT_EQ(kNumStreams, encoder_config->streams.size());
     }
 
     size_t GetNumStreams() const override { return kNumStreams; }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for the encoder to send one frame.";
       VideoSendStream::Stats stats = send_stream_->GetStats();
 
       for (size_t i = 0; i < kNumStreams; ++i) {
         ASSERT_TRUE(stats.substreams.find(kSendSsrcs[i]) !=
                     stats.substreams.end())
             << "No stats for SSRC: " << kSendSsrcs[i]
             << ", stats should exist as soon as frames have been encoded.";
         VideoSendStream::StreamStats ssrc_stats =
             stats.substreams[kSendSsrcs[i]];
@@ skipping 39 matching lines @@
                      VideoEncoderConfig* encoder_config) override {
     encoder_config->encoder_specific_settings = &vp9_settings_;
     encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
     send_config->encoder_settings.encoder = vp9_encoder_.get();
     send_config->encoder_settings.payload_name = "VP9";
     send_config->encoder_settings.payload_type = kVp9PayloadType;
     ModifyConfigsHook(send_config, receive_configs, encoder_config);
   }
 
   void PerformTest() override {
-    EXPECT_EQ(kEventSignaled, Wait())
-        << "Test timed out waiting for VP9 packet";
+    EXPECT_TRUE(Wait()) << "Test timed out waiting for VP9 packet";
   }
 
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     RTPHeader header;
     EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
     if (header.payloadType == kVp9PayloadType) {
       RtpDepacketizerVp9 vp9depacketizer;
       RtpDepacketizer::ParsedPayload vp9payload;
       const uint8_t* vp9_packet = packet + header.headerLength;
       size_t payload_length =
           length - header.headerLength - header.paddingLength;
 
       if (payload_length > 0) {
         bool parse_vp9header_successful =
             vp9depacketizer.Parse(&vp9payload, vp9_packet, payload_length);
         bool is_vp9_codec_type =
             vp9payload.type.Video.codec == RtpVideoCodecTypes::kRtpVideoVp9;
         EXPECT_TRUE(parse_vp9header_successful);
         EXPECT_TRUE(is_vp9_codec_type);
 
         RTPVideoHeaderVP9* vp9videoHeader =
             &vp9payload.type.Video.codecHeader.VP9;
         if (parse_vp9header_successful && is_vp9_codec_type) {
           InspectHeader(vp9videoHeader);
         } else {
-          observation_complete_->Set();
+          observation_complete_.Set();
         }
       }
     }
 
     return SEND_PACKET;
   }
 
  protected:
   rtc::scoped_ptr<VP9Encoder> vp9_encoder_;
   VideoCodecVP9 vp9_settings_;
 };
 
 TEST_F(VideoSendStreamTest, DISABLED_VP9FlexMode) {
   class FlexibleMode : public VP9HeaderObeserver {
     void ModifyConfigsHook(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       vp9_settings_.flexibleMode = true;
     }
 
     void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override {
       EXPECT_TRUE(vp9videoHeader->flexible_mode);
-      observation_complete_->Set();
+      observation_complete_.Set();
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, VP9FlexModeHasPictureId) {
   class FlexibleMode : public VP9HeaderObeserver {
     void ModifyConfigsHook(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       vp9_settings_.flexibleMode = true;
     }
 
     void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override {
       EXPECT_NE(vp9videoHeader->picture_id, kNoPictureId);
-      observation_complete_->Set();
+      observation_complete_.Set();
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, VP9FlexModeRefCount) {
   class FlexibleMode : public VP9HeaderObeserver {
     void ModifyConfigsHook(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       vp9_settings_.flexibleMode = true;
     }
 
     void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override {
       EXPECT_TRUE(vp9videoHeader->flexible_mode);
       if (vp9videoHeader->inter_pic_predicted) {
         EXPECT_GT(vp9videoHeader->num_ref_pics, 0u);
-        observation_complete_->Set();
+        observation_complete_.Set();
       }
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, VP9FlexModeRefs) {
   class FlexibleMode : public VP9HeaderObeserver {
     void ModifyConfigsHook(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       vp9_settings_.flexibleMode = true;
     }
 
     void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override {
       EXPECT_TRUE(vp9videoHeader->flexible_mode);
       if (vp9videoHeader->inter_pic_predicted) {
         EXPECT_GT(vp9videoHeader->num_ref_pics, 0u);
-        observation_complete_->Set();
+        observation_complete_.Set();
       }
     }
 
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 }  // namespace webrtc