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

webrtc/video/video_quality_test.cc

 /*
  *  Copyright (c) 2015 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 <stdio.h>
 
 #include <algorithm>
 #include <deque>
 #include <map>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/event.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/call.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/system_wrappers/include/cpu_info.h"
 #include "webrtc/test/layer_filtering_transport.h"
 #include "webrtc/test/run_loop.h"
 #include "webrtc/test/statistics.h"
@@ skipping 32 matching lines @@
         ssrc_to_analyze_(ssrc_to_analyze),
         frames_to_process_(duration_frames),
         frames_recorded_(0),
         frames_processed_(0),
         dropped_frames_(0),
         last_render_time_(0),
         rtp_timestamp_delta_(0),
         avg_psnr_threshold_(avg_psnr_threshold),
         avg_ssim_threshold_(avg_ssim_threshold),
         stats_polling_thread_(&PollStatsThread, this, "StatsPoller"),
-        comparison_available_event_(EventWrapper::Create()),
-        done_(EventWrapper::Create()) {
+        comparison_available_event_(false, false),
+        done_(false, false) {
     // Create thread pool for CPU-expensive PSNR/SSIM calculations.
 
     // Try to use about as many threads as cores, but leave kMinCoresLeft alone,
     // so that we don't accidentally starve "real" worker threads (codec etc).
     // Also, don't allocate more than kMaxComparisonThreads, even if there are
     // spare cores.
 
     uint32_t num_cores = CpuInfo::DetectNumberOfCores();
     RTC_DCHECK_GE(num_cores, 1u);
     static const uint32_t kMinCoresLeft = 4;
@@ skipping 130 matching lines @@
   bool IsTextureSupported() const override { return false; }
 
   void Wait() {
     // Frame comparisons can be very expensive. Wait for test to be done, but
     // at time-out check if frames_processed is going up. If so, give it more
     // time, otherwise fail. Hopefully this will reduce test flakiness.
 
     stats_polling_thread_.Start();
 
     int last_frames_processed = -1;
-    EventTypeWrapper eventType;
     int iteration = 0;
-    while ((eventType = done_->Wait(VideoQualityTest::kDefaultTimeoutMs)) !=
-           kEventSignaled) {
+    while (!done_.Wait(VideoQualityTest::kDefaultTimeoutMs)) {
       int frames_processed;
       {
         rtc::CritScope crit(&comparison_lock_);
         frames_processed = frames_processed_;
       }
 
       // Print some output so test infrastructure won't think we've crashed.
       const char* kKeepAliveMessages[3] = {
           "Uh, I'm-I'm not quite dead, sir.",
           "Uh, I-I think uh, I could pull through, sir.",
           "Actually, I think I'm all right to come with you--"};
       printf("- %s\n", kKeepAliveMessages[iteration++ % 3]);
 
       if (last_frames_processed == -1) {
         last_frames_processed = frames_processed;
         continue;
       }
       ASSERT_GT(frames_processed, last_frames_processed)
           << "Analyzer stalled while waiting for test to finish.";
       last_frames_processed = frames_processed;
     }
 
     if (iteration > 0)
       printf("- Farewell, sweet Concorde!\n");
 
     // Signal stats polling thread if that is still waiting and stop it now,
     // since it uses the send_stream_ reference that might be reclaimed after
     // returning from this method.
-    done_->Set();
+    done_.Set();
     stats_polling_thread_.Stop();
   }
 
   VideoCaptureInput* input_;
   test::LayerFilteringTransport* const transport_;
   PacketReceiver* receiver_;
   VideoSendStream* send_stream_;
 
  private:
   struct FrameComparison {
@@ skipping 76 matching lines @@
 
     VideoFrame reference_copy;
     VideoFrame render_copy;
     reference_copy.CopyFrame(reference);
     render_copy.CopyFrame(render);
 
     rtc::CritScope crit(&comparison_lock_);
     comparisons_.push_back(FrameComparison(reference_copy, render_copy, dropped,
                                            send_time_ms, recv_time_ms,
                                            render_time_ms, encoded_size));
-    comparison_available_event_->Set();
+    comparison_available_event_.Set();
   }
 
   static bool PollStatsThread(void* obj) {
     return static_cast<VideoAnalyzer*>(obj)->PollStats();
   }
 
   bool PollStats() {
-    switch (done_->Wait(kSendStatsPollingIntervalMs)) {
-      case kEventSignaled:
-      case kEventError:
-        done_->Set();  // Make sure main thread is also signaled.
-        return false;
-      case kEventTimeout:
-        break;
-      default:
-        RTC_NOTREACHED();
+    if (done_.Wait(kSendStatsPollingIntervalMs)) {
+      // Set event again to make sure main thread is also signaled, then we're
+      // done.
+      done_.Set();
+      return false;
     }
 
     VideoSendStream::Stats stats = send_stream_->GetStats();
 
     rtc::CritScope crit(&comparison_lock_);
     encode_frame_rate_.AddSample(stats.encode_frame_rate);
     encode_time_ms.AddSample(stats.avg_encode_time_ms);
     encode_usage_percent.AddSample(stats.encode_usage_percent);
     media_bitrate_bps.AddSample(stats.media_bitrate_bps);
 
     return true;
   }
 
   static bool FrameComparisonThread(void* obj) {
     return static_cast<VideoAnalyzer*>(obj)->CompareFrames();
   }
 
   bool CompareFrames() {
     if (AllFramesRecorded())
       return false;
 
     VideoFrame reference;
     VideoFrame render;
     FrameComparison comparison;
 
     if (!PopComparison(&comparison)) {
       // Wait until new comparison task is available, or test is done.
       // If done, wake up remaining threads waiting.
-      comparison_available_event_->Wait(1000);
+      comparison_available_event_.Wait(1000);
       if (AllFramesRecorded()) {
-        comparison_available_event_->Set();
+        comparison_available_event_.Set();
         return false;
       }
       return true;  // Try again.
     }
 
     PerformFrameComparison(comparison);
 
     if (FrameProcessed()) {
       PrintResults();
       if (graph_data_output_file_)
         PrintSamplesToFile();
-      done_->Set();
-      comparison_available_event_->Set();
+      done_.Set();
+      comparison_available_event_.Set();
       return false;
     }
 
     return true;
   }
 
   bool PopComparison(FrameComparison* comparison) {
     rtc::CritScope crit(&comparison_lock_);
     // If AllFramesRecorded() is true, it means we have already popped
     // frames_to_process_ frames from comparisons_, so there is no more work
@@ skipping 170 matching lines @@
   std::map<uint32_t, int64_t> send_times_ GUARDED_BY(crit_);
   std::map<uint32_t, int64_t> recv_times_ GUARDED_BY(crit_);
   std::map<uint32_t, size_t> encoded_frame_sizes_ GUARDED_BY(crit_);
   VideoFrame first_send_frame_ GUARDED_BY(crit_);
   const double avg_psnr_threshold_;
   const double avg_ssim_threshold_;
 
   rtc::CriticalSection comparison_lock_;
   std::vector<rtc::PlatformThread*> comparison_thread_pool_;
   rtc::PlatformThread stats_polling_thread_;
-  const rtc::scoped_ptr<EventWrapper> comparison_available_event_;
+  rtc::Event comparison_available_event_;
   std::deque<FrameComparison> comparisons_ GUARDED_BY(comparison_lock_);
-  const rtc::scoped_ptr<EventWrapper> done_;
+  rtc::Event done_;
 };
 
 VideoQualityTest::VideoQualityTest() : clock_(Clock::GetRealTimeClock()) {}
 
 void VideoQualityTest::TestBody() {}
 
 std::string VideoQualityTest::GenerateGraphTitle() const {
   std::stringstream ss;
   ss << params_.common.codec;
   ss << " (" << params_.common.target_bitrate_bps / 1000 << "kbps";
@@ skipping 447 matching lines @@
   send_stream_->Stop();
   receive_stream->Stop();
 
   call->DestroyVideoReceiveStream(receive_stream);
   call->DestroyVideoSendStream(send_stream_);
 
   transport.StopSending();
 }
 
 }  // namespace webrtc