Add network parameters fields in FrameStatsMessage

remoting/protocol/webrtc_frame_scheduler_simple.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/protocol/webrtc_frame_scheduler_simple.h"
 
 #include <algorithm>
 
+#include "remoting/protocol/frame_stats.h"
 #include "remoting/protocol/webrtc_dummy_video_encoder.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 // Number of samples used to estimate processing time for the next frame.
 const int kStatsWindow = 5;
@@ skipping 44 matching lines @@
 
 void WebrtcFrameSchedulerSimple::OnKeyFrameRequested() {
   DCHECK(thread_checker_.CalledOnValidThread());
   key_frame_request_ = true;
   ScheduleNextFrame(base::TimeTicks::Now());
 }
 
 void WebrtcFrameSchedulerSimple::OnChannelParameters(int packet_loss,
                                                      base::TimeDelta rtt) {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  rtt_estimate_ = rtt;
 }
 
 void WebrtcFrameSchedulerSimple::OnTargetBitrateChanged(int bitrate_kbps) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::TimeTicks now = base::TimeTicks::Now();
   pacing_bucket_.UpdateRate(bitrate_kbps * 1000 / 8, now);
   ScheduleNextFrame(now);
 }
 
 void WebrtcFrameSchedulerSimple::Start(
@@ skipping 65 matching lines @@
 
   params_out->vpx_max_quantizer = 63;
 
   params_out->clear_active_map = !top_off_is_active_;
 
   return true;
 }
 
 void WebrtcFrameSchedulerSimple::OnFrameEncoded(
     const WebrtcVideoEncoder::EncodedFrame& encoded_frame,
-    const webrtc::EncodedImageCallback::Result& send_result) {
+    const webrtc::EncodedImageCallback::Result& send_result,
+    HostFrameStats* frame_stats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(frame_pending_);
   frame_pending_ = false;
 
   base::TimeTicks now = base::TimeTicks::Now();
+
+  if (frame_stats) {
+    // Calculate |send_pending_delay| before refilling |pacing_bucket_|.
+    frame_stats->send_pending_delay =
+        std::max(base::TimeDelta(), pacing_bucket_.GetEmptyTime() - now);
+  }
+
   pacing_bucket_.RefillOrSpill(encoded_frame.data.size(), now);
 
   if (encoded_frame.data.empty()) {
     top_off_is_active_ = false;
   } else {
     frame_processing_delay_us_.Record(
         (now - last_capture_started_time_).InMicroseconds());
 
     // Top-off until the target quantizer value is reached.
     top_off_is_active_ = encoded_frame.quantizer > kTargetQuantizerForVp8TopOff;
   }
 
   ScheduleNextFrame(now);
+
+  if (frame_stats) {
+    frame_stats->rtt_estimate = rtt_estimate_;
+    frame_stats->bandwidth_estimate_kbps = pacing_bucket_.rate() * 8 / 1000;
+  }
 }
 
 void WebrtcFrameSchedulerSimple::ScheduleNextFrame(base::TimeTicks now) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (paused_ || pacing_bucket_.rate() == 0 || capture_callback_.is_null() ||
       frame_pending_) {
     return;
   }
 
@@ skipping 21 matching lines @@
 void WebrtcFrameSchedulerSimple::CaptureNextFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!frame_pending_);
   last_capture_started_time_ = base::TimeTicks::Now();
   frame_pending_ = true;
   capture_callback_.Run();
 }
 
 }  // namespace protocol
 }  // namespace remoting