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

webrtc/call/call_perf_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>
@@ skipping 154 matching lines @@
       if (first_time_in_sync_ == -1) {
         first_time_in_sync_ = now_ms;
         webrtc::test::PrintResult("sync_convergence_time",
                                   "",
                                   "synchronization",
                                   time_since_creation,
                                   "ms",
                                   false);
       }
       if (time_since_creation > kMinRunTimeMs)
-        observation_complete_->Set();
+        observation_complete_.Set();
     }
   }
 
   bool IsTextureSupported() const override { return false; }
 
  private:
   Clock* const clock_;
   const int voe_channel_;
   VoEVideoSync* const voe_sync_;
   SyncRtcpObserver* const audio_observer_;
@@ skipping 118 matching lines @@
 
   CreateFrameGeneratorCapturer();
 
   Start();
 
   fake_audio_device.Start();
   EXPECT_EQ(0, voe_base->StartPlayout(channel));
   EXPECT_EQ(0, voe_base->StartReceive(channel));
   EXPECT_EQ(0, voe_base->StartSend(channel));
 
-  EXPECT_EQ(kEventSignaled, observer.Wait())
+  EXPECT_TRUE(observer.Wait())
       << "Timed out while waiting for audio and video to be synchronized.";
 
   EXPECT_EQ(0, voe_base->StopSend(channel));
   EXPECT_EQ(0, voe_base->StopReceive(channel));
   EXPECT_EQ(0, voe_base->StopPlayout(channel));
   fake_audio_device.Stop();
 
   Stop();
   sync_send_transport.StopSending();
   sync_receive_transport.StopSending();
@@ skipping 56 matching lines @@
       }
 
       int64_t now_ms = clock_->TimeInMilliseconds();
       int64_t time_since_creation = now_ms - creation_time_ms_;
       if (time_since_creation < start_time_ms_) {
         // Wait for |start_time_ms_| before start measuring.
         return;
       }
 
       if (time_since_creation > run_time_ms_) {
-        observation_complete_->Set();
+        observation_complete_.Set();
       }
 
       FrameCaptureTimeList::iterator iter =
           capture_time_list_.find(video_frame.timestamp());
       EXPECT_TRUE(iter != capture_time_list_.end());
 
       // The real capture time has been wrapped to uint32_t before converted
       // to rtp timestamp in the sender side. So here we convert the estimated
       // capture time to a uint32_t 90k timestamp also for comparing.
       uint32_t estimated_capture_timestamp =
@@ skipping 39 matching lines @@
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       (*receive_configs)[0].renderer = this;
       // Enable the receiver side rtt calculation.
       (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = true;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for "
-                                           "estimated capture NTP time to be "
-                                           "within bounds.";
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for "
+                             "estimated capture NTP time to be "
+                             "within bounds.";
     }
 
     rtc::CriticalSection crit_;
     Clock* const clock_;
     int threshold_ms_;
     int start_time_ms_;
     int run_time_ms_;
     int64_t creation_time_ms_;
     test::FrameGeneratorCapturer* capturer_;
     bool rtp_start_timestamp_set_;
