Use RTC_UNUSED instead of conditional compilation in BWE simulator tool.

webrtc/modules/remote_bitrate_estimator/test/metric_recorder.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 "webrtc/modules/remote_bitrate_estimator/test/metric_recorder.h"
 
 #include <algorithm>
 
 #include "webrtc/modules/remote_bitrate_estimator/test/packet_sender.h"
+#include "webrtc/typedefs.h"
 
 namespace webrtc {
 namespace testing {
 namespace bwe {
 
 namespace {
 // Holder mean, Manhattan distance for p=1, EuclidianNorm/sqrt(n) for p=2.
 template <typename T>
 double NormLp(T sum, size_t size, double p) {
   return pow(sum / size, 1.0 / p);
@@ skipping 229 matching lines @@
     return false;
   }
 }
 
 void MetricRecorder::PlotThroughputHistogram(
     const std::string& title,
     const std::string& bwe_name,
     size_t num_flows,
     int64_t extra_offset_ms,
     const std::string optimum_id) const {
-#if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE
   double optimal_bitrate_per_flow_kbps = static_cast<double>(
       optimal_throughput_bits_ / RunDurationMs(extra_offset_ms));
 
   double neg_error = Renormalize(
       NormLp(sum_lp_weighted_estimate_error_[0], num_packets_received_, kP));
   double pos_error = Renormalize(
       NormLp(sum_lp_weighted_estimate_error_[1], num_packets_received_, kP));
 
   double average_bitrate_kbps = AverageBitrateKbps(extra_offset_ms);
 
   // Prevent the error to be too close to zero (plotting issue).
   double extra_error = average_bitrate_kbps / 500;
 
   std::string optimum_title =
       optimum_id.empty() ? "optimal_bitrate" : "optimal_bitrates#" + optimum_id;
 
   BWE_TEST_LOGGING_LABEL(4, title, "average_bitrate_(kbps)", num_flows);
   BWE_TEST_LOGGING_LIMITERRORBAR(
       4, bwe_name, average_bitrate_kbps,
       average_bitrate_kbps - neg_error - extra_error,
       average_bitrate_kbps + pos_error + extra_error, "estimate_error",
       optimal_bitrate_per_flow_kbps, optimum_title, flow_id_);
 
   BWE_TEST_LOGGING_LOG1("RESULTS >>> " + bwe_name + " Channel utilization : ",
                         "%lf %%",
                         100.0 * static_cast<double>(average_bitrate_kbps) /
                             optimal_bitrate_per_flow_kbps);
-#endif  // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE
+
+  RTC_UNUSED(pos_error);
+  RTC_UNUSED(neg_error);
+  RTC_UNUSED(extra_error);
+  RTC_UNUSED(optimal_bitrate_per_flow_kbps);
 }
 
 void MetricRecorder::PlotThroughputHistogram(const std::string& title,
                                              const std::string& bwe_name,
                                              size_t num_flows,
                                              int64_t extra_offset_ms) const {
   PlotThroughputHistogram(title, bwe_name, num_flows, extra_offset_ms, "");
 }
 
 void MetricRecorder::PlotDelayHistogram(const std::string& title,
                                         const std::string& bwe_name,
                                         size_t num_flows,
                                         int64_t one_way_path_delay_ms) const {
-#if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE
   double average_delay_ms =
       static_cast<double>(sum_delays_ms_) / num_packets_received_;
   int64_t percentile_5_ms = NthDelayPercentile(5);
   int64_t percentile_95_ms = NthDelayPercentile(95);
 
   BWE_TEST_LOGGING_LABEL(5, title, "average_delay_(ms)", num_flows);
   BWE_TEST_LOGGING_ERRORBAR(5, bwe_name, average_delay_ms, percentile_5_ms,
                             percentile_95_ms, "5th and 95th percentiles",
                             flow_id_);
 
   // Log added latency, disregard baseline path delay.
   BWE_TEST_LOGGING_LOG1("RESULTS >>> " + bwe_name + " Delay average : ",
                         "%lf ms", average_delay_ms - one_way_path_delay_ms);
   BWE_TEST_LOGGING_LOG1("RESULTS >>> " + bwe_name + " Delay 5th percentile : ",
                         "%ld ms", percentile_5_ms - one_way_path_delay_ms);
   BWE_TEST_LOGGING_LOG1("RESULTS >>> " + bwe_name + " Delay 95th percentile : ",
                         "%ld ms", percentile_95_ms - one_way_path_delay_ms);
-#endif  // BWE_TEST_LOGGING_COMPILE_TIME_ENABLE
+
+  RTC_UNUSED(average_delay_ms);
+  RTC_UNUSED(percentile_5_ms);
+  RTC_UNUSED(percentile_95_ms);
 }
 
 void MetricRecorder::PlotLossHistogram(const std::string& title,
                                        const std::string& bwe_name,
                                        size_t num_flows,
                                        float global_loss_ratio) const {
   BWE_TEST_LOGGING_LABEL(6, title, "packet_loss_ratio_(%)", num_flows);
   BWE_TEST_LOGGING_BAR(6, bwe_name, 100.0f * global_loss_ratio, flow_id_);
 
   BWE_TEST_LOGGING_LOG1("RESULTS >>> " + bwe_name + " Loss Ratio : ", "%f %%",
@@ skipping 94 matching lines @@
 
   double throughput_metric = U(sum_throughput_bytes_, kAlpha);
   double delay_penalty = kDelta * U(sum_delays_ms_, kBeta);
 
   return throughput_metric - delay_penalty;
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc