Delete MediaController class, move Call ownership to PeerConnection.

webrtc/pc/peerconnection.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 408 matching lines @@
   if (stats_collector_) {
     stats_collector_->WaitForPendingRequest();
     stats_collector_ = nullptr;
   }
   // Now destroy session_ before destroying other members,
   // because its destruction fires signals (such as VoiceChannelDestroyed)
   // which will trigger some final actions in PeerConnection...
   session_.reset(nullptr);
   // port_allocator_ lives on the network thread and should be destroyed there.
   network_thread()->Invoke<void>(RTC_FROM_HERE,
-                                 [this] { port_allocator_.reset(nullptr); });
+                                 [this] { port_allocator_.reset(); });
+  // call_ must be destroyed on the worker thread.
+  factory_->worker_thread()->Invoke<void>(RTC_FROM_HERE,
+                                          [this] { call_.reset(); });
 }
 
 bool PeerConnection::Initialize(
     const PeerConnectionInterface::RTCConfiguration& configuration,
     std::unique_ptr<cricket::PortAllocator> allocator,
     std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
     PeerConnectionObserver* observer) {
   TRACE_EVENT0("webrtc", "PeerConnection::Initialize");
   if (!allocator) {
     LOG(LS_ERROR) << "PeerConnection initialized without a PortAllocator? "
@@ skipping 10 matching lines @@
   port_allocator_ = std::move(allocator);
 
   // The port allocator lives on the network thread and should be initialized
   // there.
   if (!network_thread()->Invoke<bool>(
           RTC_FROM_HERE, rtc::Bind(&PeerConnection::InitializePortAllocator_n,
                                    this, configuration))) {
     return false;
   }
 
-  media_controller_.reset(factory_->CreateMediaController(
-      configuration.media_config, event_log_.get()));
+  // Call must be constructed on the worker thread.
+  factory_->worker_thread()->Invoke<void>(
+      RTC_FROM_HERE, rtc::Bind(&PeerConnection::CreateCall_w,
+                               this));
 
   session_.reset(new WebRtcSession(
-      media_controller_.get(), factory_->network_thread(),
+      call_.get(), factory_->channel_manager(), configuration.media_config,
+      event_log_.get(),
+      factory_->network_thread(),
       factory_->worker_thread(), factory_->signaling_thread(),
       port_allocator_.get(),
       std::unique_ptr<cricket::TransportController>(
           factory_->CreateTransportController(
               port_allocator_.get(),
               configuration.redetermine_role_on_ice_restart)),
 #ifdef HAVE_SCTP
       std::unique_ptr<cricket::SctpTransportInternalFactory>(
           new cricket::SctpTransportFactory(factory_->network_thread()))
 #else
@@ skipping 805 matching lines @@
   // Update stats here so that we have the most recent stats for tracks and
   // streams before the channels are closed.
   stats_->UpdateStats(kStatsOutputLevelStandard);
 
   session_->Close();
   event_log_.reset();
   network_thread()->Invoke<void>(
       RTC_FROM_HERE,
       rtc::Bind(&cricket::PortAllocator::DiscardCandidatePool,
                 port_allocator_.get()));
+
+  factory_->worker_thread()->Invoke<void>(RTC_FROM_HERE,
+                                          [this] { call_.reset(); });
 }
 
 void PeerConnection::OnSessionStateChange(WebRtcSession* /*session*/,
                                           WebRtcSession::State state) {
   switch (state) {
     case WebRtcSession::STATE_INIT:
       ChangeSignalingState(PeerConnectionInterface::kStable);
       break;
     case WebRtcSession::STATE_SENTOFFER:
       ChangeSignalingState(PeerConnectionInterface::kHaveLocalOffer);
@@ skipping 1007 matching lines @@
     return false;
   }
   return event_log_->StartLogging(file, max_size_bytes);
 }
 
 void PeerConnection::StopRtcEventLog_w() {
   if (event_log_) {
     event_log_->StopLogging();
   }
 }
+
+void PeerConnection::CreateCall_w() {

[the sun, 2017/05/02 20:30:20]

DCHECK thread affinity?

[nisse-webrtc, 2017/05/04 09:24:01]

Done.

+  RTC_DCHECK(!call_);
+
+  const int kMinBandwidthBps = 30000;
+  const int kStartBandwidthBps = 300000;
+  const int kMaxBandwidthBps = 2000000;
+
+  webrtc::Call::Config call_config(event_log_.get());
+  call_config.audio_state =
+      factory_->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));
+}
+
 }  // namespace webrtc