Late initialize MediaController, for less resource i.e. ProcessThread, usage by PeerConnection.

webrtc/api/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 503 matching lines @@
         return true;
       }
     }
     return false;
   }
 
  private:
   bool ice_restart_;
 };
 
-WebRtcSession::WebRtcSession(webrtc::MediaControllerInterface* media_controller,
-                             rtc::Thread* signaling_thread,
+WebRtcSession::WebRtcSession(rtc::Thread* signaling_thread,
                              rtc::Thread* worker_thread,
                              cricket::PortAllocator* port_allocator)
     : signaling_thread_(signaling_thread),
       worker_thread_(worker_thread),
       port_allocator_(port_allocator),
       // 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_(new cricket::TransportController(signaling_thread,
                                                              worker_thread,
                                                              port_allocator)),
-      media_controller_(media_controller),
-      channel_manager_(media_controller_->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),
       ice_restart_latch_(new IceRestartAnswerLatch),
       metrics_observer_(NULL) {
   transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLED);
   transport_controller_->SignalConnectionState.connect(
       this, &WebRtcSession::OnTransportControllerConnectionState);
   transport_controller_->SignalReceiving.connect(
       this, &WebRtcSession::OnTransportControllerReceiving);
   transport_controller_->SignalGatheringState.connect(
       this, &WebRtcSession::OnTransportControllerGatheringState);
   transport_controller_->SignalCandidatesGathered.connect(
       this, &WebRtcSession::OnTransportControllerCandidatesGathered);
 }
 
 WebRtcSession::~WebRtcSession() {
   ASSERT(signaling_thread()->IsCurrent());
   // Destroy video_channel_ first since it may have a pointer to the
   // voice_channel_.
   if (video_channel_) {
+    RTC_DCHECK(media_controller_);
     SignalVideoChannelDestroyed();
-    channel_manager_->DestroyVideoChannel(video_channel_.release());
+    media_controller_->channel_manager()->DestroyVideoChannel(
+        video_channel_.release());
   }
   if (voice_channel_) {
+    RTC_DCHECK(media_controller_);
     SignalVoiceChannelDestroyed();
-    channel_manager_->DestroyVoiceChannel(voice_channel_.release());
+    media_controller_->channel_manager()->DestroyVoiceChannel(
+        voice_channel_.release());
   }
   if (data_channel_) {
+    RTC_DCHECK(media_controller_);
     SignalDataChannelDestroyed();
-    channel_manager_->DestroyDataChannel(data_channel_.release());
+    media_controller_->channel_manager()->DestroyDataChannel(
+        data_channel_.release());
   }
   SignalDestroyed();
 
   LOG(LS_INFO) << "Session: " << id() << " is destroyed.";
 }
 
 bool WebRtcSession::Initialize(
     const PeerConnectionFactoryInterface::Options& options,
     const MediaConstraintsInterface* constraints,
     rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     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);
+  dtls_identity_store_ = std::move(dtls_identity_store);
 
   // Obtain a certificate from RTCConfiguration if any were provided (optional).
-  rtc::scoped_refptr<rtc::RTCCertificate> certificate;
   if (!rtc_configuration.certificates.empty()) {
     // TODO(hbos,torbjorng): Decide on certificate-selection strategy instead of
     // just picking the first one. The decision should be made based on the DTLS
     // handshake. The DTLS negotiations need to know about all certificates.
-    certificate = rtc_configuration.certificates[0];
+    certificate_ = rtc_configuration.certificates[0];
   }
 
   SetIceConfig(ParseIceConfig(rtc_configuration));
 
   // TODO(perkj): Take |constraints| into consideration. Return false if not all
   // mandatory constraints can be fulfilled. Note that |constraints|
   // can be null.
   bool value;
 
   if (options.disable_encryption) {
     dtls_enabled_ = false;
+    disable_encryption_ = true;
   } else {
     // Enable DTLS by default if we have an identity store or a certificate.
-    dtls_enabled_ = (dtls_identity_store || certificate);
+    dtls_enabled_ = (dtls_identity_store_ || certificate_);
     // |constraints| can override the default |dtls_enabled_| value.
     if (FindConstraint(constraints, MediaConstraintsInterface::kEnableDtlsSrtp,
                        &value, nullptr)) {
       dtls_enabled_ = value;
     }
   }
 
   // Enable creation of RTP data channels if the kEnableRtpDataChannels is set.
   // It takes precendence over the disable_sctp_data_channels
   // PeerConnectionFactoryInterface::Options.
