Remove FlexfecConfig and replace with specific struct in VideoSendStream.

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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 "webrtc/video/video_send_stream.h"
@@ skipping 76 matching lines @@
     rtp_rtcp->SetSendingMediaStatus(false);
     rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound);
     modules.push_back(rtp_rtcp);
   }
   return modules;
 }
 
 // TODO(brandtr): Update this function when we support multistream protection.
 std::unique_ptr<FlexfecSender> MaybeCreateFlexfecSender(
     const VideoSendStream::Config& config) {
-  if (config.rtp.flexfec.flexfec_payload_type < 0) {
+  if (config.rtp.flexfec.payload_type < 0) {
     return nullptr;
   }
-  RTC_DCHECK_GE(config.rtp.flexfec.flexfec_payload_type, 0);
-  RTC_DCHECK_LE(config.rtp.flexfec.flexfec_payload_type, 127);
-  if (config.rtp.flexfec.flexfec_ssrc == 0) {
+  RTC_DCHECK_GE(config.rtp.flexfec.payload_type, 0);
+  RTC_DCHECK_LE(config.rtp.flexfec.payload_type, 127);
+  if (config.rtp.flexfec.ssrc == 0) {
     LOG(LS_WARNING) << "FlexFEC is enabled, but no FlexFEC SSRC given. "
                        "Therefore disabling FlexFEC.";
     return nullptr;
   }
   if (config.rtp.flexfec.protected_media_ssrcs.empty()) {
     LOG(LS_WARNING) << "FlexFEC is enabled, but no protected media SSRC given. "
                        "Therefore disabling FlexFEC.";
     return nullptr;
   }
 
   if (config.rtp.ssrcs.size() > 1) {
     LOG(LS_WARNING) << "Both FlexFEC and simulcast are enabled. This "
                        "combination is however not supported by our current "
                        "FlexFEC implementation. Therefore disabling FlexFEC.";
     return nullptr;
   }
 
   if (config.rtp.flexfec.protected_media_ssrcs.size() > 1) {
     LOG(LS_WARNING)
         << "The supplied FlexfecConfig contained multiple protected "
            "media streams, but our implementation currently only "
            "supports protecting a single media stream. "
            "To avoid confusion, disabling FlexFEC completely.";
     return nullptr;
   }
 
   RTC_DCHECK_EQ(1U, config.rtp.flexfec.protected_media_ssrcs.size());
   return std::unique_ptr<FlexfecSender>(new FlexfecSender(
-      config.rtp.flexfec.flexfec_payload_type, config.rtp.flexfec.flexfec_ssrc,
+      config.rtp.flexfec.payload_type, config.rtp.flexfec.ssrc,
       config.rtp.flexfec.protected_media_ssrcs[0], config.rtp.extensions,
       Clock::GetRealTimeClock()));
 }
 
 }  // namespace
 
 std::string
 VideoSendStream::Config::EncoderSettings::ToString() const {
   std::stringstream ss;
   ss << "{payload_name: " << payload_name;
@@ skipping 35 matching lines @@
   ss << ", extensions: [";
   for (size_t i = 0; i < extensions.size(); ++i) {
     ss << extensions[i].ToString();
     if (i != extensions.size() - 1)
       ss << ", ";
   }
   ss << ']';
 
   ss << ", nack: {rtp_history_ms: " << nack.rtp_history_ms << '}';
   ss << ", ulpfec: " << ulpfec.ToString();
-  ss << ", flexfec: " << flexfec.ToString();
+
+  ss << ", flexfec: {payload_type: " << flexfec.payload_type;
+  ss << ", ssrc: " << flexfec.ssrc;
+  ss << ", protected_media_ssrcs: [";
+  for (size_t i = 0; i < flexfec.protected_media_ssrcs.size(); ++i) {
+    ss << flexfec.protected_media_ssrcs[i];
+    if (i != flexfec.protected_media_ssrcs.size() - 1)
+      ss << ", ";
+  }
+  ss << ']';
+
   ss << ", rtx: " << rtx.ToString();
   ss << ", c_name: " << c_name;
   ss << '}';
   return ss.str();
 }
 
 std::string VideoSendStream::Config::ToString() const {
   std::stringstream ss;
   ss << "{encoder_settings: " << encoder_settings.ToString();
   ss << ", rtp: " << rtp.ToString();
@@ skipping 1100 matching lines @@
       std::min(config_->rtp.max_packet_size,
                kPathMTU - transport_overhead_bytes_per_packet_);
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->SetMaxRtpPacketSize(rtp_packet_size);
   }
 }
 
 }  // namespace internal
 }  // namespace webrtc