Split LoggedBweProbeResult into -Success and -Failure.

Also change ParsedEventLog::EventType to enum class.

Bug: webrtc:8111
Change-Id: I4747fb9cbcbdb963fa032770078218e5b416b3da
Reviewed-on: https://webrtc-review.googlesource.com/79280
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Reviewed-by: Minyue Li <minyue@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23432}

logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc

@@ -140,7 +140,7 @@ void RtcEventLogEncoderTest::TestRtcEventAudioNetworkAdaptation(
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::AUDIO_NETWORK_ADAPTATION_EVENT);
+            ParsedRtcEventLogNew::EventType::AUDIO_NETWORK_ADAPTATION_EVENT);
 
   LoggedAudioNetworkAdaptationEvent parsed_event =
       parsed_log_.GetAudioNetworkAdaptation(0);
@@ -232,7 +232,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioPlayout) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::AUDIO_PLAYOUT_EVENT);
+            ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT);
 
   LoggedAudioPlayoutEvent playout_event = parsed_log_.GetAudioPlayout(0);
 
@@ -261,7 +261,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::AUDIO_RECEIVER_CONFIG_EVENT);
+            ParsedRtcEventLogNew::EventType::AUDIO_RECEIVER_CONFIG_EVENT);
 
   auto parsed_event = parsed_log_.GetAudioReceiveConfig(0);
   EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
@@ -286,7 +286,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioSendStreamConfig) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::AUDIO_SENDER_CONFIG_EVENT);
+            ParsedRtcEventLogNew::EventType::AUDIO_SENDER_CONFIG_EVENT);
 
   auto parsed_event = parsed_log_.GetAudioSendConfig(0);
   EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
@@ -306,7 +306,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateDelayBased) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::DELAY_BASED_BWE_UPDATE);
+            ParsedRtcEventLogNew::EventType::DELAY_BASED_BWE_UPDATE);
 
   auto parsed_event = parsed_log_.GetDelayBasedBweUpdate(0);
 
@@ -330,7 +330,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateLossBased) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::LOSS_BASED_BWE_UPDATE);
+            ParsedRtcEventLogNew::EventType::LOSS_BASED_BWE_UPDATE);
 
   LoggedBweLossBasedUpdate bwe_update = parsed_log_.GetLossBasedBweUpdate(0);
 
@@ -345,7 +345,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStarted) {
 
   ASSERT_TRUE(parsed_log_.ParseString(encoder_->EncodeLogStart(timestamp_us)));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
-  ASSERT_EQ(parsed_log_.GetEventType(0), ParsedRtcEventLogNew::LOG_START);
+  ASSERT_EQ(parsed_log_.GetEventType(0),
+            ParsedRtcEventLogNew::EventType::LOG_START);
 
   EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
 }
@@ -355,16 +356,17 @@ TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStopped) {
 
   ASSERT_TRUE(parsed_log_.ParseString(encoder_->EncodeLogEnd(timestamp_us)));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
-  ASSERT_EQ(parsed_log_.GetEventType(0), ParsedRtcEventLogNew::LOG_END);
+  ASSERT_EQ(parsed_log_.GetEventType(0),
+            ParsedRtcEventLogNew::EventType::LOG_END);
 
   EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
 }
 
 TEST_P(RtcEventLogEncoderTest, RtcEventProbeClusterCreated) {
-  const int id = RandomPositiveInt();
+  const int32_t id = RandomPositiveInt();
-  const int bitrate_bps = RandomBitrate();
+  const int32_t bitrate_bps = RandomBitrate();
-  const int min_probes = RandomPositiveInt();
+  const uint32_t min_probes = RandomPositiveInt();
-  const int min_bytes = RandomPositiveInt();
+  const uint32_t min_bytes = RandomPositiveInt();
 
   auto event = rtc::MakeUnique<RtcEventProbeClusterCreated>(
       id, bitrate_bps, min_probes, min_bytes);
@@ -375,15 +377,15 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeClusterCreated) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::BWE_PROBE_CLUSTER_CREATED_EVENT);
+            ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT);
 
   auto parsed_event = parsed_log_.GetBweProbeClusterCreated(0);
 
   EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
-  EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.id), id);
+  EXPECT_EQ(parsed_event.id, id);
-  EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.bitrate_bps), bitrate_bps);
+  EXPECT_EQ(parsed_event.bitrate_bps, bitrate_bps);
-  EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.min_packets), min_probes);
+  EXPECT_EQ(parsed_event.min_packets, min_probes);
-  EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.min_bytes), min_bytes);
+  EXPECT_EQ(parsed_event.min_bytes, min_bytes);
 }
 
 TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) {
@@ -399,20 +401,18 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::BWE_PROBE_RESULT_EVENT);
+            ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT);
 
-  auto parsed_event = parsed_log_.GetBweProbeResult(0);
+  auto parsed_event = parsed_log_.GetBweProbeFailure(0);
 
   EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
-  EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.id), id);
+  EXPECT_EQ(parsed_event.id, id);
-  ASSERT_FALSE(parsed_event.bitrate_bps);
-  ASSERT_TRUE(parsed_event.failure_reason);
   EXPECT_EQ(parsed_event.failure_reason, failure_reason);
 }
 
 TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) {
-  const int id = RandomPositiveInt();
+  const int32_t id = RandomPositiveInt();
-  const uint64_t bitrate_bps = rtc::checked_cast<uint64_t>(RandomBitrate());
+  const int32_t bitrate_bps = RandomBitrate();
 
   auto event = rtc::MakeUnique<RtcEventProbeResultSuccess>(id, bitrate_bps);
   const int64_t timestamp_us = event->timestamp_us_;
@@ -422,14 +422,13 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::BWE_PROBE_RESULT_EVENT);
+            ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT);
 
