Added logging for audio send/receive stream configs.

webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 84 matching lines @@
   if ((type == rtclog::Event::AUDIO_SENDER_CONFIG_EVENT) !=
       event.has_audio_sender_config()) {
     return ::testing::AssertionFailure()
            << "Event of type " << type << " has "
            << (event.has_audio_sender_config() ? "" : "no ")
            << "audio sender config";
   }
   return ::testing::AssertionSuccess();
 }
 
-void RtcEventLogTestHelper::VerifyReceiveStreamConfig(
+void RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     const VideoReceiveStream::Config& config) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT, event.type());
   const rtclog::VideoReceiveConfig& receiver_config =
       event.video_receiver_config();
   // Check SSRCs.
   ASSERT_TRUE(receiver_config.has_remote_ssrc());
@@ skipping 75 matching lines @@
   // Check decoders.
   EXPECT_EQ(config.decoders.size(), parsed_config.decoders.size());
   for (size_t i = 0; i < parsed_config.decoders.size(); i++) {
     EXPECT_EQ(config.decoders[i].payload_name,
               parsed_config.decoders[i].payload_name);
     EXPECT_EQ(config.decoders[i].payload_type,
               parsed_config.decoders[i].payload_type);
   }
 }
 
-void RtcEventLogTestHelper::VerifySendStreamConfig(
+void RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     const VideoSendStream::Config& config) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT, event.type());
   const rtclog::VideoSendConfig& sender_config = event.video_sender_config();
   // Check SSRCs.
   ASSERT_EQ(static_cast<int>(config.rtp.ssrcs.size()),
             sender_config.ssrcs_size());
@@ skipping 51 matching lines @@
     EXPECT_EQ(config.rtp.rtx.ssrcs[i], parsed_config.rtp.rtx.ssrcs[i]);
   }
   EXPECT_EQ(config.rtp.rtx.payload_type, parsed_config.rtp.rtx.payload_type);
   // Check encoder.
   EXPECT_EQ(config.encoder_settings.payload_name,
             parsed_config.encoder_settings.payload_name);
   EXPECT_EQ(config.encoder_settings.payload_type,
             parsed_config.encoder_settings.payload_type);
 }
 
+void RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(
+    const ParsedRtcEventLog& parsed_log,
+    size_t index,
+    const AudioReceiveStream::Config& config) {
+  const rtclog::Event& event = parsed_log.events_[index];
+  ASSERT_TRUE(IsValidBasicEvent(event));
+  ASSERT_EQ(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT, event.type());
+  const rtclog::AudioReceiveConfig& receiver_config =
+      event.audio_receiver_config();
+  // Check SSRCs.
+  ASSERT_TRUE(receiver_config.has_remote_ssrc());
+  EXPECT_EQ(config.rtp.remote_ssrc, receiver_config.remote_ssrc());
+  ASSERT_TRUE(receiver_config.has_local_ssrc());
+  EXPECT_EQ(config.rtp.local_ssrc, receiver_config.local_ssrc());
+  // Check header extensions.
+  ASSERT_EQ(static_cast<int>(config.rtp.extensions.size()),
+            receiver_config.header_extensions_size());
+  for (int i = 0; i < receiver_config.header_extensions_size(); i++) {
+    ASSERT_TRUE(receiver_config.header_extensions(i).has_name());
+    ASSERT_TRUE(receiver_config.header_extensions(i).has_id());
+    const std::string& name = receiver_config.header_extensions(i).name();
+    int id = receiver_config.header_extensions(i).id();
+    EXPECT_EQ(config.rtp.extensions[i].id, id);
+    EXPECT_EQ(config.rtp.extensions[i].uri, name);
+  }
+
+  // Check consistency of the parser.
+  AudioReceiveStream::Config parsed_config;
+  parsed_log.GetAudioReceiveConfig(index, &parsed_config);
+  EXPECT_EQ(config.rtp.remote_ssrc, parsed_config.rtp.remote_ssrc);
+  EXPECT_EQ(config.rtp.local_ssrc, parsed_config.rtp.local_ssrc);
+  // Check header extensions.
+  EXPECT_EQ(config.rtp.extensions.size(), parsed_config.rtp.extensions.size());
+  for (size_t i = 0; i < parsed_config.rtp.extensions.size(); i++) {
+    EXPECT_EQ(config.rtp.extensions[i].uri,
+              parsed_config.rtp.extensions[i].uri);
+    EXPECT_EQ(config.rtp.extensions[i].id, parsed_config.rtp.extensions[i].id);
+  }
+}
+
+void RtcEventLogTestHelper::VerifyAudioSendStreamConfig(
+    const ParsedRtcEventLog& parsed_log,
+    size_t index,
+    const AudioSendStream::Config& config) {
+  const rtclog::Event& event = parsed_log.events_[index];
+  ASSERT_TRUE(IsValidBasicEvent(event));
+  ASSERT_EQ(rtclog::Event::AUDIO_SENDER_CONFIG_EVENT, event.type());
+  const rtclog::AudioSendConfig& sender_config = event.audio_sender_config();
+  // Check SSRCs.
+  EXPECT_EQ(config.rtp.ssrc, sender_config.ssrc());
+  // Check header extensions.
+  ASSERT_EQ(static_cast<int>(config.rtp.extensions.size()),
+            sender_config.header_extensions_size());
+  for (int i = 0; i < sender_config.header_extensions_size(); i++) {
+    ASSERT_TRUE(sender_config.header_extensions(i).has_name());
+    ASSERT_TRUE(sender_config.header_extensions(i).has_id());
+    const std::string& name = sender_config.header_extensions(i).name();
+    int id = sender_config.header_extensions(i).id();
+    EXPECT_EQ(config.rtp.extensions[i].id, id);
+    EXPECT_EQ(config.rtp.extensions[i].uri, name);
+  }
+
+  // Check consistency of the parser.
+  AudioSendStream::Config parsed_config(nullptr);
+  parsed_log.GetAudioSendConfig(index, &parsed_config);
+  // Check SSRCs
+  EXPECT_EQ(config.rtp.ssrc, parsed_config.rtp.ssrc);
+  // Check header extensions.
+  EXPECT_EQ(config.rtp.extensions.size(), parsed_config.rtp.extensions.size());
+  for (size_t i = 0; i < parsed_config.rtp.extensions.size(); i++) {
+    EXPECT_EQ(config.rtp.extensions[i].uri,
+              parsed_config.rtp.extensions[i].uri);
+    EXPECT_EQ(config.rtp.extensions[i].id, parsed_config.rtp.extensions[i].id);
+  }
+}
+
 void RtcEventLogTestHelper::VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
                                            size_t index,
                                            PacketDirection direction,
                                            MediaType media_type,
                                            const uint8_t* header,
                                            size_t header_size,
                                            size_t total_size) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTP_EVENT, event.type());
@@ skipping 113 matching lines @@
 
 void RtcEventLogTestHelper::VerifyLogEndEvent(
     const ParsedRtcEventLog& parsed_log,
     size_t index) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   EXPECT_EQ(rtclog::Event::LOG_END, event.type());
 }
 
 }  // namespace webrtc