New parser for event log. Manually parse the outermost EventStream

webrtc/call/rtc_event_log_unittest.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifdef ENABLE_RTC_EVENT_LOG
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/random.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/call.h"
 #include "webrtc/call/rtc_event_log.h"
+#include "webrtc/call/rtc_event_log_parser.h"
+#include "webrtc/call/rtc_event_log_unittest_helper.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/test_suite.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/call/rtc_event_log.pb.h"
@@ skipping 13 matching lines @@
     RTPExtensionType::kRtpExtensionTransportSequenceNumber};
 const char* kExtensionNames[] = {RtpExtension::kTOffset,
                                  RtpExtension::kAudioLevel,
                                  RtpExtension::kAbsSendTime,
                                  RtpExtension::kVideoRotation,
                                  RtpExtension::kTransportSequenceNumber};
 const size_t kNumExtensions = 5;
 
 }  // namespace
 
-// TODO(terelius): Place this definition with other parsing functions?
-MediaType GetRuntimeMediaType(rtclog::MediaType media_type) {
-  switch (media_type) {
-    case rtclog::MediaType::ANY:
-      return MediaType::ANY;
-    case rtclog::MediaType::AUDIO:
-      return MediaType::AUDIO;
-    case rtclog::MediaType::VIDEO:
-      return MediaType::VIDEO;
-    case rtclog::MediaType::DATA:
-      return MediaType::DATA;
-  }
-  RTC_NOTREACHED();
-  return MediaType::ANY;
-}
-
-// Checks that the event has a timestamp, a type and exactly the data field
-// corresponding to the type.
-::testing::AssertionResult IsValidBasicEvent(const rtclog::Event& event) {
-  if (!event.has_timestamp_us())
-    return ::testing::AssertionFailure() << "Event has no timestamp";
-  if (!event.has_type())
-    return ::testing::AssertionFailure() << "Event has no event type";
-  rtclog::Event_EventType type = event.type();
-  if ((type == rtclog::Event::RTP_EVENT) != event.has_rtp_packet())
-    return ::testing::AssertionFailure()
-           << "Event of type " << type << " has "
-           << (event.has_rtp_packet() ? "" : "no ") << "RTP packet";
-  if ((type == rtclog::Event::RTCP_EVENT) != event.has_rtcp_packet())
-    return ::testing::AssertionFailure()
-           << "Event of type " << type << " has "
-           << (event.has_rtcp_packet() ? "" : "no ") << "RTCP packet";
-  if ((type == rtclog::Event::AUDIO_PLAYOUT_EVENT) !=
-      event.has_audio_playout_event())
-    return ::testing::AssertionFailure()
-           << "Event of type " << type << " has "
-           << (event.has_audio_playout_event() ? "" : "no ")
-           << "audio_playout event";
-  if ((type == rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT) !=
-      event.has_video_receiver_config())
-    return ::testing::AssertionFailure()
-           << "Event of type " << type << " has "
-           << (event.has_video_receiver_config() ? "" : "no ")
-           << "receiver config";
-  if ((type == rtclog::Event::VIDEO_SENDER_CONFIG_EVENT) !=
-      event.has_video_sender_config())
-    return ::testing::AssertionFailure()
-           << "Event of type " << type << " has "
-           << (event.has_video_sender_config() ? "" : "no ") << "sender config";
-  if ((type == rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT) !=
-      event.has_audio_receiver_config()) {
-    return ::testing::AssertionFailure()
-           << "Event of type " << type << " has "
-           << (event.has_audio_receiver_config() ? "" : "no ")
-           << "audio receiver config";
-  }
-  if ((type == rtclog::Event::AUDIO_SENDER_CONFIG_EVENT) !=
-      event.has_audio_sender_config()) {
-    return ::testing::AssertionFailure()
-           << "Event of type " << type << " has "
-           << (event.has_audio_sender_config() ? "" : "no ")
-           << "audio sender config";
-  }
-  return ::testing::AssertionSuccess();
-}
-
-void VerifyReceiveStreamConfig(const rtclog::Event& event,
-                               const VideoReceiveStream::Config& config) {
-  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.
-  ASSERT_TRUE(receiver_config.has_rtcp_mode());
-  if (config.rtp.rtcp_mode == RtcpMode::kCompound)
-    EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_COMPOUND,
-              receiver_config.rtcp_mode());
-  else
-    EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE,
-              receiver_config.rtcp_mode());
-  ASSERT_TRUE(receiver_config.has_remb());
-  EXPECT_EQ(config.rtp.remb, receiver_config.remb());
-  // Check RTX map.
-  ASSERT_EQ(static_cast<int>(config.rtp.rtx.size()),
-            receiver_config.rtx_map_size());
-  for (const rtclog::RtxMap& rtx_map : receiver_config.rtx_map()) {
-    ASSERT_TRUE(rtx_map.has_payload_type());
-    ASSERT_TRUE(rtx_map.has_config());
-    EXPECT_EQ(1u, config.rtp.rtx.count(rtx_map.payload_type()));
-    const rtclog::RtxConfig& rtx_config = rtx_map.config();
-    const VideoReceiveStream::Config::Rtp::Rtx& rtx =
-        config.rtp.rtx.at(rtx_map.payload_type());
-    ASSERT_TRUE(rtx_config.has_rtx_ssrc());
-    ASSERT_TRUE(rtx_config.has_rtx_payload_type());
-    EXPECT_EQ(rtx.ssrc, rtx_config.rtx_ssrc());
-    EXPECT_EQ(rtx.payload_type, rtx_config.rtx_payload_type());
-  }
-  // Check header extensions.
-  ASSERT_EQ(static_cast<int>(config.rtp.extensions.size()),
-            receiver_config.header_extensions_size());
-  for (int i = 0; i < receiver_config.header_extensions_size(); i++) {
-    ASSERT_TRUE(receiver_config.header_extensions(i).has_name());
-    ASSERT_TRUE(receiver_config.header_extensions(i).has_id());
-    const std::string& name = receiver_config.header_extensions(i).name();
-    int id = receiver_config.header_extensions(i).id();
-    EXPECT_EQ(config.rtp.extensions[i].id, id);
-    EXPECT_EQ(config.rtp.extensions[i].name, name);
-  }
-  // Check decoders.
-  ASSERT_EQ(static_cast<int>(config.decoders.size()),
-            receiver_config.decoders_size());
-  for (int i = 0; i < receiver_config.decoders_size(); i++) {
-    ASSERT_TRUE(receiver_config.decoders(i).has_name());
-    ASSERT_TRUE(receiver_config.decoders(i).has_payload_type());
-    const std::string& decoder_name = receiver_config.decoders(i).name();
-    int decoder_type = receiver_config.decoders(i).payload_type();
-    EXPECT_EQ(config.decoders[i].payload_name, decoder_name);
-    EXPECT_EQ(config.decoders[i].payload_type, decoder_type);
-  }
-}
-
-void VerifySendStreamConfig(const rtclog::Event& event,
-                            const VideoSendStream::Config& config) {
-  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.
-  ASSERT_EQ(static_cast<int>(config.rtp.extensions.size()),
-            sender_config.header_extensions_size());
-  for (int i = 0; i < sender_config.header_extensions_size(); i++) {
-    ASSERT_TRUE(sender_config.header_extensions(i).has_name());
-    ASSERT_TRUE(sender_config.header_extensions(i).has_id());
-    const std::string& name = sender_config.header_extensions(i).name();
-    int id = sender_config.header_extensions(i).id();
-    EXPECT_EQ(config.rtp.extensions[i].id, id);
-    EXPECT_EQ(config.rtp.extensions[i].name, name);
-  }
-  // Check RTX settings.
-  ASSERT_EQ(static_cast<int>(config.rtp.rtx.ssrcs.size()),
-            sender_config.rtx_ssrcs_size());
-  for (int i = 0; i < sender_config.rtx_ssrcs_size(); i++) {
-    EXPECT_EQ(config.rtp.rtx.ssrcs[i], sender_config.rtx_ssrcs(i));
-  }
-  if (sender_config.rtx_ssrcs_size() > 0) {
-    ASSERT_TRUE(sender_config.has_rtx_payload_type());
-    EXPECT_EQ(config.rtp.rtx.payload_type, sender_config.rtx_payload_type());
-  }
-  // Check encoder.
-  ASSERT_TRUE(sender_config.has_encoder());
-  ASSERT_TRUE(sender_config.encoder().has_name());
-  ASSERT_TRUE(sender_config.encoder().has_payload_type());
-  EXPECT_EQ(config.encoder_settings.payload_name,
-            sender_config.encoder().name());
-  EXPECT_EQ(config.encoder_settings.payload_type,
-            sender_config.encoder().payload_type());
-}
-
-void VerifyRtpEvent(const rtclog::Event& event,
-                    bool incoming,
-                    MediaType media_type,
-                    const uint8_t* header,
-                    size_t header_size,
-                    size_t total_size) {
-  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(incoming, 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());
-  ASSERT_EQ(header_size, rtp_packet.header().size());
-  for (size_t i = 0; i < header_size; i++) {
-    EXPECT_EQ(header[i], static_cast<uint8_t>(rtp_packet.header()[i]));
-  }
-}
-
-void VerifyRtcpEvent(const rtclog::Event& event,
-                     bool incoming,
-                     MediaType media_type,
-                     const uint8_t* packet,
-                     size_t total_size) {
-  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(incoming, 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++) {
-    EXPECT_EQ(packet[i], static_cast<uint8_t>(rtcp_packet.packet_data()[i]));
-  }
-}
-
-void VerifyPlayoutEvent(const rtclog::Event& event, uint32_t ssrc) {
-  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());
-}
-
-void VerifyBweLossEvent(const rtclog::Event& event,
-                        int32_t bitrate,
-                        uint8_t fraction_loss,
-                        int32_t total_packets) {
-  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());
-}
-
-void VerifyLogStartEvent(const rtclog::Event& event) {
-  ASSERT_TRUE(IsValidBasicEvent(event));
-  EXPECT_EQ(rtclog::Event::LOG_START, event.type());
-}
 
 /*
  * Bit number i of extension_bitvector is set to indicate the
  * presence of extension number i from kExtensionTypes / kExtensionNames.
  * The least significant bit extension_bitvector has number 0.
  */
 size_t GenerateRtpPacket(uint32_t extensions_bitvector,
                          uint32_t csrcs_count,
                          uint8_t* packet,
                          size_t packet_size,
@@ skipping 197 matching lines @@
             bwe_loss_updates[bwe_loss_index - 1].second, i);
         bwe_loss_index++;
       }
       if (i == rtp_count / 2) {
         log_dumper->StartLogging(temp_filename, 10000000);
       }
     }
   }
 
   // Read the generated file from disk.
