Delete webrtc/base/common.h

webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.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 "webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h"
 
 #include <stdio.h>
 
 #include <sstream>
 
-#include "webrtc/base/common.h"
 #include "webrtc/base/constructormagic.h"
 
 namespace webrtc {
 namespace testing {
 namespace bwe {
 
 class DelayCapHelper {
  public:
   // Max delay = 0 stands for +infinite.
   DelayCapHelper() : max_delay_us_(0), delay_stats_() {}
@@ skipping 188 matching lines @@
 }
 
 RateCounterFilter::RateCounterFilter(PacketProcessorListener* listener,
                                      int flow_id,
                                      const char* name,
                                      const std::string& algorithm_name)
     : PacketProcessor(listener, flow_id, kRegular),
       packets_per_second_stats_(),
       kbps_stats_(),
       start_plotting_time_ms_(0),
+#if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE
       flow_id_(flow_id),
+#endif
       name_(name),
-      algorithm_name_(algorithm_name) {
-          // Only used when compiling with BWE test logging enabled.
-          RTC_UNUSED(flow_id_);
-      }
+      algorithm_name_(algorithm_name) {}
 
 RateCounterFilter::RateCounterFilter(PacketProcessorListener* listener,
                                      const FlowIds& flow_ids,
                                      const char* name,
                                      const std::string& algorithm_name)
     : PacketProcessor(listener, flow_ids, kRegular),
       packets_per_second_stats_(),
       kbps_stats_(),
       start_plotting_time_ms_(0),
-      flow_id_(0),
       name_(name),
       algorithm_name_(algorithm_name) {
   // TODO(terelius): Appending the flow IDs to the algorithm name is a hack to
   // keep the current plot functionality without having to print the full
   // context for each PLOT line. It is unclear whether multiple flow IDs are
   // needed at all in the long term.
   std::stringstream ss;
   ss << algorithm_name_;
   for (int flow_id : flow_ids) {
     ss << ',' << flow_id;
@@ skipping 19 matching lines @@
   BWE_TEST_LOGGING_CONTEXT("RateCounterFilter");
   packets_per_second_stats_.Log("pps");
   kbps_stats_.Log("kbps");
 }
 
 Stats<double> RateCounterFilter::GetBitrateStats() const {
   return kbps_stats_;
 }
 
 void RateCounterFilter::Plot(int64_t timestamp_ms) {
+  // TODO(stefan): Reorganize logging configuration to reduce amount
+  // of preprocessor conditionals in the code.
+#if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE
   uint32_t plot_kbps = 0;
   if (timestamp_ms >= start_plotting_time_ms_) {
     plot_kbps = rate_counter_.bits_per_second() / 1000.0;
   }
   BWE_TEST_LOGGING_CONTEXT(name_.c_str());
   if (algorithm_name_.empty()) {
     BWE_TEST_LOGGING_PLOT_WITH_SSRC(0, "Throughput_kbps#1", timestamp_ms,
                                     plot_kbps, flow_id_);
   } else {
     BWE_TEST_LOGGING_PLOT_WITH_NAME_AND_SSRC(0, "Throughput_kbps#1",
                                              timestamp_ms, plot_kbps, flow_id_,
                                              algorithm_name_);
   }
-
-  RTC_UNUSED(plot_kbps);
+#endif
 }
 
 void RateCounterFilter::RunFor(int64_t /*time_ms*/, Packets* in_out) {
   assert(in_out);
   for (const Packet* packet : *in_out) {
     rate_counter_.UpdateRates(packet->send_time_us(),
                               static_cast<int>(packet->payload_size()));
   }
   packets_per_second_stats_.Push(rate_counter_.packets_per_second());
   kbps_stats_.Push(rate_counter_.bits_per_second() / 1000.0);
@@ skipping 507 matching lines @@
 uint32_t PeriodicKeyFrameSource::NextPacketSize(uint32_t frame_size,
                                                 uint32_t remaining_payload) {
   uint32_t fragments =
       (frame_size + (kMaxPayloadSizeBytes - 1)) / kMaxPayloadSizeBytes;
   uint32_t avg_size = (frame_size + fragments - 1) / fragments;
   return std::min(avg_size, remaining_payload);
 }
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc