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/ptr_util.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,
-                           size_t playout_count,
-                           size_t bwe_loss_count,
-                           uint32_t extensions_bitvector,
-                           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;
+// TODO(terelius): Merge with event type in parser once updated?
+enum class EventType {
+  INCOMING_RTP = 1,

[eladalon, 2017/09/07 13:41:28]

1. Assigning the numbers manually runs the risk of assigning the same value to
two different names.
2. Assigning beginning with 0 is preferable, as per another suggestion of mine.
3. I think it would be better to use CamelCase for the names as well. Otherwise,
you get CamelCase::UPPERCASE.

+  OUTGOING_RTP = 2,
+  INCOMING_RTCP = 3,
+  OUTGOING_RTCP = 4,
+  AUDIO_PLAYOUT = 5,
+  BWE_LOSS_UPDATE = 6,
+  BWE_DELAY_UPDATE = 7,
+  VIDEO_RECV_CONFIG = 8,
+  VIDEO_SEND_CONFIG = 9,
+  AUDIO_RECV_CONFIG = 10,
+  AUDIO_SEND_CONFIG = 11,
+  AUDIO_NETWORK_ADAPTATION = 12,
+  BWE_PROBE_CLUSTER_CREATED = 13,
+  BWE_PROBE_RESULT = 14,
+};
+
+class SessionDescription {
+ public:
+  explicit SessionDescription(unsigned int random_seed) : prng(random_seed) {}
+  void GenerateSessionDescription(size_t incoming_rtp_count,
+                                  size_t outgoing_rtp_count,
+                                  size_t incoming_rtcp_count,
+                                  size_t outgoing_rtcp_count,
+                                  size_t playout_count,
+                                  size_t bwe_loss_count,
+                                  size_t bwe_delay_count,
+                                  const RtpHeaderExtensionMap& extensions,
+                                  uint32_t csrcs_count);
+  void WriteSession();
+  void ReadAndVerifySession();
+  void PrintExpectedEvents();
+
+ private:
+  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;
-
-  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);
-    }
-  }
-  // Create rtp_count RTP packets containing random data.
-  for (size_t i = 0; i < rtp_count; i++) {
+  std::vector<BweLossEvent> bwe_loss_updates;
+  std::vector<std::pair<int32_t, BandwidthUsage> > bwe_delay_updates;
+  std::vector<rtclog::StreamConfig> receiver_configs;
+  std::vector<rtclog::StreamConfig> sender_configs;
+  std::vector<EventType> event_types;
+  Random prng;
+};
+
+void SessionDescription::GenerateSessionDescription(
+    size_t incoming_rtp_count,
+    size_t outgoing_rtp_count,
+    size_t incoming_rtcp_count,
+    size_t outgoing_rtcp_count,
+    size_t playout_count,
+    size_t bwe_loss_count,
+    size_t bwe_delay_count,
+    const RtpHeaderExtensionMap& extensions,
+    uint32_t csrcs_count) {
+  // Create configuration for the video receive stream.
+  receiver_configs.emplace_back(rtclog::StreamConfig());
+  GenerateVideoReceiveConfig(extensions, &receiver_configs.back(), &prng);
+  event_types.push_back(EventType::VIDEO_RECV_CONFIG);
+
+  // Create configuration for the video send stream.
+  sender_configs.emplace_back(rtclog::StreamConfig());
+  GenerateVideoSendConfig(extensions, &sender_configs.back(), &prng);
+  event_types.push_back(EventType::VIDEO_SEND_CONFIG);
+  const size_t config_count = 2;
+
+  // 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);
-    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.
+    incoming_rtp_packets.push_back(GenerateIncomingRtpPacket(
+        &extensions, csrcs_count, packet_size, &prng));
+    event_types.push_back(EventType::INCOMING_RTP);
+  }
+  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));
+    event_types.push_back(EventType::OUTGOING_RTP);
+  }
+  // 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));
+    event_types.push_back(EventType::INCOMING_RTCP);
+  }
+  for (size_t i = 0; i < outgoing_rtcp_count; i++) {
+    outgoing_rtcp_packets.push_back(GenerateRtcpPacket(&prng));
+    event_types.push_back(EventType::OUTGOING_RTCP);
+  }
+  // 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 bwe_loss_count random bitrate updates for LossBasedBwe.
+    event_types.push_back(EventType::AUDIO_PLAYOUT);
+  }
+  // Create 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;
-
+    bwe_loss_updates.push_back(GenerateBweLossEvent(&prng));
+    event_types.push_back(EventType::BWE_LOSS_UPDATE);
+  }
+  // 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));
+    event_types.push_back(EventType::BWE_DELAY_UPDATE);
+  }
+
+  // Order the events randomly. The configurations are stored in a separate
+  // buffer, so they might be written before any othe events. Hence, we can't
+  // mix the config events with other events.
+  for (size_t i = config_count; i < event_types.size(); i++) {
+    size_t other = prng.Rand(static_cast<uint32_t>(i),
+                             static_cast<uint32_t>(event_types.size() - 1));
+    std::swap(event_types[i], event_types[other]);
+  }
+}
+
+void SessionDescription::WriteSession() {
   // 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();
 
+  rtc::ScopedFakeClock fake_clock;
+  fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
+
   // When log_dumper goes out of scope, it causes the log file to be flushed
   // to disk.
-  {
-    rtc::ScopedFakeClock fake_clock;
-    fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
-    std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
-    log_dumper->LogVideoReceiveStreamConfig(receiver_config);
+  std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
+
+  size_t incoming_rtp_written = 0;
+  size_t outgoing_rtp_written = 0;
+  size_t incoming_rtcp_written = 0;
+  size_t outgoing_rtcp_written = 0;
+  size_t playouts_written = 0;
+  size_t bwe_loss_written = 0;
+  size_t bwe_delay_written = 0;
+  size_t recv_configs_written = 0;
+  size_t send_configs_written = 0;
+
+  for (size_t i = 0; i < event_types.size(); i++) {
     fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-    log_dumper->LogVideoSendStreamConfig(sender_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());
-      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) {
+    if (i == event_types.size() / 2)
+      log_dumper->StartLogging(temp_filename, 10000000);
+    switch (event_types[i]) {
+      case EventType::INCOMING_RTP:
+        log_dumper->LogIncomingRtpHeader(
+            incoming_rtp_packets[incoming_rtp_written++]);
+        break;
+      case EventType::OUTGOING_RTP:
+        log_dumper->LogOutgoingRtpHeader(
+            outgoing_rtp_packets[outgoing_rtp_written++],
+            PacedPacketInfo::kNotAProbe);
+        break;
+      case EventType::INCOMING_RTCP:
+        log_dumper->LogIncomingRtcpPacket(
+            incoming_rtcp_packets[incoming_rtcp_written++]);
+        break;
+      case EventType::OUTGOING_RTCP:
+        log_dumper->LogOutgoingRtcpPacket(
+            outgoing_rtcp_packets[outgoing_rtcp_written++]);
+        break;
+      case EventType::AUDIO_PLAYOUT:
+        log_dumper->LogAudioPlayout(playout_ssrcs[playouts_written++]);
+        break;
+      case EventType::BWE_LOSS_UPDATE:
         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();
-  }
+            bwe_loss_updates[bwe_loss_written].bitrate_bps,
+            bwe_loss_updates[bwe_loss_written].fraction_loss,
+            bwe_loss_updates[bwe_loss_written].total_packets);
+        bwe_loss_written++;
+        break;
+      case EventType::BWE_DELAY_UPDATE:
+        log_dumper->LogDelayBasedBweUpdate(
+            bwe_delay_updates[bwe_delay_written].first,
+            bwe_delay_updates[bwe_delay_written].second);
+        bwe_delay_written++;
+        break;
+      case EventType::VIDEO_RECV_CONFIG:
+        log_dumper->LogVideoReceiveStreamConfig(
+            receiver_configs[recv_configs_written++]);
+        break;
+      case EventType::VIDEO_SEND_CONFIG:
+        log_dumper->LogVideoSendStreamConfig(
+            sender_configs[send_configs_written++]);
+        break;
+      case EventType::AUDIO_RECV_CONFIG:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+      case EventType::AUDIO_SEND_CONFIG:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+      case EventType::AUDIO_NETWORK_ADAPTATION:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+      case EventType::BWE_PROBE_CLUSTER_CREATED:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+      case EventType::BWE_PROBE_RESULT:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+    }
+  }
+
+  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.
+void SessionDescription::ReadAndVerifySession() {
+  // 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();
 
   // 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);
-  }
+  EXPECT_GE(1000u, event_types.size() +
+                       2);  // The events must fit in the message queue.
+  EXPECT_EQ(event_types.size() + 2, parsed_log.GetNumberOfEvents());
+
+  size_t incoming_rtp_read = 0;
+  size_t outgoing_rtp_read = 0;
+  size_t incoming_rtcp_read = 0;
+  size_t outgoing_rtcp_read = 0;
+  size_t playouts_read = 0;
+  size_t bwe_loss_read = 0;
+  size_t bwe_delay_read = 0;
+  size_t recv_configs_read = 0;
+  size_t send_configs_read = 0;
+
   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++;
