Supporting Pause/Resume, Sending Estimate logging. Corrected plot colors

webrtc/modules/remote_bitrate_estimator/test/packet_sender.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/packet_sender.h"
 
 #include <algorithm>
 #include <list>
 #include <sstream>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/interface/module_common_types.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe.h"
+#include "webrtc/modules/remote_bitrate_estimator/test/metric_recorder.h"
 
 namespace webrtc {
 namespace testing {
 namespace bwe {
 
+void PacketSender::Pause() {
+  running_ = false;
+  if (metric_recorder_ != nullptr) {
+    metric_recorder_->PauseFlow();
+  }
+}
+
+void PacketSender::Resume(int64_t paused_time_ms) {
+  running_ = true;
+  if (metric_recorder_ != nullptr) {
+    metric_recorder_->ResumeFlow(paused_time_ms);
+  }
+}
+
+void PacketSender::set_metric_recorder(MetricRecorder* metric_recorder) {
+  metric_recorder_ = metric_recorder;
+}
+
+void PacketSender::RecordBitrate() {
+  if (metric_recorder_ != nullptr) {
+    BWE_TEST_LOGGING_CONTEXT("Sender");
+    BWE_TEST_LOGGING_CONTEXT(*flow_ids().begin());
+    metric_recorder_->UpdateTimeMs(clock_.TimeInMilliseconds());
+    metric_recorder_->UpdateSendingEstimateKbps(TargetBitrateKbps());
+  }
+}
+
 std::list<FeedbackPacket*> GetFeedbackPackets(Packets* in_out,
                                               int64_t end_time_ms,
                                               int flow_id) {
   std::list<FeedbackPacket*> fb_packets;
   for (auto it = in_out->begin(); it != in_out->end();) {
     if ((*it)->send_time_us() > 1000 * end_time_ms)
       break;
     if ((*it)->GetPacketType() == Packet::kFeedback &&
         flow_id == (*it)->flow_id()) {
       fb_packets.push_back(static_cast<FeedbackPacket*>(*it));
       it = in_out->erase(it);
     } else {
       ++it;
     }
   }
   return fb_packets;
 }
 
 VideoSender::VideoSender(PacketProcessorListener* listener,
                          VideoSource* source,
                          BandwidthEstimatorType estimator_type)
     : PacketSender(listener, source->flow_id()),
-      running_(true),
       source_(source),
       bwe_(CreateBweSender(estimator_type,
                            source_->bits_per_second() / 1000,
                            this,
                            &clock_)),
       previous_sending_bitrate_(0) {
   modules_.push_back(bwe_.get());
 }
 
 VideoSender::~VideoSender() {
 }
 
+void VideoSender::Pause() {
+  previous_sending_bitrate_ = TargetBitrateKbps();
+  PacketSender::Pause();
+}
+
+void VideoSender::Resume(int64_t paused_time_ms) {
+  source_->SetBitrateBps(previous_sending_bitrate_);
+  PacketSender::Resume(paused_time_ms);
+}
+
 void VideoSender::RunFor(int64_t time_ms, Packets* in_out) {
   std::list<FeedbackPacket*> feedbacks = GetFeedbackPackets(
       in_out, clock_.TimeInMilliseconds() + time_ms, source_->flow_id());
   ProcessFeedbackAndGeneratePackets(time_ms, &feedbacks, in_out);
 }
 
 void VideoSender::ProcessFeedbackAndGeneratePackets(
     int64_t time_ms,
     std::list<FeedbackPacket*>* feedbacks,
     Packets* packets) {
@@ skipping 32 matching lines @@
 }
 
 int VideoSender::GetFeedbackIntervalMs() const {
   return bwe_->GetFeedbackIntervalMs();
 }
 
 void VideoSender::OnNetworkChanged(uint32_t target_bitrate_bps,
                                    uint8_t fraction_lost,
                                    int64_t rtt) {
   source_->SetBitrateBps(target_bitrate_bps);
-}
-
-void VideoSender::Pause() {
-  running_ = false;
-  previous_sending_bitrate_ = TargetBitrateKbps();
-}
-
-void VideoSender::Resume() {
-  running_ = true;
-  source_->SetBitrateBps(previous_sending_bitrate_);
+  RecordBitrate();
 }
 
 uint32_t VideoSender::TargetBitrateKbps() {
   return (source_->bits_per_second() + 500) / 1000;
 }
 
 PacedVideoSender::PacedVideoSender(PacketProcessorListener* listener,
                                    VideoSource* source,
                                    BandwidthEstimatorType estimator)
     : VideoSender(listener, source, estimator),
@@ skipping 170 matching lines @@
       cwnd_(10),
       ssthresh_(kNoLimit),
       ack_received_(false),
       last_acked_seq_num_(0),
       next_sequence_number_(0),
       offset_ms_(offset_ms),
       last_reduction_time_ms_(-1),
       last_rtt_ms_(0),
       total_sent_bytes_(0),
       send_limit_bytes_(send_limit_bytes),
-      running_(true),
       last_generated_packets_ms_(0),
       num_recent_sent_packets_(0),
       bitrate_kbps_(0) {
 }
 
 void TcpSender::RunFor(int64_t time_ms, Packets* in_out) {
   if (clock_.TimeInMilliseconds() + time_ms < offset_ms_) {
     clock_.AdvanceTimeMilliseconds(time_ms);
     if (running_) {
-      running_ = false;
+      Pause();
     }
     return;
   }
 
-  if (!running_) {
-    running_ = true;
+  if (!running_ && total_sent_bytes_ == 0) {
+    Resume(offset_ms_);
   }
 
   int64_t start_time_ms = clock_.TimeInMilliseconds();
-  BWE_TEST_LOGGING_CONTEXT("Sender");
-  BWE_TEST_LOGGING_CONTEXT(*flow_ids().begin());
 
   std::list<FeedbackPacket*> feedbacks = GetFeedbackPackets(
       in_out, clock_.TimeInMilliseconds() + time_ms, *flow_ids().begin());
   // The number of packets which are sent in during time_ms depends on the
   // number of packets in_flight_ and the max number of packets in flight
   // (cwnd_). Therefore SendPackets() isn't directly dependent on time_ms.
   for (FeedbackPacket* fb : feedbacks) {
     clock_.AdvanceTimeMilliseconds(fb->send_time_ms() -
                                    clock_.TimeInMilliseconds());
     last_rtt_ms_ = fb->send_time_ms() - fb->latest_send_time_ms();
@@ skipping 75 matching lines @@
 }
 
 Packets TcpSender::GeneratePackets(size_t num_packets) {
   Packets generated;
 
   UpdateSendBitrateEstimate(num_packets);
 
   for (size_t i = 0; i < num_packets; ++i) {
     if ((total_sent_bytes_ + kPacketSizeBytes) > send_limit_bytes_) {
       if (running_) {
-        running_ = false;
+        Pause();
       }
       break;
     }
     generated.push_back(
         new MediaPacket(*flow_ids().begin(), 1000 * clock_.TimeInMilliseconds(),
                         kPacketSizeBytes, next_sequence_number_++));
     generated.back()->set_sender_timestamp_us(
         1000 * clock_.TimeInMilliseconds());
 
     total_sent_bytes_ += kPacketSizeBytes;
   }
 
   return generated;
 }
 
 void TcpSender::UpdateSendBitrateEstimate(size_t num_packets) {
   const int kTimeWindowMs = 500;
   num_recent_sent_packets_ += num_packets;
 
   int64_t delta_ms = clock_.TimeInMilliseconds() - last_generated_packets_ms_;
   if (delta_ms >= kTimeWindowMs) {
     bitrate_kbps_ =
         static_cast<uint32_t>(8 * num_recent_sent_packets_ * kPacketSizeBytes) /
         delta_ms;
     last_generated_packets_ms_ = clock_.TimeInMilliseconds();
     num_recent_sent_packets_ = 0;
   }
+
+  RecordBitrate();
 }
 
 uint32_t TcpSender::TargetBitrateKbps() {
   return bitrate_kbps_;
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc