Delete MediaController class, move Call ownership to PeerConnection.

webrtc/pc/webrtcsession.cc

 /*
  *  Copyright 2012 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 443 matching lines @@
           old_transport_desc->ice_ufrag, old_transport_desc->ice_pwd,
           new_transport_desc->ice_ufrag, new_transport_desc->ice_pwd)) {
     LOG(LS_INFO) << "Remote peer requests ICE restart for " << content_name
                  << ".";
     return true;
   }
   return false;
 }
 
 WebRtcSession::WebRtcSession(
-    webrtc::MediaControllerInterface* media_controller,
+    cricket::ChannelManager* channel_manager,
+    const cricket::MediaConfig& media_config,
+    RtcEventLog* event_log,
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
     cricket::PortAllocator* port_allocator,
     std::unique_ptr<cricket::TransportController> transport_controller,
     std::unique_ptr<cricket::SctpTransportInternalFactory> sctp_factory)
     : network_thread_(network_thread),
       worker_thread_(worker_thread),
       signaling_thread_(signaling_thread),
       // RFC 3264: The numeric value of the session id and version in the
       // o line MUST be representable with a "64 bit signed integer".
       // Due to this constraint session id |sid_| is max limited to LLONG_MAX.
       sid_(rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX)),
       transport_controller_(std::move(transport_controller)),
       sctp_factory_(std::move(sctp_factory)),
-      media_controller_(media_controller),
-      channel_manager_(media_controller_->channel_manager()),
+      media_config_(media_config),
+      event_log_(event_log),
+      channel_manager_(channel_manager),
       ice_observer_(NULL),
       ice_connection_state_(PeerConnectionInterface::kIceConnectionNew),
       ice_connection_receiving_(true),
       older_version_remote_peer_(false),
       dtls_enabled_(false),
       data_channel_type_(cricket::DCT_NONE),
       metrics_observer_(NULL) {
   transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLED);
   transport_controller_->SignalConnectionState.connect(
       this, &WebRtcSession::OnTransportControllerConnectionState);
@@ skipping 26 matching lines @@
     SignalDataChannelDestroyed();
     network_thread_->Invoke<void>(
         RTC_FROM_HERE, rtc::Bind(&WebRtcSession::DestroySctpTransport_n, this));
   }
 #ifdef HAVE_QUIC
   if (quic_data_transport_) {
     quic_data_transport_.reset();
   }
 #endif
 
+  // Make sure Call is destructed on the worker thread.
+  if (state() != STATE_CLOSED) {
+    worker_thread_->Invoke<void>(RTC_FROM_HERE,
+                                 rtc::Bind(&WebRtcSession::Close_w, this));
+  }
   LOG(LS_INFO) << "Session: " << id() << " is destroyed.";
 }
 
 bool WebRtcSession::Initialize(
     const PeerConnectionFactoryInterface::Options& options,
     std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
     const PeerConnectionInterface::RTCConfiguration& rtc_configuration) {
   bundle_policy_ = rtc_configuration.bundle_policy;
   rtcp_mux_policy_ = rtc_configuration.rtcp_mux_policy;
   transport_controller_->SetSslMaxProtocolVersion(options.ssl_max_version);
@@ skipping 75 matching lines @@
     }
   }
 
   webrtc_session_desc_factory_->SignalCertificateReady.connect(
       this, &WebRtcSession::OnCertificateReady);
 
   if (options.disable_encryption) {
     webrtc_session_desc_factory_->SetSdesPolicy(cricket::SEC_DISABLED);
   }
 
+  worker_thread_->Invoke<void>(RTC_FROM_HERE,
+                               rtc::Bind(&WebRtcSession::Init_w, this));
+
   return true;
 }
 
+void WebRtcSession::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 WebRtcSession::Close() {
   SetState(STATE_CLOSED);
   RemoveUnusedChannels(nullptr);
   RTC_DCHECK(!voice_channel_);
   RTC_DCHECK(!video_channel_);
   RTC_DCHECK(!rtp_data_channel_);
   RTC_DCHECK(!sctp_transport_);
-  media_controller_->Close();
+
+  worker_thread_->Invoke<void>(RTC_FROM_HERE,
+                               rtc::Bind(&WebRtcSession::Close_w, this));
+}
+
+void WebRtcSession::Close_w() {
+  RTC_DCHECK(worker_thread_->IsCurrent());
+  call_.reset();
 }
 
 cricket::BaseChannel* WebRtcSession::GetChannel(
     const std::string& content_name) {
   if (voice_channel() && voice_channel()->content_name() == content_name) {
     return voice_channel();
   }
   if (video_channel() && video_channel()->content_name() == content_name) {
     return video_channel();
   }
@@ skipping 1106 matching lines @@
   cricket::DtlsTransportInternal* rtp_dtls_transport =
       transport_controller_->CreateDtlsTransport(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   cricket::DtlsTransportInternal* rtcp_dtls_transport = nullptr;
   if (!require_rtcp_mux) {
     rtcp_dtls_transport = transport_controller_->CreateDtlsTransport(
         transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 
   voice_channel_.reset(channel_manager_->CreateVoiceChannel(
-      media_controller_, rtp_dtls_transport, rtcp_dtls_transport,
+      call(), media_config_, rtp_dtls_transport, rtcp_dtls_transport,
       transport_controller_->signaling_thread(), content->name, SrtpRequired(),
       audio_options_));
   if (!voice_channel_) {
     transport_controller_->DestroyDtlsTransport(
         transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
     if (rtcp_dtls_transport) {
       transport_controller_->DestroyDtlsTransport(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
     }
     return false;
@@ skipping 21 matching lines @@
   cricket::DtlsTransportInternal* rtp_dtls_transport =
       transport_controller_->CreateDtlsTransport(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   cricket::DtlsTransportInternal* rtcp_dtls_transport = nullptr;
   if (!require_rtcp_mux) {
     rtcp_dtls_transport = transport_controller_->CreateDtlsTransport(
         transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 
   video_channel_.reset(channel_manager_->CreateVideoChannel(
-      media_controller_, rtp_dtls_transport, rtcp_dtls_transport,
+      call(), media_config_, rtp_dtls_transport, rtcp_dtls_transport,
       transport_controller_->signaling_thread(), content->name, SrtpRequired(),
       video_options_));
 
   if (!video_channel_) {
     transport_controller_->DestroyDtlsTransport(
         transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
     if (rtcp_dtls_transport) {
       transport_controller_->DestroyDtlsTransport(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
     }
@@ skipping 44 matching lines @@
     cricket::DtlsTransportInternal* rtp_dtls_transport =
         transport_controller_->CreateDtlsTransport(
             transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
     cricket::DtlsTransportInternal* rtcp_dtls_transport = nullptr;
     if (!require_rtcp_mux) {
       rtcp_dtls_transport = transport_controller_->CreateDtlsTransport(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
     }
 
     rtp_data_channel_.reset(channel_manager_->CreateRtpDataChannel(
-        media_controller_, rtp_dtls_transport, rtcp_dtls_transport,
+        media_config_, rtp_dtls_transport, rtcp_dtls_transport,
         transport_controller_->signaling_thread(), content->name,
         SrtpRequired()));
 
     if (!rtp_data_channel_) {
       transport_controller_->DestroyDtlsTransport(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
       if (rtcp_dtls_transport) {
         transport_controller_->DestroyDtlsTransport(
             transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
       }
@@ skipping 428 matching lines @@
                                                   srtp_crypto_suite);
   }
   if (ssl_cipher_suite != rtc::TLS_NULL_WITH_NULL_NULL) {
     metrics_observer_->IncrementSparseEnumCounter(ssl_counter_type,
                                                   ssl_cipher_suite);
   }
 }
 
 void WebRtcSession::OnSentPacket_w(const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(worker_thread()->IsCurrent());
-  media_controller_->call_w()->OnSentPacket(sent_packet);
+  call()->OnSentPacket(sent_packet);
 }
 
 const std::string WebRtcSession::GetTransportName(
     const std::string& content_name) {
   cricket::BaseChannel* channel = GetChannel(content_name);
   if (!channel) {
 #ifdef HAVE_QUIC
     if (data_channel_type_ == cricket::DCT_QUIC && quic_data_transport_ &&
         content_name == quic_data_transport_->transport_name()) {
       return quic_data_transport_->transport_name();
@@ skipping 57 matching lines @@
       (rtp_data_channel_->rtcp_dtls_transport() != nullptr);
   channel_manager_->DestroyRtpDataChannel(rtp_data_channel_.release());
   transport_controller_->DestroyDtlsTransport(
       transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   if (need_to_delete_rtcp) {
     transport_controller_->DestroyDtlsTransport(
         transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 }
 }  // namespace webrtc