Replace AudioReceiveStream::Config with rtclog::StreamConfig.

BUG=webrtc:7538

Review-Url: https://codereview.webrtc.org/2851303007
Cr-Commit-Position: refs/heads/master@{#18223}

webrtc/call/call.cc

@@ -124,6 +124,15 @@ rtclog::StreamConfig CreateRtcLogStreamConfig(
   return rtclog_config;
 }
 
+rtclog::StreamConfig CreateRtcLogStreamConfig(
+    const AudioReceiveStream::Config& config) {
+  rtclog::StreamConfig rtclog_config;
+  rtclog_config.remote_ssrc = config.rtp.remote_ssrc;
+  rtclog_config.local_ssrc = config.rtp.local_ssrc;
+  rtclog_config.rtp_extensions = config.rtp.extensions;
+  return rtclog_config;
+}
+
 }  // namespace
 
 namespace internal {
@@ -594,7 +603,7 @@ webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
     const webrtc::AudioReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
-  event_log_->LogAudioReceiveStreamConfig(config);
+  event_log_->LogAudioReceiveStreamConfig(CreateRtcLogStreamConfig(config));
   AudioReceiveStream* receive_stream =
       new AudioReceiveStream(transport_send_->packet_router(), config,
                              config_.audio_state, event_log_);

webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h

@@ -36,7 +36,7 @@ class MockRtcEventLog : public RtcEventLog {
                void(const rtclog::StreamConfig& config));
 
   MOCK_METHOD1(LogAudioReceiveStreamConfig,
-               void(const webrtc::AudioReceiveStream::Config& config));
+               void(const rtclog::StreamConfig& config));
 
   MOCK_METHOD1(LogAudioSendStreamConfig,
                void(const webrtc::AudioSendStream::Config& config));

webrtc/logging/rtc_event_log/rtc_event_log.cc

