Renames RtcEventLogParseNew to RtcEventLogParser

Bug: webrtc:10170
Change-Id: I9232c276229a64fa4d8321b6c996387fe130f68b
Reviewed-on: https://webrtc-review.googlesource.com/c/116064
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Minyue Li <minyue@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26128}

logging/BUILD.gn

@@ -291,7 +291,8 @@ if (rtc_enable_protobuf) {
     visibility = [ "*" ]
     sources = [
       "rtc_event_log/logged_events.h",
-      "rtc_event_log/rtc_event_log_parser_new.cc",
+      "rtc_event_log/rtc_event_log_parser.cc",
+      "rtc_event_log/rtc_event_log_parser.h",
       "rtc_event_log/rtc_event_log_parser_new.h",
       "rtc_event_log/rtc_event_processor.h",
     ]
@@ -312,6 +313,7 @@ if (rtc_enable_protobuf) {
       "../modules/rtp_rtcp",
       "../modules/rtp_rtcp:rtp_rtcp_format",
       "../rtc_base:checks",
+      "../rtc_base:deprecation",
       "../rtc_base:protobuf_utils",
       "../rtc_base:rtc_base_approved",
       "//third_party/abseil-cpp/absl/memory",

logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc

@@ -32,7 +32,7 @@
 #include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
 #include "logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h"
 #include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
 #include "logging/rtc_event_log/rtc_event_log_unittest_helper.h"
 #include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
 #include "modules/remote_bitrate_estimator/include/bwe_defines.h"
@@ -74,7 +74,7 @@ class RtcEventLogEncoderTest
 
   template <typename ParsedType>
   const std::vector<ParsedType>* GetRtpPacketsBySsrc(
-      const ParsedRtcEventLogNew* parsed_log,
+      const ParsedRtcEventLog* parsed_log,
       uint32_t ssrc);
 
   template <typename EventType, typename ParsedType>
@@ -82,7 +82,7 @@ class RtcEventLogEncoderTest
 
   std::deque<std::unique_ptr<RtcEvent>> history_;
   std::unique_ptr<RtcEventLogEncoder> encoder_;
-  ParsedRtcEventLogNew parsed_log_;
+  ParsedRtcEventLog parsed_log_;
   const uint64_t seed_;
   Random prng_;
   const bool new_encoding_;
@@ -128,8 +128,7 @@ std::unique_ptr<RtcEventRtpPacketOutgoing> RtcEventLogEncoderTest::NewRtpPacket(
 
 template <>
 const std::vector<LoggedRtpPacketIncoming>*
-RtcEventLogEncoderTest::GetRtpPacketsBySsrc(
+RtcEventLogEncoderTest::GetRtpPacketsBySsrc(const ParsedRtcEventLog* parsed_log,
-    const ParsedRtcEventLogNew* parsed_log,
                                             uint32_t ssrc) {
   const auto& incoming_streams = parsed_log->incoming_rtp_packets_by_ssrc();
   for (const auto& stream : incoming_streams) {
@@ -142,8 +141,7 @@ RtcEventLogEncoderTest::GetRtpPacketsBySsrc(
 
 template <>
 const std::vector<LoggedRtpPacketOutgoing>*
-RtcEventLogEncoderTest::GetRtpPacketsBySsrc(
+RtcEventLogEncoderTest::GetRtpPacketsBySsrc(const ParsedRtcEventLog* parsed_log,
-    const ParsedRtcEventLogNew* parsed_log,
                                             uint32_t ssrc) {
   const auto& outgoing_streams = parsed_log->outgoing_rtp_packets_by_ssrc();
   for (const auto& stream : outgoing_streams) {

logging/rtc_event_log/rtc_event_log2rtp_dump.cc

@@ -21,7 +21,7 @@
 #include "api/array_view.h"
 #include "api/rtp_headers.h"
 #include "logging/rtc_event_log/rtc_event_log.h"
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
 #include "logging/rtc_event_log/rtc_event_processor.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
@@ -33,7 +33,7 @@
 
 namespace {
 
-using MediaType = webrtc::ParsedRtcEventLogNew::MediaType;
+using MediaType = webrtc::ParsedRtcEventLog::MediaType;
 
 WEBRTC_DEFINE_bool(
     audio,
@@ -185,7 +185,7 @@ int main(int argc, char* argv[]) {
     RTC_CHECK(ssrc_filter.has_value()) << "Failed to read SSRC filter flag.";
   }
 
-  webrtc::ParsedRtcEventLogNew parsed_stream;
+  webrtc::ParsedRtcEventLog parsed_stream;
   if (!parsed_stream.ParseFile(input_file)) {
     std::cerr << "Error while parsing input file: " << input_file << std::endl;
     return -1;
@@ -205,7 +205,7 @@ int main(int argc, char* argv[]) {
   bool header_only = false;
 
   webrtc::RtpHeaderExtensionMap default_extension_map =
-      webrtc::ParsedRtcEventLogNew::GetDefaultHeaderExtensionMap();
+      webrtc::ParsedRtcEventLog::GetDefaultHeaderExtensionMap();
   auto handle_rtp = [&default_extension_map, &rtp_writer, &rtp_counter](
                         const webrtc::LoggedRtpPacketIncoming& incoming) {
     webrtc::test::RtpPacket packet;

logging/rtc_event_log/rtc_event_log_parser.cc

@@ -8,7 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
 
 #include <stdint.h>
 #include <string.h>
@@ -788,23 +788,21 @@ LoggedRtcpPacket::LoggedRtcpPacket(uint64_t timestamp_us,
 LoggedRtcpPacket::LoggedRtcpPacket(const LoggedRtcpPacket& rhs) = default;
 LoggedRtcpPacket::~LoggedRtcpPacket() = default;
 
-ParsedRtcEventLogNew::~ParsedRtcEventLogNew() = default;
+ParsedRtcEventLog::~ParsedRtcEventLog() = default;
 
-ParsedRtcEventLogNew::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming() =
+ParsedRtcEventLog::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming() = default;
-    default;
+ParsedRtcEventLog::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming(
-ParsedRtcEventLogNew::LoggedRtpStreamIncoming::LoggedRtpStreamIncoming(
     const LoggedRtpStreamIncoming& rhs) = default;
-ParsedRtcEventLogNew::LoggedRtpStreamIncoming::~LoggedRtpStreamIncoming() =
+ParsedRtcEventLog::LoggedRtpStreamIncoming::~LoggedRtpStreamIncoming() =
     default;
 
-ParsedRtcEventLogNew::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing() =
+ParsedRtcEventLog::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing() = default;
-    default;
+ParsedRtcEventLog::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing(
-ParsedRtcEventLogNew::LoggedRtpStreamOutgoing::LoggedRtpStreamOutgoing(
     const LoggedRtpStreamOutgoing& rhs) = default;
-ParsedRtcEventLogNew::LoggedRtpStreamOutgoing::~LoggedRtpStreamOutgoing() =
+ParsedRtcEventLog::LoggedRtpStreamOutgoing::~LoggedRtpStreamOutgoing() =
     default;
 
-ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
+ParsedRtcEventLog::LoggedRtpStreamView::LoggedRtpStreamView(
     uint32_t ssrc,
     const LoggedRtpPacketIncoming* ptr,
     size_t num_elements)
@@ -814,7 +812,7 @@ ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
           num_elements,
           offsetof(LoggedRtpPacketIncoming, rtp))) {}
 
-ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
+ParsedRtcEventLog::LoggedRtpStreamView::LoggedRtpStreamView(
     uint32_t ssrc,
     const LoggedRtpPacketOutgoing* ptr,
     size_t num_elements)
@@ -824,7 +822,7 @@ ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
           num_elements,
           offsetof(LoggedRtpPacketOutgoing, rtp))) {}
 
-ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
+ParsedRtcEventLog::LoggedRtpStreamView::LoggedRtpStreamView(
     const LoggedRtpStreamView&) = default;
 
 // Return default values for header extensions, to use on streams without stored
@@ -833,7 +831,7 @@ ParsedRtcEventLogNew::LoggedRtpStreamView::LoggedRtpStreamView(
 // TODO(ivoc): Remove this once this mapping is stored in the event log for
 //             audio streams. Tracking bug: webrtc:6399
 webrtc::RtpHeaderExtensionMap
-ParsedRtcEventLogNew::GetDefaultHeaderExtensionMap() {
+ParsedRtcEventLog::GetDefaultHeaderExtensionMap() {
   webrtc::RtpHeaderExtensionMap default_map;
   default_map.Register<AudioLevel>(webrtc::RtpExtension::kAudioLevelDefaultId);
   default_map.Register<TransmissionOffset>(
@@ -853,14 +851,14 @@ ParsedRtcEventLogNew::GetDefaultHeaderExtensionMap() {
   return default_map;
 }
 
-ParsedRtcEventLogNew::ParsedRtcEventLogNew(
+ParsedRtcEventLog::ParsedRtcEventLog(
     UnconfiguredHeaderExtensions parse_unconfigured_header_extensions)
     : parse_unconfigured_header_extensions_(
           parse_unconfigured_header_extensions) {
   Clear();
 }
 
-void ParsedRtcEventLogNew::Clear() {
+void ParsedRtcEventLog::Clear() {
   default_extension_map_ = GetDefaultHeaderExtensionMap();
 
   incoming_rtx_ssrcs_.clear();
@@ -920,7 +918,7 @@ void ParsedRtcEventLogNew::Clear() {
   outgoing_rtp_extensions_maps_.clear();
 }
 
-bool ParsedRtcEventLogNew::ParseFile(const std::string& filename) {
+bool ParsedRtcEventLog::ParseFile(const std::string& filename) {
   std::ifstream file(  // no-presubmit-check TODO(webrtc:8982)
       filename, std::ios_base::in | std::ios_base::binary);
   if (!file.good() || !file.is_open()) {
@@ -931,13 +929,13 @@ bool ParsedRtcEventLogNew::ParseFile(const std::string& filename) {
   return ParseStream(file);
 }
 
-bool ParsedRtcEventLogNew::ParseString(const std::string& s) {
+bool ParsedRtcEventLog::ParseString(const std::string& s) {
   std::istringstream stream(  // no-presubmit-check TODO(webrtc:8982)
       s, std::ios_base::in | std::ios_base::binary);
   return ParseStream(stream);
 }
 
-bool ParsedRtcEventLogNew::ParseStream(
+bool ParsedRtcEventLog::ParseStream(
     std::istream& stream) {  // no-presubmit-check TODO(webrtc:8982)
   Clear();
   bool success = ParseStreamInternal(stream);
@@ -1045,7 +1043,7 @@ bool ParsedRtcEventLogNew::ParseStream(
   return success;
 }
 
-bool ParsedRtcEventLogNew::ParseStreamInternal(
+bool ParsedRtcEventLog::ParseStreamInternal(
     std::istream& stream) {  // no-presubmit-check TODO(webrtc:8982)
   constexpr uint64_t kMaxEventSize = 10000000;  // Sanity check.
   std::vector<char> buffer(0xFFFF);
@@ -1128,14 +1126,14 @@ bool ParsedRtcEventLogNew::ParseStreamInternal(
 }
 
 template <typename T>
-void ParsedRtcEventLogNew::StoreFirstAndLastTimestamp(const std::vector<T>& v) {
+void ParsedRtcEventLog::StoreFirstAndLastTimestamp(const std::vector<T>& v) {
   if (v.empty())
     return;
   first_timestamp_ = std::min(first_timestamp_, v.front().log_time_us());
   last_timestamp_ = std::max(last_timestamp_, v.back().log_time_us());
 }
 
-void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
+void ParsedRtcEventLog::StoreParsedLegacyEvent(const rtclog::Event& event) {
   RTC_CHECK(event.has_type());
   switch (event.type()) {
     case rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT: {
@@ -1308,14 +1306,13 @@ void ParsedRtcEventLogNew::StoreParsedLegacyEvent(const rtclog::Event& event) {
   }
 }
 
-
+int64_t ParsedRtcEventLog::GetTimestamp(const rtclog::Event& event) const {
-int64_t ParsedRtcEventLogNew::GetTimestamp(const rtclog::Event& event) const {
   RTC_CHECK(event.has_timestamp_us());
   return event.timestamp_us();
 }
 
 // The header must have space for at least IP_PACKET_SIZE bytes.
-const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader(
+const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLog::GetRtpHeader(
     const rtclog::Event& event,
     PacketDirection* incoming,
     uint8_t* header,
@@ -1376,7 +1373,7 @@ const webrtc::RtpHeaderExtensionMap* ParsedRtcEventLogNew::GetRtpHeader(
 }
 
 // The packet must have space for at least IP_PACKET_SIZE bytes.
-void ParsedRtcEventLogNew::GetRtcpPacket(const rtclog::Event& event,
+void ParsedRtcEventLog::GetRtcpPacket(const rtclog::Event& event,
                                       PacketDirection* incoming,
                                       uint8_t* packet,
                                       size_t* length) const {
@@ -1403,7 +1400,7 @@ void ParsedRtcEventLogNew::GetRtcpPacket(const rtclog::Event& event,
   }
 }
 
-rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig(
+rtclog::StreamConfig ParsedRtcEventLog::GetVideoReceiveConfig(
     const rtclog::Event& event) const {
   rtclog::StreamConfig config;
   RTC_CHECK(event.has_type());
@@ -1464,7 +1461,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoReceiveConfig(
   return config;
 }
 
-rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoSendConfig(
+rtclog::StreamConfig ParsedRtcEventLog::GetVideoSendConfig(
     const rtclog::Event& event) const {
   rtclog::StreamConfig config;
   RTC_CHECK(event.has_type());
@@ -1500,7 +1497,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetVideoSendConfig(
   return config;
 }
 
-rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig(
+rtclog::StreamConfig ParsedRtcEventLog::GetAudioReceiveConfig(
     const rtclog::Event& event) const {
   rtclog::StreamConfig config;
   RTC_CHECK(event.has_type());
@@ -1519,7 +1516,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioReceiveConfig(
   return config;
 }
 
-rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig(
+rtclog::StreamConfig ParsedRtcEventLog::GetAudioSendConfig(
     const rtclog::Event& event) const {
   rtclog::StreamConfig config;
   RTC_CHECK(event.has_type());
@@ -1535,7 +1532,7 @@ rtclog::StreamConfig ParsedRtcEventLogNew::GetAudioSendConfig(
   return config;
 }
 
-LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout(
+LoggedAudioPlayoutEvent ParsedRtcEventLog::GetAudioPlayout(
     const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_PLAYOUT_EVENT);
@@ -1548,7 +1545,7 @@ LoggedAudioPlayoutEvent ParsedRtcEventLogNew::GetAudioPlayout(
   return res;
 }
 
-LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate(
+LoggedBweLossBasedUpdate ParsedRtcEventLog::GetLossBasedBweUpdate(
     const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::LOSS_BASED_BWE_UPDATE);
@@ -1566,7 +1563,7 @@ LoggedBweLossBasedUpdate ParsedRtcEventLogNew::GetLossBasedBweUpdate(
   return bwe_update;
 }
 
-LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate(
+LoggedBweDelayBasedUpdate ParsedRtcEventLog::GetDelayBasedBweUpdate(
     const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::DELAY_BASED_BWE_UPDATE);
@@ -1583,8 +1580,7 @@ LoggedBweDelayBasedUpdate ParsedRtcEventLogNew::GetDelayBasedBweUpdate(
   return res;
 }
 
-LoggedAudioNetworkAdaptationEvent
+LoggedAudioNetworkAdaptationEvent ParsedRtcEventLog::GetAudioNetworkAdaptation(
-ParsedRtcEventLogNew::GetAudioNetworkAdaptation(
     const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);
@@ -1610,8 +1606,7 @@ ParsedRtcEventLogNew::GetAudioNetworkAdaptation(
   return res;
 }
 
-LoggedBweProbeClusterCreatedEvent
+LoggedBweProbeClusterCreatedEvent ParsedRtcEventLog::GetBweProbeClusterCreated(
-ParsedRtcEventLogNew::GetBweProbeClusterCreated(
     const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT);
@@ -1630,7 +1625,7 @@ ParsedRtcEventLogNew::GetBweProbeClusterCreated(
   return res;
 }
 
-LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
+LoggedBweProbeFailureEvent ParsedRtcEventLog::GetBweProbeFailure(
     const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT);
@@ -1660,7 +1655,7 @@ LoggedBweProbeFailureEvent ParsedRtcEventLogNew::GetBweProbeFailure(
   return res;
 }
 
-LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
+LoggedBweProbeSuccessEvent ParsedRtcEventLog::GetBweProbeSuccess(
     const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PROBE_RESULT_EVENT);
@@ -1679,7 +1674,7 @@ LoggedBweProbeSuccessEvent ParsedRtcEventLogNew::GetBweProbeSuccess(
   return res;
 }
 
-LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState(
+LoggedAlrStateEvent ParsedRtcEventLog::GetAlrState(
     const rtclog::Event& event) const {
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::ALR_STATE_EVENT);
@@ -1693,7 +1688,7 @@ LoggedAlrStateEvent ParsedRtcEventLogNew::GetAlrState(
   return res;
 }
 
-LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig(
+LoggedIceCandidatePairConfig ParsedRtcEventLog::GetIceCandidatePairConfig(
     const rtclog::Event& rtc_event) const {
   RTC_CHECK(rtc_event.has_type());
   RTC_CHECK_EQ(rtc_event.type(), rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG);
@@ -1729,7 +1724,7 @@ LoggedIceCandidatePairConfig ParsedRtcEventLogNew::GetIceCandidatePairConfig(
   return res;
 }
 
-LoggedIceCandidatePairEvent ParsedRtcEventLogNew::GetIceCandidatePairEvent(
+LoggedIceCandidatePairEvent ParsedRtcEventLog::GetIceCandidatePairEvent(
     const rtclog::Event& rtc_event) const {
   RTC_CHECK(rtc_event.has_type());
   RTC_CHECK_EQ(rtc_event.type(), rtclog::Event::ICE_CANDIDATE_PAIR_EVENT);
@@ -1748,7 +1743,7 @@ LoggedIceCandidatePairEvent ParsedRtcEventLogNew::GetIceCandidatePairEvent(
 
 // Returns the MediaType for registered SSRCs. Search from the end to use last
 // registered types first.
-ParsedRtcEventLogNew::MediaType ParsedRtcEventLogNew::GetMediaType(
+ParsedRtcEventLog::MediaType ParsedRtcEventLog::GetMediaType(
     uint32_t ssrc,
     PacketDirection direction) const {
   if (direction == kIncomingPacket) {
@@ -1774,7 +1769,7 @@ ParsedRtcEventLogNew::MediaType ParsedRtcEventLogNew::GetMediaType(
 }
 
 const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
-    const ParsedRtcEventLogNew& parsed_log) {
+    const ParsedRtcEventLog& parsed_log) {
   using RtpPacketType = LoggedRtpPacketOutgoing;
   using TransportFeedbackType = LoggedRtcpPacketTransportFeedback;
 
@@ -1856,7 +1851,7 @@ const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
 }
 
 // Helper functions for new format start here
-void ParsedRtcEventLogNew::StoreParsedNewFormatEvent(
+void ParsedRtcEventLog::StoreParsedNewFormatEvent(
     const rtclog2::EventStream& stream) {
   RTC_DCHECK_EQ(stream.stream_size(), 0);
 
@@ -1929,7 +1924,7 @@ void ParsedRtcEventLogNew::StoreParsedNewFormatEvent(
   }
 }
 
-void ParsedRtcEventLogNew::StoreAlrStateEvent(const rtclog2::AlrState& proto) {
+void ParsedRtcEventLog::StoreAlrStateEvent(const rtclog2::AlrState& proto) {
   RTC_CHECK(proto.has_timestamp_ms());
   RTC_CHECK(proto.has_in_alr());
   LoggedAlrStateEvent alr_event;
@@ -1940,7 +1935,7 @@ void ParsedRtcEventLogNew::StoreAlrStateEvent(const rtclog2::AlrState& proto) {
   // TODO(terelius): Should we delta encode this event type?
 }
 
-void ParsedRtcEventLogNew::StoreAudioPlayoutEvent(
+void ParsedRtcEventLog::StoreAudioPlayoutEvent(
     const rtclog2::AudioPlayoutEvents& proto) {
   RTC_CHECK(proto.has_timestamp_ms());
   RTC_CHECK(proto.has_local_ssrc());
@@ -1984,28 +1979,27 @@ void ParsedRtcEventLogNew::StoreAudioPlayoutEvent(
   }
 }
 
-void ParsedRtcEventLogNew::StoreIncomingRtpPackets(
+void ParsedRtcEventLog::StoreIncomingRtpPackets(
     const rtclog2::IncomingRtpPackets& proto) {
   StoreRtpPackets(proto, &incoming_rtp_packets_map_);
 }
 
-void ParsedRtcEventLogNew::StoreOutgoingRtpPackets(
+void ParsedRtcEventLog::StoreOutgoingRtpPackets(
     const rtclog2::OutgoingRtpPackets& proto) {
   StoreRtpPackets(proto, &outgoing_rtp_packets_map_);
 }
 
-void ParsedRtcEventLogNew::StoreIncomingRtcpPackets(
+void ParsedRtcEventLog::StoreIncomingRtcpPackets(
     const rtclog2::IncomingRtcpPackets& proto) {
   StoreRtcpPackets(proto, &incoming_rtcp_packets_);
 }
 
-void ParsedRtcEventLogNew::StoreOutgoingRtcpPackets(
+void ParsedRtcEventLog::StoreOutgoingRtcpPackets(
     const rtclog2::OutgoingRtcpPackets& proto) {
   StoreRtcpPackets(proto, &outgoing_rtcp_packets_);
 }
 
-void ParsedRtcEventLogNew::StoreStartEvent(
+void ParsedRtcEventLog::StoreStartEvent(const rtclog2::BeginLogEvent& proto) {
-    const rtclog2::BeginLogEvent& proto) {
   RTC_CHECK(proto.has_timestamp_ms());
   RTC_CHECK(proto.has_version());
   RTC_CHECK(proto.has_utc_time_ms());
@@ -2016,14 +2010,14 @@ void ParsedRtcEventLogNew::StoreStartEvent(
   start_log_events_.push_back(start_event);
 }
 
-void ParsedRtcEventLogNew::StoreStopEvent(const rtclog2::EndLogEvent& proto) {
+void ParsedRtcEventLog::StoreStopEvent(const rtclog2::EndLogEvent& proto) {
   RTC_CHECK(proto.has_timestamp_ms());
   LoggedStopEvent stop_event(proto.timestamp_ms() * 1000);
 
   stop_log_events_.push_back(stop_event);
 }
 
-void ParsedRtcEventLogNew::StoreBweLossBasedUpdate(
+void ParsedRtcEventLog::StoreBweLossBasedUpdate(
     const rtclog2::LossBasedBweUpdates& proto) {
   RTC_CHECK(proto.has_timestamp_ms());
   RTC_CHECK(proto.has_bitrate_bps());
@@ -2091,7 +2085,7 @@ void ParsedRtcEventLogNew::StoreBweLossBasedUpdate(
   }
 }
 
-void ParsedRtcEventLogNew::StoreBweDelayBasedUpdate(
+void ParsedRtcEventLog::StoreBweDelayBasedUpdate(
     const rtclog2::DelayBasedBweUpdates& proto) {
   RTC_CHECK(proto.has_timestamp_ms());
   RTC_CHECK(proto.has_bitrate_bps());
@@ -2148,7 +2142,7 @@ void ParsedRtcEventLogNew::StoreBweDelayBasedUpdate(
   }
 }
 
-void ParsedRtcEventLogNew::StoreBweProbeClusterCreated(
+void ParsedRtcEventLog::StoreBweProbeClusterCreated(
     const rtclog2::BweProbeCluster& proto) {
   LoggedBweProbeClusterCreatedEvent probe_cluster;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2167,7 +2161,7 @@ void ParsedRtcEventLogNew::StoreBweProbeClusterCreated(
   // TODO(terelius): Should we delta encode this event type?
 }
 
-void ParsedRtcEventLogNew::StoreBweProbeSuccessEvent(
+void ParsedRtcEventLog::StoreBweProbeSuccessEvent(
     const rtclog2::BweProbeResultSuccess& proto) {
   LoggedBweProbeSuccessEvent probe_result;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2182,7 +2176,7 @@ void ParsedRtcEventLogNew::StoreBweProbeSuccessEvent(
   // TODO(terelius): Should we delta encode this event type?
 }
 
-void ParsedRtcEventLogNew::StoreBweProbeFailureEvent(
+void ParsedRtcEventLog::StoreBweProbeFailureEvent(
     const rtclog2::BweProbeResultFailure& proto) {
   LoggedBweProbeFailureEvent probe_result;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2197,7 +2191,7 @@ void ParsedRtcEventLogNew::StoreBweProbeFailureEvent(
   // TODO(terelius): Should we delta encode this event type?
 }
 
-void ParsedRtcEventLogNew::StoreAudioNetworkAdaptationEvent(
+void ParsedRtcEventLog::StoreAudioNetworkAdaptationEvent(
     const rtclog2::AudioNetworkAdaptations& proto) {
   RTC_CHECK(proto.has_timestamp_ms());
 
@@ -2350,7 +2344,7 @@ void ParsedRtcEventLogNew::StoreAudioNetworkAdaptationEvent(
   }
 }
 
-void ParsedRtcEventLogNew::StoreDtlsTransportState(
+void ParsedRtcEventLog::StoreDtlsTransportState(
     const rtclog2::DtlsTransportStateEvent& proto) {
   LoggedDtlsTransportState dtls_state;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2363,7 +2357,7 @@ void ParsedRtcEventLogNew::StoreDtlsTransportState(
   dtls_transport_states_.push_back(dtls_state);
 }
 
-void ParsedRtcEventLogNew::StoreDtlsWritableState(
+void ParsedRtcEventLog::StoreDtlsWritableState(
     const rtclog2::DtlsWritableState& proto) {
   LoggedDtlsWritableState dtls_writable_state;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2374,7 +2368,7 @@ void ParsedRtcEventLogNew::StoreDtlsWritableState(
   dtls_writable_states_.push_back(dtls_writable_state);
 }
 
-void ParsedRtcEventLogNew::StoreIceCandidatePairConfig(
+void ParsedRtcEventLog::StoreIceCandidatePairConfig(
     const rtclog2::IceCandidatePairConfig& proto) {
   LoggedIceCandidatePairConfig ice_config;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2411,7 +2405,7 @@ void ParsedRtcEventLogNew::StoreIceCandidatePairConfig(
   // TODO(terelius): Should we delta encode this event type?
 }
 
-void ParsedRtcEventLogNew::StoreIceCandidateEvent(
+void ParsedRtcEventLog::StoreIceCandidateEvent(
     const rtclog2::IceCandidatePairEvent& proto) {
   LoggedIceCandidatePairEvent ice_event;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2430,7 +2424,7 @@ void ParsedRtcEventLogNew::StoreIceCandidateEvent(
   // TODO(terelius): Should we delta encode this event type?
 }
 
-void ParsedRtcEventLogNew::StoreVideoRecvConfig(
+void ParsedRtcEventLog::StoreVideoRecvConfig(
     const rtclog2::VideoRecvStreamConfig& proto) {
   LoggedVideoRecvConfig stream;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2449,7 +2443,7 @@ void ParsedRtcEventLogNew::StoreVideoRecvConfig(
   video_recv_configs_.push_back(stream);
 }
 
-void ParsedRtcEventLogNew::StoreVideoSendConfig(
+void ParsedRtcEventLog::StoreVideoSendConfig(
     const rtclog2::VideoSendStreamConfig& proto) {
   LoggedVideoSendConfig stream;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2466,7 +2460,7 @@ void ParsedRtcEventLogNew::StoreVideoSendConfig(
   video_send_configs_.push_back(stream);
 }
 
-void ParsedRtcEventLogNew::StoreAudioRecvConfig(
+void ParsedRtcEventLog::StoreAudioRecvConfig(
     const rtclog2::AudioRecvStreamConfig& proto) {
   LoggedAudioRecvConfig stream;
   RTC_CHECK(proto.has_timestamp_ms());
@@ -2482,7 +2476,7 @@ void ParsedRtcEventLogNew::StoreAudioRecvConfig(
   audio_recv_configs_.push_back(stream);
 }
 
-void ParsedRtcEventLogNew::StoreAudioSendConfig(
+void ParsedRtcEventLog::StoreAudioSendConfig(
     const rtclog2::AudioSendStreamConfig& proto) {
   LoggedAudioSendConfig stream;
   RTC_CHECK(proto.has_timestamp_ms());

logging/rtc_event_log/rtc_event_log_parser.h

@@ -0,0 +1,686 @@
+/*
+ *  Copyright 2019 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.
+ */
+#ifndef LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_
+#define LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_
+
+#include <iterator>
+#include <map>
+#include <set>
+#include <sstream>  // no-presubmit-check TODO(webrtc:8982)
+#include <string>
+#include <utility>  // pair
+#include <vector>
+
+#include "call/video_receive_stream.h"
+#include "call/video_send_stream.h"
+#include "logging/rtc_event_log/logged_events.h"
+#include "logging/rtc_event_log/rtc_event_log.h"
+#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
+#include "rtc_base/ignore_wundef.h"
+
+// Files generated at build-time by the protobuf compiler.
+RTC_PUSH_IGNORING_WUNDEF()
+#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
+#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
+#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log2.pb.h"
+#else
+#include "logging/rtc_event_log/rtc_event_log.pb.h"
+#include "logging/rtc_event_log/rtc_event_log2.pb.h"
+#endif
+RTC_POP_IGNORING_WUNDEF()
+
+namespace webrtc {
+
+template <typename T>
+class PacketView;
+
+template <typename T>
+class PacketIterator {
+  friend class PacketView<T>;
+
+ public:
+  // Standard iterator traits.
+  using difference_type = std::ptrdiff_t;
+  using value_type = T;
+  using pointer = T*;
+  using reference = T&;
+  using iterator_category = std::bidirectional_iterator_tag;
+
+  // The default-contructed iterator is meaningless, but is required by the
+  // ForwardIterator concept.
+  PacketIterator() : ptr_(nullptr), element_size_(0) {}
+  PacketIterator(const PacketIterator& other)
+      : ptr_(other.ptr_), element_size_(other.element_size_) {}
+  PacketIterator(const PacketIterator&& other)
+      : ptr_(other.ptr_), element_size_(other.element_size_) {}
+  ~PacketIterator() = default;
+
+  PacketIterator& operator=(const PacketIterator& other) {
+    ptr_ = other.ptr_;
+    element_size_ = other.element_size_;
+    return *this;
+  }
+  PacketIterator& operator=(const PacketIterator&& other) {
+    ptr_ = other.ptr_;
+    element_size_ = other.element_size_;
+    return *this;
+  }
+
+  bool operator==(const PacketIterator<T>& other) const {
+    RTC_DCHECK_EQ(element_size_, other.element_size_);
+    return ptr_ == other.ptr_;
+  }
+  bool operator!=(const PacketIterator<T>& other) const {
+    RTC_DCHECK_EQ(element_size_, other.element_size_);
+    return ptr_ != other.ptr_;
+  }
+
+  PacketIterator& operator++() {
+    ptr_ += element_size_;
+    return *this;
+  }
+  PacketIterator& operator--() {
+    ptr_ -= element_size_;
+    return *this;
+  }
+  PacketIterator operator++(int) {
+    PacketIterator iter_copy(ptr_, element_size_);
+    ptr_ += element_size_;
+    return iter_copy;
+  }
+  PacketIterator operator--(int) {
+    PacketIterator iter_copy(ptr_, element_size_);
+    ptr_ -= element_size_;
+    return iter_copy;
+  }
+
+  T& operator*() { return *reinterpret_cast<T*>(ptr_); }
+  const T& operator*() const { return *reinterpret_cast<const T*>(ptr_); }
+
+ private:
+  PacketIterator(typename std::conditional<std::is_const<T>::value,
+                                           const void*,
+                                           void*>::type p,
+                 size_t s)
+      : ptr_(reinterpret_cast<decltype(ptr_)>(p)), element_size_(s) {}
+
+  typename std::conditional<std::is_const<T>::value, const char*, char*>::type
+      ptr_;
+  size_t element_size_;
+};
+
+// Suppose that we have a struct S where we are only interested in a specific
+// member M. Given an array of S, PacketView can be used to treat the array
+// as an array of M, without exposing the type S to surrounding code and without
+// accessing the member through a virtual function. In this case, we want to
+// have a common view for incoming and outgoing RtpPackets, hence the PacketView
+// name.
+// Note that constructing a PacketView bypasses the typesystem, so the caller
+// has to take extra care when constructing these objects. The implementation
+// also requires that the containing struct is standard-layout (e.g. POD).
+//
+// Usage example:
+// struct A {...};
+// struct B { A a; ...};
+// struct C { A a; ...};
+// size_t len = 10;
+// B* array1 = new B[len];
+// C* array2 = new C[len];
+//
+// PacketView<A> view1 = PacketView<A>::Create<B>(array1, len, offsetof(B, a));
+// PacketView<A> view2 = PacketView<A>::Create<C>(array2, len, offsetof(C, a));
+//
+// The following code works with either view1 or view2.
+// void f(PacketView<A> view)
+// for (A& a : view) {
+//   DoSomething(a);
+// }
+template <typename T>
+class PacketView {
+ public:
+  template <typename U>
+  static PacketView Create(U* ptr, size_t num_elements, size_t offset) {
+    static_assert(std::is_standard_layout<U>::value,
+                  "PacketView can only be created for standard layout types.");
+    static_assert(std::is_standard_layout<T>::value,
+                  "PacketView can only be created for standard layout types.");
+    return PacketView(ptr, num_elements, offset, sizeof(U));
+  }
+
+  using iterator = PacketIterator<T>;
+  using const_iterator = PacketIterator<const T>;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  iterator begin() { return iterator(data_, element_size_); }
+  iterator end() {
+    auto end_ptr = data_ + num_elements_ * element_size_;
+    return iterator(end_ptr, element_size_);
+  }
+
+  const_iterator begin() const { return const_iterator(data_, element_size_); }
+  const_iterator end() const {
+    auto end_ptr = data_ + num_elements_ * element_size_;
+    return const_iterator(end_ptr, element_size_);
+  }
+
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  size_t size() const { return num_elements_; }
+
+  T& operator[](size_t i) {
+    auto elem_ptr = data_ + i * element_size_;
+    return *reinterpret_cast<T*>(elem_ptr);
+  }
+
+  const T& operator[](size_t i) const {
+    auto elem_ptr = data_ + i * element_size_;
+    return *reinterpret_cast<const T*>(elem_ptr);
+  }
+
+ private:
+  PacketView(typename std::conditional<std::is_const<T>::value,
+                                       const void*,
+                                       void*>::type data,
+             size_t num_elements,
+             size_t offset,
+             size_t element_size)
+      : data_(reinterpret_cast<decltype(data_)>(data) + offset),
+        num_elements_(num_elements),
+        element_size_(element_size) {}
+
+  typename std::conditional<std::is_const<T>::value, const char*, char*>::type
+      data_;
+  size_t num_elements_;
+  size_t element_size_;
+};
+
+class ParsedRtcEventLog {
+  friend class RtcEventLogTestHelper;
+
+ public:
+  enum class MediaType { ANY, AUDIO, VIDEO, DATA };
+  enum class UnconfiguredHeaderExtensions {
+    kDontParse,
+    kAttemptWebrtcDefaultConfig
+  };
+
+  struct LoggedRtpStreamIncoming {
+    LoggedRtpStreamIncoming();
+    LoggedRtpStreamIncoming(const LoggedRtpStreamIncoming&);
+    ~LoggedRtpStreamIncoming();
+    uint32_t ssrc;
+    std::vector<LoggedRtpPacketIncoming> incoming_packets;
+  };
+
+  struct LoggedRtpStreamOutgoing {
+    LoggedRtpStreamOutgoing();
+    LoggedRtpStreamOutgoing(const LoggedRtpStreamOutgoing&);
+    ~LoggedRtpStreamOutgoing();
+    uint32_t ssrc;
+    std::vector<LoggedRtpPacketOutgoing> outgoing_packets;
+  };
+
+  struct LoggedRtpStreamView {
+    LoggedRtpStreamView(uint32_t ssrc,
+                        const LoggedRtpPacketIncoming* ptr,
+                        size_t num_elements);
+    LoggedRtpStreamView(uint32_t ssrc,
+                        const LoggedRtpPacketOutgoing* ptr,
+                        size_t num_elements);
+    LoggedRtpStreamView(const LoggedRtpStreamView&);
+    uint32_t ssrc;
+    PacketView<const LoggedRtpPacket> packet_view;
+  };
+
+  static webrtc::RtpHeaderExtensionMap GetDefaultHeaderExtensionMap();
+
+  explicit ParsedRtcEventLog(
+      UnconfiguredHeaderExtensions parse_unconfigured_header_extensions =
+          UnconfiguredHeaderExtensions::kDontParse);
+
+  ~ParsedRtcEventLog();
+
+  // Clears previously parsed events and resets the ParsedRtcEventLogNew to an
+  // empty state.
+  void Clear();
+
+  // Reads an RtcEventLog file and returns true if parsing was successful.
+  bool ParseFile(const std::string& file_name);
+
+  // Reads an RtcEventLog from a string and returns true if successful.
+  bool ParseString(const std::string& s);
+
+  // Reads an RtcEventLog from an istream and returns true if successful.
+  bool ParseStream(
+      std::istream& stream);  // no-presubmit-check TODO(webrtc:8982)
+
+  MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) 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_;
+  }
+
+  // Stream configurations.
+  const std::vector<LoggedAudioRecvConfig>& audio_recv_configs() const {
+    return audio_recv_configs_;
+  }
+
+  const std::vector<LoggedAudioSendConfig>& audio_send_configs() const {
+    return audio_send_configs_;
+  }
+
+  const std::vector<LoggedVideoRecvConfig>& video_recv_configs() const {
+    return video_recv_configs_;
+  }
+
+  const std::vector<LoggedVideoSendConfig>& video_send_configs() const {
+    return video_send_configs_;
+  }
+
+  // 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_;
+  }
+
+  const std::vector<LoggedAlrStateEvent>& alr_state_events() const {
+    return alr_state_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<LoggedBweProbeFailureEvent>& bwe_probe_failure_events()
+      const {
+    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_;
+  }
+
+  // DTLS
+  const std::vector<LoggedDtlsTransportState>& dtls_transport_states() const {
+    return dtls_transport_states_;
+  }
+
+  const std::vector<LoggedDtlsWritableState>& dtls_writable_states() const {
+    return dtls_writable_states_;
+  }
+
+  // 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_;
+  }
+
+  // RTP
+  const std::vector<LoggedRtpStreamIncoming>& incoming_rtp_packets_by_ssrc()
+      const {
+    return incoming_rtp_packets_by_ssrc_;
+  }
+
+  const std::vector<LoggedRtpStreamOutgoing>& outgoing_rtp_packets_by_ssrc()
+      const {
+    return outgoing_rtp_packets_by_ssrc_;
+  }
+
+  const std::vector<LoggedRtpStreamView>& rtp_packets_by_ssrc(
+      PacketDirection direction) const {
+    if (direction == kIncomingPacket)
+      return incoming_rtp_packet_views_by_ssrc_;
+    else
+      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) {
+      return incoming_rr_;
+    } else {
+      return outgoing_rr_;
+    }
+  }
+
+  const std::vector<LoggedRtcpPacketSenderReport>& sender_reports(
+      PacketDirection direction) const {
+    if (direction == kIncomingPacket) {
+      return incoming_sr_;
+    } else {
+      return outgoing_sr_;
+    }
+  }
+
+  const std::vector<LoggedRtcpPacketNack>& nacks(
+      PacketDirection direction) const {
+    if (direction == kIncomingPacket) {
+      return incoming_nack_;
+    } else {
+      return outgoing_nack_;
+    }
+  }
+
+  const std::vector<LoggedRtcpPacketRemb>& rembs(
+      PacketDirection direction) const {
+    if (direction == kIncomingPacket) {
+      return incoming_remb_;
+    } else {
+      return outgoing_remb_;
+    }
+  }
+
+  const std::vector<LoggedRtcpPacketTransportFeedback>& transport_feedbacks(
+      PacketDirection direction) const {
+    if (direction == kIncomingPacket) {
+      return incoming_transport_feedback_;
+    } else {
+      return outgoing_transport_feedback_;
+    }
+  }
+
+  int64_t first_timestamp() const { return first_timestamp_; }
+  int64_t last_timestamp() const { return last_timestamp_; }
+
+ private:
+  bool ParseStreamInternal(
+      std::istream& stream);  // no-presubmit-check TODO(webrtc:8982)
+
+  void StoreParsedLegacyEvent(const rtclog::Event& event);
+
+  template <typename T>
+  void StoreFirstAndLastTimestamp(const std::vector<T>& v);
+
+  // Reads the arrival timestamp (in microseconds) from a rtclog::Event.
+  int64_t GetTimestamp(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
+  // parameters. Each output parameter can be set to nullptr if that value
+  // isn't needed.
+  // NB: The header must have space for at least IP_PACKET_SIZE bytes.
+  // Returns: a pointer to a header extensions map acquired from parsing
+  // corresponding Audio/Video Sender/Receiver config events.
+  // Warning: if the same SSRC is reused by both video and audio streams during
+  // call, extensions maps may be incorrect (the last one would be returned).
+  const webrtc::RtpHeaderExtensionMap* GetRtpHeader(
+      const rtclog::Event& event,
+      PacketDirection* incoming,
+      uint8_t* header,
+      size_t* header_length,
+      size_t* total_length,
+      int* probe_cluster_id) const;
+
+  // Reads packet, direction and packet length from the RTCP event at |index|,
+  // and stores the values in the corresponding output parameters.
+  // Each output parameter can be set to nullptr if that value isn't needed.
+  // NB: The packet must have space for at least IP_PACKET_SIZE bytes.
+  void GetRtcpPacket(const rtclog::Event& event,
+                     PacketDirection* incoming,
+                     uint8_t* packet,
+                     size_t* length) const;
+
+  rtclog::StreamConfig GetVideoReceiveConfig(const rtclog::Event& event) const;
+  rtclog::StreamConfig GetVideoSendConfig(const rtclog::Event& event) const;
+  rtclog::StreamConfig GetAudioReceiveConfig(const rtclog::Event& event) const;
+  rtclog::StreamConfig GetAudioSendConfig(const rtclog::Event& event) const;
+
+  LoggedAudioPlayoutEvent GetAudioPlayout(const rtclog::Event& event) const;
+
+  LoggedBweLossBasedUpdate GetLossBasedBweUpdate(
+      const rtclog::Event& event) const;
+  LoggedBweDelayBasedUpdate GetDelayBasedBweUpdate(
+      const rtclog::Event& event) const;
+
+  LoggedAudioNetworkAdaptationEvent GetAudioNetworkAdaptation(
+      const rtclog::Event& event) const;
+
+  LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated(
+      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;
+
+  LoggedIceCandidatePairConfig GetIceCandidatePairConfig(
+      const rtclog::Event& event) const;
+  LoggedIceCandidatePairEvent GetIceCandidatePairEvent(
+      const rtclog::Event& event) const;
+
+  // Parsing functions for new format.
+  void StoreParsedNewFormatEvent(const rtclog2::EventStream& event);
+  void StoreIncomingRtpPackets(const rtclog2::IncomingRtpPackets& proto);
+  void StoreOutgoingRtpPackets(const rtclog2::OutgoingRtpPackets& proto);
+  void StoreIncomingRtcpPackets(const rtclog2::IncomingRtcpPackets& proto);
+  void StoreOutgoingRtcpPackets(const rtclog2::OutgoingRtcpPackets& proto);
+  void StoreStartEvent(const rtclog2::BeginLogEvent& proto);
+  void StoreStopEvent(const rtclog2::EndLogEvent& proto);
+  void StoreAlrStateEvent(const rtclog2::AlrState& proto);
+  void StoreAudioNetworkAdaptationEvent(
+      const rtclog2::AudioNetworkAdaptations& proto);
+  void StoreAudioPlayoutEvent(const rtclog2::AudioPlayoutEvents& proto);
+  void StoreBweLossBasedUpdate(const rtclog2::LossBasedBweUpdates& proto);
+  void StoreBweDelayBasedUpdate(const rtclog2::DelayBasedBweUpdates& proto);
+  void StoreBweProbeClusterCreated(const rtclog2::BweProbeCluster& proto);
+  void StoreBweProbeSuccessEvent(const rtclog2::BweProbeResultSuccess& proto);
+  void StoreBweProbeFailureEvent(const rtclog2::BweProbeResultFailure& proto);
+  void StoreDtlsTransportState(const rtclog2::DtlsTransportStateEvent& proto);
+  void StoreDtlsWritableState(const rtclog2::DtlsWritableState& proto);
+  void StoreIceCandidatePairConfig(
+      const rtclog2::IceCandidatePairConfig& proto);
+  void StoreIceCandidateEvent(const rtclog2::IceCandidatePairEvent& proto);
+  void StoreAudioRecvConfig(const rtclog2::AudioRecvStreamConfig& proto);
+  void StoreAudioSendConfig(const rtclog2::AudioSendStreamConfig& proto);
+  void StoreVideoRecvConfig(const rtclog2::VideoRecvStreamConfig& proto);
+  void StoreVideoSendConfig(const rtclog2::VideoSendStreamConfig& proto);
+  // End of new parsing functions.
+
+  struct Stream {
+    Stream(uint32_t ssrc,
+           MediaType media_type,
+           PacketDirection direction,
+           webrtc::RtpHeaderExtensionMap map)
+        : ssrc(ssrc),
+          media_type(media_type),
+          direction(direction),
+          rtp_extensions_map(map) {}
+    uint32_t ssrc;
+    MediaType media_type;
+    PacketDirection direction;
+    webrtc::RtpHeaderExtensionMap rtp_extensions_map;
+  };
+
+  const UnconfiguredHeaderExtensions parse_unconfigured_header_extensions_;
+
+  // Make a default extension map for streams without configuration information.
+  // TODO(ivoc): Once configuration of audio streams is stored in the event log,
+  //             this can be removed. Tracking bug: webrtc:6399
+  RtpHeaderExtensionMap default_extension_map_;
+
+  // Tracks what each stream is configured for. Note that a single SSRC can be
+  // in several sets. For example, the SSRC used for sending video over RTX
+  // will appear in both video_ssrcs_ and rtx_ssrcs_. In the unlikely case that
+  // an SSRC is reconfigured to a different media type mid-call, it will also
+  // appear in multiple sets.
+  std::set<uint32_t> incoming_rtx_ssrcs_;
+  std::set<uint32_t> incoming_video_ssrcs_;
+  std::set<uint32_t> incoming_audio_ssrcs_;
+  std::set<uint32_t> outgoing_rtx_ssrcs_;
+  std::set<uint32_t> outgoing_video_ssrcs_;
+  std::set<uint32_t> outgoing_audio_ssrcs_;
+
+  // Maps an SSRC to the parsed  RTP headers in that stream. Header extensions
+  // are parsed if the stream has been configured. This is only used for
+  // grouping the events by SSRC during parsing; the events are moved to
+  // incoming_rtp_packets_by_ssrc_ once the parsing is done.
+  std::map<uint32_t, std::vector<LoggedRtpPacketIncoming>>
+      incoming_rtp_packets_map_;
+  std::map<uint32_t, std::vector<LoggedRtpPacketOutgoing>>
+      outgoing_rtp_packets_map_;
+
+  // RTP headers.
+  std::vector<LoggedRtpStreamIncoming> incoming_rtp_packets_by_ssrc_;
+  std::vector<LoggedRtpStreamOutgoing> outgoing_rtp_packets_by_ssrc_;
+  std::vector<LoggedRtpStreamView> incoming_rtp_packet_views_by_ssrc_;
+  std::vector<LoggedRtpStreamView> outgoing_rtp_packet_views_by_ssrc_;
+
+  // Raw RTCP packets.
+  std::vector<LoggedRtcpPacketIncoming> incoming_rtcp_packets_;
+  std::vector<LoggedRtcpPacketOutgoing> outgoing_rtcp_packets_;
+
+  // Parsed RTCP messages. Currently not separated based on SSRC.
+  std::vector<LoggedRtcpPacketReceiverReport> incoming_rr_;
+  std::vector<LoggedRtcpPacketReceiverReport> outgoing_rr_;
+  std::vector<LoggedRtcpPacketSenderReport> incoming_sr_;
+  std::vector<LoggedRtcpPacketSenderReport> outgoing_sr_;
+  std::vector<LoggedRtcpPacketNack> incoming_nack_;
+  std::vector<LoggedRtcpPacketNack> outgoing_nack_;
+  std::vector<LoggedRtcpPacketRemb> incoming_remb_;
+  std::vector<LoggedRtcpPacketRemb> outgoing_remb_;
+  std::vector<LoggedRtcpPacketTransportFeedback> incoming_transport_feedback_;
+  std::vector<LoggedRtcpPacketTransportFeedback> outgoing_transport_feedback_;
+
+  std::vector<LoggedStartEvent> start_log_events_;
+  std::vector<LoggedStopEvent> stop_log_events_;
+
+  std::vector<LoggedAlrStateEvent> alr_state_events_;
+
+  std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>
+      audio_playout_events_;
+
+  std::vector<LoggedAudioNetworkAdaptationEvent>
+      audio_network_adaptation_events_;
+
+  std::vector<LoggedBweProbeClusterCreatedEvent>
+      bwe_probe_cluster_created_events_;
+
+  std::vector<LoggedBweProbeFailureEvent> bwe_probe_failure_events_;
+  std::vector<LoggedBweProbeSuccessEvent> bwe_probe_success_events_;
+
+  std::vector<LoggedBweDelayBasedUpdate> bwe_delay_updates_;
+  std::vector<LoggedBweLossBasedUpdate> bwe_loss_updates_;
+
+  std::vector<LoggedDtlsTransportState> dtls_transport_states_;
+  std::vector<LoggedDtlsWritableState> dtls_writable_states_;
+
+  std::vector<LoggedIceCandidatePairConfig> ice_candidate_pair_configs_;
+  std::vector<LoggedIceCandidatePairEvent> ice_candidate_pair_events_;
+
+  std::vector<LoggedAudioRecvConfig> audio_recv_configs_;
+  std::vector<LoggedAudioSendConfig> audio_send_configs_;
+  std::vector<LoggedVideoRecvConfig> video_recv_configs_;
+  std::vector<LoggedVideoSendConfig> video_send_configs_;
+
+  uint8_t last_incoming_rtcp_packet_[IP_PACKET_SIZE];
+  uint8_t last_incoming_rtcp_packet_length_;
+
+  int64_t first_timestamp_;
+  int64_t last_timestamp_;
+
+  // The extension maps are mutable to allow us to insert the default
+  // configuration when parsing an RTP header for an unconfigured stream.
+  // TODO(terelius): This is only used for the legacy format. Remove once we've
+  // fully transitioned to the new format.
+  mutable std::map<uint32_t, webrtc::RtpHeaderExtensionMap>
+      incoming_rtp_extensions_maps_;
+  mutable std::map<uint32_t, webrtc::RtpHeaderExtensionMap>
+      outgoing_rtp_extensions_maps_;
+};
+
+struct MatchedSendArrivalTimes {
+  MatchedSendArrivalTimes(int64_t fb, int64_t tx, int64_t rx, int64_t ps)
+      : feedback_arrival_time_ms(fb),
+        send_time_ms(tx),
+        arrival_time_ms(rx),
+        payload_size(ps) {}
+
+  int64_t feedback_arrival_time_ms;
+  int64_t send_time_ms;     // PacketFeedback::kNoSendTime for late feedback.
+  int64_t arrival_time_ms;  // PacketFeedback::kNotReceived for lost packets.
+  int64_t payload_size;
+};
+const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
+    const ParsedRtcEventLog& parsed_log);
+
+}  // namespace webrtc
+
+#endif  // LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_H_

logging/rtc_event_log/rtc_event_log_parser_new.h

@@ -9,678 +9,9 @@
  */
 #ifndef LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_NEW_H_
 #define LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_NEW_H_
-
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
-#include <iterator>
+#include "rtc_base/deprecation.h"
-#include <map>
-#include <set>
-#include <sstream>  // no-presubmit-check TODO(webrtc:8982)
-#include <string>
-#include <utility>  // pair
-#include <vector>
-
-#include "call/video_receive_stream.h"
-#include "call/video_send_stream.h"
-#include "logging/rtc_event_log/logged_events.h"
-#include "logging/rtc_event_log/rtc_event_log.h"
-#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
-#include "rtc_base/ignore_wundef.h"
-
-// Files generated at build-time by the protobuf compiler.
-RTC_PUSH_IGNORING_WUNDEF()
-#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
-#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
-#include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log2.pb.h"
-#else
-#include "logging/rtc_event_log/rtc_event_log.pb.h"
-#include "logging/rtc_event_log/rtc_event_log2.pb.h"
-#endif
-RTC_POP_IGNORING_WUNDEF()
-
 namespace webrtc {
-
+using ParsedRtcEventLogNew RTC_DEPRECATED = ParsedRtcEventLog;
-template <typename T>
+}
-class PacketView;
-
-template <typename T>
-class PacketIterator {
-  friend class PacketView<T>;
-
- public:
-  // Standard iterator traits.
-  using difference_type = std::ptrdiff_t;
-  using value_type = T;
-  using pointer = T*;
-  using reference = T&;
-  using iterator_category = std::bidirectional_iterator_tag;
-
-  // The default-contructed iterator is meaningless, but is required by the
-  // ForwardIterator concept.
-  PacketIterator() : ptr_(nullptr), element_size_(0) {}
-  PacketIterator(const PacketIterator& other)
-      : ptr_(other.ptr_), element_size_(other.element_size_) {}
-  PacketIterator(const PacketIterator&& other)
-      : ptr_(other.ptr_), element_size_(other.element_size_) {}
-  ~PacketIterator() = default;
-
-  PacketIterator& operator=(const PacketIterator& other) {
-    ptr_ = other.ptr_;
-    element_size_ = other.element_size_;
-    return *this;
-  }
-  PacketIterator& operator=(const PacketIterator&& other) {
-    ptr_ = other.ptr_;
-    element_size_ = other.element_size_;
-    return *this;
-  }
-
-  bool operator==(const PacketIterator<T>& other) const {
-    RTC_DCHECK_EQ(element_size_, other.element_size_);
-    return ptr_ == other.ptr_;
-  }
-  bool operator!=(const PacketIterator<T>& other) const {
-    RTC_DCHECK_EQ(element_size_, other.element_size_);
-    return ptr_ != other.ptr_;
-  }
-
-  PacketIterator& operator++() {
-    ptr_ += element_size_;
-    return *this;
-  }
-  PacketIterator& operator--() {
-    ptr_ -= element_size_;
-    return *this;
-  }
-  PacketIterator operator++(int) {
-    PacketIterator iter_copy(ptr_, element_size_);
-    ptr_ += element_size_;
-    return iter_copy;
-  }
-  PacketIterator operator--(int) {
-    PacketIterator iter_copy(ptr_, element_size_);
-    ptr_ -= element_size_;
-    return iter_copy;
-  }
-
-  T& operator*() { return *reinterpret_cast<T*>(ptr_); }
-  const T& operator*() const { return *reinterpret_cast<const T*>(ptr_); }
-
- private:
-  PacketIterator(typename std::conditional<std::is_const<T>::value,
-                                           const void*,
-                                           void*>::type p,
-                 size_t s)
-      : ptr_(reinterpret_cast<decltype(ptr_)>(p)), element_size_(s) {}
-
-  typename std::conditional<std::is_const<T>::value, const char*, char*>::type
-      ptr_;
-  size_t element_size_;
-};
-
-// Suppose that we have a struct S where we are only interested in a specific
-// member M. Given an array of S, PacketView can be used to treat the array
-// as an array of M, without exposing the type S to surrounding code and without
-// accessing the member through a virtual function. In this case, we want to
-// have a common view for incoming and outgoing RtpPackets, hence the PacketView
-// name.
-// Note that constructing a PacketView bypasses the typesystem, so the caller
-// has to take extra care when constructing these objects. The implementation
-// also requires that the containing struct is standard-layout (e.g. POD).
-//
-// Usage example:
-// struct A {...};
-// struct B { A a; ...};
-// struct C { A a; ...};
-// size_t len = 10;
-// B* array1 = new B[len];
-// C* array2 = new C[len];
-//
-// PacketView<A> view1 = PacketView<A>::Create<B>(array1, len, offsetof(B, a));
-// PacketView<A> view2 = PacketView<A>::Create<C>(array2, len, offsetof(C, a));
-//
-// The following code works with either view1 or view2.
-// void f(PacketView<A> view)
-// for (A& a : view) {
-//   DoSomething(a);
-// }
-template <typename T>
-class PacketView {
- public:
-  template <typename U>
-  static PacketView Create(U* ptr, size_t num_elements, size_t offset) {
-    static_assert(std::is_standard_layout<U>::value,
-                  "PacketView can only be created for standard layout types.");
-    static_assert(std::is_standard_layout<T>::value,
-                  "PacketView can only be created for standard layout types.");
-    return PacketView(ptr, num_elements, offset, sizeof(U));
-  }
-
-  using iterator = PacketIterator<T>;
-  using const_iterator = PacketIterator<const T>;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-  iterator begin() { return iterator(data_, element_size_); }
-  iterator end() {
-    auto end_ptr = data_ + num_elements_ * element_size_;
-    return iterator(end_ptr, element_size_);
-  }
-
-  const_iterator begin() const { return const_iterator(data_, element_size_); }
-  const_iterator end() const {
-    auto end_ptr = data_ + num_elements_ * element_size_;
-    return const_iterator(end_ptr, element_size_);
-  }
-
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-
-  size_t size() const { return num_elements_; }
-
-  T& operator[](size_t i) {
-    auto elem_ptr = data_ + i * element_size_;
-    return *reinterpret_cast<T*>(elem_ptr);
-  }
-
-  const T& operator[](size_t i) const {
-    auto elem_ptr = data_ + i * element_size_;
-    return *reinterpret_cast<const T*>(elem_ptr);
-  }
-
- private:
-  PacketView(typename std::conditional<std::is_const<T>::value,
-                                       const void*,
-                                       void*>::type data,
-             size_t num_elements,
-             size_t offset,
-             size_t element_size)
-      : data_(reinterpret_cast<decltype(data_)>(data) + offset),
-        num_elements_(num_elements),
-        element_size_(element_size) {}
-
-  typename std::conditional<std::is_const<T>::value, const char*, char*>::type
-      data_;
-  size_t num_elements_;
-  size_t element_size_;
-};
-
-class ParsedRtcEventLogNew {
-  friend class RtcEventLogTestHelper;
-
- public:
-  enum class MediaType { ANY, AUDIO, VIDEO, DATA };
-  enum class UnconfiguredHeaderExtensions {
-    kDontParse,
-    kAttemptWebrtcDefaultConfig
-  };
-
-  struct LoggedRtpStreamIncoming {
-    LoggedRtpStreamIncoming();
-    LoggedRtpStreamIncoming(const LoggedRtpStreamIncoming&);
-    ~LoggedRtpStreamIncoming();
-    uint32_t ssrc;
-    std::vector<LoggedRtpPacketIncoming> incoming_packets;
-  };
-
-  struct LoggedRtpStreamOutgoing {
-    LoggedRtpStreamOutgoing();
-    LoggedRtpStreamOutgoing(const LoggedRtpStreamOutgoing&);
-    ~LoggedRtpStreamOutgoing();
-    uint32_t ssrc;
-    std::vector<LoggedRtpPacketOutgoing> outgoing_packets;
-  };
-
-  struct LoggedRtpStreamView {
-    LoggedRtpStreamView(uint32_t ssrc,
-                        const LoggedRtpPacketIncoming* ptr,
-                        size_t num_elements);
-    LoggedRtpStreamView(uint32_t ssrc,
-                        const LoggedRtpPacketOutgoing* ptr,
-                        size_t num_elements);
-    LoggedRtpStreamView(const LoggedRtpStreamView&);
-    uint32_t ssrc;
-    PacketView<const LoggedRtpPacket> packet_view;
-  };
-
-  static webrtc::RtpHeaderExtensionMap GetDefaultHeaderExtensionMap();
-
-  explicit ParsedRtcEventLogNew(
-      UnconfiguredHeaderExtensions parse_unconfigured_header_extensions =
-          UnconfiguredHeaderExtensions::kDontParse);
-
-  ~ParsedRtcEventLogNew();
-
-  // Clears previously parsed events and resets the ParsedRtcEventLogNew to an
-  // empty state.
-  void Clear();
-
-  // Reads an RtcEventLog file and returns true if parsing was successful.
-  bool ParseFile(const std::string& file_name);
-
-  // Reads an RtcEventLog from a string and returns true if successful.
-  bool ParseString(const std::string& s);
-
-  // Reads an RtcEventLog from an istream and returns true if successful.
-  bool ParseStream(
-      std::istream& stream);  // no-presubmit-check TODO(webrtc:8982)
-
-  MediaType GetMediaType(uint32_t ssrc, PacketDirection direction) 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_;
-  }
-
-  // Stream configurations.
-  const std::vector<LoggedAudioRecvConfig>& audio_recv_configs() const {
-    return audio_recv_configs_;
-  }
-
-  const std::vector<LoggedAudioSendConfig>& audio_send_configs() const {
-    return audio_send_configs_;
-  }
-
-  const std::vector<LoggedVideoRecvConfig>& video_recv_configs() const {
-    return video_recv_configs_;
-  }
-
-  const std::vector<LoggedVideoSendConfig>& video_send_configs() const {
-    return video_send_configs_;
-  }
-
-  // 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_;
-  }
-
-  const std::vector<LoggedAlrStateEvent>& alr_state_events() const {
-    return alr_state_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<LoggedBweProbeFailureEvent>& bwe_probe_failure_events()
-      const {
-    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_;
-  }
-
-  // DTLS
-  const std::vector<LoggedDtlsTransportState>& dtls_transport_states() const {
-    return dtls_transport_states_;
-  }
-
-  const std::vector<LoggedDtlsWritableState>& dtls_writable_states() const {
-    return dtls_writable_states_;
-  }
-
-  // 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_;
-  }
-
-  // RTP
-  const std::vector<LoggedRtpStreamIncoming>& incoming_rtp_packets_by_ssrc()
-      const {
-    return incoming_rtp_packets_by_ssrc_;
-  }
-
-  const std::vector<LoggedRtpStreamOutgoing>& outgoing_rtp_packets_by_ssrc()
-      const {
-    return outgoing_rtp_packets_by_ssrc_;
-  }
-
-  const std::vector<LoggedRtpStreamView>& rtp_packets_by_ssrc(
-      PacketDirection direction) const {
-    if (direction == kIncomingPacket)
-      return incoming_rtp_packet_views_by_ssrc_;
-    else
-      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) {
-      return incoming_rr_;
-    } else {
-      return outgoing_rr_;
-    }
-  }
-
-  const std::vector<LoggedRtcpPacketSenderReport>& sender_reports(
-      PacketDirection direction) const {
-    if (direction == kIncomingPacket) {
-      return incoming_sr_;
-    } else {
-      return outgoing_sr_;
-    }
-  }
-
-  const std::vector<LoggedRtcpPacketNack>& nacks(
-      PacketDirection direction) const {
-    if (direction == kIncomingPacket) {
-      return incoming_nack_;
-    } else {
-      return outgoing_nack_;
-    }
-  }
-
-  const std::vector<LoggedRtcpPacketRemb>& rembs(
-      PacketDirection direction) const {
-    if (direction == kIncomingPacket) {
-      return incoming_remb_;
-    } else {
-      return outgoing_remb_;
-    }
-  }
-
-  const std::vector<LoggedRtcpPacketTransportFeedback>& transport_feedbacks(
-      PacketDirection direction) const {
-    if (direction == kIncomingPacket) {
-      return incoming_transport_feedback_;
-    } else {
-      return outgoing_transport_feedback_;
-    }
-  }
-
-  int64_t first_timestamp() const { return first_timestamp_; }
-  int64_t last_timestamp() const { return last_timestamp_; }
-
- private:
-  bool ParseStreamInternal(
-      std::istream& stream);  // no-presubmit-check TODO(webrtc:8982)
-
-  void StoreParsedLegacyEvent(const rtclog::Event& event);
-
-  template <typename T>
-  void StoreFirstAndLastTimestamp(const std::vector<T>& v);
-
-  // Reads the arrival timestamp (in microseconds) from a rtclog::Event.
-  int64_t GetTimestamp(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
-  // parameters. Each output parameter can be set to nullptr if that value
-  // isn't needed.
-  // NB: The header must have space for at least IP_PACKET_SIZE bytes.
-  // Returns: a pointer to a header extensions map acquired from parsing
-  // corresponding Audio/Video Sender/Receiver config events.
-  // Warning: if the same SSRC is reused by both video and audio streams during
-  // call, extensions maps may be incorrect (the last one would be returned).
-  const webrtc::RtpHeaderExtensionMap* GetRtpHeader(
-      const rtclog::Event& event,
-      PacketDirection* incoming,
-      uint8_t* header,
-      size_t* header_length,
-      size_t* total_length,
-      int* probe_cluster_id) const;
-
-  // Reads packet, direction and packet length from the RTCP event at |index|,
-  // and stores the values in the corresponding output parameters.
-  // Each output parameter can be set to nullptr if that value isn't needed.
-  // NB: The packet must have space for at least IP_PACKET_SIZE bytes.
-  void GetRtcpPacket(const rtclog::Event& event,
-                     PacketDirection* incoming,
-                     uint8_t* packet,
-                     size_t* length) const;
-
-  rtclog::StreamConfig GetVideoReceiveConfig(const rtclog::Event& event) const;
-  rtclog::StreamConfig GetVideoSendConfig(const rtclog::Event& event) const;
-  rtclog::StreamConfig GetAudioReceiveConfig(const rtclog::Event& event) const;
-  rtclog::StreamConfig GetAudioSendConfig(const rtclog::Event& event) const;
-
-  LoggedAudioPlayoutEvent GetAudioPlayout(const rtclog::Event& event) const;
-
-  LoggedBweLossBasedUpdate GetLossBasedBweUpdate(
-      const rtclog::Event& event) const;
-  LoggedBweDelayBasedUpdate GetDelayBasedBweUpdate(
-      const rtclog::Event& event) const;
-
-  LoggedAudioNetworkAdaptationEvent GetAudioNetworkAdaptation(
-      const rtclog::Event& event) const;
-
-  LoggedBweProbeClusterCreatedEvent GetBweProbeClusterCreated(
-      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;
-
-  LoggedIceCandidatePairConfig GetIceCandidatePairConfig(
-      const rtclog::Event& event) const;
-  LoggedIceCandidatePairEvent GetIceCandidatePairEvent(
-      const rtclog::Event& event) const;
-
-  // Parsing functions for new format.
-  void StoreParsedNewFormatEvent(const rtclog2::EventStream& event);
-  void StoreIncomingRtpPackets(const rtclog2::IncomingRtpPackets& proto);
-  void StoreOutgoingRtpPackets(const rtclog2::OutgoingRtpPackets& proto);
-  void StoreIncomingRtcpPackets(const rtclog2::IncomingRtcpPackets& proto);
-  void StoreOutgoingRtcpPackets(const rtclog2::OutgoingRtcpPackets& proto);
-  void StoreStartEvent(const rtclog2::BeginLogEvent& proto);
-  void StoreStopEvent(const rtclog2::EndLogEvent& proto);
-  void StoreAlrStateEvent(const rtclog2::AlrState& proto);
-  void StoreAudioNetworkAdaptationEvent(
-      const rtclog2::AudioNetworkAdaptations& proto);
-  void StoreAudioPlayoutEvent(const rtclog2::AudioPlayoutEvents& proto);
-  void StoreBweLossBasedUpdate(const rtclog2::LossBasedBweUpdates& proto);
-  void StoreBweDelayBasedUpdate(const rtclog2::DelayBasedBweUpdates& proto);
-  void StoreBweProbeClusterCreated(const rtclog2::BweProbeCluster& proto);
-  void StoreBweProbeSuccessEvent(const rtclog2::BweProbeResultSuccess& proto);
-  void StoreBweProbeFailureEvent(const rtclog2::BweProbeResultFailure& proto);
-  void StoreDtlsTransportState(const rtclog2::DtlsTransportStateEvent& proto);
-  void StoreDtlsWritableState(const rtclog2::DtlsWritableState& proto);
-  void StoreIceCandidatePairConfig(
-      const rtclog2::IceCandidatePairConfig& proto);
-  void StoreIceCandidateEvent(const rtclog2::IceCandidatePairEvent& proto);
-  void StoreAudioRecvConfig(const rtclog2::AudioRecvStreamConfig& proto);
-  void StoreAudioSendConfig(const rtclog2::AudioSendStreamConfig& proto);
-  void StoreVideoRecvConfig(const rtclog2::VideoRecvStreamConfig& proto);
-  void StoreVideoSendConfig(const rtclog2::VideoSendStreamConfig& proto);
-  // End of new parsing functions.
-
-  struct Stream {
-    Stream(uint32_t ssrc,
-           MediaType media_type,
-           PacketDirection direction,
-           webrtc::RtpHeaderExtensionMap map)
-        : ssrc(ssrc),
-          media_type(media_type),
-          direction(direction),
-          rtp_extensions_map(map) {}
-    uint32_t ssrc;
-    MediaType media_type;
-    PacketDirection direction;
-    webrtc::RtpHeaderExtensionMap rtp_extensions_map;
-  };
-
-  const UnconfiguredHeaderExtensions parse_unconfigured_header_extensions_;
-
-  // Make a default extension map for streams without configuration information.
-  // TODO(ivoc): Once configuration of audio streams is stored in the event log,
-  //             this can be removed. Tracking bug: webrtc:6399
-  RtpHeaderExtensionMap default_extension_map_;
-
-  // Tracks what each stream is configured for. Note that a single SSRC can be
-  // in several sets. For example, the SSRC used for sending video over RTX
-  // will appear in both video_ssrcs_ and rtx_ssrcs_. In the unlikely case that
-  // an SSRC is reconfigured to a different media type mid-call, it will also
-  // appear in multiple sets.
-  std::set<uint32_t> incoming_rtx_ssrcs_;
-  std::set<uint32_t> incoming_video_ssrcs_;
-  std::set<uint32_t> incoming_audio_ssrcs_;
-  std::set<uint32_t> outgoing_rtx_ssrcs_;
-  std::set<uint32_t> outgoing_video_ssrcs_;
-  std::set<uint32_t> outgoing_audio_ssrcs_;
-
-  // Maps an SSRC to the parsed  RTP headers in that stream. Header extensions
-  // are parsed if the stream has been configured. This is only used for
-  // grouping the events by SSRC during parsing; the events are moved to
-  // incoming_rtp_packets_by_ssrc_ once the parsing is done.
-  std::map<uint32_t, std::vector<LoggedRtpPacketIncoming>>
-      incoming_rtp_packets_map_;
-  std::map<uint32_t, std::vector<LoggedRtpPacketOutgoing>>
-      outgoing_rtp_packets_map_;
-
-  // RTP headers.
-  std::vector<LoggedRtpStreamIncoming> incoming_rtp_packets_by_ssrc_;
-  std::vector<LoggedRtpStreamOutgoing> outgoing_rtp_packets_by_ssrc_;
-  std::vector<LoggedRtpStreamView> incoming_rtp_packet_views_by_ssrc_;
-  std::vector<LoggedRtpStreamView> outgoing_rtp_packet_views_by_ssrc_;
-
-  // Raw RTCP packets.
-  std::vector<LoggedRtcpPacketIncoming> incoming_rtcp_packets_;
-  std::vector<LoggedRtcpPacketOutgoing> outgoing_rtcp_packets_;
-
-  // Parsed RTCP messages. Currently not separated based on SSRC.
-  std::vector<LoggedRtcpPacketReceiverReport> incoming_rr_;
-  std::vector<LoggedRtcpPacketReceiverReport> outgoing_rr_;
-  std::vector<LoggedRtcpPacketSenderReport> incoming_sr_;
-  std::vector<LoggedRtcpPacketSenderReport> outgoing_sr_;
-  std::vector<LoggedRtcpPacketNack> incoming_nack_;
-  std::vector<LoggedRtcpPacketNack> outgoing_nack_;
-  std::vector<LoggedRtcpPacketRemb> incoming_remb_;
-  std::vector<LoggedRtcpPacketRemb> outgoing_remb_;
-  std::vector<LoggedRtcpPacketTransportFeedback> incoming_transport_feedback_;
-  std::vector<LoggedRtcpPacketTransportFeedback> outgoing_transport_feedback_;
-
-  std::vector<LoggedStartEvent> start_log_events_;
-  std::vector<LoggedStopEvent> stop_log_events_;
-
-  std::vector<LoggedAlrStateEvent> alr_state_events_;
-
-  std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>
-      audio_playout_events_;
-
-  std::vector<LoggedAudioNetworkAdaptationEvent>
-      audio_network_adaptation_events_;
-
-  std::vector<LoggedBweProbeClusterCreatedEvent>
-      bwe_probe_cluster_created_events_;
-
-  std::vector<LoggedBweProbeFailureEvent> bwe_probe_failure_events_;
-  std::vector<LoggedBweProbeSuccessEvent> bwe_probe_success_events_;
-
-  std::vector<LoggedBweDelayBasedUpdate> bwe_delay_updates_;
-  std::vector<LoggedBweLossBasedUpdate> bwe_loss_updates_;
-
-  std::vector<LoggedDtlsTransportState> dtls_transport_states_;
-  std::vector<LoggedDtlsWritableState> dtls_writable_states_;
-
-  std::vector<LoggedIceCandidatePairConfig> ice_candidate_pair_configs_;
-  std::vector<LoggedIceCandidatePairEvent> ice_candidate_pair_events_;
-
-  std::vector<LoggedAudioRecvConfig> audio_recv_configs_;
-  std::vector<LoggedAudioSendConfig> audio_send_configs_;
-  std::vector<LoggedVideoRecvConfig> video_recv_configs_;
-  std::vector<LoggedVideoSendConfig> video_send_configs_;
-
-  uint8_t last_incoming_rtcp_packet_[IP_PACKET_SIZE];
-  uint8_t last_incoming_rtcp_packet_length_;
-
-  int64_t first_timestamp_;
-  int64_t last_timestamp_;
-
-  // The extension maps are mutable to allow us to insert the default
-  // configuration when parsing an RTP header for an unconfigured stream.
-  // TODO(terelius): This is only used for the legacy format. Remove once we've
-  // fully transitioned to the new format.
-  mutable std::map<uint32_t, webrtc::RtpHeaderExtensionMap>
-      incoming_rtp_extensions_maps_;
-  mutable std::map<uint32_t, webrtc::RtpHeaderExtensionMap>
-      outgoing_rtp_extensions_maps_;
-};
-
-struct MatchedSendArrivalTimes {
-  MatchedSendArrivalTimes(int64_t fb, int64_t tx, int64_t rx, int64_t ps)
-      : feedback_arrival_time_ms(fb),
-        send_time_ms(tx),
-        arrival_time_ms(rx),
-        payload_size(ps) {}
-
-  int64_t feedback_arrival_time_ms;
-  int64_t send_time_ms;     // PacketFeedback::kNoSendTime for late feedback.
-  int64_t arrival_time_ms;  // PacketFeedback::kNotReceived for lost packets.
-  int64_t payload_size;
-};
-const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
-    const ParsedRtcEventLogNew& parsed_log);
-
-}  // namespace webrtc
-
 #endif  // LOGGING_RTC_EVENT_LOG_RTC_EVENT_LOG_PARSER_NEW_H_

logging/rtc_event_log/rtc_event_log_unittest.cc

@@ -37,7 +37,7 @@
 #include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
 #include "logging/rtc_event_log/output/rtc_event_log_output_file.h"
 #include "logging/rtc_event_log/rtc_event_log.h"
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
 #include "logging/rtc_event_log/rtc_event_log_unittest_helper.h"
 #include "logging/rtc_event_log/rtc_stream_config.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
@@ -498,7 +498,7 @@ void RtcEventLogSession::WriteLog(EventCounts count,
 // same as what we wrote down.
 void RtcEventLogSession::ReadAndVerifyLog() {
   // Read the generated file from disk.
-  ParsedRtcEventLogNew parsed_log;
+  ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename_));
 
   // Start and stop events.
@@ -785,7 +785,7 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) {
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
-  ParsedRtcEventLogNew parsed_log;
+  ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   const auto& start_log_events = parsed_log.start_log_events();

logging/rtc_event_log/rtc_event_log_unittest_helper.h

@@ -35,7 +35,7 @@
 #include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
 #include "logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h"
 #include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
 #include "logging/rtc_event_log/rtc_stream_config.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"

logging/rtc_event_log/rtc_event_processor_unittest.cc

@@ -16,7 +16,7 @@
 #include <numeric>
 
 #include "absl/memory/memory.h"
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/random.h"
 #include "test/gtest.h"

modules/audio_coding/neteq/tools/rtc_event_log_source.cc

@@ -24,10 +24,10 @@ namespace webrtc {
 namespace test {
 
 namespace {
-bool ShouldSkipStream(ParsedRtcEventLogNew::MediaType media_type,
+bool ShouldSkipStream(ParsedRtcEventLog::MediaType media_type,
                       uint32_t ssrc,
                       absl::optional<uint32_t> ssrc_filter) {
-  if (media_type != ParsedRtcEventLogNew::MediaType::AUDIO)
+  if (media_type != ParsedRtcEventLog::MediaType::AUDIO)
     return true;
   if (ssrc_filter.has_value() && ssrc != *ssrc_filter)
     return true;
@@ -65,7 +65,7 @@ RtcEventLogSource::RtcEventLogSource() : PacketSource() {}
 
 bool RtcEventLogSource::OpenFile(const std::string& file_name,
                                  absl::optional<uint32_t> ssrc_filter) {
-  ParsedRtcEventLogNew parsed_log;
+  ParsedRtcEventLog parsed_log;
   if (!parsed_log.ParseFile(file_name))
     return false;
 
@@ -104,7 +104,7 @@ bool RtcEventLogSource::OpenFile(const std::string& file_name,
   // This wouldn't be needed if we knew that there was at most one audio stream.
   webrtc::RtcEventProcessor event_processor;
   for (const auto& rtp_packets : parsed_log.incoming_rtp_packets_by_ssrc()) {
-    ParsedRtcEventLogNew::MediaType media_type =
+    ParsedRtcEventLog::MediaType media_type =
         parsed_log.GetMediaType(rtp_packets.ssrc, webrtc::kIncomingPacket);
     if (ShouldSkipStream(media_type, rtp_packets.ssrc, ssrc_filter)) {
       continue;

modules/audio_coding/neteq/tools/rtc_event_log_source.h

@@ -16,7 +16,7 @@
 #include <vector>
 
 #include "absl/types/optional.h"
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
 #include "modules/audio_coding/neteq/tools/packet_source.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "rtc_base/constructormagic.h"

rtc_tools/event_log_visualizer/analyzer.cc

@@ -445,7 +445,7 @@ std::string GetDirectionAsShortString(PacketDirection direction) {
 
 }  // namespace
 
-EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLogNew& log,
+EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log,
                                    bool normalize_time)
     : parsed_log_(log),
       window_duration_(250000),

rtc_tools/event_log_visualizer/analyzer.h

@@ -18,7 +18,7 @@
 #include <utility>
 #include <vector>
 
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
 #include "modules/audio_coding/neteq/tools/neteq_stats_getter.h"
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_tools/event_log_visualizer/plot_base.h"
@@ -31,7 +31,7 @@ class EventLogAnalyzer {
   // The EventLogAnalyzer keeps a reference to the ParsedRtcEventLogNew for the
   // duration of its lifetime. The ParsedRtcEventLogNew must not be destroyed or
   // modified while the EventLogAnalyzer is being used.
-  EventLogAnalyzer(const ParsedRtcEventLogNew& log, bool normalize_time);
+  EventLogAnalyzer(const ParsedRtcEventLog& log, bool normalize_time);
 
   void CreatePacketGraph(PacketDirection direction, Plot* plot);
 
@@ -223,7 +223,7 @@ class EventLogAnalyzer {
 
   std::string GetCandidatePairLogDescriptionFromId(uint32_t candidate_pair_id);
 
-  const ParsedRtcEventLogNew& parsed_log_;
+  const ParsedRtcEventLog& parsed_log_;
 
   // A list of SSRCs we are interested in analysing.
   // If left empty, all SSRCs will be considered relevant.

rtc_tools/event_log_visualizer/main.cc

@@ -17,7 +17,7 @@
 #include <utility>
 
 #include "logging/rtc_event_log/rtc_event_log.h"
-#include "logging/rtc_event_log/rtc_event_log_parser_new.h"
+#include "logging/rtc_event_log/rtc_event_log_parser.h"
 #include "modules/audio_coding/neteq/include/neteq.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/report_block.h"
 #include "rtc_base/checks.h"
@@ -258,13 +258,13 @@ int main(int argc, char* argv[]) {
 
   std::string filename = argv[1];
 
-  webrtc::ParsedRtcEventLogNew::UnconfiguredHeaderExtensions header_extensions =
+  webrtc::ParsedRtcEventLog::UnconfiguredHeaderExtensions header_extensions =
-      webrtc::ParsedRtcEventLogNew::UnconfiguredHeaderExtensions::kDontParse;
+      webrtc::ParsedRtcEventLog::UnconfiguredHeaderExtensions::kDontParse;
   if (FLAG_parse_unconfigured_header_extensions) {
-    header_extensions = webrtc::ParsedRtcEventLogNew::
+    header_extensions = webrtc::ParsedRtcEventLog::
         UnconfiguredHeaderExtensions::kAttemptWebrtcDefaultConfig;
   }
-  webrtc::ParsedRtcEventLogNew parsed_log(header_extensions);
+  webrtc::ParsedRtcEventLog parsed_log(header_extensions);
 
   if (!parsed_log.ParseFile(filename)) {
     std::cerr << "Could not parse the entire log file." << std::endl;