Increase the send-time history to 60 seconds.

webrtc/test/fake_network_pipe.cc

 /*
  *  Copyright (c) 2012 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/test/fake_network_pipe.h"
 
 #include <assert.h>
 #include <math.h>
 #include <string.h>
 
 #include <algorithm>
 #include <cmath>
 
+#include "webrtc/base/logging.h"
 #include "webrtc/call/call.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
 FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
                                  const FakeNetworkPipe::Config& config)
     : FakeNetworkPipe(clock, config, 1) {}
 
 FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
                                  const FakeNetworkPipe::Config& config,
                                  uint64_t seed)
     : clock_(clock),
       packet_receiver_(NULL),
       random_(seed),
       config_(config),
       dropped_packets_(0),
       sent_packets_(0),
       total_packet_delay_(0),
       bursting_(false),
-      next_process_time_(clock_->TimeInMilliseconds()) {
+      next_process_time_(clock_->TimeInMilliseconds()),
+      last_log_time_(clock_->TimeInMilliseconds()) {
   double prob_loss = config.loss_percent / 100.0;
   if (config_.avg_burst_loss_length == -1) {
     // Uniform loss
     prob_loss_bursting_ = prob_loss;
     prob_start_bursting_ = prob_loss;
   } else {
     // Lose packets according to a gilbert-elliot model.
     int avg_burst_loss_length = config.avg_burst_loss_length;
     int min_avg_burst_loss_length = std::ceil(prob_loss / (1 - prob_loss));
 
@@ skipping 76 matching lines @@
 
   return static_cast<int>(total_packet_delay_ /
                           static_cast<int64_t>(sent_packets_));
 }
 
 void FakeNetworkPipe::Process() {
   int64_t time_now = clock_->TimeInMilliseconds();
   std::queue<NetworkPacket*> packets_to_deliver;
   {
     rtc::CritScope crit(&lock_);
+    if (time_now - last_log_time_ > 5000) {
+      int64_t queueing_delay_ms = 0;
+      if (!capacity_link_.empty()) {
+        queueing_delay_ms = time_now - capacity_link_.front()->send_time();
+      }
+      LOG(LS_INFO) << "Network queue: " << queueing_delay_ms << " ms.";
+      last_log_time_ = time_now;
+    }
     // Check the capacity link first.
     while (!capacity_link_.empty() &&
            time_now >= capacity_link_.front()->arrival_time()) {
       // Time to get this packet.
       NetworkPacket* packet = capacity_link_.front();
       capacity_link_.pop();
 
       // Drop packets at an average rate of |config_.loss_percent| with
       // and average loss burst length of |config_.avg_burst_loss_length|.
       if ((bursting_ && random_.Rand<double>() < prob_loss_bursting_) ||
@@ skipping 48 matching lines @@
 int64_t FakeNetworkPipe::TimeUntilNextProcess() const {
   rtc::CritScope crit(&lock_);
   const int64_t kDefaultProcessIntervalMs = 5;
   if (capacity_link_.empty() || delay_link_.empty())
     return kDefaultProcessIntervalMs;
   return std::max<int64_t>(next_process_time_ - clock_->TimeInMilliseconds(),
                            0);
 }
 
 }  // namespace webrtc