Rename some variables and methods in RTC event log.

webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc

 /*
  *  Copyright (c) 2016 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 24 matching lines @@
     case rtclog::MediaType::AUDIO:
       return MediaType::AUDIO;
     case rtclog::MediaType::VIDEO:
       return MediaType::VIDEO;
     case rtclog::MediaType::DATA:
       return MediaType::DATA;
   }
   RTC_NOTREACHED();
   return MediaType::ANY;
 }
+
+BandwidthUsage GetRuntimeDetectorState(
+    rtclog::DelayBasedBweUpdate::DetectorState detector_state) {
+  switch (detector_state) {
+    case rtclog::DelayBasedBweUpdate::BWE_NORMAL:
+      return kBwNormal;
+    case rtclog::DelayBasedBweUpdate::BWE_UNDERUSING:
+      return kBwUnderusing;
+    case rtclog::DelayBasedBweUpdate::BWE_OVERUSING:
+      return kBwOverusing;
+  }
+  RTC_NOTREACHED();
+  return kBwNormal;
+}
 }  // namespace
 
 // Checks that the event has a timestamp, a type and exactly the data field
 // corresponding to the type.
 ::testing::AssertionResult IsValidBasicEvent(const rtclog::Event& event) {
   if (!event.has_timestamp_us()) {
     return ::testing::AssertionFailure() << "Event has no timestamp";
   }
   if (!event.has_type()) {
     return ::testing::AssertionFailure() << "Event has no event type";
   }
   rtclog::Event_EventType type = event.type();
   if ((type == rtclog::Event::RTP_EVENT) != event.has_rtp_packet()) {
     return ::testing::AssertionFailure()
            << "Event of type " << type << " has "
            << (event.has_rtp_packet() ? "" : "no ") << "RTP packet";
   }
   if ((type == rtclog::Event::RTCP_EVENT) != event.has_rtcp_packet()) {
     return ::testing::AssertionFailure()
            << "Event of type " << type << " has "
            << (event.has_rtcp_packet() ? "" : "no ") << "RTCP packet";
   }
+  if ((type == rtclog::Event::LOSS_BASED_BWE_UPDATE) !=
+      event.has_loss_based_bwe_update()) {
+    return ::testing::AssertionFailure()
+           << "Event of type " << type << " has "
+           << (event.has_loss_based_bwe_update() ? "" : "no ") << "loss update";
+  }
+  if ((type == rtclog::Event::DELAY_BASED_BWE_UPDATE) !=
+      event.has_delay_based_bwe_update()) {
+    return ::testing::AssertionFailure()
+           << "Event of type " << type << " has "
+           << (event.has_delay_based_bwe_update() ? "" : "no ")
+           << "delay update";
+  }
   if ((type == rtclog::Event::AUDIO_PLAYOUT_EVENT) !=
       event.has_audio_playout_event()) {
     return ::testing::AssertionFailure()
            << "Event of type " << type << " has "
            << (event.has_audio_playout_event() ? "" : "no ")
            << "audio_playout event";
   }
   if ((type == rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT) !=
       event.has_video_receiver_config()) {
     return ::testing::AssertionFailure()
@@ skipping 14 matching lines @@
            << (event.has_audio_receiver_config() ? "" : "no ")
            << "audio receiver config";
   }
   if ((type == rtclog::Event::AUDIO_SENDER_CONFIG_EVENT) !=
       event.has_audio_sender_config()) {
     return ::testing::AssertionFailure()
            << "Event of type " << type << " has "
            << (event.has_audio_sender_config() ? "" : "no ")
            << "audio sender config";
   }
+  if ((type == rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT) !=
+      event.has_audio_network_adaptation()) {
+    return ::testing::AssertionFailure()
+           << "Event of type " << type << " has "
+           << (event.has_audio_network_adaptation() ? "" : "no ")
+           << "audio network adaptation";
+  }
   return ::testing::AssertionSuccess();
 }
 
 void RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     const VideoReceiveStream::Config& config) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT, event.type());
@@ skipping 323 matching lines @@
 }
 
 void RtcEventLogTestHelper::VerifyBweLossEvent(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     int32_t bitrate,
     uint8_t fraction_loss,
     int32_t total_packets) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
-  ASSERT_EQ(rtclog::Event::BWE_PACKET_LOSS_EVENT, event.type());
-  const rtclog::BwePacketLossEvent& bwe_event = event.bwe_packet_loss_event();
-  ASSERT_TRUE(bwe_event.has_bitrate());
-  EXPECT_EQ(bitrate, bwe_event.bitrate());
+  ASSERT_EQ(rtclog::Event::LOSS_BASED_BWE_UPDATE, event.type());
+  const rtclog::LossBasedBweUpdate& bwe_event = event.loss_based_bwe_update();
+  ASSERT_TRUE(bwe_event.has_bitrate_bps());
+  EXPECT_EQ(bitrate, bwe_event.bitrate_bps());
   ASSERT_TRUE(bwe_event.has_fraction_loss());
   EXPECT_EQ(fraction_loss, bwe_event.fraction_loss());
   ASSERT_TRUE(bwe_event.has_total_packets());
   EXPECT_EQ(total_packets, bwe_event.total_packets());
 
   // Check consistency of the parser.
   int32_t parsed_bitrate;
   uint8_t parsed_fraction_loss;
   int32_t parsed_total_packets;
-  parsed_log.GetBwePacketLossEvent(
+  parsed_log.GetLossBasedBweUpdate(
       index, &parsed_bitrate, &parsed_fraction_loss, &parsed_total_packets);
   EXPECT_EQ(bitrate, parsed_bitrate);
   EXPECT_EQ(fraction_loss, parsed_fraction_loss);
   EXPECT_EQ(total_packets, parsed_total_packets);
 }
 
+void RtcEventLogTestHelper::VerifyBweDelayEvent(
+    const ParsedRtcEventLog& parsed_log,
+    size_t index,
+    int32_t bitrate,
+    BandwidthUsage detector_state) {
+  const rtclog::Event& event = parsed_log.events_[index];
+  ASSERT_TRUE(IsValidBasicEvent(event));
+  ASSERT_EQ(rtclog::Event::DELAY_BASED_BWE_UPDATE, event.type());
+  const rtclog::DelayBasedBweUpdate& bwe_event = event.delay_based_bwe_update();
+  ASSERT_TRUE(bwe_event.has_bitrate_bps());
+  EXPECT_EQ(bitrate, bwe_event.bitrate_bps());
+  ASSERT_TRUE(bwe_event.has_detector_state());
+  EXPECT_EQ(detector_state,
+            GetRuntimeDetectorState(bwe_event.detector_state()));
+
+  // Check consistency of the parser.
+  int32_t parsed_bitrate;
+  BandwidthUsage parsed_detector_state;
+  parsed_log.GetDelayBasedBweUpdate(index, &parsed_bitrate,
+                                    &parsed_detector_state);
+  EXPECT_EQ(bitrate, parsed_bitrate);
+  EXPECT_EQ(detector_state, parsed_detector_state);
+}
+
 void RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
   AudioNetworkAdaptor::EncoderRuntimeConfig parsed_config;
   parsed_log.GetAudioNetworkAdaptation(index, &parsed_config);
   EXPECT_EQ(config.bitrate_bps, parsed_config.bitrate_bps);
   EXPECT_EQ(config.enable_dtx, parsed_config.enable_dtx);
   EXPECT_EQ(config.enable_fec, parsed_config.enable_fec);
   EXPECT_EQ(config.frame_length_ms, parsed_config.frame_length_ms);
@@ skipping 12 matching lines @@
 
 void RtcEventLogTestHelper::VerifyLogEndEvent(
     const ParsedRtcEventLog& parsed_log,
     size_t index) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   EXPECT_EQ(rtclog::Event::LOG_END, event.type());
 }
 
 }  // namespace webrtc