-  auto parsed_event = parsed_log_.GetBweProbeResult(0);
+  auto parsed_event = parsed_log_.GetBweProbeSuccess(0);
 
   EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
-  EXPECT_EQ(rtc::dchecked_cast<int>(parsed_event.id), id);
+  EXPECT_EQ(parsed_event.id, id);
   EXPECT_EQ(parsed_event.bitrate_bps, bitrate_bps);
-  ASSERT_FALSE(parsed_event.failure_reason);
 }
 
 void RtcEventLogEncoderTest::TestRtcEventRtcpPacket(PacketDirection direction) {
@@ -449,7 +448,8 @@ void RtcEventLogEncoderTest::TestRtcEventRtcpPacket(PacketDirection direction) {
   std::string encoded = encoder_->EncodeBatch(history_.begin(), history_.end());
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
-  ASSERT_EQ(parsed_log_.GetEventType(0), ParsedRtcEventLogNew::RTCP_EVENT);
+  ASSERT_EQ(parsed_log_.GetEventType(0),
+            ParsedRtcEventLogNew::EventType::RTCP_EVENT);
 
   PacketDirection parsed_direction;
   uint8_t parsed_packet[IP_PACKET_SIZE];  // "Parsed" = after event-encoding.
@@ -503,7 +503,8 @@ void RtcEventLogEncoderTest::TestRtcEventRtpPacket(PacketDirection direction) {
   std::string encoded = encoder_->EncodeBatch(history_.begin(), history_.end());
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
-  ASSERT_EQ(parsed_log_.GetEventType(0), ParsedRtcEventLogNew::RTP_EVENT);
+  ASSERT_EQ(parsed_log_.GetEventType(0),
+            ParsedRtcEventLogNew::EventType::RTP_EVENT);
 
   PacketDirection parsed_direction;
   uint8_t parsed_rtp_header[IP_PACKET_SIZE];
@@ -554,7 +555,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoReceiveStreamConfig) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::VIDEO_RECEIVER_CONFIG_EVENT);
+            ParsedRtcEventLogNew::EventType::VIDEO_RECEIVER_CONFIG_EVENT);
 
   auto parsed_event = parsed_log_.GetVideoReceiveConfig(0);
   EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);
@@ -580,7 +581,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoSendStreamConfig) {
   ASSERT_TRUE(parsed_log_.ParseString(encoded));
   ASSERT_EQ(parsed_log_.GetNumberOfEvents(), 1u);
   ASSERT_EQ(parsed_log_.GetEventType(0),
-            ParsedRtcEventLogNew::VIDEO_SENDER_CONFIG_EVENT);
+            ParsedRtcEventLogNew::EventType::VIDEO_SENDER_CONFIG_EVENT);
 
   auto parsed_event = parsed_log_.GetVideoSendConfig(0)[0];
   EXPECT_EQ(parsed_log_.GetTimestamp(0), timestamp_us);

logging/rtc_event_log/rtc_event_log2rtp_dump.cc