@@ skipping 26 matching lines @@
   SetOptionFromOptionalConstraint(constraints,
       MediaConstraintsInterface::kCombinedAudioVideoBwe,
       &audio_options_.combined_audio_video_bwe);
 
   audio_options_.audio_jitter_buffer_max_packets =
       rtc::Optional<int>(rtc_configuration.audio_jitter_buffer_max_packets);
 
   audio_options_.audio_jitter_buffer_fast_accelerate = rtc::Optional<bool>(
       rtc_configuration.audio_jitter_buffer_fast_accelerate);
 
+  port_allocator()->set_candidate_filter(
+      ConvertIceTransportTypeToCandidateFilter(rtc_configuration.type));
+
+  return true;
+}
+
+void WebRtcSession::LateInitialize(
+    webrtc::MediaControllerInterface* media_controller) {
+  RTC_DCHECK(media_controller);
+  RTC_DCHECK(!media_controller_);
+  media_controller_ = media_controller;
+
   if (!dtls_enabled_) {
     // Construct with DTLS disabled.
     webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory(
-        signaling_thread(), channel_manager_, this, id()));
+        signaling_thread(), media_controller_->channel_manager(), this, id()));
   } else {
     // Construct with DTLS enabled.
-    if (!certificate) {
+    if (!certificate_) {
       // Use the |dtls_identity_store| to generate a certificate.
-      RTC_DCHECK(dtls_identity_store);
+      RTC_DCHECK(dtls_identity_store_);
       webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory(
-          signaling_thread(), channel_manager_, std::move(dtls_identity_store),
-          this, id()));
+          signaling_thread(), media_controller_->channel_manager(),
+          std::move(dtls_identity_store_), this, id()));
     } else {
       // Use the already generated certificate.
       webrtc_session_desc_factory_.reset(new WebRtcSessionDescriptionFactory(
-          signaling_thread(), channel_manager_, certificate, this, id()));
+          signaling_thread(), media_controller_->channel_manager(),
+          certificate_, this, id()));

[tommi, 2016/02/22 15:22:05]

after LateInitialize() has executed, is there need for certificate_?  I'm
wondering if it could be passed as a parameter to LateInitialize or if we should
then (at least?) set certificate_ to null at the end of LateInitialize().

[the sun, 2016/02/23 14:14:03]

I decided not to pass it as an argument as that required storing some of the
other arguments to Initialize() (constraints, rtc_config). So it is one or the
other, and I chose the path where the logic would be changed the least.

Nulling certificate_ makes sense as we don't allow multiple calls to
LateInitialize() per the DCHECKs at the start, and the transfer of ownership of
dtls_identity_store. I wonder however, could there be a situation where we get
other DOM calls after pc.close()?

     }
   }
 
   webrtc_session_desc_factory_->SignalCertificateReady.connect(
       this, &WebRtcSession::OnCertificateReady);
 
-  if (options.disable_encryption) {
+  if (disable_encryption_) {
     webrtc_session_desc_factory_->SetSdesPolicy(cricket::SEC_DISABLED);
   }
-  port_allocator()->set_candidate_filter(
-      ConvertIceTransportTypeToCandidateFilter(rtc_configuration.type));
-
-  return true;
 }
 
 void WebRtcSession::Close() {
   SetState(STATE_CLOSED);
   RemoveUnusedChannels(nullptr);
   ASSERT(!voice_channel_);
   ASSERT(!video_channel_);
   ASSERT(!data_channel_);
+  media_controller_ = nullptr;
 }
 
 void WebRtcSession::SetSdesPolicy(cricket::SecurePolicy secure_policy) {
   webrtc_session_desc_factory_->SetSdesPolicy(secure_policy);
 }
 
 cricket::SecurePolicy WebRtcSession::SdesPolicy() const {
   return webrtc_session_desc_factory_->SdesPolicy();
 }
 