-    }
-  }
+
+  for (size_t i = 0; i < event_types.size(); i++) {
+    switch (event_types[i]) {
+      case EventType::INCOMING_RTP:
+        RtcEventLogTestHelper::VerifyRtpEvent(
+            parsed_log, i + 1, kIncomingPacket,
+            incoming_rtp_packets[incoming_rtp_read++]);
+        break;
+      case EventType::OUTGOING_RTP:
+        RtcEventLogTestHelper::VerifyRtpEvent(
+            parsed_log, i + 1, kOutgoingPacket,
+            outgoing_rtp_packets[outgoing_rtp_read++]);
+        break;
+      case EventType::INCOMING_RTCP:
+        RtcEventLogTestHelper::VerifyRtcpEvent(
+            parsed_log, i + 1, kIncomingPacket,
+            incoming_rtcp_packets[incoming_rtcp_read].data(),
+            incoming_rtcp_packets[incoming_rtcp_read].size());
+        incoming_rtcp_read++;
+        break;
+      case EventType::OUTGOING_RTCP:
+        RtcEventLogTestHelper::VerifyRtcpEvent(
+            parsed_log, i + 1, kOutgoingPacket,
+            outgoing_rtcp_packets[outgoing_rtcp_read].data(),
+            outgoing_rtcp_packets[outgoing_rtcp_read].size());
+        outgoing_rtcp_read++;
+        break;
+      case EventType::AUDIO_PLAYOUT:
+        RtcEventLogTestHelper::VerifyPlayoutEvent(
+            parsed_log, i + 1, playout_ssrcs[playouts_read++]);
+        break;
+      case EventType::BWE_LOSS_UPDATE:
+        RtcEventLogTestHelper::VerifyBweLossEvent(
+            parsed_log, i + 1, bwe_loss_updates[bwe_loss_read].bitrate_bps,
+            bwe_loss_updates[bwe_loss_read].fraction_loss,
+            bwe_loss_updates[bwe_loss_read].total_packets);
+        bwe_loss_read++;
+        break;
+      case EventType::BWE_DELAY_UPDATE:
+        RtcEventLogTestHelper::VerifyBweDelayEvent(
+            parsed_log, i + 1, bwe_delay_updates[bwe_delay_read].first,
+            bwe_delay_updates[bwe_delay_read].second);
+        bwe_delay_read++;
+        break;
+      case EventType::VIDEO_RECV_CONFIG:
+        RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
+            parsed_log, i + 1, receiver_configs[recv_configs_read++]);
+        break;
+      case EventType::VIDEO_SEND_CONFIG:
+        RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
+            parsed_log, i + 1, sender_configs[send_configs_read++]);
+        break;
+      case EventType::AUDIO_RECV_CONFIG:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+      case EventType::AUDIO_SEND_CONFIG:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+      case EventType::AUDIO_NETWORK_ADAPTATION:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+      case EventType::BWE_PROBE_CLUSTER_CREATED:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+      case EventType::BWE_PROBE_RESULT:
+        // Not implemented
+        RTC_NOTREACHED();
+        break;
+    }
+  }
+
+  RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log,
+                                           parsed_log.GetNumberOfEvents() - 1);
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
+void SessionDescription::PrintExpectedEvents() {

[eladalon, 2017/09/07 13:41:28]

It would probably be better to make the function accept an std::ostream, rather
than assume stdout is intended?

+  for (size_t i = 0; i < event_types.size(); i++) {

[eladalon, 2017/09/07 13:41:28]

I think it would be safer to create a map of the enum-class's values to strings
of their name, because that way you could static_assert the number of
EventType-s and the number of their names is the same, making it less likely
someone would edit one without editing the other. (Also, because the map refers
to the enum-class's values by name, you can't rename them in one place without
getting a compilation error right next to the string, which would remind you to
edit it, too.)

+    switch (event_types[i]) {
+      case EventType::INCOMING_RTP:
+        printf("RTP(in) ");
+        break;
+      case EventType::OUTGOING_RTP:
+        printf("RTP(out) ");
+        break;
+      case EventType::INCOMING_RTCP:
+        printf("RTCP(in) ");
+        break;
+      case EventType::OUTGOING_RTCP:
+        printf("RTCP(out) ");
+        break;
+      case EventType::AUDIO_PLAYOUT:
+        printf("PLAYOUT ");
+        break;
+      case EventType::BWE_LOSS_UPDATE:
+        printf("BWE_LOSS ");
+        break;
+      case EventType::BWE_DELAY_UPDATE:
+        printf("BWE_DELAY ");
+        break;
+      case EventType::VIDEO_RECV_CONFIG:
+        printf("VIDEO_RECV_CONFIG ");
+        break;
+      case EventType::VIDEO_SEND_CONFIG:
+        printf("VIDEO_SEND_CONFIG ");
+        break;
+      case EventType::AUDIO_RECV_CONFIG:
+        printf("AUDIO_RECV_CONFIG ");
+        break;
+      case EventType::AUDIO_SEND_CONFIG:
+        printf("AUDIO_SEND_CONFIG ");
+        break;
+      case EventType::AUDIO_NETWORK_ADAPTATION:
+        printf("ANA ");
+        break;
+      case EventType::BWE_PROBE_CLUSTER_CREATED:
+        printf("BWE_PROBE_CREATED ");
+        break;
+      case EventType::BWE_PROBE_RESULT:
+        printf("BWE_PROBE_RESULT ");
+        break;
+    }
+  }
+  printf("\n");
+}
+
+void PrintActualEvents(const ParsedRtcEventLog& parsed_log) {
+  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+    switch (parsed_log.GetEventType(i)) {
+      case ParsedRtcEventLog::EventType::UNKNOWN_EVENT:
+        printf("UNKNOWN_EVENT ");
+        break;
+      case ParsedRtcEventLog::EventType::LOG_START:
+        printf("LOG_START ");
+        break;
+      case ParsedRtcEventLog::EventType::LOG_END:
+        printf("LOG_END ");
+        break;
+      case ParsedRtcEventLog::EventType::RTP_EVENT:
+        printf("RTP_EVENT ");
+        break;
+      case ParsedRtcEventLog::EventType::RTCP_EVENT:
+        printf("RTCP_EVENT ");
+        break;
+      case ParsedRtcEventLog::EventType::AUDIO_PLAYOUT_EVENT:
+        printf("AUDIO_PLAYOUT_EVENT ");
+        break;
+      case ParsedRtcEventLog::EventType::LOSS_BASED_BWE_UPDATE:
+        printf("LOSS_BASED_BWE_UPDATE ");
+        break;
+      case ParsedRtcEventLog::EventType::DELAY_BASED_BWE_UPDATE:
+        printf("DELAY_BASED_BWE_UPDATE ");
+        break;
+      case ParsedRtcEventLog::EventType::VIDEO_RECEIVER_CONFIG_EVENT:
+        printf("VIDEO_RECEIVER_CONFIG_EVET ");
+        break;
+      case ParsedRtcEventLog::EventType::VIDEO_SENDER_CONFIG_EVENT:
+        printf("VIDEO_SENDER_CONFIG_EVENT ");
+        break;
+      case ParsedRtcEventLog::EventType::AUDIO_RECEIVER_CONFIG_EVENT:
+        printf("AUDIO_RECEIVER_CONFIG_EVET ");
+        break;
+      case ParsedRtcEventLog::EventType::AUDIO_SENDER_CONFIG_EVENT:
+        printf("AUDIO_SENDER_CONFIG_EVENT ");
+        break;
+      case ParsedRtcEventLog::EventType::AUDIO_NETWORK_ADAPTATION_EVENT:
+        printf("AUDIO_NETWORK_ADAPTATION_EVENT ");
+        break;
+      case ParsedRtcEventLog::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT:
+        printf("BWE_PROBE_CLUSTER_CREATED_EVENT ");
+        break;
+      case ParsedRtcEventLog::EventType::BWE_PROBE_RESULT_EVENT:
+        printf("BWE_PROBE_RESULT_EVENT ");
+        break;
+    }
+  }
+  printf("\n");
+}
+
 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;
