Delete MediaController class, move Call ownership to PeerConnection.

webrtc/ortc/rtptransportcontrolleradapter.cc

 /*
  *  Copyright 2017 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.
  */
 
@@ skipping 103 matching lines @@
   if (voice_channel_) {
     // This would mean audio RTP senders/receivers that are using us haven't
     // been destroyed. This isn't safe (see error log above).
     DestroyVoiceChannel();
   }
   if (voice_channel_) {
     // This would mean video RTP senders/receivers that are using us haven't
     // been destroyed. This isn't safe (see error log above).
     DestroyVideoChannel();
   }
+  // Call must be destroyed on the worker thread.
+  worker_thread_->Invoke<void>(
+      RTC_FROM_HERE,
+      rtc::Bind(&RtpTransportControllerAdapter::Close_w, this));
 }
 
 RTCErrorOr<std::unique_ptr<RtpTransportInterface>>
 RtpTransportControllerAdapter::CreateProxiedRtpTransport(
     const RtcpParameters& rtcp_parameters,
     PacketTransportInterface* rtp,
     PacketTransportInterface* rtcp) {
   auto result =
       RtpTransportAdapter::CreateProxied(rtcp_parameters, rtp, rtcp, this);
   if (result.ok()) {
@@ skipping 443 matching lines @@
 }
 
 RtpTransportControllerAdapter::RtpTransportControllerAdapter(
     const cricket::MediaConfig& config,
     cricket::ChannelManager* channel_manager,
     webrtc::RtcEventLog* event_log,
     rtc::Thread* signaling_thread,
     rtc::Thread* worker_thread)
     : signaling_thread_(signaling_thread),
       worker_thread_(worker_thread),
-      media_controller_(MediaControllerInterface::Create(config,
-                                                         worker_thread,
-                                                         channel_manager,
-                                                         event_log)) {
+      media_config_(config),
+      channel_manager_(channel_manager),
+      event_log_(event_log) {
   RTC_DCHECK_RUN_ON(signaling_thread_);
-  RTC_DCHECK(channel_manager);
-  // MediaControllerInterface::Create should never fail.
-  RTC_DCHECK(media_controller_);
+  RTC_DCHECK(channel_manager_);
   // Add "dummy" codecs to the descriptions, because the media engines
   // currently reject empty lists of codecs. Note that these codecs will never
   // actually be used, because when parameters are set, the dummy codecs will
   // be replaced by actual codecs before any send/receive streams are created.
   static const cricket::AudioCodec dummy_audio(0, cricket::kPcmuCodecName, 8000,
                                                0, 1);
   static const cricket::VideoCodec dummy_video(96, cricket::kVp8CodecName);
   local_audio_description_.AddCodec(dummy_audio);
   remote_audio_description_.AddCodec(dummy_audio);
   local_video_description_.AddCodec(dummy_video);
   remote_video_description_.AddCodec(dummy_video);
+
+  worker_thread_->Invoke<void>(
+      RTC_FROM_HERE,
+      rtc::Bind(&RtpTransportControllerAdapter::Init_w, this));
+}
+
+// TODO(nisse): Duplicates corresponding method in PeerConnection (used
+// to be in MediaController).

[stefan-webrtc, 2017/05/05 08:47:05]

I think this TODO should say when these duplicates can be removed, and perhaps
why they're needed?

[stefan-webrtc, 2017/05/05 08:53:50]

Talked offline, and duplicates are needed since this is an ORTC object and isn't
used by PC. 

[nisse-webrtc, 2017/05/05 09:02:37]

I'm afraid I'm not at all familiar with the new ortc-related code. Taylor, do
you see any good way to reduce duplication?

One possibility might be make these bandwidth values the default values in the
definition of the config struct? (For a followup, I'll now try to get this cl
landed).

[Taylor Brandstetter, 2017/05/05 16:32:01]

I wouldn't worry about reducing this duplication. Eventually this whole class
will be deleted and it will naturally go away; see the comment in the header
file. Speaking of which, that comment should be updated to remove "wraps a
MediaController".

+void RtpTransportControllerAdapter::Init_w() {
+  RTC_DCHECK(worker_thread_->IsCurrent());
+  RTC_DCHECK(!call_);
+
+  const int kMinBandwidthBps = 30000;
+  const int kStartBandwidthBps = 300000;
+  const int kMaxBandwidthBps = 2000000;
+
+  webrtc::Call::Config call_config(event_log_);
+  call_config.audio_state = channel_manager_->media_engine()->GetAudioState();
+  call_config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
+  call_config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
+  call_config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
+
+  call_.reset(webrtc::Call::Create(call_config));
+}
+
+void RtpTransportControllerAdapter::Close_w() {
+  call_.reset();
 }
 
 RTCError RtpTransportControllerAdapter::AttachAudioSender(
     OrtcRtpSenderAdapter* sender,
     RtpTransportInterface* inner_transport) {
   if (have_audio_sender_) {
     LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
                          "Using two audio RtpSenders with the same "
                          "RtpTransportControllerAdapter is not currently "
                          "supported.");
@@ skipping 195 matching lines @@
   // Empty parameters should result in receiving being stopped.
   RTCError err = ValidateAndApplyVideoReceiverParameters(RtpParameters());
   RTC_DCHECK(err.ok());
   have_video_receiver_ = false;
   if (!have_video_sender_) {
     DestroyVideoChannel();
   }
 }
 
 void RtpTransportControllerAdapter::CreateVoiceChannel() {
-  voice_channel_ = media_controller_->channel_manager()->CreateVoiceChannel(
-      media_controller_.get(),
+  voice_channel_ = channel_manager_->CreateVoiceChannel(
+      call_.get(), media_config_,
       inner_audio_transport_->GetRtpPacketTransport()->GetInternal(),
       inner_audio_transport_->GetRtcpPacketTransport()
           ? inner_audio_transport_->GetRtcpPacketTransport()->GetInternal()
           : nullptr,
       signaling_thread_, "audio", false, cricket::AudioOptions());
   RTC_DCHECK(voice_channel_);
   voice_channel_->Enable(true);
 }
 
 void RtpTransportControllerAdapter::CreateVideoChannel() {
-  video_channel_ = media_controller_->channel_manager()->CreateVideoChannel(
-      media_controller_.get(),
+  video_channel_ = channel_manager_->CreateVideoChannel(
+      call_.get(), media_config_,
       inner_video_transport_->GetRtpPacketTransport()->GetInternal(),
       inner_video_transport_->GetRtcpPacketTransport()
           ? inner_video_transport_->GetRtcpPacketTransport()->GetInternal()
           : nullptr,
       signaling_thread_, "video", false, cricket::VideoOptions());
   RTC_DCHECK(video_channel_);
   video_channel_->Enable(true);
 }
 
 void RtpTransportControllerAdapter::DestroyVoiceChannel() {
   RTC_DCHECK(voice_channel_);
-  media_controller_->channel_manager()->DestroyVoiceChannel(voice_channel_);
+  channel_manager_->DestroyVoiceChannel(voice_channel_);
   voice_channel_ = nullptr;
   inner_audio_transport_ = nullptr;
 }
 
 void RtpTransportControllerAdapter::DestroyVideoChannel() {
   RTC_DCHECK(video_channel_);
-  media_controller_->channel_manager()->DestroyVideoChannel(video_channel_);
+  channel_manager_->DestroyVideoChannel(video_channel_);
   video_channel_ = nullptr;
   inner_video_transport_ = nullptr;
 }
 
 void RtpTransportControllerAdapter::CopyRtcpParametersToDescriptions(
     const RtcpParameters& params,
     cricket::MediaContentDescription* local,
     cricket::MediaContentDescription* remote) {
   local->set_rtcp_mux(params.mux);
   remote->set_rtcp_mux(params.mux);
@@ skipping 82 matching lines @@
     local_description->set_cryptos(cryptos);
 
     cryptos.clear();
     cryptos.push_back(*(rtp_transport->GetInternal()->send_key()));
     remote_description->set_cryptos(cryptos);
   }
   return RTCError::OK();
 }
 
 }  // namespace webrtc