MediaController/Call instantiation.

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 15 matching lines @@
  */
 
 #include "talk/session/media/channelmanager.h"
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #include <algorithm>
 
+#include "talk/app/webrtc/mediacontroller.h"
 #include "talk/media/base/capturemanager.h"
 #include "talk/media/base/hybriddataengine.h"
 #include "talk/media/base/rtpdataengine.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/devices/devicemanager.h"
 #ifdef HAVE_SCTP
 #include "talk/media/sctp/sctpdataengine.h"
 #endif
 #include "talk/session/media/srtpfilter.h"
 #include "webrtc/base/bind.h"
@@ skipping 255 matching lines @@
   capture_manager_.reset(NULL);
 }
 
 void ChannelManager::Terminate_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   // 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(), nullptr);
+    DestroyVoiceChannel_w(voice_channels_.back());
   }
   if (!SetCaptureDevice_w(NULL)) {
     LOG(LS_WARNING) << "failed to delete video capturer";
   }
   media_engine_->Terminate();
 }
 
 VoiceChannel* ChannelManager::CreateVoiceChannel(
+    webrtc::MediaControllerInterface* media_controller,
     BaseSession* session,
     const std::string& content_name,
     bool rtcp,
     const AudioOptions& options) {
   return worker_thread_->Invoke<VoiceChannel*>(
-      Bind(&ChannelManager::CreateVoiceChannel_w, this, session, content_name,
-           rtcp, options));
+      Bind(&ChannelManager::CreateVoiceChannel_w,
+          this,
+          media_controller,
+          session,
+          content_name,
+          rtcp,
+          options));
 }
 
 VoiceChannel* ChannelManager::CreateVoiceChannel_w(
+    webrtc::MediaControllerInterface* media_controller,
     BaseSession* session,
     const std::string& content_name,
     bool rtcp,
     const AudioOptions& options) {
   ASSERT(initialized_);
   ASSERT(worker_thread_ == rtc::Thread::Current());
-  VoiceMediaChannel* media_channel = media_engine_->CreateChannel(options);
+  ASSERT(nullptr != media_controller);
+  VoiceMediaChannel* media_channel =
+      media_engine_->CreateChannel(media_controller->call_w(), options);
   if (!media_channel)
     return nullptr;
 
   VoiceChannel* voice_channel = new VoiceChannel(
       worker_thread_, media_engine_.get(), media_channel,
       session, content_name, rtcp);
   if (!voice_channel->Init()) {
     delete voice_channel;
     return nullptr;
   }
   voice_channels_.push_back(voice_channel);
   return voice_channel;
 }
 
-void ChannelManager::DestroyVoiceChannel(VoiceChannel* voice_channel,
-                                         VideoChannel* video_channel) {
+void ChannelManager::DestroyVoiceChannel(VoiceChannel* voice_channel) {
   if (voice_channel) {
     worker_thread_->Invoke<void>(
-        Bind(&ChannelManager::DestroyVoiceChannel_w, this, voice_channel,
-             video_channel));
+        Bind(&ChannelManager::DestroyVoiceChannel_w, this, voice_channel));
   }
 }
 
-void ChannelManager::DestroyVoiceChannel_w(VoiceChannel* voice_channel,
-                                           VideoChannel* video_channel) {
+void ChannelManager::DestroyVoiceChannel_w(VoiceChannel* voice_channel) {
   // Destroy voice channel.
   ASSERT(initialized_);
   ASSERT(worker_thread_ == rtc::Thread::Current());
   VoiceChannels::iterator it = std::find(voice_channels_.begin(),
       voice_channels_.end(), voice_channel);
   ASSERT(it != voice_channels_.end());
   if (it == voice_channels_.end())
     return;
-
-  if (video_channel) {
-    video_channel->media_channel()->DetachVoiceChannel();
-  }
   voice_channels_.erase(it);
   delete voice_channel;
 }
 
 VideoChannel* ChannelManager::CreateVideoChannel(
+    webrtc::MediaControllerInterface* media_controller,
     BaseSession* session,
     const std::string& content_name,
     bool rtcp,
-    VoiceChannel* voice_channel) {
+    const VideoOptions& options) {
   return worker_thread_->Invoke<VideoChannel*>(
       Bind(&ChannelManager::CreateVideoChannel_w,
            this,
+           media_controller,
            session,
            content_name,
            rtcp,
-           VideoOptions(),
-           voice_channel));
+           options));
 }
 
-VideoChannel* ChannelManager::CreateVideoChannel(
+VideoChannel* ChannelManager::CreateVideoChannel_w(
+    webrtc::MediaControllerInterface* media_controller,
     BaseSession* session,
     const std::string& content_name,
     bool rtcp,
-    const VideoOptions& options,
-    VoiceChannel* voice_channel) {
-  return worker_thread_->Invoke<VideoChannel*>(
-      Bind(&ChannelManager::CreateVideoChannel_w,
-           this,
-           session,
-           content_name,
-           rtcp,
-           options,
-           voice_channel));
-}
-
-VideoChannel* ChannelManager::CreateVideoChannel_w(
-    BaseSession* session,
-    const std::string& content_name,
-    bool rtcp,
-    const VideoOptions& options,
-    VoiceChannel* voice_channel) {
+    const VideoOptions& options) {
   ASSERT(initialized_);
   ASSERT(worker_thread_ == rtc::Thread::Current());
+  ASSERT(nullptr != media_controller);
   VideoMediaChannel* media_channel =
-      // voice_channel can be NULL in case of NullVoiceEngine.
-      media_engine_->CreateVideoChannel(
-          options, voice_channel ? voice_channel->media_channel() : NULL);
+      media_engine_->CreateVideoChannel(media_controller->call_w(), options);
   if (media_channel == NULL)
     return NULL;
 
   VideoChannel* video_channel = new VideoChannel(
       worker_thread_, media_channel,
       session, content_name, rtcp);
   if (!video_channel->Init()) {
     delete video_channel;
     return NULL;
   }
@@ skipping 487 matching lines @@
     const VideoFormat& max_format) {
   device_manager_->SetVideoCaptureDeviceMaxFormat(usb_id, max_format);
 }
 
 bool ChannelManager::StartAecDump(rtc::PlatformFile file) {
   return worker_thread_->Invoke<bool>(
       Bind(&MediaEngineInterface::StartAecDump, media_engine_.get(), file));
 }
 
 }  // namespace cricket