More Simulation Framework features

webrtc/modules/remote_bitrate_estimator/test/bwe_test.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 30 matching lines @@
 }
 
 void PacketProcessorRunner::RunFor(int64_t time_ms,
                                    int64_t time_now_ms,
                                    Packets* in_out) {
   Packets to_process;
   FindPacketsToProcess(processor_->flow_ids(), in_out, &to_process);
   processor_->RunFor(time_ms, &to_process);
   QueuePackets(&to_process, time_now_ms * 1000);
   if (!to_process.empty()) {
-    processor_->Plot((to_process.back()->send_time_us() + 500) / 1000);
+    processor_->Plot(to_process.back()->send_time_ms());
   }
   in_out->merge(to_process, DereferencingComparator<Packet>);
 }
 
 void PacketProcessorRunner::FindPacketsToProcess(const FlowIds& flow_ids,
                                                  Packets* in,
                                                  Packets* out) {
   assert(out->empty());
   for (Packets::iterator it = in->begin(); it != in->end();) {
     // TODO(holmer): Further optimize this by looking for consecutive flow ids
@@ skipping 200 matching lines @@
     sources.push_back(new AdaptiveVideoSource(media_flow, 30, 300, 0,
                                               kFlowStartOffsetMs));
     senders.push_back(new PacedVideoSender(&uplink_, sources.back(), bwe_type));
   }
 
   const int64_t kTcpStartOffsetMs = 5000;
   for (int tcp_flow : tcp_flow_ids)
     senders.push_back(new TcpSender(&uplink_, tcp_flow, kTcpStartOffsetMs));
 
   ChokeFilter choke(&uplink_, all_flow_ids);
-  choke.SetCapacity(capacity_kbps);
-  choke.SetMaxDelay(max_delay_ms);
+  choke.set_capacity_kbps(capacity_kbps);
+  choke.set_max_delay_ms(max_delay_ms);
 
   DelayFilter delay_uplink(&uplink_, all_flow_ids);
-  delay_uplink.SetDelayMs(25);
+  delay_uplink.SetOneWayDelayMs(25);
 
   std::vector<RateCounterFilter*> rate_counters;
   for (int flow : all_flow_ids) {
     rate_counters.push_back(
         new RateCounterFilter(&uplink_, flow, "receiver_input"));
   }
 
   RateCounterFilter total_utilization(&uplink_, all_flow_ids,
                                       "total_utilization");
 
   std::vector<PacketReceiver*> receivers;
   i = 0;
   for (int media_flow : media_flow_ids) {
     receivers.push_back(
         new PacketReceiver(&uplink_, media_flow, bwe_type, i++ == 0, false));
   }
   for (int tcp_flow : tcp_flow_ids) {
     receivers.push_back(
         new PacketReceiver(&uplink_, tcp_flow, kTcpEstimator, false, false));
   }
 
   DelayFilter delay_downlink(&downlink_, all_flow_ids);
-  delay_downlink.SetDelayMs(25);
+  delay_downlink.SetOneWayDelayMs(25);
 
   RunFor(run_time_seconds * 1000);
 
   std::map<int, Stats<double>> flow_throughput_kbps;
   for (RateCounterFilter* rate_counter : rate_counters) {
     int flow_id = *rate_counter->flow_ids().begin();
     flow_throughput_kbps[flow_id] = rate_counter->GetBitrateStats();
   }
 
   std::map<int, Stats<double>> flow_delay_ms;
@@ skipping 10 matching lines @@
   for (PacketSender* sender : senders)
     delete sender;
   for (RateCounterFilter* rate_counter : rate_counters)
     delete rate_counter;
   for (PacketReceiver* receiver : receivers)
     delete receiver;
 }
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc