Added protobuf message for loss-based BWE events, and wired it up to the send side bandwidth estima…

webrtc/modules/bitrate_controller/send_side_bandwidth_estimation.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/modules/bitrate_controller/send_side_bandwidth_estimation.h"
 
 #include <cmath>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/call/rtc_event_log.h"
 #include "webrtc/system_wrappers/interface/field_trial.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/metrics.h"
 
 namespace webrtc {
 namespace {
 const int64_t kBweIncreaseIntervalMs = 1000;
 const int64_t kBweDecreaseIntervalMs = 300;
 const int64_t kStartPhaseMs = 2000;
 const int64_t kBweConverganceTimeMs = 20000;
@@ skipping 25 matching lines @@
       last_low_bitrate_log_ms_(-1),
       time_last_receiver_block_ms_(0),
       last_fraction_loss_(0),
       last_round_trip_time_ms_(0),
       bwe_incoming_(0),
       time_last_decrease_ms_(0),
       first_report_time_ms_(-1),
       initially_lost_packets_(0),
       bitrate_at_2_seconds_kbps_(0),
       uma_update_state_(kNoUpdate),
-      rampup_uma_stats_updated_(kNumUmaRampupMetrics, false) {
-}
+      rampup_uma_stats_updated_(kNumUmaRampupMetrics, false),
+      event_log_(nullptr) {
+  }
 
 SendSideBandwidthEstimation::~SendSideBandwidthEstimation() {}
 
 void SendSideBandwidthEstimation::SetSendBitrate(int bitrate) {
   RTC_DCHECK_GT(bitrate, 0);
   bitrate_ = bitrate;
 
   // Clear last sent bitrate history so the new value can be used directly
   // and not capped.
   min_bitrate_history_.clear();
@@ skipping 125 matching lines @@
       //   If instead one would do: bitrate_ *= 1.08^(delta time), it would
       //   take over one second since the lower packet loss to achieve 108kbps.
       bitrate_ = static_cast<uint32_t>(
           min_bitrate_history_.front().second * 1.08 + 0.5);
 
       // Add 1 kbps extra, just to make sure that we do not get stuck
       // (gives a little extra increase at low rates, negligible at higher
       // rates).
       bitrate_ += 1000;
 
+      if (event_log_) {
+        event_log_->LogBwePacketLossEvent(bitrate_, last_fraction_loss_,

[stefan-webrtc, 2015/10/19 08:43:22]

Would there be a point in differentiating between bitrate increases and
decreases in the log?

[terelius, 2015/10/26 17:40:18]

Since we have log the fraction lost, we are able to figure out whether the
change should be an increase of decrease. (At least assuming that we know
roughly which version of WebRTC is used and the packet loss limits don't change
dramatically between WebRTC versions. Current limits are 2% and 10%.)

Once we start logging all BWE changes we should also be able to see whether the
change was an increase or decrease by comparing whith the previous estimate.

[stefan-webrtc, 2015/10/28 16:03:18]

True, sgtm

+                                          accumulate_expected_packets_);
+      }
     } else if (last_fraction_loss_ <= 26) {
       // Loss between 2% - 10%: Do nothing.
 
     } else {
       // Loss > 10%: Limit the rate decreases to once a kBweDecreaseIntervalMs +
       // rtt.
       if ((now_ms - time_last_decrease_ms_) >=
           (kBweDecreaseIntervalMs + last_round_trip_time_ms_)) {
         time_last_decrease_ms_ = now_ms;
 
         // Reduce rate:
         //   newRate = rate * (1 - 0.5*lossRate);
         //   where packetLoss = 256*lossRate;
         bitrate_ = static_cast<uint32_t>(
             (bitrate_ * static_cast<double>(512 - last_fraction_loss_)) /
             512.0);
       }
+      if (event_log_) {
+        event_log_->LogBwePacketLossEvent(bitrate_, last_fraction_loss_,
+                                          accumulate_expected_packets_);
+      }
     }
   }
   bitrate_ = CapBitrateToThresholds(now_ms, bitrate_);
 }
 
 bool SendSideBandwidthEstimation::IsInStartPhase(int64_t now_ms) const {
   return first_report_time_ms_ == -1 ||
          now_ms - first_report_time_ms_ < kStartPhaseMs;
 }
 
@@ skipping 30 matching lines @@
         now_ms - last_low_bitrate_log_ms_ > kLowBitrateLogPeriodMs) {
       LOG(LS_WARNING) << "Estimated available bandwidth " << bitrate / 1000
                       << " kbps is below configured min bitrate "
                       << min_bitrate_configured_ / 1000 << " kbps.";
       last_low_bitrate_log_ms_ = now_ms;
     }
     bitrate = min_bitrate_configured_;
   }
   return bitrate;
 }
+
+void SendSideBandwidthEstimation::SetEventLog(RtcEventLog* event_log) {
+  event_log_ = event_log;
+}
+
 }  // namespace webrtc