Introduce new constructor to PlatformThread.

webrtc/call/rampup_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.
  */
 
@@ skipping 26 matching lines @@
 RampUpTester::RampUpTester(size_t num_video_streams,
                            size_t num_audio_streams,
                            size_t num_flexfec_streams,
                            unsigned int start_bitrate_bps,
                            int64_t min_run_time_ms,
                            const std::string& extension_type,
                            bool rtx,
                            bool red,
                            bool report_perf_stats)
     : EndToEndTest(test::CallTest::kLongTimeoutMs),
-      event_(false, false),
+      stop_event_(false, false),
       clock_(Clock::GetRealTimeClock()),
       num_video_streams_(num_video_streams),
       num_audio_streams_(num_audio_streams),
       num_flexfec_streams_(num_flexfec_streams),
       rtx_(rtx),
       red_(red),
       sender_call_(nullptr),
       send_stream_(nullptr),
       start_bitrate_bps_(start_bitrate_bps),
       min_run_time_ms_(min_run_time_ms),
       report_perf_stats_(report_perf_stats),
       expected_bitrate_bps_(0),
       test_start_ms_(-1),
       ramp_up_finished_ms_(-1),
       extension_type_(extension_type),
       video_ssrcs_(GenerateSsrcs(num_video_streams_, 100)),
       video_rtx_ssrcs_(GenerateSsrcs(num_video_streams_, 200)),
       audio_ssrcs_(GenerateSsrcs(num_audio_streams_, 300)),
       poller_thread_(&BitrateStatsPollingThread,
                      this,
                      "BitrateStatsPollingThread") {
   if (red_)
     EXPECT_EQ(0u, num_flexfec_streams_);
   EXPECT_LE(num_audio_streams_, 1u);
 }
 
 RampUpTester::~RampUpTester() {
-  event_.Set();
 }
 
 Call::Config RampUpTester::GetSenderCallConfig() {
   Call::Config call_config(&event_log_);
   if (start_bitrate_bps_ != 0) {
     call_config.bitrate_config.start_bitrate_bps = start_bitrate_bps_;
   }
   call_config.bitrate_config.min_bitrate_bps = 10000;
   return call_config;
 }
@@ skipping 189 matching lines @@
     (*receive_configs)[0].transport_cc = true;
     (*receive_configs)[0].rtp_header_extensions.push_back(RtpExtension(
         extension_type_.c_str(), kTransportSequenceNumberExtensionId));
   }
 }
 
 void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) {
   sender_call_ = sender_call;
 }
 