@@ skipping 32 matching lines @@
                                   int encode_delay_ms) {
   class LoadObserver : public test::SendTest, public webrtc::LoadObserver {
    public:
     LoadObserver(LoadObserver::Load tested_load, int encode_delay_ms)
         : SendTest(kLongTimeoutMs),
           tested_load_(tested_load),
           encoder_(Clock::GetRealTimeClock(), encode_delay_ms) {}
 
     void OnLoadUpdate(Load load) override {
       if (load == tested_load_)
-        observation_complete_->Set();
+        observation_complete_.Set();
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->overuse_callback = this;
       send_config->encoder_settings.encoder = &encoder_;
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timed out before receiving an overuse callback.";
+      EXPECT_TRUE(Wait()) << "Timed out before receiving an overuse callback.";
     }
 
     LoadObserver::Load tested_load_;
     test::DelayedEncoder encoder_;
   } test(tested_load, encode_delay_ms);
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(CallPerfTest, ReceivesCpuUnderuse) {
@@ skipping 47 matching lines @@
             // Expect bitrate stats to roughly match the max encode bitrate.
             if (bitrate_kbps > (kMaxEncodeBitrateKbps -
                                 kAcceptableBitrateErrorMargin / 2) &&
                 bitrate_kbps < (kMaxEncodeBitrateKbps +
                                 kAcceptableBitrateErrorMargin / 2)) {
               ++num_bitrate_observations_in_range_;
             }
           }
           if (num_bitrate_observations_in_range_ ==
               kNumBitrateObservationsInRange)
-            observation_complete_->Set();
+            observation_complete_.Set();
         }
       }
       return SEND_PACKET;
     }
 
     void OnStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       if (pad_to_min_bitrate_) {
         encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
       } else {
         RTC_DCHECK_EQ(0, encoder_config->min_transmit_bitrate_bps);
       }
     }
 
     void PerformTest() override {
-      EXPECT_EQ(kEventSignaled, Wait())
-          << "Timeout while waiting for send-bitrate stats.";
+      EXPECT_TRUE(Wait()) << "Timeout while waiting for send-bitrate stats.";
     }
 
     VideoSendStream* send_stream_;
     const bool pad_to_min_bitrate_;
     int num_bitrate_observations_in_range_;
   } test(pad_to_min_bitrate);
 
   fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(CallPerfTest, PadsToMinTransmitBitrate) { TestMinTransmitBitrate(true); }
 
 TEST_F(CallPerfTest, NoPadWithoutMinTransmitBitrate) {
   TestMinTransmitBitrate(false);
 }
 
 TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
   static const uint32_t kInitialBitrateKbps = 400;
   static const uint32_t kReconfigureThresholdKbps = 600;
   static const uint32_t kPermittedReconfiguredBitrateDiffKbps = 100;
 
   class BitrateObserver : public test::EndToEndTest, public test::FakeEncoder {
    public:
     BitrateObserver()
         : EndToEndTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
-          time_to_reconfigure_(webrtc::EventWrapper::Create()),
+          time_to_reconfigure_(false, false),
           encoder_inits_(0),
           last_set_bitrate_(0),
           send_stream_(nullptr) {}
 
     int32_t InitEncode(const VideoCodec* config,
                        int32_t number_of_cores,
                        size_t max_payload_size) override {
       if (encoder_inits_ == 0) {
         EXPECT_EQ(kInitialBitrateKbps, config->startBitrate)
             << "Encoder not initialized at expected bitrate.";
       }
       ++encoder_inits_;
       if (encoder_inits_ == 2) {
         EXPECT_GE(last_set_bitrate_, kReconfigureThresholdKbps);
         EXPECT_NEAR(config->startBitrate,
                     last_set_bitrate_,
                     kPermittedReconfiguredBitrateDiffKbps)
             << "Encoder reconfigured with bitrate too far away from last set.";
-        observation_complete_->Set();
+        observation_complete_.Set();
       }
       return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
     }
 
     int32_t SetRates(uint32_t new_target_bitrate_kbps,
                      uint32_t framerate) override {
       last_set_bitrate_ = new_target_bitrate_kbps;
       if (encoder_inits_ == 1 &&
           new_target_bitrate_kbps > kReconfigureThresholdKbps) {
-        time_to_reconfigure_->Set();
+        time_to_reconfigure_.Set();
       }
       return FakeEncoder::SetRates(new_target_bitrate_kbps, framerate);
     }
 
     Call::Config GetSenderCallConfig() override {
       Call::Config config = EndToEndTest::GetSenderCallConfig();
       config.bitrate_config.start_bitrate_bps = kInitialBitrateKbps * 1000;
       return config;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
       encoder_config->streams[0].min_bitrate_bps = 50000;
       encoder_config->streams[0].target_bitrate_bps =
           encoder_config->streams[0].max_bitrate_bps = 2000000;
 
       encoder_config_ = *encoder_config;
     }
 
     void OnStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
     }
 
     void PerformTest() override {
-      ASSERT_EQ(kEventSignaled, time_to_reconfigure_->Wait(kDefaultTimeoutMs))
+      ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeoutMs))
           << "Timed out before receiving an initial high bitrate.";
       encoder_config_.streams[0].width *= 2;
       encoder_config_.streams[0].height *= 2;
       EXPECT_TRUE(send_stream_->ReconfigureVideoEncoder(encoder_config_));
-      EXPECT_EQ(kEventSignaled, Wait())
+      EXPECT_TRUE(Wait())
           << "Timed out while waiting for a couple of high bitrate estimates "
              "after reconfiguring the send stream.";
     }
 
    private:
-    rtc::scoped_ptr<webrtc::EventWrapper> time_to_reconfigure_;
+    rtc::Event time_to_reconfigure_;
     int encoder_inits_;
     uint32_t last_set_bitrate_;
     VideoSendStream* send_stream_;
     VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 }  // namespace webrtc