@@ -64,8 +64,7 @@ class RtcEventLogImpl final : public RtcEventLog {
   void StopLogging() override;
   void LogVideoReceiveStreamConfig(const rtclog::StreamConfig& config) override;
   void LogVideoSendStreamConfig(const rtclog::StreamConfig& config) override;
-  void LogAudioReceiveStreamConfig(
+  void LogAudioReceiveStreamConfig(const rtclog::StreamConfig& config) override;
-      const AudioReceiveStream::Config& config) override;
   void LogAudioSendStreamConfig(const AudioSendStream::Config& config) override;
   void LogRtpHeader(PacketDirection direction,
                     MediaType media_type,
@@ -351,17 +350,17 @@ void RtcEventLogImpl::LogVideoSendStreamConfig(
 }
 
 void RtcEventLogImpl::LogAudioReceiveStreamConfig(
-    const AudioReceiveStream::Config& config) {
+    const rtclog::StreamConfig& config) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT);
 
   rtclog::AudioReceiveConfig* receiver_config =
       event->mutable_audio_receiver_config();
-  receiver_config->set_remote_ssrc(config.rtp.remote_ssrc);
+  receiver_config->set_remote_ssrc(config.remote_ssrc);
-  receiver_config->set_local_ssrc(config.rtp.local_ssrc);
+  receiver_config->set_local_ssrc(config.local_ssrc);
 
-  for (const auto& e : config.rtp.extensions) {
+  for (const auto& e : config.rtp_extensions) {
     rtclog::RtpHeaderExtension* extension =
         receiver_config->add_header_extensions();
     extension->set_name(e.uri);

webrtc/logging/rtc_event_log/rtc_event_log.h

@@ -119,9 +119,9 @@ class RtcEventLog {
   // Logs configuration information for a video send stream.
   virtual void LogVideoSendStreamConfig(const rtclog::StreamConfig& config) = 0;
 
-  // Logs configuration information for webrtc::AudioReceiveStream.
+  // Logs configuration information for an audio receive stream.
   virtual void LogAudioReceiveStreamConfig(
-      const webrtc::AudioReceiveStream::Config& config) = 0;
+      const rtclog::StreamConfig& config) = 0;
 
   // Logs configuration information for webrtc::AudioSendStream.
   virtual void LogAudioSendStreamConfig(
@@ -202,7 +202,7 @@ class RtcEventLogNullImpl final : public RtcEventLog {
       const rtclog::StreamConfig& config) override {}
   void LogVideoSendStreamConfig(const rtclog::StreamConfig& config) override {}
   void LogAudioReceiveStreamConfig(
-      const AudioReceiveStream::Config& config) override {}
+      const rtclog::StreamConfig& config) override {}
   void LogAudioSendStreamConfig(
       const AudioSendStream::Config& config) override {}
   void LogRtpHeader(PacketDirection direction,

webrtc/logging/rtc_event_log/rtc_event_log2text.cc

@@ -399,18 +399,18 @@ int main(int argc, char* argv[]) {
     }
     if (parsed_stream.GetEventType(i) ==
         webrtc::ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT) {
-      webrtc::AudioReceiveStream::Config config;
+      webrtc::rtclog::StreamConfig config;
       parsed_stream.GetAudioReceiveConfig(i, &config);
-      global_streams.emplace_back(config.rtp.remote_ssrc,
+      global_streams.emplace_back(config.remote_ssrc,
                                   webrtc::MediaType::AUDIO,
                                   webrtc::kIncomingPacket);
-      global_streams.emplace_back(config.rtp.local_ssrc,
+      global_streams.emplace_back(config.local_ssrc,
                                   webrtc::MediaType::AUDIO,
                                   webrtc::kOutgoingPacket);
       if (!FLAGS_noconfig && !FLAGS_noaudio && !FLAGS_noincoming) {
         std::cout << parsed_stream.GetTimestamp(i) << "\tAUDIO_RECV_CONFIG"
-                  << "\tssrc=" << config.rtp.remote_ssrc
+                  << "\tssrc=" << config.remote_ssrc
-                  << "\tfeedback_ssrc=" << config.rtp.local_ssrc << std::endl;
+                  << "\tfeedback_ssrc=" << config.local_ssrc << std::endl;
       }
     }
     if (parsed_stream.GetEventType(i) ==

webrtc/logging/rtc_event_log/rtc_event_log_parser.cc

@@ -417,7 +417,7 @@ void ParsedRtcEventLog::GetVideoSendConfig(size_t index,
 
 void ParsedRtcEventLog::GetAudioReceiveConfig(
     size_t index,
-    AudioReceiveStream::Config* config) const {
+    rtclog::StreamConfig* config) const {
   RTC_CHECK_LT(index, GetNumberOfEvents());
   const rtclog::Event& event = events_[index];
   RTC_CHECK(config != nullptr);
@@ -428,11 +428,11 @@ void ParsedRtcEventLog::GetAudioReceiveConfig(
       event.audio_receiver_config();
   // Get SSRCs.
   RTC_CHECK(receiver_config.has_remote_ssrc());
-  config->rtp.remote_ssrc = receiver_config.remote_ssrc();
+  config->remote_ssrc = receiver_config.remote_ssrc();
   RTC_CHECK(receiver_config.has_local_ssrc());
-  config->rtp.local_ssrc = receiver_config.local_ssrc();
+  config->local_ssrc = receiver_config.local_ssrc();
   // Get header extensions.
-  GetHeaderExtensions(&config->rtp.extensions,
+  GetHeaderExtensions(&config->rtp_extensions,
                       receiver_config.header_extensions());
 }
 

webrtc/logging/rtc_event_log/rtc_event_log_parser.h

@@ -122,10 +122,9 @@ class ParsedRtcEventLog {
   // Only the fields that are stored in the protobuf will be written.
   void GetVideoSendConfig(size_t index, rtclog::StreamConfig* config) const;
 
-  // Reads a config event to a (non-NULL) AudioReceiveStream::Config struct.
+  // Reads a config event to a (non-NULL) StreamConfig struct.
   // Only the fields that are stored in the protobuf will be written.
-  void GetAudioReceiveConfig(size_t index,
+  void GetAudioReceiveConfig(size_t index, rtclog::StreamConfig* config) const;
-                             AudioReceiveStream::Config* config) const;
 
   // Reads a config event to a (non-NULL) AudioSendStream::Config struct.
   // Only the fields that are stored in the protobuf will be written.

webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc

@@ -191,15 +191,15 @@ void GenerateVideoSendConfig(uint32_t extensions_bitvector,
 }
 
 void GenerateAudioReceiveConfig(uint32_t extensions_bitvector,
-                                AudioReceiveStream::Config* config,
+                                rtclog::StreamConfig* config,
                                 Random* prng) {
   // Add SSRCs for the stream.
-  config->rtp.remote_ssrc = prng->Rand<uint32_t>();
+  config->remote_ssrc = prng->Rand<uint32_t>();
-  config->rtp.local_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(
+      config->rtp_extensions.push_back(
           RtpExtension(kExtensionNames[i], prng->Rand<int>()));
     }
   }
@@ -783,7 +783,7 @@ class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest {
     RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(parsed_log, index,
                                                           config);
   }
-  AudioReceiveStream::Config config;
+  rtclog::StreamConfig config;
 };
 
 class AudioSendConfigReadWriteTest : public ConfigReadWriteTest {

webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc

@@ -299,7 +299,7 @@ void RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
 void RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
-    const AudioReceiveStream::Config& config) {
+    const rtclog::StreamConfig& config) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT, event.type());
@@ -307,32 +307,32 @@ void RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(
       event.audio_receiver_config();
   // Check SSRCs.
   ASSERT_TRUE(receiver_config.has_remote_ssrc());
-  EXPECT_EQ(config.rtp.remote_ssrc, receiver_config.remote_ssrc());
+  EXPECT_EQ(config.remote_ssrc, receiver_config.remote_ssrc());
   ASSERT_TRUE(receiver_config.has_local_ssrc());
-  EXPECT_EQ(config.rtp.local_ssrc, receiver_config.local_ssrc());
+  EXPECT_EQ(config.local_ssrc, receiver_config.local_ssrc());
   // Check header extensions.
-  ASSERT_EQ(static_cast<int>(config.rtp.extensions.size()),
+  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].id, id);
-    EXPECT_EQ(config.rtp.extensions[i].uri, name);
+    EXPECT_EQ(config.rtp_extensions[i].uri, name);
   }
 
   // Check consistency of the parser.
-  AudioReceiveStream::Config parsed_config;
+  rtclog::StreamConfig parsed_config;
   parsed_log.GetAudioReceiveConfig(index, &parsed_config);
-  EXPECT_EQ(config.rtp.remote_ssrc, parsed_config.rtp.remote_ssrc);
+  EXPECT_EQ(config.remote_ssrc, parsed_config.remote_ssrc);
-  EXPECT_EQ(config.rtp.local_ssrc, parsed_config.rtp.local_ssrc);
+  EXPECT_EQ(config.local_ssrc, parsed_config.local_ssrc);
   // Check header extensions.
-  EXPECT_EQ(config.rtp.extensions.size(), parsed_config.rtp.extensions.size());
+  EXPECT_EQ(config.rtp_extensions.size(), parsed_config.rtp_extensions.size());
-  for (size_t i = 0; i < parsed_config.rtp.extensions.size(); i++) {
+  for (size_t i = 0; i < parsed_config.rtp_extensions.size(); i++) {
-    EXPECT_EQ(config.rtp.extensions[i].uri,
+    EXPECT_EQ(config.rtp_extensions[i].uri,
-              parsed_config.rtp.extensions[i].uri);
+              parsed_config.rtp_extensions[i].uri);
-    EXPECT_EQ(config.rtp.extensions[i].id, parsed_config.rtp.extensions[i].id);
+    EXPECT_EQ(config.rtp_extensions[i].id, parsed_config.rtp_extensions[i].id);
   }
 }
 

webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h

@@ -28,7 +28,7 @@ class RtcEventLogTestHelper {
   static void VerifyAudioReceiveStreamConfig(
       const ParsedRtcEventLog& parsed_log,
       size_t index,
-      const AudioReceiveStream::Config& config);
+      const rtclog::StreamConfig& config);
   static void VerifyAudioSendStreamConfig(
       const ParsedRtcEventLog& parsed_log,
       size_t index,

webrtc/tools/event_log_visualizer/analyzer.cc

@@ -357,10 +357,10 @@ EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log)
         break;
       }
       case ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT: {
-        AudioReceiveStream::Config config;
+        rtclog::StreamConfig config;
         parsed_log_.GetAudioReceiveConfig(i, &config);
-        StreamId stream(config.rtp.remote_ssrc, kIncomingPacket);
+        StreamId stream(config.remote_ssrc, kIncomingPacket);
-        extension_maps[stream] = RtpHeaderExtensionMap(config.rtp.extensions);
+        extension_maps[stream] = RtpHeaderExtensionMap(config.rtp_extensions);
         audio_ssrcs_.insert(stream);
         break;
       }

webrtc/voice_engine/channel.cc

@@ -85,7 +85,7 @@ class RtcEventLogProxy final : public webrtc::RtcEventLog {
   }
 
   void LogAudioReceiveStreamConfig(
-      const webrtc::AudioReceiveStream::Config& config) override {
+      const webrtc::rtclog::StreamConfig& config) override {
     rtc::CritScope lock(&crit_);
     if (event_log_) {
       event_log_->LogAudioReceiveStreamConfig(config);