+  SessionDescription session(321 /*Random seed*/);
+  session.GenerateSessionDescription(3,  // Number of incoming RTP packets.
+                                     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.
+  session.WriteSession();
+  session.ReadAndVerifySession();
+}
+
+TEST(RtcEventLogTest, LogSessionAndReadBackWith2Extensions) {
+  RtpHeaderExtensionMap extensions;
+  extensions.Register(kRtpExtensionAbsoluteSendTime,
+                      kAbsoluteSendTimeExtensionId);
+  extensions.Register(kRtpExtensionTransportSequenceNumber,
+                      kTransportSequenceNumberExtensionId);
+  SessionDescription session(3141592653u /*Random seed*/);
+  session.GenerateSessionDescription(4, 4, 1, 1, 0, 0, 0, extensions, 0);
+  session.WriteSession();
+  session.ReadAndVerifySession();
+}
+
+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]);
+  }
+  SessionDescription session(2718281828u /*Random seed*/);
+  session.GenerateSessionDescription(5, 4, 1, 1, 3, 2, 2, extensions, 2);
+  session.WriteSession();
+  session.ReadAndVerifySession();
+}
+
+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.
-    }
-  }
-}
+      SessionDescription session(extension_selection * 3 + csrcs_count +
+                                 1 /*Random seed*/);
+      session.GenerateSessionDescription(
+          2 + extension_selection,  // Number of incoming RTP packets.

[eladalon, 2017/09/07 13:41:28]

You could perhaps make GenerateSessionDescription() accept a vector, where the
indices correspond to EventType-s. Then:
vector<size_t> ook(EventType::Count, 0);
ook[EventType::IncomingRtp] = 3;
ook[EventType::OutgoingRtp] = 94;
GenerateSessionDescription(ook);

This would probably be more self-documenting and less brittle, IMHO.

+          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.
+      session.WriteSession();
+      session.ReadAndVerifySession();
+    }
+  }
+}
 
 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(rtcp_packet);
   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.
   EXPECT_EQ(4u, parsed_log.GetNumberOfEvents());
 
   RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
 
-  RtcEventLogTestHelper::VerifyRtpEvent(
-      parsed_log, 1, kIncomingPacket, rtp_packet.data(),
-      rtp_packet.headers_size(), rtp_packet.size());
+  RtcEventLogTestHelper::VerifyRtpEvent(parsed_log, 1, kIncomingPacket,
+                                        rtp_packet);
 
   RtcEventLogTestHelper::VerifyRtcpEvent(
       parsed_log, 2, kOutgoingPacket, rtcp_packet.data(), rtcp_packet.size());
 
   RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 3);
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
@@ skipping 224 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