-  rtclog::EventStream parsed_stream;
+  ParsedRtcEventLog parsed_log;
 
-  ASSERT_TRUE(RtcEventLog::ParseRtcEventLog(temp_filename, &parsed_stream));
+  ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down. For RTCP we log the full packets, but for
   // RTP we should only log the header.
-  const int event_count = config_count + playout_count + bwe_loss_count +
-                          rtcp_count + rtp_count + 1;
-  EXPECT_EQ(event_count, parsed_stream.stream_size());
-  VerifyReceiveStreamConfig(parsed_stream.stream(0), receiver_config);
-  VerifySendStreamConfig(parsed_stream.stream(1), sender_config);
+  const size_t event_count = config_count + playout_count + bwe_loss_count +
+                             rtcp_count + rtp_count + 1;
+  EXPECT_EQ(event_count, parsed_log.GetNumberOfEvents());
+  RtcEventLogTestHelper::VerifyReceiveStreamConfig(parsed_log, 0,
+                                                   receiver_config);
+  RtcEventLogTestHelper::VerifySendStreamConfig(parsed_log, 1, sender_config);
   size_t event_index = config_count;
   size_t rtcp_index = 1;
   size_t playout_index = 1;
   size_t bwe_loss_index = 1;
   for (size_t i = 1; i <= rtp_count; i++) {
-    VerifyRtpEvent(parsed_stream.stream(event_index),
-                   (i % 2 == 0),  // Every second packet is incoming.
-                   (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
-                   rtp_packets[i - 1].data(), rtp_header_sizes[i - 1],
-                   rtp_packets[i - 1].size());
+    RtcEventLogTestHelper::VerifyRtpEvent(
+        parsed_log, event_index,
+        (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
+        (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
+        rtp_packets[i - 1].data(), rtp_header_sizes[i - 1],
+        rtp_packets[i - 1].size());
     event_index++;
     if (i * rtcp_count >= rtcp_index * rtp_count) {
-      VerifyRtcpEvent(parsed_stream.stream(event_index),
-                      rtcp_index % 2 == 0,  // Every second packet is incoming.
-                      rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
-                      rtcp_packets[rtcp_index - 1].data(),
-                      rtcp_packets[rtcp_index - 1].size());
+      RtcEventLogTestHelper::VerifyRtcpEvent(
+          parsed_log, event_index,
+          rtcp_index % 2 == 0 ? kIncomingPacket : kOutgoingPacket,
+          rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
+          rtcp_packets[rtcp_index - 1].data(),
+          rtcp_packets[rtcp_index - 1].size());
       event_index++;
       rtcp_index++;
     }
     if (i * playout_count >= playout_index * rtp_count) {
-      VerifyPlayoutEvent(parsed_stream.stream(event_index),
-                         playout_ssrcs[playout_index - 1]);
+      RtcEventLogTestHelper::VerifyPlayoutEvent(
+          parsed_log, event_index, playout_ssrcs[playout_index - 1]);
       event_index++;
       playout_index++;
     }
     if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
-      VerifyBweLossEvent(parsed_stream.stream(event_index),
-                         bwe_loss_updates[bwe_loss_index - 1].first,
-                         bwe_loss_updates[bwe_loss_index - 1].second, i);
+      RtcEventLogTestHelper::VerifyBweLossEvent(
+          parsed_log, event_index, bwe_loss_updates[bwe_loss_index - 1].first,
+          bwe_loss_updates[bwe_loss_index - 1].second, i);
       event_index++;
       bwe_loss_index++;
     }
     if (i == rtp_count / 2) {
-      VerifyLogStartEvent(parsed_stream.stream(event_index));
+      RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, event_index);
       event_index++;
     }
   }
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
 TEST(RtcEventLogTest, LogSessionAndReadBack) {
   // Log 5 RTP, 2 RTCP, 0 playout events and 0 BWE events
@@ skipping 85 matching lines @@
     log_dumper->StartLogging(temp_filename, 10000000);
     log_dumper->LogRtpHeader(kIncomingPacket, MediaType::VIDEO,
                              recent_rtp_packet.data(),
                              recent_rtp_packet.size());
     log_dumper->LogRtcpPacket(kOutgoingPacket, MediaType::VIDEO,
                               recent_rtcp_packet.data(),
                               recent_rtcp_packet.size());
   }
 
   // Read the generated file from disk.
-  rtclog::EventStream parsed_stream;
-  ASSERT_TRUE(RtcEventLog::ParseRtcEventLog(temp_filename, &parsed_stream));
+  ParsedRtcEventLog parsed_log;
+  ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote. Old RTP and RTCP events should have been discarded,
   // but old configuration events should still be available.
-  EXPECT_EQ(5, parsed_stream.stream_size());
-  VerifyReceiveStreamConfig(parsed_stream.stream(0), receiver_config);
-  VerifySendStreamConfig(parsed_stream.stream(1), sender_config);
-  VerifyLogStartEvent(parsed_stream.stream(2));
-  VerifyRtpEvent(parsed_stream.stream(3), true, MediaType::VIDEO,
-                 recent_rtp_packet.data(), recent_header_size,
-                 recent_rtp_packet.size());
-  VerifyRtcpEvent(parsed_stream.stream(4), false, MediaType::VIDEO,
-                  recent_rtcp_packet.data(), recent_rtcp_packet.size());
+  EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
+  RtcEventLogTestHelper::VerifyReceiveStreamConfig(parsed_log, 0,
+                                                   receiver_config);
+  RtcEventLogTestHelper::VerifySendStreamConfig(parsed_log, 1, sender_config);
+  RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 2);
+  RtcEventLogTestHelper::VerifyRtpEvent(
+      parsed_log, 3, kIncomingPacket, MediaType::VIDEO,
+      recent_rtp_packet.data(), recent_header_size, recent_rtp_packet.size());
+  RtcEventLogTestHelper::VerifyRtcpEvent(
+      parsed_log, 4, kOutgoingPacket, MediaType::VIDEO,
+      recent_rtcp_packet.data(), recent_rtcp_packet.size());
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
 TEST(RtcEventLogTest, DropOldEvents) {
   // Enable all header extensions
   uint32_t extensions = (1u << kNumExtensions) - 1;
   uint32_t csrcs_count = 2;
   DropOldEvents(extensions, csrcs_count, 141421356);
   DropOldEvents(extensions, csrcs_count, 173205080);
 }
 
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG