Split LogRtpHeader and LogRtcpPacket into separate versions for incoming and outgoing packets.

webrtc/logging/rtc_event_log/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.
  */
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "webrtc/call/call.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_extension_map.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_header_extensions.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "webrtc/rtc_base/buffer.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/fakeclock.h"
 #include "webrtc/rtc_base/random.h"
 #include "webrtc/test/gtest.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/logging/rtc_event_log/rtc_event_log.pb.h"
 #else
 #include "webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
 #endif
 
 namespace webrtc {
 
 namespace {
 
+const uint8_t kTransmissionTimeOffsetExtensionId = 1;
+const uint8_t kAbsoluteSendTimeExtensionId = 14;
+const uint8_t kTransportSequenceNumberExtensionId = 13;
+const uint8_t kAudioLevelExtensionId = 9;
+const uint8_t kVideoRotationExtensionId = 5;
+
+const uint8_t kExtensionIds[] = {
+    kTransmissionTimeOffsetExtensionId, kAbsoluteSendTimeExtensionId,
+    kTransportSequenceNumberExtensionId, kAudioLevelExtensionId,
+    kVideoRotationExtensionId};
 const RTPExtensionType kExtensionTypes[] = {
     RTPExtensionType::kRtpExtensionTransmissionTimeOffset,
+    RTPExtensionType::kRtpExtensionAbsoluteSendTime,
+    RTPExtensionType::kRtpExtensionTransportSequenceNumber,
     RTPExtensionType::kRtpExtensionAudioLevel,
-    RTPExtensionType::kRtpExtensionAbsoluteSendTime,
-    RTPExtensionType::kRtpExtensionVideoRotation,
-    RTPExtensionType::kRtpExtensionTransportSequenceNumber};
+    RTPExtensionType::kRtpExtensionVideoRotation};
 const char* kExtensionNames[] = {
-    RtpExtension::kTimestampOffsetUri, RtpExtension::kAudioLevelUri,
-    RtpExtension::kAbsSendTimeUri, RtpExtension::kVideoRotationUri,
-    RtpExtension::kTransportSequenceNumberUri};
+    RtpExtension::kTimestampOffsetUri, RtpExtension::kAbsSendTimeUri,
+    RtpExtension::kTransportSequenceNumberUri, RtpExtension::kAudioLevelUri,
+    RtpExtension::kVideoRotationUri};
+
 const size_t kNumExtensions = 5;
 
-void PrintActualEvents(const ParsedRtcEventLog& parsed_log) {
-  std::map<int, size_t> actual_event_counts;
-  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
-    actual_event_counts[parsed_log.GetEventType(i)]++;
-  }
-  printf("Actual events: ");
-  for (auto kv : actual_event_counts) {
-    printf("%d_count = %zu, ", kv.first, kv.second);
-  }
-  printf("\n");
-  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
-    printf("%4d ", parsed_log.GetEventType(i));
-  }
-  printf("\n");
-}
+struct BweLossEvent {
+  int32_t bitrate_bps;
+  uint8_t fraction_loss;
+  int32_t total_packets;
+};
 
-void PrintExpectedEvents(size_t rtp_count,
-                         size_t rtcp_count,
-                         size_t playout_count,
-                         size_t bwe_loss_count) {
-  printf(
-      "Expected events: rtp_count = %zu, rtcp_count = %zu,"
-      "playout_count = %zu, bwe_loss_count = %zu\n",
-      rtp_count, rtcp_count, playout_count, bwe_loss_count);
-  size_t rtcp_index = 1, playout_index = 1, bwe_loss_index = 1;
-  printf("strt  cfg  cfg ");
-  for (size_t i = 1; i <= rtp_count; i++) {
-    printf(" rtp ");
-    if (i * rtcp_count >= rtcp_index * rtp_count) {
-      printf("rtcp ");
-      rtcp_index++;
-    }
-    if (i * playout_count >= playout_index * rtp_count) {
-      printf("play ");
-      playout_index++;
-    }
-    if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
-      printf("loss ");
-      bwe_loss_index++;
-    }
-  }
-  printf("end \n");
-}
 }  // namespace
 
-/*
- * 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.
- */
-RtpPacketToSend GenerateRtpPacket(const RtpHeaderExtensionMap* extensions,
-                                  uint32_t csrcs_count,
-                                  size_t packet_size,
-                                  Random* prng) {
+RtpPacketToSend GenerateOutgoingRtpPacket(
+    const RtpHeaderExtensionMap* extensions,
+    uint32_t csrcs_count,
+    size_t packet_size,
+    Random* prng) {
   RTC_CHECK_GE(packet_size, 16 + 4 * csrcs_count + 4 * kNumExtensions);
 
   std::vector<uint32_t> csrcs;
   for (unsigned i = 0; i < csrcs_count; i++) {
     csrcs.push_back(prng->Rand<uint32_t>());
   }
 
   RtpPacketToSend rtp_packet(extensions, packet_size);
   rtp_packet.SetPayloadType(prng->Rand(127));
   rtp_packet.SetMarker(prng->Rand<bool>());
   rtp_packet.SetSequenceNumber(prng->Rand<uint16_t>());
   rtp_packet.SetSsrc(prng->Rand<uint32_t>());
   rtp_packet.SetTimestamp(prng->Rand<uint32_t>());
   rtp_packet.SetCsrcs(csrcs);
 
   rtp_packet.SetExtension<TransmissionOffset>(prng->Rand(0x00ffffff));
   rtp_packet.SetExtension<AudioLevel>(prng->Rand<bool>(), prng->Rand(127));
   rtp_packet.SetExtension<AbsoluteSendTime>(prng->Rand(0x00ffffff));
   rtp_packet.SetExtension<VideoOrientation>(prng->Rand(2));
   rtp_packet.SetExtension<TransportSequenceNumber>(prng->Rand<uint16_t>());
 
   size_t payload_size = packet_size - rtp_packet.headers_size();
   uint8_t* payload = rtp_packet.AllocatePayload(payload_size);
   for (size_t i = 0; i < payload_size; i++) {
     payload[i] = prng->Rand<uint8_t>();
   }
   return rtp_packet;
 }
 
+RtpPacketReceived GenerateIncomingRtpPacket(
+    const RtpHeaderExtensionMap* extensions,
+    uint32_t csrcs_count,
+    size_t packet_size,
+    Random* prng) {
+  RtpPacketToSend packet_out =
+      GenerateOutgoingRtpPacket(extensions, csrcs_count, packet_size, prng);
+  RtpPacketReceived packet_in(extensions);
+  packet_in.Parse(packet_out.data(), packet_out.size());
+  return packet_in;
+}
+
 rtc::Buffer GenerateRtcpPacket(Random* prng) {
   rtcp::ReportBlock report_block;
   report_block.SetMediaSsrc(prng->Rand<uint32_t>());  // Remote SSRC.
   report_block.SetFractionLost(prng->Rand(50));
 
   rtcp::SenderReport sender_report;
   sender_report.SetSenderSsrc(prng->Rand<uint32_t>());
   sender_report.SetNtp(NtpTime(prng->Rand<uint32_t>(), prng->Rand<uint32_t>()));
   sender_report.SetPacketCount(prng->Rand<uint32_t>());
   sender_report.AddReportBlock(report_block);
 
   return sender_report.Build();
 }
 
-void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
+void GenerateVideoReceiveConfig(const RtpHeaderExtensionMap& extensions,
                                 rtclog::StreamConfig* config,
                                 Random* prng) {
   // Add SSRCs for the stream.
   config->remote_ssrc = prng->Rand<uint32_t>();
   config->local_ssrc = prng->Rand<uint32_t>();
   // Add extensions and settings for RTCP.
   config->rtcp_mode =
       prng->Rand<bool>() ? RtcpMode::kCompound : RtcpMode::kReducedSize;
   config->remb = prng->Rand<bool>();
   config->rtx_ssrc = prng->Rand<uint32_t>();
   config->codecs.emplace_back(prng->Rand<bool>() ? "VP8" : "H264",
                               prng->Rand(1, 127), prng->Rand(1, 127));
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
-    if (extensions_bitvector & (1u << i)) {
-      config->rtp_extensions.emplace_back(kExtensionNames[i],
-                                          prng->Rand<int>());
+    uint8_t id = extensions.GetId(kExtensionTypes[i]);
+    if (id != RtpHeaderExtensionMap::kInvalidId) {
+      config->rtp_extensions.emplace_back(kExtensionNames[i], id);
     }
   }
 }
 
-void GenerateVideoSendConfig(uint32_t extensions_bitvector,
+void GenerateVideoSendConfig(const RtpHeaderExtensionMap& extensions,
                              rtclog::StreamConfig* config,
                              Random* prng) {
   config->codecs.emplace_back(prng->Rand<bool>() ? "VP8" : "H264",
                               prng->Rand(1, 127), prng->Rand(1, 127));
   config->local_ssrc = prng->Rand<uint32_t>();
   config->rtx_ssrc = prng->Rand<uint32_t>();
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
-    if (extensions_bitvector & (1u << i)) {
-      config->rtp_extensions.push_back(
-          RtpExtension(kExtensionNames[i], prng->Rand<int>()));
+    uint8_t id = extensions.GetId(kExtensionTypes[i]);
+    if (id != RtpHeaderExtensionMap::kInvalidId) {
+      config->rtp_extensions.emplace_back(kExtensionNames[i], id);
     }
   }
 }
 
-void GenerateAudioReceiveConfig(uint32_t extensions_bitvector,
+void GenerateAudioReceiveConfig(const RtpHeaderExtensionMap& extensions,
                                 rtclog::StreamConfig* config,
                                 Random* prng) {
   // Add SSRCs for the stream.
   config->remote_ssrc = prng->Rand<uint32_t>();
   config->local_ssrc = prng->Rand<uint32_t>();
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
-    if (extensions_bitvector & (1u << i)) {
-      config->rtp_extensions.push_back(
-          RtpExtension(kExtensionNames[i], prng->Rand<int>()));
+    uint8_t id = extensions.GetId(kExtensionTypes[i]);
+    if (id != RtpHeaderExtensionMap::kInvalidId) {
+      config->rtp_extensions.emplace_back(kExtensionNames[i], id);
     }
   }
 }
 
-void GenerateAudioSendConfig(uint32_t extensions_bitvector,
+void GenerateAudioSendConfig(const RtpHeaderExtensionMap& extensions,
                              rtclog::StreamConfig* config,
                              Random* prng) {
   // Add SSRC to the stream.
   config->local_ssrc = prng->Rand<uint32_t>();
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
-    if (extensions_bitvector & (1u << i)) {
-      config->rtp_extensions.push_back(
-          RtpExtension(kExtensionNames[i], prng->Rand<int>()));
+    uint8_t id = extensions.GetId(kExtensionTypes[i]);
+    if (id != RtpHeaderExtensionMap::kInvalidId) {
+      config->rtp_extensions.emplace_back(kExtensionNames[i], id);
     }
   }
 }
 
-void GenerateAudioNetworkAdaptation(uint32_t extensions_bitvector,
+BweLossEvent GenerateBweLossEvent(Random* prng) {
+  BweLossEvent loss_event;
+  loss_event.bitrate_bps = prng->Rand(6000, 10000000);
+  loss_event.fraction_loss = prng->Rand<uint8_t>();
+  loss_event.total_packets = prng->Rand(1, 1000);
+  return loss_event;
+}
+
+void GenerateAudioNetworkAdaptation(const RtpHeaderExtensionMap& extensions,
                                     AudioEncoderRuntimeConfig* config,
                                     Random* prng) {
   config->bitrate_bps = rtc::Optional<int>(prng->Rand(0, 3000000));
   config->enable_fec = rtc::Optional<bool>(prng->Rand<bool>());
   config->enable_dtx = rtc::Optional<bool>(prng->Rand<bool>());
   config->frame_length_ms = rtc::Optional<int>(prng->Rand(10, 120));
   config->num_channels = rtc::Optional<size_t>(prng->Rand(1, 2));
   config->uplink_packet_loss_fraction =
       rtc::Optional<float>(prng->Rand<float>());
 }
 
 // Test for the RtcEventLog class. Dumps some RTP packets and other events
 // to disk, then reads them back to see if they match.
-void LogSessionAndReadBack(size_t rtp_count,
-                           size_t rtcp_count,
+void LogSessionAndReadBack(size_t incoming_rtp_count,

[eladalon, 2017/09/05 11:57:01]

IMHO, it would be good to break this function down, since it's too big. I would
suggest having separate functions for randomly generating a session, for writing
it to a file and for reading it back from a file. (State would have to be kept
in between, but everything would be clearer, I think.)

[terelius, 2017/09/07 12:53:55]

Done. Created a class SessionDescription that keeps the actual events and the
order they are written. Split this function into one for generation, one for
writing and one for reading/verifying. Added back functions (equivalent to)
PrintActualEvents and PrintExpectedEvents as discussed offline.

+                           size_t outgoing_rtp_count,
+                           size_t incoming_rtcp_count,
+                           size_t outgoing_rtcp_count,
                            size_t playout_count,
                            size_t bwe_loss_count,
-                           uint32_t extensions_bitvector,
+                           size_t bwe_delay_count,
+                           const RtpHeaderExtensionMap& extensions,
                            uint32_t csrcs_count,
                            unsigned int random_seed) {
-  ASSERT_LE(rtcp_count, rtp_count);
-  ASSERT_LE(playout_count, rtp_count);
-  ASSERT_LE(bwe_loss_count, rtp_count);
-  std::vector<RtpPacketToSend> rtp_packets;
-  std::vector<rtc::Buffer> rtcp_packets;
+  std::vector<RtpPacketReceived> incoming_rtp_packets;
+  std::vector<RtpPacketToSend> outgoing_rtp_packets;
+  std::vector<rtc::Buffer> incoming_rtcp_packets;
+  std::vector<rtc::Buffer> outgoing_rtcp_packets;
   std::vector<uint32_t> playout_ssrcs;
-  std::vector<std::pair<int32_t, uint8_t> > bwe_loss_updates;
+  std::vector<BweLossEvent> bwe_loss_updates;
+  std::vector<std::pair<int32_t, BandwidthUsage> > bwe_delay_updates;
 
   rtclog::StreamConfig receiver_config;
   rtclog::StreamConfig sender_config;
 
-  Random prng(random_seed);
-
-  // Initialize rtp header extensions to be used in generated rtp packets.
-  RtpHeaderExtensionMap extensions;
-  for (unsigned i = 0; i < kNumExtensions; i++) {
-    if (extensions_bitvector & (1u << i)) {
-      extensions.Register(kExtensionTypes[i], i + 1);
+  {
+    Random prng(random_seed);
+    // Create incoming and outgoing RTP packets containing random data.
+    for (size_t i = 0; i < incoming_rtp_count; i++) {
+      size_t packet_size = prng.Rand(1000, 1100);
+      incoming_rtp_packets.push_back(GenerateIncomingRtpPacket(
+          &extensions, csrcs_count, packet_size, &prng));
     }
+    for (size_t i = 0; i < outgoing_rtp_count; i++) {
+      size_t packet_size = prng.Rand(1000, 1100);
+      outgoing_rtp_packets.push_back(GenerateOutgoingRtpPacket(
+          &extensions, csrcs_count, packet_size, &prng));
+    }
+    // Create incoming and outgoing RTCP packets containing random data.
+    for (size_t i = 0; i < incoming_rtcp_count; i++) {
+      incoming_rtcp_packets.push_back(GenerateRtcpPacket(&prng));
+    }
+    for (size_t i = 0; i < outgoing_rtcp_count; i++) {
+      outgoing_rtcp_packets.push_back(GenerateRtcpPacket(&prng));
+    }
+    // Create random SSRCs to use when logging AudioPlayout events.
+    for (size_t i = 0; i < playout_count; i++) {
+      playout_ssrcs.push_back(prng.Rand<uint32_t>());
+    }
+    // Create random bitrate updates for LossBasedBwe.
+    for (size_t i = 0; i < bwe_loss_count; i++) {
+      bwe_loss_updates.push_back(GenerateBweLossEvent(&prng));
+    }
+    // Create random bitrate updates for DelayBasedBwe.
+    for (size_t i = 0; i < bwe_delay_count; i++) {
+      bwe_delay_updates.push_back(std::make_pair(
+          prng.Rand(6000, 10000000), prng.Rand<bool>()
+                                         ? BandwidthUsage::kBwOverusing
+                                         : BandwidthUsage::kBwUnderusing));
+    }
+    // Create configurations for the video streams.
+    GenerateVideoReceiveConfig(extensions, &receiver_config, &prng);
+    GenerateVideoSendConfig(extensions, &sender_config, &prng);
   }
-  // Create rtp_count RTP packets containing random data.
-  for (size_t i = 0; i < rtp_count; i++) {
-    size_t packet_size = prng.Rand(1000, 1100);
-    rtp_packets.push_back(
-        GenerateRtpPacket(&extensions, csrcs_count, packet_size, &prng));
-  }
-  // Create rtcp_count RTCP packets containing random data.
-  for (size_t i = 0; i < rtcp_count; i++) {
-    rtcp_packets.push_back(GenerateRtcpPacket(&prng));
-  }
-  // Create playout_count random SSRCs to use when logging AudioPlayout events.
-  for (size_t i = 0; i < playout_count; i++) {
-    playout_ssrcs.push_back(prng.Rand<uint32_t>());
-  }
-  // Create bwe_loss_count random bitrate updates for LossBasedBwe.
-  for (size_t i = 0; i < bwe_loss_count; i++) {
-    bwe_loss_updates.push_back(
-        std::make_pair(prng.Rand<int32_t>(), prng.Rand<uint8_t>()));
-  }
-  // Create configurations for the video streams.
-  GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config, &prng);
-  GenerateVideoSendConfig(extensions_bitvector, &sender_config, &prng);
-  const int config_count = 2;
 
   // Find the name of the current test, in order to use it as a temporary
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // When log_dumper goes out of scope, it causes the log file to be flushed
   // to disk.
   {
+    Random prng(random_seed);
     rtc::ScopedFakeClock fake_clock;
     fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
     std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
     log_dumper->LogVideoReceiveStreamConfig(receiver_config);
     fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
     log_dumper->LogVideoSendStreamConfig(sender_config);
+    size_t events_remaining = incoming_rtp_count + outgoing_rtp_count +
+                              incoming_rtcp_count + outgoing_rtcp_count +
+                              playout_count + bwe_loss_count + bwe_delay_count;
+    size_t remaining_incoming_rtp = incoming_rtp_count;
+    size_t remaining_outgoing_rtp = outgoing_rtp_count;
+    size_t remaining_incoming_rtcp = incoming_rtcp_count;
+    size_t remaining_outgoing_rtcp = outgoing_rtcp_count;
+    size_t remaining_playouts = playout_count;
+    size_t remaining_bwe_loss = bwe_loss_count;
+    size_t remaining_bwe_delay = bwe_delay_count;
+    for (; events_remaining; events_remaining--) {
+      fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
+      if (events_remaining == (incoming_rtp_count + outgoing_rtp_count) / 2) {
+        log_dumper->StartLogging(temp_filename, 10000000);
+      }
+      size_t event_type = prng.Rand(0u, events_remaining - 1);
+      if (event_type < remaining_incoming_rtp) {
+        log_dumper->LogIncomingRtpHeader(
+            incoming_rtp_packets[remaining_incoming_rtp - 1]);
+        remaining_incoming_rtp--;
+        continue;
+      }
+      event_type -= remaining_incoming_rtp;
+      if (event_type < remaining_outgoing_rtp) {
+        log_dumper->LogOutgoingRtpHeader(
+            outgoing_rtp_packets[remaining_outgoing_rtp - 1],
+            PacedPacketInfo::kNotAProbe);
+        remaining_outgoing_rtp--;
+        continue;
+      }
+      event_type -= remaining_outgoing_rtp;
+      if (event_type < remaining_incoming_rtcp) {
+        log_dumper->LogIncomingRtcpPacket(rtc::ArrayView<const uint8_t>(

[danilchap, 2017/09/05 08:47:16]

suggestion:
log_dumper->LogIncomingRtcpPacket(incoming_rtcp_packets[--remaining_incoming_rtcp]);

[terelius, 2017/09/07 12:53:55]

Done.

+            incoming_rtcp_packets[remaining_incoming_rtcp - 1].data(),
+            incoming_rtcp_packets[remaining_incoming_rtcp - 1].size()));
+        remaining_incoming_rtcp--;
+        continue;
+      }
+      event_type -= remaining_incoming_rtcp;
+      if (event_type < remaining_outgoing_rtcp) {
+        log_dumper->LogOutgoingRtcpPacket(rtc::ArrayView<const uint8_t>(
+            outgoing_rtcp_packets[remaining_outgoing_rtcp - 1].data(),
+            outgoing_rtcp_packets[remaining_outgoing_rtcp - 1].size()));
+        remaining_outgoing_rtcp--;
+        continue;
+      }
+      event_type -= remaining_outgoing_rtcp;
+      if (event_type < remaining_playouts) {
+        log_dumper->LogAudioPlayout(playout_ssrcs[remaining_playouts - 1]);
+        remaining_playouts--;
+        continue;
+      }
+      event_type -= remaining_playouts;
+      if (event_type < remaining_bwe_loss) {
+        log_dumper->LogLossBasedBweUpdate(
+            bwe_loss_updates[remaining_bwe_loss - 1].bitrate_bps,
+            bwe_loss_updates[remaining_bwe_loss - 1].fraction_loss,
+            bwe_loss_updates[remaining_bwe_loss - 1].total_packets);
+        remaining_bwe_loss--;
+        continue;
+      }
+      event_type -= remaining_bwe_loss;
+      if (event_type < remaining_bwe_delay) {
+        log_dumper->LogDelayBasedBweUpdate(
+            bwe_delay_updates[remaining_bwe_delay - 1].first,
+            bwe_delay_updates[remaining_bwe_delay - 1].second);
+        remaining_bwe_delay--;
+        continue;
+      }
+      event_type -= remaining_bwe_delay;
+      RTC_NOTREACHED();
+    }
+    log_dumper->StopLogging();
+  }
+
+  // Read the file and verify that what we read back from the event log is the
+  // same as what we wrote down.
+  {
+    // Read the generated file from disk.
+    ParsedRtcEventLog parsed_log;
+    ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
+    const int config_count = 2;
+    const size_t event_count = config_count + incoming_rtp_count +
+                               outgoing_rtp_count + incoming_rtcp_count +
+                               outgoing_rtcp_count + playout_count +
+                               bwe_loss_count + bwe_delay_count + 2;
+    EXPECT_GE(1000u, event_count);  // The events must fit in the message queue.
+    EXPECT_EQ(event_count, parsed_log.GetNumberOfEvents());
+
+    Random prng(random_seed);
+    rtc::ScopedFakeClock fake_clock;
+    fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
+    RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
+    RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, 1,
+                                                          receiver_config);
     fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-    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++) {
-      log_dumper->LogRtpHeader(
-          (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
-          rtp_packets[i - 1].data(), rtp_packets[i - 1].size());
+    RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, 2,
+                                                       sender_config);
+    size_t events_remaining = incoming_rtp_count + outgoing_rtp_count +
+                              incoming_rtcp_count + outgoing_rtcp_count +
+                              playout_count + bwe_loss_count + bwe_delay_count;
+    size_t remaining_incoming_rtp = incoming_rtp_count;
+    size_t remaining_outgoing_rtp = outgoing_rtp_count;
+    size_t remaining_incoming_rtcp = incoming_rtcp_count;
+    size_t remaining_outgoing_rtcp = outgoing_rtcp_count;
+    size_t remaining_playouts = playout_count;
+    size_t remaining_bwe_loss = bwe_loss_count;
+    size_t remaining_bwe_delay = bwe_delay_count;
+    for (; events_remaining; events_remaining--) {
       fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-      if (i * rtcp_count >= rtcp_index * rtp_count) {
-        log_dumper->LogRtcpPacket(
-            (rtcp_index % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
-            rtcp_packets[rtcp_index - 1].data(),
-            rtcp_packets[rtcp_index - 1].size());
-        rtcp_index++;
-        fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-      }
-      if (i * playout_count >= playout_index * rtp_count) {
-        log_dumper->LogAudioPlayout(playout_ssrcs[playout_index - 1]);
-        playout_index++;
-        fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-      }
-      if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
-        log_dumper->LogLossBasedBweUpdate(
-            bwe_loss_updates[bwe_loss_index - 1].first,
-            bwe_loss_updates[bwe_loss_index - 1].second, i);
-        bwe_loss_index++;
-        fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-      }
-      if (i == rtp_count / 2) {
-        log_dumper->StartLogging(temp_filename, 10000000);
-        fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-      }
-    }
-    log_dumper->StopLogging();
-  }
-
-  // Read the generated file from disk.
-  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 down. For RTCP we log the full packets, but for
-  // RTP we should only log the header.
-  const size_t event_count = config_count + playout_count + bwe_loss_count +
-                             rtcp_count + rtp_count + 2;
-  EXPECT_GE(1000u, event_count);  // The events must fit in the message queue.
-  EXPECT_EQ(event_count, parsed_log.GetNumberOfEvents());
-  if (event_count != parsed_log.GetNumberOfEvents()) {
-    // Print the expected and actual event types for easier debugging.
-    PrintActualEvents(parsed_log);
-    PrintExpectedEvents(rtp_count, rtcp_count, playout_count, bwe_loss_count);
-  }
-  RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
-  RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, 1,
-                                                        receiver_config);
-  RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, 2,
-                                                     sender_config);
-  size_t event_index = config_count + 1;
-  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++) {
-    RtcEventLogTestHelper::VerifyRtpEvent(
-        parsed_log, event_index,
-        (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
-        rtp_packets[i - 1].data(), rtp_packets[i - 1].headers_size(),
-        rtp_packets[i - 1].size());
-    event_index++;
-    if (i * rtcp_count >= rtcp_index * rtp_count) {
-      RtcEventLogTestHelper::VerifyRtcpEvent(
-          parsed_log, event_index,
-          rtcp_index % 2 == 0 ? kIncomingPacket : kOutgoingPacket,
-          rtcp_packets[rtcp_index - 1].data(),
-          rtcp_packets[rtcp_index - 1].size());
-      event_index++;
-      rtcp_index++;
-    }
-    if (i * playout_count >= playout_index * rtp_count) {
-      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) {
-      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++;
-    }
-  }
-
-  // Clean up temporary file - can be pretty slow.
-  remove(temp_filename.c_str());
+      size_t event_type = prng.Rand(0u, events_remaining - 1);
+      if (event_type < remaining_incoming_rtp) {
+        RtcEventLogTestHelper::VerifyRtpEvent(
+            parsed_log, event_count - events_remaining - 1, kIncomingPacket,
+            incoming_rtp_packets[remaining_incoming_rtp - 1]);
+        remaining_incoming_rtp--;
+        continue;
+      }
+      event_type -= remaining_incoming_rtp;
+      if (event_type < remaining_outgoing_rtp) {
+        RtcEventLogTestHelper::VerifyRtpEvent(
+            parsed_log, event_count - events_remaining - 1, kOutgoingPacket,
+            outgoing_rtp_packets[remaining_outgoing_rtp - 1]);
+        remaining_outgoing_rtp--;
+        continue;
+      }
+      event_type -= remaining_outgoing_rtp;
+      if (event_type < remaining_incoming_rtcp) {
+        RtcEventLogTestHelper::VerifyRtcpEvent(
+            parsed_log, event_count - events_remaining - 1, kIncomingPacket,
+            incoming_rtcp_packets[remaining_incoming_rtcp - 1].data(),
+            incoming_rtcp_packets[remaining_incoming_rtcp - 1].size());
+        remaining_incoming_rtcp--;
+        continue;
+      }
+      event_type -= remaining_incoming_rtcp;
+      if (event_type < remaining_outgoing_rtcp) {
+        RtcEventLogTestHelper::VerifyRtcpEvent(
+            parsed_log, event_count - events_remaining - 1, kOutgoingPacket,
+            outgoing_rtcp_packets[remaining_outgoing_rtcp - 1].data(),
+            outgoing_rtcp_packets[remaining_outgoing_rtcp - 1].size());
+        remaining_outgoing_rtcp--;
+        continue;
+      }
+      event_type -= remaining_outgoing_rtcp;
+      if (event_type < remaining_playouts) {
+        RtcEventLogTestHelper::VerifyPlayoutEvent(
+            parsed_log, event_count - events_remaining - 1,
+            playout_ssrcs[remaining_playouts - 1]);
+        remaining_playouts--;
+        continue;
+      }
+      event_type -= remaining_playouts;
+      if (event_type < remaining_bwe_loss) {
+        RtcEventLogTestHelper::VerifyBweLossEvent(
+            parsed_log, event_count - events_remaining - 1,
+            bwe_loss_updates[remaining_bwe_loss - 1].bitrate_bps,
+            bwe_loss_updates[remaining_bwe_loss - 1].fraction_loss,
+            bwe_loss_updates[remaining_bwe_loss - 1].total_packets);
+        remaining_bwe_loss--;
+        continue;
+      }
+      event_type -= remaining_bwe_loss;
+      if (event_type < remaining_bwe_delay) {
+        RtcEventLogTestHelper::VerifyBweDelayEvent(
+            parsed_log, event_count - events_remaining - 1,
+            bwe_delay_updates[remaining_bwe_delay - 1].first,
+            bwe_delay_updates[remaining_bwe_delay - 1].second);
+        remaining_bwe_delay--;
+        continue;
+      }
+      event_type -= remaining_bwe_delay;
+      RTC_NOTREACHED();
+    }
+    RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, event_count - 1);
+
+    // 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
-  // with no header extensions or CSRCS.
-  LogSessionAndReadBack(5, 2, 0, 0, 0, 0, 321);
-
-  // Enable AbsSendTime and TransportSequenceNumbers.
-  uint32_t extensions = 0;
+  RtpHeaderExtensionMap extensions;
+  LogSessionAndReadBack(3,           // Number of incoming RTP packets.

[eladalon, 2017/09/05 11:57:01]

One hack you could employ would be to define enums - NumberOfOutgoingRtpPackets,
NumberOfIngoingRtpPackets, etc. - and have the function accept them. This way
you get self-documentation that can't become outdates, as a comment would be if
things get shifted around. I am not sure if this would be overkill, though, or
purely against the coding style.

[terelius, 2017/09/07 12:53:55]

Seems like overkill imo.

+                        2,           // Number of outgoing RTP packets.
+                        1,           // Number of incoming RTCP packets.
+                        1,           // Number of outgoing RTCP packets.
+                        0,           // Number of playout events.
+                        0,           // Number of BWE loss events.
+                        0,           // Number of BWE delay events.
+                        extensions,  // No extensions.
+                        0,           // Number of contributing sources.
+                        321);        // Random seed.
+}
+
+TEST(RtcEventLogTest, LogSessionAndReadBackWith2Extensions) {
+  RtpHeaderExtensionMap extensions;
+  extensions.Register(kRtpExtensionAbsoluteSendTime,
+                      kAbsoluteSendTimeExtensionId);
+  extensions.Register(kRtpExtensionTransportSequenceNumber,
+                      kTransportSequenceNumberExtensionId);
+  LogSessionAndReadBack(4, 4, 1, 1, 0, 0, 0, extensions, 0, 3141592653u);
+}
+
+TEST(RtcEventLogTest, LogSessionAndReadBackWithAllExtensions) {
+  RtpHeaderExtensionMap extensions;
   for (uint32_t i = 0; i < kNumExtensions; i++) {
-    if (kExtensionTypes[i] == RTPExtensionType::kRtpExtensionAbsoluteSendTime ||
-        kExtensionTypes[i] ==
-            RTPExtensionType::kRtpExtensionTransportSequenceNumber) {
-      extensions |= 1u << i;
-    }
-  }
-  LogSessionAndReadBack(8, 2, 0, 0, extensions, 0, 3141592653u);
-
-  extensions = (1u << kNumExtensions) - 1;  // Enable all header extensions.
-  LogSessionAndReadBack(9, 2, 3, 2, extensions, 2, 2718281828u);
-
+    extensions.Register(kExtensionTypes[i], kExtensionIds[i]);
+  }
+  LogSessionAndReadBack(5, 4, 1, 1, 3, 2, 2, extensions, 2, 2718281828u);
+}
+
+TEST(RtcEventLogTest, LogSessionAndReadBackAllCombinations) {
   // Try all combinations of header extensions and up to 2 CSRCS.
-  for (extensions = 0; extensions < (1u << kNumExtensions); extensions++) {
+  for (uint32_t extension_selection = 0;
+       extension_selection < (1u << kNumExtensions); extension_selection++) {
+    RtpHeaderExtensionMap extensions;
+    for (uint32_t i = 0; i < kNumExtensions; i++) {
+      if (extension_selection & (1u << i)) {
+        extensions.Register(kExtensionTypes[i], kExtensionIds[i]);
+      }
+    }
     for (uint32_t csrcs_count = 0; csrcs_count < 3; csrcs_count++) {
-      LogSessionAndReadBack(5 + extensions,   // Number of RTP packets.
-                            2 + csrcs_count,  // Number of RTCP packets.
-                            3 + csrcs_count,  // Number of playout events.
-                            1 + csrcs_count,  // Number of BWE loss events.
-                            extensions,       // Bit vector choosing extensions.
-                            csrcs_count,      // Number of contributing sources.
-                            extensions * 3 + csrcs_count + 1);  // Random seed.
-    }
-  }
-}
+      LogSessionAndReadBack(
+          2 + extension_selection,  // Number of incoming RTP packets.
+          2 + extension_selection,  // Number of outgoing RTP packets.
+          1 + csrcs_count,          // Number of incoming RTCP packets.
+          1 + csrcs_count,          // Number of outgoing RTCP packets.
+          3 + csrcs_count,          // Number of playout events.
+          1 + csrcs_count,          // Number of BWE loss events.
+          2 + csrcs_count,          // Number of BWE delay events.
+          extensions,               // Bit vector choosing extensions.
+          csrcs_count,              // Number of contributing sources.
+          extension_selection * 3 + csrcs_count + 1);  // Random seed.
+    }
+  }
+}
 
 TEST(RtcEventLogTest, LogEventAndReadBack) {
   Random prng(987654321);
 
   // Create one RTP and one RTCP packet containing random data.
   size_t packet_size = prng.Rand(1000, 1100);
-  RtpPacketToSend rtp_packet =
-      GenerateRtpPacket(nullptr, 0, packet_size, &prng);
+  RtpPacketReceived rtp_packet =
+      GenerateIncomingRtpPacket(nullptr, 0, packet_size, &prng);
   rtc::Buffer rtcp_packet = GenerateRtcpPacket(&prng);
 
   // Find the name of the current test, in order to use it as a temporary
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // Add RTP, start logging, add RTCP and then stop logging
   rtc::ScopedFakeClock fake_clock;
   fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
   std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
 
-  log_dumper->LogRtpHeader(kIncomingPacket, rtp_packet.data(),
-                           rtp_packet.size());
+  log_dumper->LogIncomingRtpHeader(rtp_packet);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
 
   log_dumper->StartLogging(temp_filename, 10000000);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
 
-  log_dumper->LogRtcpPacket(kOutgoingPacket, rtcp_packet.data(),
-                            rtcp_packet.size());
+  log_dumper->LogOutgoingRtcpPacket(
+      rtc::ArrayView<const uint8_t>(rtcp_packet.data(), rtcp_packet.size()));

[danilchap, 2017/09/05 08:47:16]

rtc::Buffer is implicitly convertable to rtc::ArrayView, so you should be able
to write just
log_dumper->LogOutgoingRtcpPacket(rtcp_packet);

[terelius, 2017/09/07 12:53:55]

Done.

   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
 
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   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 down.
@@ skipping 241 matching lines @@
   RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 4);
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
 class ConfigReadWriteTest {
  public:
   ConfigReadWriteTest() : prng(987654321) {}
   virtual ~ConfigReadWriteTest() {}
-  virtual void GenerateConfig(uint32_t extensions_bitvector) = 0;
+  virtual void GenerateConfig(const RtpHeaderExtensionMap& extensions) = 0;
   virtual void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                             size_t index) = 0;
   virtual void LogConfig(RtcEventLog* event_log) = 0;
 
   void DoTest() {
     // Find the name of the current test, in order to use it as a temporary
     // filename.
     auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
     const std::string temp_filename =
         test::OutputPath() + test_info->test_case_name() + test_info->name();
 
     // Use all extensions.
-    uint32_t extensions_bitvector = (1u << kNumExtensions) - 1;
-    GenerateConfig(extensions_bitvector);
+    RtpHeaderExtensionMap extensions;
+    for (uint32_t i = 0; i < kNumExtensions; i++) {
+      extensions.Register(kExtensionTypes[i], kExtensionIds[i]);
+    }
+    GenerateConfig(extensions);
 
     // Log a single config event and stop logging.
     rtc::ScopedFakeClock fake_clock;
     fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
     std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
 
     log_dumper->StartLogging(temp_filename, 10000000);
     LogConfig(log_dumper.get());
     log_dumper->StopLogging();
 
@@ skipping 12 matching lines @@
     RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 2);
 
     // Clean up temporary file - can be pretty slow.
     remove(temp_filename.c_str());
   }
   Random prng;
 };
 
 class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest {
  public:
-  void GenerateConfig(uint32_t extensions_bitvector) override {
-    GenerateAudioReceiveConfig(extensions_bitvector, &config, &prng);
+  void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+    GenerateAudioReceiveConfig(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
     event_log->LogAudioReceiveStreamConfig(config);
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(parsed_log, index,
                                                           config);
   }
   rtclog::StreamConfig config;
 };
 
 class AudioSendConfigReadWriteTest : public ConfigReadWriteTest {
  public:
   AudioSendConfigReadWriteTest() {}
-  void GenerateConfig(uint32_t extensions_bitvector) override {
-    GenerateAudioSendConfig(extensions_bitvector, &config, &prng);
+  void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+    GenerateAudioSendConfig(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
     event_log->LogAudioSendStreamConfig(config);
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyAudioSendStreamConfig(parsed_log, index,
                                                        config);
   }
   rtclog::StreamConfig config;
 };
 
 class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest {
  public:
   VideoReceiveConfigReadWriteTest() {}
-  void GenerateConfig(uint32_t extensions_bitvector) override {
-    GenerateVideoReceiveConfig(extensions_bitvector, &config, &prng);
+  void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+    GenerateVideoReceiveConfig(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
     event_log->LogVideoReceiveStreamConfig(config);
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, index,
                                                           config);
   }
   rtclog::StreamConfig config;
 };
 
 class VideoSendConfigReadWriteTest : public ConfigReadWriteTest {
  public:
   VideoSendConfigReadWriteTest() {}
-  void GenerateConfig(uint32_t extensions_bitvector) override {
-    GenerateVideoSendConfig(extensions_bitvector, &config, &prng);
+  void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+    GenerateVideoSendConfig(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
     event_log->LogVideoSendStreamConfig(config);
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, index,
                                                        config);
   }
   rtclog::StreamConfig config;
 };
 
 class AudioNetworkAdaptationReadWriteTest : public ConfigReadWriteTest {
  public:
-  void GenerateConfig(uint32_t extensions_bitvector) override {
-    GenerateAudioNetworkAdaptation(extensions_bitvector, &config, &prng);
+  void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+    GenerateAudioNetworkAdaptation(extensions, &config, &prng);
   }
   void LogConfig(RtcEventLog* event_log) override {
     event_log->LogAudioNetworkAdaptation(config);
   }
   void VerifyConfig(const ParsedRtcEventLog& parsed_log,
                     size_t index) override {
     RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(parsed_log, index,
                                                         config);
   }
   AudioEncoderRuntimeConfig config;
@@ skipping 18 matching lines @@
   VideoSendConfigReadWriteTest test;
   test.DoTest();
 }
 
 TEST(RtcEventLogTest, LogAudioNetworkAdaptation) {
   AudioNetworkAdaptationReadWriteTest test;
   test.DoTest();
 }
 
 }  // namespace webrtc