Delete MediaController class, move Call ownership to PeerConnection.

webrtc/pc/channelmanager.cc

 /*
  *  Copyright 2004 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/pc/channelmanager.h"
 
 #include <algorithm>
 
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/media/base/device.h"
 #include "webrtc/media/base/rtpdataengine.h"
 #include "webrtc/pc/srtpfilter.h"
-#include "webrtc/pc/mediacontroller.h"
 
 namespace cricket {
 
 
 using rtc::Bind;
 
 ChannelManager::ChannelManager(std::unique_ptr<MediaEngineInterface> me,
                                std::unique_ptr<DataEngineInterface> dme,
                                rtc::Thread* thread) {
   Construct(std::move(me), std::move(dme), thread, thread);
@@ skipping 137 matching lines @@
   // Need to destroy the voice/video channels
   while (!video_channels_.empty()) {
     DestroyVideoChannel_w(video_channels_.back());
   }
   while (!voice_channels_.empty()) {
     DestroyVoiceChannel_w(voice_channels_.back());
   }
 }
 
 VoiceChannel* ChannelManager::CreateVoiceChannel(
-    webrtc::MediaControllerInterface* media_controller,
+    webrtc::Call* call,
+    const cricket::MediaConfig& media_config,
     DtlsTransportInternal* rtp_transport,
     DtlsTransportInternal* rtcp_transport,
     rtc::Thread* signaling_thread,
     const std::string& content_name,
     bool srtp_required,
     const AudioOptions& options) {
   return worker_thread_->Invoke<VoiceChannel*>(
       RTC_FROM_HERE,
-      Bind(&ChannelManager::CreateVoiceChannel_w, this, media_controller,
+      Bind(&ChannelManager::CreateVoiceChannel_w, this, call, media_config,
            rtp_transport, rtcp_transport, rtp_transport, rtcp_transport,
            signaling_thread, content_name, srtp_required, options));
 }
 
 VoiceChannel* ChannelManager::CreateVoiceChannel(
-    webrtc::MediaControllerInterface* media_controller,
+    webrtc::Call* call,
+    const cricket::MediaConfig& media_config,
     rtc::PacketTransportInternal* rtp_transport,
     rtc::PacketTransportInternal* rtcp_transport,
     rtc::Thread* signaling_thread,
     const std::string& content_name,
     bool srtp_required,
     const AudioOptions& options) {
   return worker_thread_->Invoke<VoiceChannel*>(
       RTC_FROM_HERE,
-      Bind(&ChannelManager::CreateVoiceChannel_w, this, media_controller,
+      Bind(&ChannelManager::CreateVoiceChannel_w, this, call, media_config,
            nullptr, nullptr, rtp_transport, rtcp_transport, signaling_thread,
            content_name, srtp_required, options));
 }
 
 VoiceChannel* ChannelManager::CreateVoiceChannel_w(
-    webrtc::MediaControllerInterface* media_controller,
+    webrtc::Call* call,
+    const cricket::MediaConfig& media_config,
     DtlsTransportInternal* rtp_dtls_transport,
     DtlsTransportInternal* rtcp_dtls_transport,
     rtc::PacketTransportInternal* rtp_packet_transport,
     rtc::PacketTransportInternal* rtcp_packet_transport,
     rtc::Thread* signaling_thread,
     const std::string& content_name,
     bool srtp_required,
     const AudioOptions& options) {
   RTC_DCHECK(initialized_);
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
-  RTC_DCHECK(nullptr != media_controller);
+  RTC_DCHECK(nullptr != call);
 
   VoiceMediaChannel* media_channel = media_engine_->CreateChannel(
-      media_controller->call_w(), media_controller->config(), options);
+      call, media_config, options);
   if (!media_channel)
     return nullptr;
 
   VoiceChannel* voice_channel =
       new VoiceChannel(worker_thread_, network_thread_, signaling_thread,
                        media_engine_.get(), media_channel, content_name,
                        rtcp_packet_transport == nullptr, srtp_required);
 
   if (!voice_channel->Init_w(rtp_dtls_transport, rtcp_dtls_transport,
                              rtp_packet_transport, rtcp_packet_transport)) {
@@ skipping 21 matching lines @@
   VoiceChannels::iterator it = std::find(voice_channels_.begin(),
       voice_channels_.end(), voice_channel);
   RTC_DCHECK(it != voice_channels_.end());
   if (it == voice_channels_.end())
     return;
   voice_channels_.erase(it);
   delete voice_channel;
 }
 
 VideoChannel* ChannelManager::CreateVideoChannel(
-    webrtc::MediaControllerInterface* media_controller,
+    webrtc::Call* call,
+    const cricket::MediaConfig& media_config,
     DtlsTransportInternal* rtp_transport,
     DtlsTransportInternal* rtcp_transport,
     rtc::Thread* signaling_thread,
     const std::string& content_name,
     bool srtp_required,
     const VideoOptions& options) {
   return worker_thread_->Invoke<VideoChannel*>(
       RTC_FROM_HERE,
-      Bind(&ChannelManager::CreateVideoChannel_w, this, media_controller,
+      Bind(&ChannelManager::CreateVideoChannel_w, this, call, media_config,
            rtp_transport, rtcp_transport, rtp_transport, rtcp_transport,
            signaling_thread, content_name, srtp_required, options));
 }
 
 VideoChannel* ChannelManager::CreateVideoChannel(
-    webrtc::MediaControllerInterface* media_controller,
+    webrtc::Call* call,
+    const cricket::MediaConfig& media_config,
     rtc::PacketTransportInternal* rtp_transport,
     rtc::PacketTransportInternal* rtcp_transport,
     rtc::Thread* signaling_thread,
     const std::string& content_name,
     bool srtp_required,
     const VideoOptions& options) {
   return worker_thread_->Invoke<VideoChannel*>(
       RTC_FROM_HERE,
-      Bind(&ChannelManager::CreateVideoChannel_w, this, media_controller,
+      Bind(&ChannelManager::CreateVideoChannel_w, this, call, media_config,
            nullptr, nullptr, rtp_transport, rtcp_transport, signaling_thread,
            content_name, srtp_required, options));
 }
 
 VideoChannel* ChannelManager::CreateVideoChannel_w(
-    webrtc::MediaControllerInterface* media_controller,
+    webrtc::Call* call,
+    const cricket::MediaConfig& media_config,
     DtlsTransportInternal* rtp_dtls_transport,
     DtlsTransportInternal* rtcp_dtls_transport,
     rtc::PacketTransportInternal* rtp_packet_transport,
     rtc::PacketTransportInternal* rtcp_packet_transport,
     rtc::Thread* signaling_thread,
     const std::string& content_name,
     bool srtp_required,
     const VideoOptions& options) {
   RTC_DCHECK(initialized_);
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
-  RTC_DCHECK(nullptr != media_controller);
+  RTC_DCHECK(nullptr != call);
   VideoMediaChannel* media_channel = media_engine_->CreateVideoChannel(
-      media_controller->call_w(), media_controller->config(), options);
+      call, media_config, options);
   if (media_channel == NULL) {
     return NULL;
   }
 
   VideoChannel* video_channel = new VideoChannel(
       worker_thread_, network_thread_, signaling_thread, media_channel,
       content_name, rtcp_packet_transport == nullptr, srtp_required);
   if (!video_channel->Init_w(rtp_dtls_transport, rtcp_dtls_transport,
                              rtp_packet_transport, rtcp_packet_transport)) {
     delete video_channel;
@@ skipping 21 matching lines @@
       video_channels_.end(), video_channel);
   RTC_DCHECK(it != video_channels_.end());
   if (it == video_channels_.end())
     return;
 
   video_channels_.erase(it);
   delete video_channel;
 }
 
 RtpDataChannel* ChannelManager::CreateRtpDataChannel(
-    webrtc::MediaControllerInterface* media_controller,
+    const cricket::MediaConfig& media_config,
     DtlsTransportInternal* rtp_transport,
     DtlsTransportInternal* rtcp_transport,
     rtc::Thread* signaling_thread,
     const std::string& content_name,
     bool srtp_required) {
   return worker_thread_->Invoke<RtpDataChannel*>(
       RTC_FROM_HERE, Bind(&ChannelManager::CreateRtpDataChannel_w, this,
-                          media_controller, rtp_transport, rtcp_transport,
+                          media_config, rtp_transport, rtcp_transport,
                           signaling_thread, content_name, srtp_required));
 }
 
 RtpDataChannel* ChannelManager::CreateRtpDataChannel_w(
-    webrtc::MediaControllerInterface* media_controller,
+    const cricket::MediaConfig& media_config,
     DtlsTransportInternal* rtp_transport,
     DtlsTransportInternal* rtcp_transport,
     rtc::Thread* signaling_thread,
     const std::string& content_name,
     bool srtp_required) {
   // This is ok to alloc from a thread other than the worker thread.
   RTC_DCHECK(initialized_);
-  MediaConfig config;
-  if (media_controller) {
-    config = media_controller->config();
-  }
-  DataMediaChannel* media_channel = data_media_engine_->CreateChannel(config);
+  DataMediaChannel* media_channel
+      = data_media_engine_->CreateChannel(media_config);
   if (!media_channel) {
     LOG(LS_WARNING) << "Failed to create RTP data channel.";
     return nullptr;
   }
 
   RtpDataChannel* data_channel = new RtpDataChannel(
       worker_thread_, network_thread_, signaling_thread, media_channel,
       content_name, rtcp_transport == nullptr, srtp_required);
   if (!data_channel->Init_w(rtp_transport, rtcp_transport, rtp_transport,
                             rtcp_transport)) {
@@ skipping 35 matching lines @@
                           media_engine_.get(), file, max_size_bytes));
 }
 
 void ChannelManager::StopAecDump() {
   worker_thread_->Invoke<void>(
       RTC_FROM_HERE,
       Bind(&MediaEngineInterface::StopAecDump, media_engine_.get()));
 }
 
 }  // namespace cricket