Split out dscp option from VideoOptions to new struct MediaChannelOptions.

webrtc/media/webrtc/webrtcvideoengine2.cc

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 508 matching lines @@
   LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
 }
 
 void WebRtcVideoEngine2::Init() {
   LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
   initialized_ = true;
 }
 
 WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
     webrtc::Call* call,
-    const VideoOptions& options) {
+    const MediaChannelOptions& options,
+    const VideoOptions& video_options) {
   RTC_DCHECK(initialized_);
-  LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
-  return new WebRtcVideoChannel2(call, options, video_codecs_,
-      external_encoder_factory_, external_decoder_factory_);
+  LOG(LS_INFO) << "CreateChannel. Options: " << video_options.ToString();
+  return new WebRtcVideoChannel2(call, options, video_options, video_codecs_,
+                                 external_encoder_factory_,
+                                 external_decoder_factory_);
 }
 
 const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
   return video_codecs_;
 }
 
 RtpCapabilities WebRtcVideoEngine2::GetCapabilities() const {
   RtpCapabilities capabilities;
   capabilities.header_extensions.push_back(
       RtpHeaderExtension(kRtpTimestampOffsetHeaderExtension,
@@ skipping 68 matching lines @@
                      0);
 
     AddDefaultFeedbackParams(&codec);
     supported_codecs.push_back(codec);
   }
   return supported_codecs;
 }
 
 WebRtcVideoChannel2::WebRtcVideoChannel2(
     webrtc::Call* call,
-    const VideoOptions& options,
+    const MediaChannelOptions& options,
+    const VideoOptions& video_options,
     const std::vector<VideoCodec>& recv_codecs,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     WebRtcVideoDecoderFactory* external_decoder_factory)
-    : call_(call),
+    : VideoMediaChannel(options),
+      call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       external_encoder_factory_(external_encoder_factory),
       external_decoder_factory_(external_decoder_factory) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   SetDefaultOptions();
-  options_.SetAll(options);
+  options_.SetAll(video_options);
   if (options_.cpu_overuse_detection)
     signal_cpu_adaptation_ = *options_.cpu_overuse_detection;
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   default_send_ssrc_ = 0;
   RTC_DCHECK(ValidateCodecFormats(recv_codecs));
   recv_codecs_ = FilterSupportedCodecs(MapCodecs(recv_codecs));
 }
 
 void WebRtcVideoChannel2::SetDefaultOptions() {
   options_.cpu_overuse_detection = rtc::Optional<bool>(true);
-  options_.dscp = rtc::Optional<bool>(false);
   options_.suspend_below_min_bitrate = rtc::Optional<bool>(false);
   options_.screencast_min_bitrate_kbps = rtc::Optional<int>(0);
 }
 
 WebRtcVideoChannel2::~WebRtcVideoChannel2() {
   for (auto& kv : send_streams_)
     delete kv.second;
   for (auto& kv : receive_streams_)
     delete kv.second;
 }
@@ skipping 112 matching lines @@
   // Handle RTCP mode.
   if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) {
     changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>(
         params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
                                  : webrtc::RtcpMode::kCompound);
   }
 
   return true;
 }
 
+rtc::DiffServCodePoint WebRtcVideoChannel2::MediaTypeDscpValue() const {
+  return rtc::DSCP_AF41;
+}
+
 bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) {
   TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendParameters");
   LOG(LS_INFO) << "SetSendParameters: " << params.ToString();
   ChangedSendParameters changed_params;
   if (!GetChangedSendParameters(params, &changed_params)) {
     return false;
   }
 
   bool bitrate_config_changed = false;
 
@@ skipping 32 matching lines @@
   }
 
   if (changed_params.options) {
     options_.SetAll(*changed_params.options);
     {
       rtc::CritScope lock(&capturer_crit_);
       if (options_.cpu_overuse_detection) {
         signal_cpu_adaptation_ = *options_.cpu_overuse_detection;
       }
     }
-    rtc::DiffServCodePoint dscp =
-        options_.dscp.value_or(false) ? rtc::DSCP_AF41 : rtc::DSCP_DEFAULT;
-    MediaChannel::SetDscp(dscp);
   }
 
   {
     rtc::CritScope stream_lock(&stream_crit_);
     for (auto& kv : send_streams_) {
       kv.second->SetSendParameters(changed_params);
     }
     if (changed_params.codec) {
       // Update receive feedback parameters from new codec.
       LOG(LS_INFO)
@@ skipping 1685 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO