Method to parse event log directly from a string.

webrtc/call/rtc_event_log_unittest_helper.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 90 matching lines @@
            << (event.has_audio_sender_config() ? "" : "no ")
            << "audio sender config";
   }
   return ::testing::AssertionSuccess();
 }
 
 void RtcEventLogTestHelper::VerifyReceiveStreamConfig(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     const VideoReceiveStream::Config& config) {
-  const rtclog::Event& event = parsed_log.stream_[index];
+  const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT, event.type());
   const rtclog::VideoReceiveConfig& receiver_config =
       event.video_receiver_config();
   // Check SSRCs.
   ASSERT_TRUE(receiver_config.has_remote_ssrc());
   EXPECT_EQ(config.rtp.remote_ssrc, receiver_config.remote_ssrc());
   ASSERT_TRUE(receiver_config.has_local_ssrc());
   EXPECT_EQ(config.rtp.local_ssrc, receiver_config.local_ssrc());
   // Check RTCP settings.
@@ skipping 75 matching lines @@
               parsed_config.decoders[i].payload_name);
     EXPECT_EQ(config.decoders[i].payload_type,
               parsed_config.decoders[i].payload_type);
   }
 }
 
 void RtcEventLogTestHelper::VerifySendStreamConfig(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     const VideoSendStream::Config& config) {
-  const rtclog::Event& event = parsed_log.stream_[index];
+  const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT, event.type());
   const rtclog::VideoSendConfig& sender_config = event.video_sender_config();
   // Check SSRCs.
   ASSERT_EQ(static_cast<int>(config.rtp.ssrcs.size()),
             sender_config.ssrcs_size());
   for (int i = 0; i < sender_config.ssrcs_size(); i++) {
     EXPECT_EQ(config.rtp.ssrcs[i], sender_config.ssrcs(i));
   }
   // Check header extensions.
@@ skipping 54 matching lines @@
             parsed_config.encoder_settings.payload_type);
 }
 
 void RtcEventLogTestHelper::VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
                                            size_t index,
                                            PacketDirection direction,
                                            MediaType media_type,
                                            const uint8_t* header,
                                            size_t header_size,
                                            size_t total_size) {
-  const rtclog::Event& event = parsed_log.stream_[index];
+  const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTP_EVENT, event.type());
   const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
   ASSERT_TRUE(rtp_packet.has_incoming());
   EXPECT_EQ(direction == kIncomingPacket, rtp_packet.incoming());
   ASSERT_TRUE(rtp_packet.has_type());
   EXPECT_EQ(media_type, GetRuntimeMediaType(rtp_packet.type()));
   ASSERT_TRUE(rtp_packet.has_packet_length());
   EXPECT_EQ(total_size, rtp_packet.packet_length());
   ASSERT_TRUE(rtp_packet.has_header());
@@ skipping 16 matching lines @@
   EXPECT_EQ(0, std::memcmp(header, parsed_header, header_size));
   EXPECT_EQ(total_size, parsed_total_size);
 }
 
 void RtcEventLogTestHelper::VerifyRtcpEvent(const ParsedRtcEventLog& parsed_log,
                                             size_t index,
                                             PacketDirection direction,
                                             MediaType media_type,
                                             const uint8_t* packet,
                                             size_t total_size) {
-  const rtclog::Event& event = parsed_log.stream_[index];
+  const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTCP_EVENT, event.type());
   const rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet();
   ASSERT_TRUE(rtcp_packet.has_incoming());
   EXPECT_EQ(direction == kIncomingPacket, rtcp_packet.incoming());
   ASSERT_TRUE(rtcp_packet.has_type());
   EXPECT_EQ(media_type, GetRuntimeMediaType(rtcp_packet.type()));
   ASSERT_TRUE(rtcp_packet.has_packet_data());
   ASSERT_EQ(total_size, rtcp_packet.packet_data().size());
   for (size_t i = 0; i < total_size; i++) {
@@ skipping 10 matching lines @@
   EXPECT_EQ(direction, parsed_direction);
   EXPECT_EQ(media_type, parsed_media_type);
   ASSERT_EQ(total_size, parsed_total_size);
   EXPECT_EQ(0, std::memcmp(packet, parsed_packet, total_size));
 }
 
 void RtcEventLogTestHelper::VerifyPlayoutEvent(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     uint32_t ssrc) {
-  const rtclog::Event& event = parsed_log.stream_[index];
+  const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::AUDIO_PLAYOUT_EVENT, event.type());
   const rtclog::AudioPlayoutEvent& playout_event = event.audio_playout_event();
   ASSERT_TRUE(playout_event.has_local_ssrc());
   EXPECT_EQ(ssrc, playout_event.local_ssrc());
 
   // Check consistency of the parser.
   uint32_t parsed_ssrc;
   parsed_log.GetAudioPlayout(index, &parsed_ssrc);
   EXPECT_EQ(ssrc, parsed_ssrc);
 }
 
 void RtcEventLogTestHelper::VerifyBweLossEvent(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     int32_t bitrate,
     uint8_t fraction_loss,
     int32_t total_packets) {
-  const rtclog::Event& event = parsed_log.stream_[index];
+  const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::BWE_PACKET_LOSS_EVENT, event.type());
   const rtclog::BwePacketLossEvent& bwe_event = event.bwe_packet_loss_event();
   ASSERT_TRUE(bwe_event.has_bitrate());
   EXPECT_EQ(bitrate, bwe_event.bitrate());
   ASSERT_TRUE(bwe_event.has_fraction_loss());
   EXPECT_EQ(fraction_loss, bwe_event.fraction_loss());
   ASSERT_TRUE(bwe_event.has_total_packets());
   EXPECT_EQ(total_packets, bwe_event.total_packets());
 
   // Check consistency of the parser.
   int32_t parsed_bitrate;
   uint8_t parsed_fraction_loss;
   int32_t parsed_total_packets;
   parsed_log.GetBwePacketLossEvent(
       index, &parsed_bitrate, &parsed_fraction_loss, &parsed_total_packets);
   EXPECT_EQ(bitrate, parsed_bitrate);
   EXPECT_EQ(fraction_loss, parsed_fraction_loss);
   EXPECT_EQ(total_packets, parsed_total_packets);
 }
 
 void RtcEventLogTestHelper::VerifyLogStartEvent(
     const ParsedRtcEventLog& parsed_log,
     size_t index) {
-  const rtclog::Event& event = parsed_log.stream_[index];
+  const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   EXPECT_EQ(rtclog::Event::LOG_START, event.type());
 }
 
 void RtcEventLogTestHelper::VerifyLogEndEvent(
     const ParsedRtcEventLog& parsed_log,
     size_t index) {
-  const rtclog::Event& event = parsed_log.stream_[index];
+  const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   EXPECT_EQ(rtclog::Event::LOG_END, event.type());
 }
 
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG