Rename some variables and methods in RTC event log.

webrtc/logging/rtc_event_log/rtc_event_log.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.
  */
 
@@ skipping 56 matching lines @@
   void LogAudioSendStreamConfig(const AudioSendStream::Config& config) override;
   void LogRtpHeader(PacketDirection direction,
                     MediaType media_type,
                     const uint8_t* header,
                     size_t packet_length) override;
   void LogRtcpPacket(PacketDirection direction,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override;
   void LogAudioPlayout(uint32_t ssrc) override;
-  void LogBwePacketLossEvent(int32_t bitrate,
+  void LogLossBasedBweUpdate(int32_t bitrate_bps,
                              uint8_t fraction_loss,
                              int32_t total_packets) override;
+  void LogDelayBasedBweUpdate(int32_t bitrate_bps,
+                              BandwidthUsage detector_state) override;
   void LogAudioNetworkAdaptation(
       const AudioNetworkAdaptor::EncoderRuntimeConfig& config) override;
 
  private:
   void StoreEvent(std::unique_ptr<rtclog::Event>* event);
 
   // Message queue for passing control messages to the logging thread.
   SwapQueue<RtcEventLogHelperThread::ControlMessage> message_queue_;
 
   // Message queue for passing events to the logging thread.
@@ skipping 32 matching lines @@
       return rtclog::MediaType::AUDIO;
     case MediaType::VIDEO:
       return rtclog::MediaType::VIDEO;
     case MediaType::DATA:
       return rtclog::MediaType::DATA;
   }
   RTC_NOTREACHED();
   return rtclog::ANY;
 }
 
+rtclog::DelayBasedBweUpdate::DetectorState ConvertDetectorState(
+    BandwidthUsage state) {
+  switch (state) {
+    case BandwidthUsage::kBwNormal:
+      return rtclog::DelayBasedBweUpdate::BWE_NORMAL;
+    case BandwidthUsage::kBwUnderusing:
+      return rtclog::DelayBasedBweUpdate::BWE_UNDERUSING;
+    case BandwidthUsage::kBwOverusing:
+      return rtclog::DelayBasedBweUpdate::BWE_OVERUSING;
+  }
+  RTC_NOTREACHED();
+  return rtclog::DelayBasedBweUpdate::BWE_NORMAL;
+}
+
 // The RTP and RTCP buffers reserve space for twice the expected number of
 // sent packets because they also contain received packets.
 static const int kEventsPerSecond = 1000;
 static const int kControlMessagesPerSecond = 10;
 }  // namespace
 
 // RtcEventLogImpl member functions.
 RtcEventLogImpl::RtcEventLogImpl()
     // Allocate buffers for roughly one second of history.
     : message_queue_(kControlMessagesPerSecond),
@@ skipping 274 matching lines @@
 
 void RtcEventLogImpl::LogAudioPlayout(uint32_t ssrc) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::AUDIO_PLAYOUT_EVENT);
   auto playout_event = event->mutable_audio_playout_event();
   playout_event->set_local_ssrc(ssrc);
   StoreEvent(&event);
 }
 
-void RtcEventLogImpl::LogBwePacketLossEvent(int32_t bitrate,
+void RtcEventLogImpl::LogLossBasedBweUpdate(int32_t bitrate_bps,
                                             uint8_t fraction_loss,
                                             int32_t total_packets) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
-  event->set_type(rtclog::Event::BWE_PACKET_LOSS_EVENT);
-  auto bwe_event = event->mutable_bwe_packet_loss_event();
-  bwe_event->set_bitrate(bitrate);
+  event->set_type(rtclog::Event::LOSS_BASED_BWE_UPDATE);
+  auto bwe_event = event->mutable_loss_based_bwe_update();
+  bwe_event->set_bitrate_bps(bitrate_bps);
   bwe_event->set_fraction_loss(fraction_loss);
   bwe_event->set_total_packets(total_packets);
   StoreEvent(&event);
 }
 
+void RtcEventLogImpl::LogDelayBasedBweUpdate(int32_t bitrate_bps,
+                                             BandwidthUsage detector_state) {
+  std::unique_ptr<rtclog::Event> event(new rtclog::Event());
+  event->set_timestamp_us(rtc::TimeMicros());
+  event->set_type(rtclog::Event::DELAY_BASED_BWE_UPDATE);
+  auto bwe_event = event->mutable_delay_based_bwe_update();
+  bwe_event->set_bitrate_bps(bitrate_bps);
+  bwe_event->set_detector_state(ConvertDetectorState(detector_state));
+  StoreEvent(&event);
+}
+
 void RtcEventLogImpl::LogAudioNetworkAdaptation(
     const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);
   auto audio_network_adaptation = event->mutable_audio_network_adaptation();
   if (config.bitrate_bps)
     audio_network_adaptation->set_bitrate_bps(*config.bitrate_bps);
   if (config.frame_length_ms)
     audio_network_adaptation->set_frame_length_ms(*config.frame_length_ms);
@@ skipping 51 matching lines @@
 #else
   return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
 #endif  // ENABLE_RTC_EVENT_LOG
 }
 
 std::unique_ptr<RtcEventLog> RtcEventLog::CreateNull() {
   return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
 }
 
 }  // namespace webrtc