-bool RampUpTester::BitrateStatsPollingThread(void* obj) {
-  return static_cast<RampUpTester*>(obj)->PollStats();
+void RampUpTester::BitrateStatsPollingThread(void* obj) {
+  static_cast<RampUpTester*>(obj)->PollStats();
 }
 
-bool RampUpTester::PollStats() {
-  if (sender_call_) {
-    Call::Stats stats = sender_call_->GetStats();
+void RampUpTester::PollStats() {
+  do {
+    if (sender_call_) {
+      Call::Stats stats = sender_call_->GetStats();
 
-    EXPECT_GE(stats.send_bandwidth_bps, start_bitrate_bps_);
-    EXPECT_GE(expected_bitrate_bps_, 0);
-    if (stats.send_bandwidth_bps >= expected_bitrate_bps_ &&
-        (min_run_time_ms_ == -1 ||
-         clock_->TimeInMilliseconds() - test_start_ms_ >= min_run_time_ms_)) {
-      ramp_up_finished_ms_ = clock_->TimeInMilliseconds();
-      observation_complete_.Set();
+      EXPECT_GE(stats.send_bandwidth_bps, start_bitrate_bps_);
+      EXPECT_GE(expected_bitrate_bps_, 0);
+      if (stats.send_bandwidth_bps >= expected_bitrate_bps_ &&
+          (min_run_time_ms_ == -1 ||
+           clock_->TimeInMilliseconds() - test_start_ms_ >= min_run_time_ms_)) {
+        ramp_up_finished_ms_ = clock_->TimeInMilliseconds();
+        observation_complete_.Set();
+      }
     }
-  }
-
-  return !event_.Wait(kPollIntervalMs);
+  } while (!stop_event_.Wait(kPollIntervalMs));
 }
 
 void RampUpTester::ReportResult(const std::string& measurement,
                                 size_t value,
                                 const std::string& units) const {
   webrtc::test::PrintResult(
       measurement, "",
       ::testing::UnitTest::GetInstance()->current_test_info()->name(), value,
       units, false);
 }
@@ skipping 59 matching lines @@
     ReportResult("ramp-up-average-network-latency",
                  send_transport_->GetAverageDelayMs(), "milliseconds");
   }
 }
 
 void RampUpTester::PerformTest() {
   test_start_ms_ = clock_->TimeInMilliseconds();
   poller_thread_.Start();
   EXPECT_TRUE(Wait()) << "Timed out while waiting for ramp-up to complete.";
   TriggerTestDone();
+  stop_event_.Set();
   poller_thread_.Stop();
 }
 
 RampUpDownUpTester::RampUpDownUpTester(size_t num_video_streams,
                                        size_t num_audio_streams,
                                        size_t num_flexfec_streams,
                                        unsigned int start_bitrate_bps,
                                        const std::string& extension_type,
                                        bool rtx,
                                        bool red,
@@ skipping 15 matching lines @@
       interval_start_ms_(clock_->TimeInMilliseconds()),
       sent_bytes_(0),
       loss_rates_(loss_rates) {
   forward_transport_config_.link_capacity_kbps = link_rates_[test_state_];
   forward_transport_config_.queue_delay_ms = 100;
   forward_transport_config_.loss_percent = loss_rates_[test_state_];
 }
 
 RampUpDownUpTester::~RampUpDownUpTester() {}
 
-bool RampUpDownUpTester::PollStats() {
-  if (send_stream_) {
-    webrtc::VideoSendStream::Stats stats = send_stream_->GetStats();
-    int transmit_bitrate_bps = 0;
-    for (auto it : stats.substreams) {
-      transmit_bitrate_bps += it.second.total_bitrate_bps;
+void RampUpDownUpTester::PollStats() {
+  do {
+    if (send_stream_) {
+      webrtc::VideoSendStream::Stats stats = send_stream_->GetStats();
+      int transmit_bitrate_bps = 0;
+      for (auto it : stats.substreams) {
+        transmit_bitrate_bps += it.second.total_bitrate_bps;
+      }
+      EvolveTestState(transmit_bitrate_bps, stats.suspended);
+    } else if (num_audio_streams_ > 0 && sender_call_ != nullptr) {
+      // An audio send stream doesn't have bitrate stats, so the call send BW is
+      // currently used instead.
+      int transmit_bitrate_bps = sender_call_->GetStats().send_bandwidth_bps;
+      EvolveTestState(transmit_bitrate_bps, false);
     }
-    EvolveTestState(transmit_bitrate_bps, stats.suspended);
-  } else if (num_audio_streams_ > 0 && sender_call_ != nullptr) {
-    // An audio send stream doesn't have bitrate stats, so the call send BW is
-    // currently used instead.
-    int transmit_bitrate_bps = sender_call_->GetStats().send_bandwidth_bps;
-    EvolveTestState(transmit_bitrate_bps, false);
-  }
-
-  return !event_.Wait(kPollIntervalMs);
+  } while (!stop_event_.Wait(kPollIntervalMs));
 }
 
 Call::Config RampUpDownUpTester::GetReceiverCallConfig() {
   Call::Config config(&event_log_);
   config.bitrate_config.min_bitrate_bps = 10000;
   return config;
 }
 
 std::string RampUpDownUpTester::GetModifierString() const {
   std::string str("_");
@@ skipping 195 matching lines @@
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AudioTransportSequenceNumber) {
   RampUpTester test(0, 1, 0, 300000, 10000,
                     RtpExtension::kTransportSequenceNumberUri, false, false,
                     false);
   RunBaseTest(&test);
 }
 }  // namespace webrtc