Split out dscp option from VideoOptions to new struct MediaChannelOptions.

talk/session/media/channelmanager.cc

 /*
  * libjingle
  * Copyright 2004 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 234 matching lines @@
     DestroyVoiceChannel_w(voice_channels_.back());
   }
   media_engine_->Terminate();
 }
 
 VoiceChannel* ChannelManager::CreateVoiceChannel(
     webrtc::MediaControllerInterface* media_controller,
     TransportController* transport_controller,
     const std::string& content_name,
     bool rtcp,
-    const AudioOptions& options) {
+    const MediaChannelOptions& options,
+    const AudioOptions& audio_options) {
   return worker_thread_->Invoke<VoiceChannel*>(
       Bind(&ChannelManager::CreateVoiceChannel_w, this, media_controller,
-           transport_controller, content_name, rtcp, options));
+           transport_controller, content_name, rtcp, options, audio_options));
 }
 
 VoiceChannel* ChannelManager::CreateVoiceChannel_w(
     webrtc::MediaControllerInterface* media_controller,
     TransportController* transport_controller,
     const std::string& content_name,
     bool rtcp,
-    const AudioOptions& options) {
+    const MediaChannelOptions& options,
+    const AudioOptions& audio_options) {
   ASSERT(initialized_);
   ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(nullptr != media_controller);
   VoiceMediaChannel* media_channel =
-      media_engine_->CreateChannel(media_controller->call_w(), options);
+      media_engine_->CreateChannel(
+          media_controller->call_w(), options, audio_options);
   if (!media_channel)
     return nullptr;
 
   VoiceChannel* voice_channel =
       new VoiceChannel(worker_thread_, media_engine_.get(), media_channel,
                        transport_controller, content_name, rtcp);
   if (!voice_channel->Init()) {
     delete voice_channel;
     return nullptr;
   }
@@ skipping 21 matching lines @@
     return;
   voice_channels_.erase(it);
   delete voice_channel;
 }
 
 VideoChannel* ChannelManager::CreateVideoChannel(
     webrtc::MediaControllerInterface* media_controller,
     TransportController* transport_controller,
     const std::string& content_name,
     bool rtcp,
-    const VideoOptions& options) {
+    const MediaChannelOptions& options,
+    const VideoOptions& video_options) {
   return worker_thread_->Invoke<VideoChannel*>(
       Bind(&ChannelManager::CreateVideoChannel_w, this, media_controller,
-           transport_controller, content_name, rtcp, options));
+           transport_controller, content_name, rtcp, options, video_options));
 }
 
 VideoChannel* ChannelManager::CreateVideoChannel_w(
     webrtc::MediaControllerInterface* media_controller,
     TransportController* transport_controller,
     const std::string& content_name,
     bool rtcp,
-    const VideoOptions& options) {
+    const MediaChannelOptions& options,
+    const VideoOptions& video_options) {
   ASSERT(initialized_);
   ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(nullptr != media_controller);
   VideoMediaChannel* media_channel =
-      media_engine_->CreateVideoChannel(media_controller->call_w(), options);
+      media_engine_->CreateVideoChannel(
+          media_controller->call_w(), options, video_options);
   if (media_channel == NULL) {
     return NULL;
   }
 
   VideoChannel* video_channel = new VideoChannel(
       worker_thread_, media_channel, transport_controller, content_name, rtcp);
   if (!video_channel->Init()) {
     delete video_channel;
     return NULL;
   }
@@ skipping 228 matching lines @@
   return worker_thread_->Invoke<bool>(
       Bind(&MediaEngineInterface::StartRtcEventLog, media_engine_.get(), file));
 }
 
 void ChannelManager::StopRtcEventLog() {
   worker_thread_->Invoke<void>(
       Bind(&MediaEngineInterface::StopRtcEventLog, media_engine_.get()));
 }
 
 }  // namespace cricket