Don't report perf metrics for packet loss ramp-up tests.

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 33 matching lines @@
                            bool red,
                            bool report_perf_stats)
     : EndToEndTest(test::CallTest::kLongTimeoutMs),
       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),
+      report_perf_stats_(report_perf_stats),
       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") {
@@ skipping 314 matching lines @@
   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,
-                                       const std::vector<int>& loss_rates)
+                                       const std::vector<int>& loss_rates,
+                                       bool report_perf_stats)
     : RampUpTester(num_video_streams,
                    num_audio_streams,
                    num_flexfec_streams,
                    start_bitrate_bps,
                    0,
                    extension_type,
                    rtx,
                    red,
-                   true),
+                   report_perf_stats),
       link_rates_({GetHighLinkCapacity(), kLowBandwidthLimitBps / 1000,
                    GetHighLinkCapacity(), 0}),
       test_state_(kFirstRampup),
       next_state_(kTransitionToNextState),
       state_start_ms_(clock_->TimeInMilliseconds()),
       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;
@@ skipping 75 matching lines @@
 bool RampUpDownUpTester::ExpectingFec() const {
   return num_flexfec_streams_ > 0 && forward_transport_config_.loss_percent > 0;
 }
 
 void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
   int64_t now = clock_->TimeInMilliseconds();
   switch (test_state_) {
     case kFirstRampup:
       EXPECT_FALSE(suspended);
       if (bitrate_bps >= GetExpectedHighBitrate()) {
-        webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
-                                  "first_rampup", now - state_start_ms_, "ms",
-                                  false);
+        if (report_perf_stats_) {
+          webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
+                                    "first_rampup", now - state_start_ms_, "ms",
+                                    false);
+        }
         // Apply loss during the transition between states if FEC is enabled.
         forward_transport_config_.loss_percent = loss_rates_[test_state_];
         test_state_ = kTransitionToNextState;
         next_state_ = kLowRate;
       }
       break;
     case kLowRate: {
       // Audio streams are never suspended.
       bool check_suspend_state = num_video_streams_ > 0;
       if (bitrate_bps < kExpectedLowBitrateBps &&
           suspended == check_suspend_state) {
-        webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
-                                  "rampdown", now - state_start_ms_, "ms",
-                                  false);
+        if (report_perf_stats_) {
+          webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
+                                    "rampdown", now - state_start_ms_, "ms",
+                                    false);
+        }
         // Apply loss during the transition between states if FEC is enabled.
         forward_transport_config_.loss_percent = loss_rates_[test_state_];
         test_state_ = kTransitionToNextState;
         next_state_ = kSecondRampup;
       }
       break;
     }
     case kSecondRampup:
       if (bitrate_bps >= GetExpectedHighBitrate() && !suspended) {
-        webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
-                                  "second_rampup", now - state_start_ms_, "ms",
-                                  false);
-        ReportResult("ramp-up-down-up-average-network-latency",
-                     send_transport_->GetAverageDelayMs(), "milliseconds");
+        if (report_perf_stats_) {
+          webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
+                                    "second_rampup", now - state_start_ms_,
+                                    "ms", false);
+          ReportResult("ramp-up-down-up-average-network-latency",
+                       send_transport_->GetAverageDelayMs(), "milliseconds");
+        }
         // Apply loss during the transition between states if FEC is enabled.
         forward_transport_config_.loss_percent = loss_rates_[test_state_];
         test_state_ = kTransitionToNextState;
         next_state_ = kTestEnd;
       }
       break;
     case kTestEnd:
       observation_complete_.Set();
       break;
     case kTransitionToNextState:
@@ skipping 20 matching lines @@
     EXPECT_EQ(nullptr, video_send_stream_);
     EXPECT_TRUE(video_receive_streams_.empty());
   }
 };
 
 static const uint32_t kStartBitrateBps = 60000;
 
 TEST_F(RampUpTest, UpDownUpAbsSendTimeSimulcastRedRtx) {
   std::vector<int> loss_rates = {0, 0, 0, 0};
   RampUpDownUpTester test(3, 0, 0, kStartBitrateBps,
-                          RtpExtension::kAbsSendTimeUri, true, true,
-                          loss_rates);
+                          RtpExtension::kAbsSendTimeUri, true, true, loss_rates,
+                          true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpTransportSequenceNumberRtx) {
   std::vector<int> loss_rates = {0, 0, 0, 0};
   RampUpDownUpTester test(3, 0, 0, kStartBitrateBps,
                           RtpExtension::kTransportSequenceNumberUri, true,
-                          false, loss_rates);
+                          false, loss_rates, true);
   RunBaseTest(&test);
 }
 
+// TODO(holmer): Tests which don't report perf stats should be moved to a
+// different executable since they per definition are not perf tests.
 TEST_F(RampUpTest, UpDownUpTransportSequenceNumberPacketLoss) {
   std::vector<int> loss_rates = {20, 0, 0, 0};
   RampUpDownUpTester test(1, 0, 1, kStartBitrateBps,
                           RtpExtension::kTransportSequenceNumberUri, true,
-                          false, loss_rates);
+                          false, loss_rates, false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpAudioVideoTransportSequenceNumberRtx) {
   std::vector<int> loss_rates = {0, 0, 0, 0};
   RampUpDownUpTester test(3, 1, 0, kStartBitrateBps,
                           RtpExtension::kTransportSequenceNumberUri, true,
-                          false, loss_rates);
+                          false, loss_rates, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpAudioTransportSequenceNumberRtx) {
   std::vector<int> loss_rates = {0, 0, 0, 0};
   RampUpDownUpTester test(0, 1, 0, kStartBitrateBps,
                           RtpExtension::kTransportSequenceNumberUri, true,
-                          false, loss_rates);
+                          false, loss_rates, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TOffsetSimulcastRedRtx) {
   RampUpTester test(3, 0, 0, 0, 0, RtpExtension::kTimestampOffsetUri, true,
                     true, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AbsSendTime) {
@@ skipping 26 matching lines @@
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AudioTransportSequenceNumber) {
   RampUpTester test(0, 1, 0, 300000, 10000,
                     RtpExtension::kTransportSequenceNumberUri, false, false,
                     false);
   RunBaseTest(&test);
 }
 }  // namespace webrtc