Simplify creating RtpHeaderExtensionMap in EventLogAnalyzer

webrtc/tools/event_log_visualizer/analyzer.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 10 matching lines @@
 #include "webrtc/api/call/audio_send_stream.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/rate_statistics.h"
 #include "webrtc/call.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/video_receive_stream.h"
 #include "webrtc/video_send_stream.h"
 
 namespace webrtc {
 namespace plotting {
 
 namespace {
@@ skipping 43 matching lines @@
   }
   if (difference > max_difference / 2 || difference < min_difference / 2) {
     LOG(LS_WARNING) << "Difference between" << later << " and " << earlier
                     << " expected to be in the range (" << min_difference / 2
                     << "," << max_difference / 2 << ") but is " << difference
                     << ". Correct unwrapping is uncertain.";
   }
   return difference;
 }
 
-void RegisterHeaderExtensions(
-    const std::vector<webrtc::RtpExtension>& extensions,
-    webrtc::RtpHeaderExtensionMap* extension_map) {
-  extension_map->Erase();
-  for (const webrtc::RtpExtension& extension : extensions) {
-    extension_map->Register(webrtc::StringToRtpExtensionType(extension.uri),
-                            extension.id);
-  }
-}
-
 // Return default values for header extensions, to use on streams without stored
 // mapping data. Currently this only applies to audio streams, since the mapping
 // is not stored in the event log.
 // TODO(ivoc): Remove this once this mapping is stored in the event log for
 //             audio streams. Tracking bug: webrtc:6399
 webrtc::RtpHeaderExtensionMap GetDefaultHeaderExtensionMap() {
   webrtc::RtpHeaderExtensionMap default_map;
-  default_map.Register(
-      webrtc::StringToRtpExtensionType(webrtc::RtpExtension::kAudioLevelUri),
-      webrtc::RtpExtension::kAudioLevelDefaultId);
-  default_map.Register(
-      webrtc::StringToRtpExtensionType(webrtc::RtpExtension::kAbsSendTimeUri),
+  default_map.Register<AudioLevel>(webrtc::RtpExtension::kAudioLevelDefaultId);
+  default_map.Register<AbsoluteSendTime>(
       webrtc::RtpExtension::kAbsSendTimeDefaultId);
   return default_map;
 }
 
 constexpr float kLeftMargin = 0.01f;
 constexpr float kRightMargin = 0.02f;
 constexpr float kBottomMargin = 0.02f;
 constexpr float kTopMargin = 0.05f;
 
 class PacketSizeBytes {
@@ skipping 188 matching lines @@
       uint64_t timestamp = parsed_log_.GetTimestamp(i);
       first_timestamp = std::min(first_timestamp, timestamp);
       last_timestamp = std::max(last_timestamp, timestamp);
     }
 
     switch (parsed_log_.GetEventType(i)) {
       case ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT: {
         VideoReceiveStream::Config config(nullptr);
         parsed_log_.GetVideoReceiveConfig(i, &config);
         StreamId stream(config.rtp.remote_ssrc, kIncomingPacket);
-        RegisterHeaderExtensions(config.rtp.extensions,
-                                 &extension_maps[stream]);
+        extension_maps[stream] = RtpHeaderExtensionMap(config.rtp.extensions);
         video_ssrcs_.insert(stream);
         for (auto kv : config.rtp.rtx) {
           StreamId rtx_stream(kv.second.ssrc, kIncomingPacket);
-          RegisterHeaderExtensions(config.rtp.extensions,
-                                   &extension_maps[rtx_stream]);
+          extension_maps[rtx_stream] =
+              RtpHeaderExtensionMap(config.rtp.extensions);
           video_ssrcs_.insert(rtx_stream);
           rtx_ssrcs_.insert(rtx_stream);
         }
         break;
       }
       case ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT: {
         VideoSendStream::Config config(nullptr);
         parsed_log_.GetVideoSendConfig(i, &config);
         for (auto ssrc : config.rtp.ssrcs) {
           StreamId stream(ssrc, kOutgoingPacket);
-          RegisterHeaderExtensions(config.rtp.extensions,
-                                   &extension_maps[stream]);
+          extension_maps[stream] = RtpHeaderExtensionMap(config.rtp.extensions);
           video_ssrcs_.insert(stream);
         }
         for (auto ssrc : config.rtp.rtx.ssrcs) {
           StreamId rtx_stream(ssrc, kOutgoingPacket);
-          RegisterHeaderExtensions(config.rtp.extensions,
-                                   &extension_maps[rtx_stream]);
+          extension_maps[rtx_stream] =
+              RtpHeaderExtensionMap(config.rtp.extensions);
           video_ssrcs_.insert(rtx_stream);
           rtx_ssrcs_.insert(rtx_stream);
         }
         break;
       }
       case ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT: {
         AudioReceiveStream::Config config;
         parsed_log_.GetAudioReceiveConfig(i, &config);
         StreamId stream(config.rtp.remote_ssrc, kIncomingPacket);
-        RegisterHeaderExtensions(config.rtp.extensions,
-                                 &extension_maps[stream]);
+        extension_maps[stream] = RtpHeaderExtensionMap(config.rtp.extensions);
         audio_ssrcs_.insert(stream);
         break;
       }
       case ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT: {
         AudioSendStream::Config config(nullptr);
         parsed_log_.GetAudioSendConfig(i, &config);
         StreamId stream(config.rtp.ssrc, kOutgoingPacket);
-        RegisterHeaderExtensions(config.rtp.extensions,
-                                 &extension_maps[stream]);
+        extension_maps[stream] = RtpHeaderExtensionMap(config.rtp.extensions);
         audio_ssrcs_.insert(stream);
         break;
       }
       case ParsedRtcEventLog::RTP_EVENT: {
         MediaType media_type;
         parsed_log_.GetRtpHeader(i, &direction, &media_type, header,
                                  &header_length, &total_length);
         // Parse header to get SSRC.
         RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
         RTPHeader parsed_header;
@@ skipping 792 matching lines @@
     point.y -= estimated_base_delay_ms;
   // Add the data set to the plot.
   plot->series_list_.push_back(std::move(time_series));
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Delay (ms)", kBottomMargin, kTopMargin);
   plot->SetTitle("Network Delay Change.");
 }
 }  // namespace plotting
 }  // namespace webrtc