@@ skipping 986 matching lines @@
   }
   return true;
 }
 
 void WebRtcSession::RemoveUnusedChannels(const SessionDescription* desc) {
   // Destroy video_channel_ first since it may have a pointer to the
   // voice_channel_.
   const cricket::ContentInfo* video_info =
       cricket::GetFirstVideoContent(desc);
   if ((!video_info || video_info->rejected) && video_channel_) {
+    RTC_DCHECK(media_controller_);
     SignalVideoChannelDestroyed();
-    channel_manager_->DestroyVideoChannel(video_channel_.release());
+    media_controller_->channel_manager()->DestroyVideoChannel(
+        video_channel_.release());
   }
 
   const cricket::ContentInfo* voice_info =
       cricket::GetFirstAudioContent(desc);
   if ((!voice_info || voice_info->rejected) && voice_channel_) {
+    RTC_DCHECK(media_controller_);
     SignalVoiceChannelDestroyed();
-    channel_manager_->DestroyVoiceChannel(voice_channel_.release());
+    media_controller_->channel_manager()->DestroyVoiceChannel(
+        voice_channel_.release());
   }
 
   const cricket::ContentInfo* data_info =
       cricket::GetFirstDataContent(desc);
   if ((!data_info || data_info->rejected) && data_channel_) {
+    RTC_DCHECK(media_controller_);
     SignalDataChannelDestroyed();
-    channel_manager_->DestroyDataChannel(data_channel_.release());
+    media_controller_->channel_manager()->DestroyDataChannel(
+        data_channel_.release());
   }
 }
 
 // TODO(mallinath) - Add a correct error code if the channels are not created
 // due to BUNDLE is enabled but rtcp-mux is disabled.
 bool WebRtcSession::CreateChannels(const SessionDescription* desc) {
   // Creating the media channels and transport proxies.
   const cricket::ContentInfo* voice = cricket::GetFirstAudioContent(desc);
   if (voice && !voice->rejected && !voice_channel_) {
     if (!CreateVoiceChannel(voice)) {
@@ skipping 42 matching lines @@
     if (!EnableBundle(*bundle_group)) {
       LOG(LS_WARNING) << "max-bundle failed to enable bundling.";
       return false;
     }
   }
 
   return true;
 }
 
 bool WebRtcSession::CreateVoiceChannel(const cricket::ContentInfo* content) {
-  voice_channel_.reset(channel_manager_->CreateVoiceChannel(
+  RTC_DCHECK(media_controller_);
+  voice_channel_.reset(media_controller_->channel_manager()->CreateVoiceChannel(
       media_controller_, transport_controller_.get(), content->name, true,
       audio_options_));
   if (!voice_channel_) {
     return false;
   }
 
   voice_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
 
   SignalVoiceChannelCreated();
   voice_channel_->transport_channel()->SignalSentPacket.connect(
       this, &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 bool WebRtcSession::CreateVideoChannel(const cricket::ContentInfo* content) {
-  video_channel_.reset(channel_manager_->CreateVideoChannel(
+  RTC_DCHECK(media_controller_);
+  video_channel_.reset(media_controller_->channel_manager()->CreateVideoChannel(
       media_controller_, transport_controller_.get(), content->name, true,
       video_options_));
   if (!video_channel_) {
     return false;
   }
 
   video_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
 
   SignalVideoChannelCreated();
   video_channel_->transport_channel()->SignalSentPacket.connect(
       this, &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content) {
+  RTC_DCHECK(media_controller_);
   bool sctp = (data_channel_type_ == cricket::DCT_SCTP);
-  data_channel_.reset(channel_manager_->CreateDataChannel(
+  data_channel_.reset(media_controller_->channel_manager()->CreateDataChannel(
       transport_controller_.get(), content->name, !sctp, data_channel_type_));
   if (!data_channel_) {
     return false;
   }
 
   if (sctp) {
     data_channel_->SignalDataReceived.connect(
         this, &WebRtcSession::OnDataChannelMessageReceived);
   }
 
@@ skipping 316 matching lines @@
   }
   if (ssl_cipher_suite != rtc::TLS_NULL_WITH_NULL_NULL) {
     metrics_observer_->IncrementSparseEnumCounter(ssl_counter_type,
                                                   ssl_cipher_suite);
   }
 }
 
 void WebRtcSession::OnSentPacket_w(cricket::TransportChannel* channel,
                                    const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(worker_thread()->IsCurrent());
+  RTC_DCHECK(media_controller_);
   media_controller_->call_w()->OnSentPacket(sent_packet);
 }
 
 }  // namespace webrtc