@@ -128,7 +128,7 @@ int main(int argc, char* argv[]) {
     // a softer failure option, but it does not seem useful to generate
     // RTP dumps based on broken event logs.
     if (FLAG_rtp && parsed_stream.GetEventType(i) ==
-                        webrtc::ParsedRtcEventLogNew::RTP_EVENT) {
+                        webrtc::ParsedRtcEventLogNew::EventType::RTP_EVENT) {
       webrtc::test::RtpPacket packet;
       webrtc::PacketDirection direction;
       parsed_stream.GetRtpHeader(i, &direction, packet.data, &packet.length,
@@ -166,7 +166,7 @@ int main(int argc, char* argv[]) {
       rtp_counter++;
     }
     if (FLAG_rtcp && parsed_stream.GetEventType(i) ==
-                         webrtc::ParsedRtcEventLogNew::RTCP_EVENT) {
+                         webrtc::ParsedRtcEventLogNew::EventType::RTCP_EVENT) {
       webrtc::test::RtpPacket packet;
       webrtc::PacketDirection direction;
       parsed_stream.GetRtcpPacket(i, &direction, packet.data, &packet.length);

logging/rtc_event_log/rtc_event_log2text.cc

@@ -409,7 +409,7 @@ int main(int argc, char* argv[]) {
   for (size_t i = 0; i < parsed_stream.GetNumberOfEvents(); i++) {
     bool event_recognized = false;
     switch (parsed_stream.GetEventType(i)) {
-      case webrtc::ParsedRtcEventLogNew::UNKNOWN_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT: {
         if (FLAG_unknown) {
           std::cout << parsed_stream.GetTimestamp(i) << "\tUNKNOWN_EVENT"
                     << std::endl;
@@ -418,7 +418,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::LOG_START: {
+      case webrtc::ParsedRtcEventLogNew::EventType::LOG_START: {
         if (FLAG_startstop) {
           std::cout << parsed_stream.GetTimestamp(i) << "\tLOG_START"
                     << std::endl;
@@ -427,7 +427,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::LOG_END: {
+      case webrtc::ParsedRtcEventLogNew::EventType::LOG_END: {
         if (FLAG_startstop) {
           std::cout << parsed_stream.GetTimestamp(i) << "\tLOG_END"
                     << std::endl;
@@ -436,7 +436,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::RTP_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::RTP_EVENT: {
         if (FLAG_rtp) {
           size_t header_length;
           size_t total_length;
@@ -513,7 +513,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::RTCP_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::RTCP_EVENT: {
         if (FLAG_rtcp) {
           size_t length;
           uint8_t packet[IP_PACKET_SIZE];
@@ -580,7 +580,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::AUDIO_PLAYOUT_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT: {
         if (FLAG_playout) {
           auto audio_playout = parsed_stream.GetAudioPlayout(i);
           std::cout << audio_playout.log_time_us() << "\tAUDIO_PLAYOUT"
@@ -590,7 +590,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::LOSS_BASED_BWE_UPDATE: {
+      case webrtc::ParsedRtcEventLogNew::EventType::LOSS_BASED_BWE_UPDATE: {
         if (FLAG_bwe) {
           auto bwe_update = parsed_stream.GetLossBasedBweUpdate(i);
           std::cout << bwe_update.log_time_us() << "\tBWE(LOSS_BASED)"
@@ -604,7 +604,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::DELAY_BASED_BWE_UPDATE: {
+      case webrtc::ParsedRtcEventLogNew::EventType::DELAY_BASED_BWE_UPDATE: {
         if (FLAG_bwe) {
           auto bwe_update = parsed_stream.GetDelayBasedBweUpdate(i);
           std::cout << bwe_update.log_time_us() << "\tBWE(DELAY_BASED)"
@@ -616,7 +616,8 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::VIDEO_RECEIVER_CONFIG_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::
+          VIDEO_RECEIVER_CONFIG_EVENT: {
         if (FLAG_config && FLAG_video && FLAG_incoming) {
           webrtc::rtclog::StreamConfig config =
               parsed_stream.GetVideoReceiveConfig(i);
@@ -641,7 +642,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::VIDEO_SENDER_CONFIG_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::VIDEO_SENDER_CONFIG_EVENT: {
         if (FLAG_config && FLAG_video && FLAG_outgoing) {
           std::vector<webrtc::rtclog::StreamConfig> configs =
               parsed_stream.GetVideoSendConfig(i);
@@ -668,7 +669,8 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::AUDIO_RECEIVER_CONFIG_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::
+          AUDIO_RECEIVER_CONFIG_EVENT: {
         if (FLAG_config && FLAG_audio && FLAG_incoming) {
           webrtc::rtclog::StreamConfig config =
               parsed_stream.GetAudioReceiveConfig(i);
@@ -693,7 +695,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::AUDIO_SENDER_CONFIG_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::AUDIO_SENDER_CONFIG_EVENT: {
         if (FLAG_config && FLAG_audio && FLAG_outgoing) {
           webrtc::rtclog::StreamConfig config =
               parsed_stream.GetAudioSendConfig(i);
@@ -717,7 +719,8 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::AUDIO_NETWORK_ADAPTATION_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::
+          AUDIO_NETWORK_ADAPTATION_EVENT: {
         if (FLAG_ana) {
           auto ana_event = parsed_stream.GetAudioNetworkAdaptation(i);
           char buffer[300];
@@ -749,7 +752,8 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::BWE_PROBE_CLUSTER_CREATED_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::
+          BWE_PROBE_CLUSTER_CREATED_EVENT: {
         if (FLAG_probe) {
           auto probe_event = parsed_stream.GetBweProbeClusterCreated(i);
           std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_CREATED("
@@ -762,28 +766,34 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::BWE_PROBE_RESULT_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT: {
         if (FLAG_probe) {
-          webrtc::LoggedBweProbeResultEvent probe_result =
+          webrtc::LoggedBweProbeFailureEvent probe_result =
-              parsed_stream.GetBweProbeResult(i);
+              parsed_stream.GetBweProbeFailure(i);
-          if (probe_result.failure_reason) {
+          std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_FAILURE("
-            std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_SUCCESS("
+                    << probe_result.id << ")"
-                      << probe_result.id << ")"
+                    << "\tfailure_reason="
-                      << "\tfailure_reason="
+                    << static_cast<int>(probe_result.failure_reason)
-                      << static_cast<int>(*probe_result.failure_reason)
+                    << std::endl;
-                      << std::endl;
-          } else {
-            std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_SUCCESS("
-                      << probe_result.id << ")"
-                      << "\tbitrate_bps=" << *probe_result.bitrate_bps
-                      << std::endl;
-          }
         }
         event_recognized = true;
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::ALR_STATE_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT: {
+        if (FLAG_probe) {
+          webrtc::LoggedBweProbeSuccessEvent probe_result =
+              parsed_stream.GetBweProbeSuccess(i);
+          std::cout << parsed_stream.GetTimestamp(i) << "\tPROBE_SUCCESS("
+                    << probe_result.id << ")"
+                    << "\tbitrate_bps=" << probe_result.bitrate_bps
+                    << std::endl;
+        }
+        event_recognized = true;
+        break;
+      }
+
+      case webrtc::ParsedRtcEventLogNew::EventType::ALR_STATE_EVENT: {
         if (FLAG_bwe) {
           webrtc::LoggedAlrStateEvent alr_state = parsed_stream.GetAlrState(i);
           std::cout << parsed_stream.GetTimestamp(i) << "\tALR_STATE"
@@ -793,7 +803,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::ICE_CANDIDATE_PAIR_CONFIG: {
+      case webrtc::ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_CONFIG: {
         if (FLAG_ice) {
           webrtc::LoggedIceCandidatePairConfig ice_cp_config =
               parsed_stream.GetIceCandidatePairConfig(i);
@@ -807,7 +817,7 @@ int main(int argc, char* argv[]) {
         break;
       }
 
-      case webrtc::ParsedRtcEventLogNew::ICE_CANDIDATE_PAIR_EVENT: {
+      case webrtc::ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_EVENT: {
         if (FLAG_ice) {
           webrtc::LoggedIceCandidatePairEvent ice_cp_event =
               parsed_stream.GetIceCandidatePairEvent(i);
@@ -823,8 +833,9 @@ int main(int argc, char* argv[]) {
     }
 
     if (!event_recognized) {
-      std::cout << "Unrecognized event (" << parsed_stream.GetEventType(i)
+      std::cout << "Unrecognized event ("
-                << ")" << std::endl;
+                << static_cast<int>(parsed_stream.GetEventType(i)) << ")"
+                << std::endl;
     }
   }
   return 0;

logging/rtc_event_log/rtc_event_log_parser_new.cc

@@ -80,7 +80,10 @@ ParsedRtcEventLogNew::EventType GetRuntimeEventType(
     case rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT:
       return ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT;
     case rtclog::Event::BWE_PROBE_RESULT_EVENT:
-      return ParsedRtcEventLogNew::EventType::BWE_PROBE_RESULT_EVENT;
+      // Probe successes and failures are currently stored in the same proto
+      // message, we are moving towards separate messages. Probe results
+      // therefore need special treatment in the parser.
+      return ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT;
     case rtclog::Event::ALR_STATE_EVENT:
       return ParsedRtcEventLogNew::EventType::ALR_STATE_EVENT;
     case rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG:
@@ -313,7 +316,8 @@ void ParsedRtcEventLogNew::Clear() {
   audio_playout_events_.clear();
   audio_network_adaptation_events_.clear();
   bwe_probe_cluster_created_events_.clear();
-  bwe_probe_result_events_.clear();
+  bwe_probe_failure_events_.clear();
+  bwe_probe_success_events_.clear();
   bwe_delay_updates_.clear();
   bwe_loss_updates_.clear();
   alr_state_events_.clear();
@@ -467,8 +471,8 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
     last_timestamp_ = std::max(last_timestamp_, timestamp);
   }
 
-  switch (event.type()) {
+  switch (GetEventType(event)) {
-    case rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT: {
+    case ParsedRtcEventLogNew::EventType::VIDEO_RECEIVER_CONFIG_EVENT: {
       rtclog::StreamConfig config = GetVideoReceiveConfig(event);
       video_recv_configs_.emplace_back(GetTimestamp(event), config);
       incoming_rtp_extensions_maps_[config.remote_ssrc] =
@@ -483,7 +487,7 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
       incoming_rtx_ssrcs_.insert(config.rtx_ssrc);
       break;
     }
-    case rtclog::Event::VIDEO_SENDER_CONFIG_EVENT: {
+    case ParsedRtcEventLogNew::EventType::VIDEO_SENDER_CONFIG_EVENT: {
       std::vector<rtclog::StreamConfig> configs = GetVideoSendConfig(event);
       video_send_configs_.emplace_back(GetTimestamp(event), configs);
       for (const auto& config : configs) {
@@ -497,7 +501,7 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
       }
       break;
     }
-    case rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT: {
+    case ParsedRtcEventLogNew::EventType::AUDIO_RECEIVER_CONFIG_EVENT: {
       rtclog::StreamConfig config = GetAudioReceiveConfig(event);
       audio_recv_configs_.emplace_back(GetTimestamp(event), config);
       incoming_rtp_extensions_maps_[config.remote_ssrc] =
@@ -507,7 +511,7 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
       incoming_audio_ssrcs_.insert(config.remote_ssrc);
       break;
     }
-    case rtclog::Event::AUDIO_SENDER_CONFIG_EVENT: {
+    case ParsedRtcEventLogNew::EventType::AUDIO_SENDER_CONFIG_EVENT: {
       rtclog::StreamConfig config = GetAudioSendConfig(event);
       audio_send_configs_.emplace_back(GetTimestamp(event), config);
       outgoing_rtp_extensions_maps_[config.local_ssrc] =
@@ -515,7 +519,7 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
       outgoing_audio_ssrcs_.insert(config.local_ssrc);
       break;
     }
-    case rtclog::Event::RTP_EVENT: {
+    case ParsedRtcEventLogNew::EventType::RTP_EVENT: {
       PacketDirection direction;
       uint8_t header[IP_PACKET_SIZE];
       size_t header_length;
@@ -546,7 +550,7 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
       }
       break;
     }
-    case rtclog::Event::RTCP_EVENT: {
+    case ParsedRtcEventLogNew::EventType::RTCP_EVENT: {
       PacketDirection direction;
       uint8_t packet[IP_PACKET_SIZE];
       size_t total_length;
@@ -632,55 +636,59 @@ void ParsedRtcEventLogNew::StoreParsedEvent(const rtclog::Event& event) {
       }
       break;
     }
-    case rtclog::Event::LOG_START: {
+    case ParsedRtcEventLogNew::EventType::LOG_START: {
       start_log_events_.push_back(LoggedStartEvent(GetTimestamp(event)));
       break;
     }
-    case rtclog::Event::LOG_END: {
+    case ParsedRtcEventLogNew::EventType::LOG_END: {
       stop_log_events_.push_back(LoggedStopEvent(GetTimestamp(event)));
       break;
     }
-    case rtclog::Event::AUDIO_PLAYOUT_EVENT: {
+    case ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT: {
       LoggedAudioPlayoutEvent playout_event = GetAudioPlayout(event);
       audio_playout_events_[playout_event.ssrc].push_back(playout_event);
       break;
     }
-    case rtclog::Event::LOSS_BASED_BWE_UPDATE: {
+    case ParsedRtcEventLogNew::EventType::LOSS_BASED_BWE_UPDATE: {
       bwe_loss_updates_.push_back(GetLossBasedBweUpdate(event));
       break;
     }
-    case rtclog::Event::DELAY_BASED_BWE_UPDATE: {
+    case ParsedRtcEventLogNew::EventType::DELAY_BASED_BWE_UPDATE: {
       bwe_delay_updates_.push_back(GetDelayBasedBweUpdate(event));
       break;
     }
-    case rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT: {
+    case ParsedRtcEventLogNew::EventType::AUDIO_NETWORK_ADAPTATION_EVENT: {
       LoggedAudioNetworkAdaptationEvent ana_event =
           GetAudioNetworkAdaptation(event);
       audio_network_adaptation_events_.push_back(ana_event);
       break;
     }
-    case rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT: {
+    case ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT: {
       bwe_probe_cluster_created_events_.push_back(
           GetBweProbeClusterCreated(event));
       break;
     }
-    case rtclog::Event::BWE_PROBE_RESULT_EVENT: {
+    case ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT: {
-      bwe_probe_result_events_.push_back(GetBweProbeResult(event));
+      bwe_probe_failure_events_.push_back(GetBweProbeFailure(event));
       break;
     }
-    case rtclog::Event::ALR_STATE_EVENT: {
+    case ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT: {
+      bwe_probe_success_events_.push_back(GetBweProbeSuccess(event));
+      break;
+    }
+    case ParsedRtcEventLogNew::EventType::ALR_STATE_EVENT: {
       alr_state_events_.push_back(GetAlrState(event));
       break;
     }
-    case rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG: {
+    case ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_CONFIG: {
       ice_candidate_pair_configs_.push_back(GetIceCandidatePairConfig(event));
       break;
     }
-    case rtclog::Event::ICE_CANDIDATE_PAIR_EVENT: {
+    case ParsedRtcEventLogNew::EventType::ICE_CANDIDATE_PAIR_EVENT: {
       ice_candidate_pair_events_.push_back(GetIceCandidatePairEvent(event));
       break;
     }
-    case rtclog::Event::UNKNOWN_EVENT: {
+    case ParsedRtcEventLogNew::EventType::UNKNOWN_EVENT: {
       break;
     }
   }
@@ -705,7 +713,19 @@ ParsedRtcEventLogNew::EventType ParsedRtcEventLogNew::GetEventType(
     size_t index) const {
   RTC_CHECK_LT(index, GetNumberOfEvents());
   const rtclog::Event& event = events_[index];
+  return GetEventType(event);
+}
+
+ParsedRtcEventLogNew::EventType ParsedRtcEventLogNew::GetEventType(
+    const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
+  if (event.type() == rtclog::Event::BWE_PROBE_RESULT_EVENT) {
+    RTC_CHECK(event.has_probe_result());
+    RTC_CHECK(event.probe_result().has_result());
+    if (event.probe_result().result() == rtclog::BweProbeResult::SUCCESS)
+      return ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT;
+    return ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT;
+  }
   return GetRuntimeEventType(event.type());
 }
 
@@ -1108,30 +1128,29 @@ ParsedRtcEventLogNew::GetBweProbeClusterCreated(
   return res;
 }
 
-LoggedBweProbeResultEvent ParsedRtcEventLogNew::GetBweProbeResult(
+LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
     size_t index) const {
   RTC_CHECK_LT(index, GetNumberOfEvents());
   const rtclog::Event& event = events_[index];
-  return GetBweProbeResult(event);
+  return GetBweProbeFailure(event);
 }
 
-LoggedBweProbeResultEvent ParsedRtcEventLogNew::GetBweProbeResult(
+LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
     const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT);
   RTC_CHECK(event.has_probe_result());
   const rtclog::BweProbeResult& pr_event = event.probe_result();
-  LoggedBweProbeResultEvent res;
+  RTC_CHECK(pr_event.has_result());
+  RTC_CHECK_NE(pr_event.result(), rtclog::BweProbeResult::SUCCESS);
+
+  LoggedBweProbeFailureEvent res;
   res.timestamp_us = GetTimestamp(event);
   RTC_CHECK(pr_event.has_id());
   res.id = pr_event.id();
-
   RTC_CHECK(pr_event.has_result());
-  if (pr_event.result() == rtclog::BweProbeResult::SUCCESS) {
+  if (pr_event.result() ==
-    RTC_CHECK(pr_event.has_bitrate_bps());
+      rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL) {
-    res.bitrate_bps = pr_event.bitrate_bps();
-  } else if (pr_event.result() ==
-             rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL) {
     res.failure_reason = ProbeFailureReason::kInvalidSendReceiveInterval;
   } else if (pr_event.result() ==
              rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO) {
@@ -1141,6 +1160,33 @@ LoggedBweProbeResultEvent ParsedRtcEventLogNew::GetBweProbeResult(
   } else {
     RTC_NOTREACHED();
   }
+  RTC_CHECK(!pr_event.has_bitrate_bps());
+
+  return res;
+}
+
+LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
+    size_t index) const {
+  RTC_CHECK_LT(index, GetNumberOfEvents());
+  const rtclog::Event& event = events_[index];
+  return GetBweProbeSuccess(event);
+}
+
+LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
+    const rtclog::Event& event) const {
+  RTC_CHECK(event.has_type());
+  RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT);
+  RTC_CHECK(event.has_probe_result());
+  const rtclog::BweProbeResult& pr_event = event.probe_result();
+  RTC_CHECK(pr_event.has_result());
+  RTC_CHECK_EQ(pr_event.result(), rtclog::BweProbeResult::SUCCESS);
+
+  LoggedBweProbeSuccessEvent res;
+  res.timestamp_us = GetTimestamp(event);
+  RTC_CHECK(pr_event.has_id());
+  res.id = pr_event.id();
+  RTC_CHECK(pr_event.has_bitrate_bps());
+  res.bitrate_bps = pr_event.bitrate_bps();
 
   return res;
 }

logging/rtc_event_log/rtc_event_log_parser_new.h

@@ -96,11 +96,18 @@ struct LoggedBweProbeClusterCreatedEvent {
   int64_t log_time_ms() const { return timestamp_us / 1000; }
 };
 
-struct LoggedBweProbeResultEvent {
+struct LoggedBweProbeSuccessEvent {
   int64_t timestamp_us;
   int32_t id;
-  rtc::Optional<int32_t> bitrate_bps;
+  int32_t bitrate_bps;
-  rtc::Optional<ProbeFailureReason> failure_reason;
+  int64_t log_time_us() const { return timestamp_us; }
+  int64_t log_time_ms() const { return timestamp_us / 1000; }
+};
+
+struct LoggedBweProbeFailureEvent {
+  int64_t timestamp_us;
+  int32_t id;
+  ProbeFailureReason failure_reason;
   int64_t log_time_us() const { return timestamp_us; }
   int64_t log_time_ms() const { return timestamp_us / 1000; }
 };
@@ -463,7 +470,7 @@ class ParsedRtcEventLogNew {
   friend class RtcEventLogTestHelper;
 
  public:
-  enum EventType {
+  enum class EventType {
     UNKNOWN_EVENT = 0,
     LOG_START = 1,
     LOG_END = 2,
@@ -478,10 +485,11 @@ class ParsedRtcEventLogNew {
     AUDIO_SENDER_CONFIG_EVENT = 11,
     AUDIO_NETWORK_ADAPTATION_EVENT = 16,
     BWE_PROBE_CLUSTER_CREATED_EVENT = 17,
-    BWE_PROBE_RESULT_EVENT = 18,
+    BWE_PROBE_FAILURE_EVENT = 18,
-    ALR_STATE_EVENT = 19,
+    BWE_PROBE_SUCCESS_EVENT = 19,
-    ICE_CANDIDATE_PAIR_CONFIG = 20,
+    ALR_STATE_EVENT = 20,
-    ICE_CANDIDATE_PAIR_EVENT = 21,
+    ICE_CANDIDATE_PAIR_CONFIG = 21,
+    ICE_CANDIDATE_PAIR_EVENT = 22,
   };
 
   enum class MediaType { ANY, AUDIO, VIDEO, DATA };
@@ -490,6 +498,37 @@ class ParsedRtcEventLogNew {
     kAttemptWebrtcDefaultConfig
   };
 
+  struct LoggedRtpStreamIncoming {
+    uint32_t ssrc;
+    std::vector<LoggedRtpPacketIncoming> incoming_packets;
+  };
+
+  struct LoggedRtpStreamOutgoing {
+    uint32_t ssrc;
+    std::vector<LoggedRtpPacketOutgoing> outgoing_packets;
+  };
+
+  struct LoggedRtpStreamView {
+    LoggedRtpStreamView(uint32_t ssrc,
+                        const LoggedRtpPacketIncoming* ptr,
+                        size_t num_elements)
+        : ssrc(ssrc),
+          packet_view(PacketView<const LoggedRtpPacket>::Create(
+              ptr,
+              num_elements,
+              offsetof(LoggedRtpPacketIncoming, rtp))) {}
+    LoggedRtpStreamView(uint32_t ssrc,
+                        const LoggedRtpPacketOutgoing* ptr,
+                        size_t num_elements)
+        : ssrc(ssrc),
+          packet_view(PacketView<const LoggedRtpPacket>::Create(
+              ptr,
+              num_elements,
+              offsetof(LoggedRtpPacketOutgoing, rtp))) {}
+    uint32_t ssrc;
+    PacketView<const LoggedRtpPacket> packet_view;
+  };
+
   explicit ParsedRtcEventLogNew(
       UnconfiguredHeaderExtensions parse_unconfigured_header_extensions =
           UnconfiguredHeaderExtensions::kDontParse);
@@ -517,6 +556,7 @@ class ParsedRtcEventLogNew {
 
   // Reads the event type of the rtclog::Event at |index|.
   EventType GetEventType(size_t index) const;
+  EventType GetEventType(const rtclog::Event& event) const;
 
   // Reads the header, direction, header length and packet length from the RTP
   // event at |index|, and stores the values in the corresponding output
@@ -601,7 +641,8 @@ class ParsedRtcEventLogNew {
   LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated(
       size_t index) const;
 
-  LoggedBweProbeResultEvent GetBweProbeResult(size_t index) const;
+  LoggedBweProbeFailureEvent GetBweProbeFailure(size_t index) const;
+  LoggedBweProbeSuccessEvent GetBweProbeSuccess(size_t index) const;
 
   MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) const;
 
@@ -611,96 +652,91 @@ class ParsedRtcEventLogNew {
 
   LoggedIceCandidatePairEvent GetIceCandidatePairEvent(size_t index) const;
 
+  // Configured SSRCs.
   const std::set<uint32_t>& incoming_rtx_ssrcs() const {
     return incoming_rtx_ssrcs_;
   }
+
   const std::set<uint32_t>& incoming_video_ssrcs() const {
     return incoming_video_ssrcs_;
   }
+
   const std::set<uint32_t>& incoming_audio_ssrcs() const {
     return incoming_audio_ssrcs_;
   }
+
   const std::set<uint32_t>& outgoing_rtx_ssrcs() const {
     return outgoing_rtx_ssrcs_;
   }
+
   const std::set<uint32_t>& outgoing_video_ssrcs() const {
     return outgoing_video_ssrcs_;
   }
+
   const std::set<uint32_t>& outgoing_audio_ssrcs() const {
     return outgoing_audio_ssrcs_;
   }
 
+  // Beginning and end of log segments.
   const std::vector<LoggedStartEvent>& start_log_events() const {
     return start_log_events_;
   }
+
   const std::vector<LoggedStopEvent>& stop_log_events() const {
     return stop_log_events_;
   }
+
+  // Audio
   const std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>&
   audio_playout_events() const {
     return audio_playout_events_;
   }
+
   const std::vector<LoggedAudioNetworkAdaptationEvent>&
   audio_network_adaptation_events() const {
     return audio_network_adaptation_events_;
   }
+
+  // Bandwidth estimation
   const std::vector<LoggedBweProbeClusterCreatedEvent>&
   bwe_probe_cluster_created_events() const {
     return bwe_probe_cluster_created_events_;
   }
-  const std::vector<LoggedBweProbeResultEvent>& bwe_probe_result_events()
+
+  const std::vector<LoggedBweProbeFailureEvent>& bwe_probe_failure_events()
       const {
-    return bwe_probe_result_events_;
+    return bwe_probe_failure_events_;
   }
+
+  const std::vector<LoggedBweProbeSuccessEvent>& bwe_probe_success_events()
+      const {
+    return bwe_probe_success_events_;
+  }
+
   const std::vector<LoggedBweDelayBasedUpdate>& bwe_delay_updates() const {
     return bwe_delay_updates_;
   }
+
   const std::vector<LoggedBweLossBasedUpdate>& bwe_loss_updates() const {
     return bwe_loss_updates_;
   }
+
   const std::vector<LoggedAlrStateEvent>& alr_state_events() const {
     return alr_state_events_;
   }
+
+  // ICE events
   const std::vector<LoggedIceCandidatePairConfig>& ice_candidate_pair_configs()
       const {
     return ice_candidate_pair_configs_;
   }
+
   const std::vector<LoggedIceCandidatePairEvent>& ice_candidate_pair_events()
       const {
     return ice_candidate_pair_events_;
   }
 
-  struct LoggedRtpStreamIncoming {
+  // RTP
-    uint32_t ssrc;
-    std::vector<LoggedRtpPacketIncoming> incoming_packets;
-  };
-
-  struct LoggedRtpStreamOutgoing {
-    uint32_t ssrc;
-    std::vector<LoggedRtpPacketOutgoing> outgoing_packets;
-  };
-
-  struct LoggedRtpStreamView {
-    LoggedRtpStreamView(uint32_t ssrc,
-                        const LoggedRtpPacketIncoming* ptr,
-                        size_t num_elements)
-        : ssrc(ssrc),
-          packet_view(PacketView<const LoggedRtpPacket>::Create(
-              ptr,
-              num_elements,
-              offsetof(LoggedRtpPacketIncoming, rtp))) {}
-    LoggedRtpStreamView(uint32_t ssrc,
-                        const LoggedRtpPacketOutgoing* ptr,
-                        size_t num_elements)
-        : ssrc(ssrc),
-          packet_view(PacketView<const LoggedRtpPacket>::Create(
-              ptr,
-              num_elements,
-              offsetof(LoggedRtpPacketOutgoing, rtp))) {}
-    uint32_t ssrc;
-    PacketView<const LoggedRtpPacket> packet_view;
-  };
-
   const std::vector<LoggedRtpStreamIncoming>& incoming_rtp_packets_by_ssrc()
       const {
     return incoming_rtp_packets_by_ssrc_;
@@ -711,14 +747,6 @@ class ParsedRtcEventLogNew {
     return outgoing_rtp_packets_by_ssrc_;
   }
 
-  const std::vector<LoggedRtcpPacketIncoming>& incoming_rtcp_packets() const {
-    return incoming_rtcp_packets_;
-  }
-
-  const std::vector<LoggedRtcpPacketOutgoing>& outgoing_rtcp_packets() const {
-    return outgoing_rtcp_packets_;
-  }
-
   const std::vector<LoggedRtpStreamView>& rtp_packets_by_ssrc(
       PacketDirection direction) const {
     if (direction == kIncomingPacket)
@@ -727,6 +755,15 @@ class ParsedRtcEventLogNew {
       return outgoing_rtp_packet_views_by_ssrc_;
   }
 
+  // RTCP
+  const std::vector<LoggedRtcpPacketIncoming>& incoming_rtcp_packets() const {
+    return incoming_rtcp_packets_;
+  }
+
+  const std::vector<LoggedRtcpPacketOutgoing>& outgoing_rtcp_packets() const {
+    return outgoing_rtcp_packets_;
+  }
+
   const std::vector<LoggedRtcpPacketReceiverReport>& receiver_reports(
       PacketDirection direction) const {
     if (direction == kIncomingPacket) {
@@ -799,7 +836,10 @@ class ParsedRtcEventLogNew {
 
   LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated(
       const rtclog::Event& event) const;
-  LoggedBweProbeResultEvent GetBweProbeResult(const rtclog::Event& event) const;
+  LoggedBweProbeFailureEvent GetBweProbeFailure(
+      const rtclog::Event& event) const;
+  LoggedBweProbeSuccessEvent GetBweProbeSuccess(
+      const rtclog::Event& event) const;
 
   LoggedAlrStateEvent GetAlrState(const rtclog::Event& event) const;
 
@@ -887,7 +927,8 @@ class ParsedRtcEventLogNew {
   std::vector<LoggedBweProbeClusterCreatedEvent>
       bwe_probe_cluster_created_events_;
 
-  std::vector<LoggedBweProbeResultEvent> bwe_probe_result_events_;
+  std::vector<LoggedBweProbeFailureEvent> bwe_probe_failure_events_;
+  std::vector<LoggedBweProbeSuccessEvent> bwe_probe_success_events_;
 
   std::vector<LoggedBweDelayBasedUpdate> bwe_delay_updates_;
 

logging/rtc_event_log/rtc_event_log_unittest.cc

@@ -145,8 +145,10 @@ const std::map<ParsedRtcEventLogNew::EventType, std::string>
           "AUDIO_NETWORK_ADAPTATION"},
          {ParsedRtcEventLogNew::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT,
           "BWE_PROBE_CREATED"},
-         {ParsedRtcEventLogNew::EventType::BWE_PROBE_RESULT_EVENT,
+         {ParsedRtcEventLogNew::EventType::BWE_PROBE_SUCCESS_EVENT,
-          "BWE_PROBE_RESULT"}});
+          "BWE_PROBE_SUCCESS"},
+         {ParsedRtcEventLogNew::EventType::BWE_PROBE_FAILURE_EVENT,
+          "BWE_PROBE_FAILURE"}});
 }  // namespace
 
 void PrintActualEvents(const ParsedRtcEventLogNew& parsed_log,

modules/audio_coding/neteq/tools/rtc_event_log_source.cc

@@ -40,7 +40,7 @@ std::unique_ptr<Packet> RtcEventLogSource::NextPacket() {
   for (; rtp_packet_index_ < parsed_stream_.GetNumberOfEvents();
        rtp_packet_index_++) {
     if (parsed_stream_.GetEventType(rtp_packet_index_) ==
-        ParsedRtcEventLogNew::RTP_EVENT) {
+        ParsedRtcEventLogNew::EventType::RTP_EVENT) {
       PacketDirection direction;
       size_t header_length;
       size_t packet_length;
@@ -84,7 +84,7 @@ std::unique_ptr<Packet> RtcEventLogSource::NextPacket() {
 int64_t RtcEventLogSource::NextAudioOutputEventMs() {
   while (audio_output_index_ < parsed_stream_.GetNumberOfEvents()) {
     if (parsed_stream_.GetEventType(audio_output_index_) ==
-        ParsedRtcEventLogNew::AUDIO_PLAYOUT_EVENT) {
+        ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT) {
       LoggedAudioPlayoutEvent playout_event =
           parsed_stream_.GetAudioPlayout(audio_output_index_);
       if (!(use_ssrc_filter_ && playout_event.ssrc != ssrc_)) {

rtc_tools/event_log_visualizer/analyzer.cc

@@ -977,12 +977,10 @@ void EventLogAnalyzer::CreateTotalOutgoingBitrateGraph(Plot* plot,
 
   TimeSeries result_series("Probing results.", LineStyle::kNone,
                            PointStyle::kHighlight);
-  for (auto& result : parsed_log_.bwe_probe_result_events()) {
+  for (auto& result : parsed_log_.bwe_probe_success_events()) {
-    if (result.bitrate_bps) {
+    float x = ToCallTimeSec(result.log_time_us());
-      float x = ToCallTimeSec(result.log_time_us());
+    float y = static_cast<float>(result.bitrate_bps) / 1000;
-      float y = static_cast<float>(*result.bitrate_bps) / 1000;
+    result_series.points.emplace_back(x, y);
-      result_series.points.emplace_back(x, y);
-    }
   }
 
   IntervalSeries alr_state("ALR", "#555555", IntervalSeries::kHorizontal);