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

webrtc/api/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.
  */
 
 #include "webrtc/api/peerconnection.h"
 
 #include <algorithm>
 #include <cctype>  // for isdigit
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/audiotrack.h"
 #include "webrtc/api/dtmfsender.h"
 #include "webrtc/api/jsepicecandidate.h"
 #include "webrtc/api/jsepsessiondescription.h"
-#include "webrtc/api/mediaconstraintsinterface.h"
 #include "webrtc/api/mediastream.h"
 #include "webrtc/api/mediastreamobserver.h"
 #include "webrtc/api/mediastreamproxy.h"
 #include "webrtc/api/mediastreamtrackproxy.h"
 #include "webrtc/api/remoteaudiosource.h"
 #include "webrtc/api/remotevideocapturer.h"
 #include "webrtc/api/rtpreceiver.h"
 #include "webrtc/api/rtpsender.h"
 #include "webrtc/api/streamcollection.h"
 #include "webrtc/api/videosource.h"
@@ skipping 500 matching lines @@
   // Candidates must have unique priorities, so that connectivity checks
   // are performed in a well-defined order.
   int priority = static_cast<int>(turn_servers->size() - 1);
   for (cricket::RelayServerConfig& turn_server : *turn_servers) {
     // First in the list gets highest priority.
     turn_server.priority = priority--;
   }
   return true;
 }
 
+class PeerConnection::StoredConstraints : public MediaConstraintsInterface {
+ public:
+  explicit StoredConstraints(const MediaConstraintsInterface* constraints) {
+    if (constraints) {
+      mandatory_ = constraints->GetMandatory();
+      optional_ = constraints->GetOptional();
+    }
+  }
+  ~StoredConstraints() override {}
+
+  const MediaConstraintsInterface::Constraints&
+      GetMandatory() const override { return mandatory_; }
+  const MediaConstraintsInterface::Constraints&
+      GetOptional() const override { return optional_; }
+ private:
+  MediaConstraintsInterface::Constraints mandatory_;
+  MediaConstraintsInterface::Constraints optional_;
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(StoredConstraints);
+};
+
+class PeerConnection::LiveSession {

[pthatcher1, 2016/02/26 21:51:20]

What is a LiveSession?  It appears to be a random bag of stuff with a funny
name.

The semantics seem to be "a MediaController plus everything that needs a
MediaController within a PeerConnection".

I think it would be much cleaner to:

1.  Add a WebRtcSession::SetMediaController, and have WebRtcSession act
reasonably when the MediaController is unset (not explode).

2.  Remove the dependency of RemoteMediaStreamFactory on MediaController.  If
that's too hard, also make a RemoteMediaStreamFactory::SetMediaController, like
for WebRtcSession.

3.  When it's time to create a MediaController, do so and set it on the
WebRtcSession (and the RemoteMediaStreamFactory if needed).



As another alternative, why don't we just create a MediaController which the
WebRtcSession and the RemoteMediaStreamFactory can reference immediately, but
not Init the MediaController until later?  It might be easier to work with a
MediaController that hasn't been Inited than with a WebRtcSession without a
MediaController.

[the sun, 2016/02/29 15:58:22]

Indeed. Great suggestion! Look at the current solution.

+ public:
+  LiveSession(PeerConnection* pc,
+              PeerConnectionFactory* factory,
+              cricket::PortAllocator* port_allocator,
+              const cricket::MediaConfig& media_config,
+              const PeerConnectionInterface::RTCConfiguration& configuration,
+              const MediaConstraintsInterface* constraints,
+              rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store) {
+    RTC_DCHECK(pc);
+    RTC_DCHECK(factory);
+    RTC_DCHECK(port_allocator);
+    RTC_DCHECK(constraints);
+    media_controller_.reset(factory->CreateMediaController(media_config));
+    remote_stream_factory_.reset(new RemoteMediaStreamFactory(
+        factory->signaling_thread(), media_controller_->channel_manager()));
+    session_.reset(
+        new WebRtcSession(media_controller_.get(), factory->signaling_thread(),
+                          factory->worker_thread(), port_allocator));
+    stats_.reset(new StatsCollector(pc));
+
+    // Initialize the WebRtcSession. It creates transport channels etc.
+    RTC_CHECK(session_->Initialize(factory->options(), constraints,
+        std::move(dtls_identity_store), configuration));
+
+    // Register PeerConnection as receiver of local ice candidates.
+    // All the callbacks will be posted to the application from PeerConnection.
+    session_->RegisterIceObserver(pc);
+    session_->SignalState.connect(pc, &PeerConnection::OnSessionStateChange);
+    session_->SignalVoiceChannelDestroyed.connect(
+        pc, &PeerConnection::OnVoiceChannelDestroyed);
+    session_->SignalVideoChannelDestroyed.connect(
+        pc, &PeerConnection::OnVideoChannelDestroyed);
+    session_->SignalDataChannelCreated.connect(
+        pc, &PeerConnection::OnDataChannelCreated);
+    session_->SignalDataChannelDestroyed.connect(
+        pc, &PeerConnection::OnDataChannelDestroyed);
+    session_->SignalDataChannelOpenMessage.connect(
+        pc, &PeerConnection::OnDataChannelOpenMessage);
+  }
+
+  ~LiveSession() {
+    // TODO(solenberg): Disconnect signals. Kill kill kill.
+  }
+
+  RemoteMediaStreamFactory* remote_stream_factory() {
+    return remote_stream_factory_.get();
+  }
+  WebRtcSession* session() {
+    return session_.get();
+  }
+  StatsCollector* stats() {
+    return stats_.get();
+  }
+
+ private:
+  rtc::scoped_ptr<MediaControllerInterface> media_controller_;
+  rtc::scoped_ptr<RemoteMediaStreamFactory> remote_stream_factory_;
+  // The session_ scoped_ptr is declared at the bottom of PeerConnection
+  // because its destruction fires signals (such as VoiceChannelDestroyed)
+  // which will trigger some final actions in PeerConnection...
+  rtc::scoped_ptr<WebRtcSession> session_;
+  // ... But stats_ depends on session_ so it should be destroyed even earlier.
+  rtc::scoped_ptr<StatsCollector> stats_;
+
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(LiveSession);
+};
+
 PeerConnection::PeerConnection(PeerConnectionFactory* factory)
     : factory_(factory),
       observer_(NULL),
       uma_observer_(NULL),
       signaling_state_(kStable),
       ice_state_(kIceNew),
       ice_connection_state_(kIceConnectionNew),
       ice_gathering_state_(kIceGatheringNew),
       local_streams_(StreamCollection::Create()),
       remote_streams_(StreamCollection::Create()) {}
 
 PeerConnection::~PeerConnection() {
   TRACE_EVENT0("webrtc", "PeerConnection::~PeerConnection");
   RTC_DCHECK(signaling_thread()->IsCurrent());
-  // Need to detach RTP senders/receivers from WebRtcSession,
-  // since it's about to be destroyed.
-  for (const auto& sender : senders_) {
-    sender->Stop();
-  }
-  for (const auto& receiver : receivers_) {
-    receiver->Stop();
-  }
+  DestroyLiveSession();
 }
 
 bool PeerConnection::Initialize(
     const PeerConnectionInterface::RTCConfiguration& configuration,
     const MediaConstraintsInterface* constraints,
     rtc::scoped_ptr<cricket::PortAllocator> allocator,
     rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     PeerConnectionObserver* observer) {
   TRACE_EVENT0("webrtc", "PeerConnection::Initialize");
   RTC_DCHECK(observer != nullptr);
@@ skipping 31 matching lines @@
   if (configuration.tcp_candidate_policy == kTcpCandidatePolicyDisabled) {
     portallocator_flags |= cricket::PORTALLOCATOR_DISABLE_TCP;
     LOG(LS_INFO) << "TCP candidates are disabled.";
   }
 
   port_allocator_->set_flags(portallocator_flags);
   // No step delay is used while allocating ports.
   port_allocator_->set_step_delay(cricket::kMinimumStepDelay);
 
   // We rely on default values when constraints aren't found.
-  cricket::MediaConfig media_config;
-
-  media_config.disable_prerenderer_smoothing =
+  media_config_.disable_prerenderer_smoothing =
       configuration.disable_prerenderer_smoothing;
 
   // Find DSCP constraint.
   FindConstraint(constraints, MediaConstraintsInterface::kEnableDscp,
-                 &media_config.enable_dscp, NULL);
+                 &media_config_.enable_dscp, NULL);
   // Find constraints for cpu overuse detection.
   FindConstraint(constraints, MediaConstraintsInterface::kCpuOveruseDetection,
-                 &media_config.enable_cpu_overuse_detection, NULL);
+                 &media_config_.enable_cpu_overuse_detection, NULL);
 
-  media_controller_.reset(factory_->CreateMediaController(media_config));
-
-  remote_stream_factory_.reset(new RemoteMediaStreamFactory(
-      factory_->signaling_thread(), media_controller_->channel_manager()));
-
-  session_.reset(
-      new WebRtcSession(media_controller_.get(), factory_->signaling_thread(),
-                        factory_->worker_thread(), port_allocator_.get()));
-  stats_.reset(new StatsCollector(this));
-
-  // Initialize the WebRtcSession. It creates transport channels etc.
-  if (!session_->Initialize(factory_->options(), constraints,
-                            std::move(dtls_identity_store), configuration)) {
-    return false;
-  }
-
-  // Register PeerConnection as receiver of local ice candidates.
-  // All the callbacks will be posted to the application from PeerConnection.
-  session_->RegisterIceObserver(this);
-  session_->SignalState.connect(this, &PeerConnection::OnSessionStateChange);
-  session_->SignalVoiceChannelDestroyed.connect(
-      this, &PeerConnection::OnVoiceChannelDestroyed);
-  session_->SignalVideoChannelDestroyed.connect(
-      this, &PeerConnection::OnVideoChannelDestroyed);
-  session_->SignalDataChannelCreated.connect(
-      this, &PeerConnection::OnDataChannelCreated);
-  session_->SignalDataChannelDestroyed.connect(
-      this, &PeerConnection::OnDataChannelDestroyed);
-  session_->SignalDataChannelOpenMessage.connect(
-      this, &PeerConnection::OnDataChannelOpenMessage);
+  configuration_ = configuration;
+  constraints_.reset(new StoredConstraints(constraints));
+  dtls_identity_store_ = std::move(dtls_identity_store);
   return true;
 }
 
 rtc::scoped_refptr<StreamCollectionInterface>
 PeerConnection::local_streams() {
   return local_streams_;
 }
 
 rtc::scoped_refptr<StreamCollectionInterface>
 PeerConnection::remote_streams() {
@@ skipping 21 matching lines @@
       this, &PeerConnection::OnVideoTrackRemoved);
   stream_observers_.push_back(rtc::scoped_ptr<MediaStreamObserver>(observer));
 
   for (const auto& track : local_stream->GetAudioTracks()) {
     OnAudioTrackAdded(track.get(), local_stream);
   }
   for (const auto& track : local_stream->GetVideoTracks()) {
     OnVideoTrackAdded(track.get(), local_stream);
   }
 
-  stats_->AddStream(local_stream);
+  stats()->AddStream(local_stream);
   observer_->OnRenegotiationNeeded();
   return true;
 }
 
 void PeerConnection::RemoveStream(MediaStreamInterface* local_stream) {
   TRACE_EVENT0("webrtc", "PeerConnection::RemoveStream");
   for (const auto& track : local_stream->GetAudioTracks()) {
     OnAudioTrackRemoved(track.get(), local_stream);
   }
   for (const auto& track : local_stream->GetVideoTracks()) {
@@ skipping 21 matching lines @@
     std::vector<MediaStreamInterface*> streams) {
   TRACE_EVENT0("webrtc", "PeerConnection::AddTrack");
   if (IsClosed()) {
     return nullptr;
   }
   if (streams.size() >= 2) {
     LOG(LS_ERROR)
         << "Adding a track with two streams is not currently supported.";
     return nullptr;
   }
+
   // TODO(deadbeef): Support adding a track to two different senders.
   if (FindSenderForTrack(track) != senders_.end()) {
     LOG(LS_ERROR) << "Sender for track " << track->id() << " already exists.";
     return nullptr;
   }
 
   // TODO(deadbeef): Support adding a track to multiple streams.
   rtc::scoped_refptr<RtpSenderInterface> new_sender;
   if (track->kind() == MediaStreamTrackInterface::kAudioKind) {
     new_sender = RtpSenderProxy::Create(
         signaling_thread(),
-        new AudioRtpSender(static_cast<AudioTrackInterface*>(track),
-                           session_.get(), stats_.get()));
+        new AudioRtpSender(static_cast<AudioTrackInterface*>(track), session(),
+                           stats()));
     if (!streams.empty()) {
       new_sender->set_stream_id(streams[0]->label());
     }
     const TrackInfo* track_info = FindTrackInfo(
         local_audio_tracks_, new_sender->stream_id(), track->id());
     if (track_info) {
       new_sender->SetSsrc(track_info->ssrc);
     }
   } else if (track->kind() == MediaStreamTrackInterface::kVideoKind) {
     new_sender = RtpSenderProxy::Create(
         signaling_thread(),
         new VideoRtpSender(static_cast<VideoTrackInterface*>(track),
-                           session_.get()));
+                           session()));
     if (!streams.empty()) {
       new_sender->set_stream_id(streams[0]->label());
     }
     const TrackInfo* track_info = FindTrackInfo(
         local_video_tracks_, new_sender->stream_id(), track->id());
     if (track_info) {
       new_sender->SetSsrc(track_info->ssrc);
     }
   } else {
     LOG(LS_ERROR) << "CreateSender called with invalid kind: " << track->kind();
@@ skipping 16 matching lines @@
     LOG(LS_ERROR) << "Couldn't find sender " << sender->id() << " to remove.";
     return false;
   }
   (*it)->Stop();
   senders_.erase(it);
 
   observer_->OnRenegotiationNeeded();
   return true;
 }
 
+WebRtcSession* PeerConnection::session() {
+  CreateLiveSession();
+  return live_session_->session();
+}
+
 rtc::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
     AudioTrackInterface* track) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateDtmfSender");
   if (!track) {
     LOG(LS_ERROR) << "CreateDtmfSender - track is NULL.";
     return NULL;
   }
   if (!local_streams_->FindAudioTrack(track->id())) {
     LOG(LS_ERROR) << "CreateDtmfSender is called with a non local audio track.";
     return NULL;
   }
 
   rtc::scoped_refptr<DtmfSenderInterface> sender(
-      DtmfSender::Create(track, signaling_thread(), session_.get()));
+      DtmfSender::Create(track, signaling_thread(), session()));
   if (!sender.get()) {
     LOG(LS_ERROR) << "CreateDtmfSender failed on DtmfSender::Create.";
     return NULL;
   }
   return DtmfSenderProxy::Create(signaling_thread(), sender.get());
 }
 
 rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
     const std::string& kind,
     const std::string& stream_id) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateSender");
   rtc::scoped_refptr<RtpSenderInterface> new_sender;
   if (kind == MediaStreamTrackInterface::kAudioKind) {
     new_sender = RtpSenderProxy::Create(
-        signaling_thread(), new AudioRtpSender(session_.get(), stats_.get()));
+        signaling_thread(), new AudioRtpSender(session(), stats()));
   } else if (kind == MediaStreamTrackInterface::kVideoKind) {
     new_sender = RtpSenderProxy::Create(signaling_thread(),
-                                        new VideoRtpSender(session_.get()));
+                                        new VideoRtpSender(session()));
   } else {
     LOG(LS_ERROR) << "CreateSender called with invalid kind: " << kind;
     return new_sender;
   }
   if (!stream_id.empty()) {
     new_sender->set_stream_id(stream_id);
   }
   senders_.push_back(new_sender);
   return new_sender;
 }
@@ skipping 11 matching lines @@
 bool PeerConnection::GetStats(StatsObserver* observer,
                               MediaStreamTrackInterface* track,
                               StatsOutputLevel level) {
   TRACE_EVENT0("webrtc", "PeerConnection::GetStats");
   RTC_DCHECK(signaling_thread()->IsCurrent());
   if (!VERIFY(observer != NULL)) {
     LOG(LS_ERROR) << "GetStats - observer is NULL.";
     return false;
   }
 
-  stats_->UpdateStats(level);
+  stats()->UpdateStats(level);
   signaling_thread()->Post(this, MSG_GETSTATS,
                            new GetStatsMsg(observer, track));
   return true;
 }
 
 PeerConnectionInterface::SignalingState PeerConnection::signaling_state() {
   return signaling_state_;
 }
 
 PeerConnectionInterface::IceState PeerConnection::ice_state() {
@@ skipping 22 matching lines @@
     internal_config.reset(new InternalDataChannelInit(*config));
   }
   rtc::scoped_refptr<DataChannelInterface> channel(
       InternalCreateDataChannel(label, internal_config.get()));
   if (!channel.get()) {
     return nullptr;
   }
 
   // Trigger the onRenegotiationNeeded event for every new RTP DataChannel, or
   // the first SCTP DataChannel.
-  if (session_->data_channel_type() == cricket::DCT_RTP || first_datachannel) {
+  if (session()->data_channel_type() == cricket::DCT_RTP || first_datachannel) {
     observer_->OnRenegotiationNeeded();
   }
 
   return DataChannelProxy::Create(signaling_thread(), channel.get());
 }
 
 void PeerConnection::CreateOffer(CreateSessionDescriptionObserver* observer,
                                  const MediaConstraintsInterface* constraints) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateOffer");
   if (!VERIFY(observer != nullptr)) {
@@ skipping 54 matching lines @@
   }
 
   cricket::MediaSessionOptions session_options;
   if (!GetOptionsForOffer(options, &session_options)) {
     std::string error = "CreateOffer called with invalid options.";
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailure(observer, error);
     return;
   }
 
-  session_->CreateOffer(observer, options, session_options);
+  session()->CreateOffer(observer, options, session_options);
 }
 
 void PeerConnection::CreateAnswer(
     CreateSessionDescriptionObserver* observer,
     const MediaConstraintsInterface* constraints) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateAnswer");
   if (!VERIFY(observer != nullptr)) {
     LOG(LS_ERROR) << "CreateAnswer - observer is NULL.";
     return;
   }
 
   cricket::MediaSessionOptions session_options;
   if (!GetOptionsForAnswer(constraints, &session_options)) {
     std::string error = "CreateAnswer called with invalid constraints.";
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailure(observer, error);
     return;
   }
 
-  session_->CreateAnswer(observer, constraints, session_options);
+  session()->CreateAnswer(observer, constraints, session_options);
 }
 
 void PeerConnection::SetLocalDescription(
     SetSessionDescriptionObserver* observer,
     SessionDescriptionInterface* desc) {
   TRACE_EVENT0("webrtc", "PeerConnection::SetLocalDescription");
   if (!VERIFY(observer != nullptr)) {
     LOG(LS_ERROR) << "SetLocalDescription - observer is NULL.";
     return;
   }
   if (!desc) {
     PostSetSessionDescriptionFailure(observer, "SessionDescription is NULL.");
     return;
   }
   // Update stats here so that we have the most recent stats for tracks and
   // streams that might be removed by updating the session description.
-  stats_->UpdateStats(kStatsOutputLevelStandard);
+  stats()->UpdateStats(kStatsOutputLevelStandard);
   std::string error;
-  if (!session_->SetLocalDescription(desc, &error)) {
+  if (!session()->SetLocalDescription(desc, &error)) {
     PostSetSessionDescriptionFailure(observer, error);
     return;
   }
 
   // If setting the description decided our SSL role, allocate any necessary
   // SCTP sids.
   rtc::SSLRole role;
-  if (session_->data_channel_type() == cricket::DCT_SCTP &&
-      session_->GetSslRole(session_->data_channel(), &role)) {
+  if (session()->data_channel_type() == cricket::DCT_SCTP &&
+      session()->GetSslRole(session()->data_channel(), &role)) {
     AllocateSctpSids(role);
   }
 
   // Update state and SSRC of local MediaStreams and DataChannels based on the
   // local session description.
   const cricket::ContentInfo* audio_content =
       GetFirstAudioContent(desc->description());
   if (audio_content) {
     if (audio_content->rejected) {
       RemoveTracks(cricket::MEDIA_TYPE_AUDIO);
@@ skipping 29 matching lines @@
       UpdateLocalRtpDataChannels(data_desc->streams());
     }
   }
 
   SetSessionDescriptionMsg* msg = new SetSessionDescriptionMsg(observer);
   signaling_thread()->Post(this, MSG_SET_SESSIONDESCRIPTION_SUCCESS, msg);
 
   // MaybeStartGathering needs to be called after posting
   // MSG_SET_SESSIONDESCRIPTION_SUCCESS, so that we don't signal any candidates
   // before signaling that SetLocalDescription completed.
-  session_->MaybeStartGathering();
+  session()->MaybeStartGathering();
 }
 
 void PeerConnection::SetRemoteDescription(
     SetSessionDescriptionObserver* observer,
     SessionDescriptionInterface* desc) {
   TRACE_EVENT0("webrtc", "PeerConnection::SetRemoteDescription");
   if (!VERIFY(observer != nullptr)) {
     LOG(LS_ERROR) << "SetRemoteDescription - observer is NULL.";
     return;
   }
   if (!desc) {
     PostSetSessionDescriptionFailure(observer, "SessionDescription is NULL.");
     return;
   }
   // Update stats here so that we have the most recent stats for tracks and
   // streams that might be removed by updating the session description.
-  stats_->UpdateStats(kStatsOutputLevelStandard);
+  stats()->UpdateStats(kStatsOutputLevelStandard);
   std::string error;
-  if (!session_->SetRemoteDescription(desc, &error)) {
+  if (!session()->SetRemoteDescription(desc, &error)) {
     PostSetSessionDescriptionFailure(observer, error);
     return;
   }
 
   // If setting the description decided our SSL role, allocate any necessary
   // SCTP sids.
   rtc::SSLRole role;
-  if (session_->data_channel_type() == cricket::DCT_SCTP &&
-      session_->GetSslRole(session_->data_channel(), &role)) {
+  if (session()->data_channel_type() == cricket::DCT_SCTP &&
+      session()->GetSslRole(session()->data_channel(), &role)) {
     AllocateSctpSids(role);
   }
 
   const cricket::SessionDescription* remote_desc = desc->description();
   const cricket::ContentInfo* audio_content = GetFirstAudioContent(remote_desc);
   const cricket::ContentInfo* video_content = GetFirstVideoContent(remote_desc);
   const cricket::AudioContentDescription* audio_desc =
       GetFirstAudioContentDescription(remote_desc);
   const cricket::VideoContentDescription* video_desc =
       GetFirstVideoContentDescription(remote_desc);
@@ skipping 46 matching lines @@
   if (data_desc) {
     if (rtc::starts_with(data_desc->protocol().data(),
                          cricket::kMediaProtocolRtpPrefix)) {
       UpdateRemoteRtpDataChannels(GetActiveStreams(data_desc));
     }
   }
 
   // Iterate new_streams and notify the observer about new MediaStreams.
   for (size_t i = 0; i < new_streams->count(); ++i) {
     MediaStreamInterface* new_stream = new_streams->at(i);
-    stats_->AddStream(new_stream);
+    stats()->AddStream(new_stream);
     observer_->OnAddStream(new_stream);
   }
 
   UpdateEndedRemoteMediaStreams();
 
   SetSessionDescriptionMsg* msg = new SetSessionDescriptionMsg(observer);
   signaling_thread()->Post(this, MSG_SET_SESSIONDESCRIPTION_SUCCESS, msg);
 }
 
 bool PeerConnection::SetConfiguration(const RTCConfiguration& config) {
   TRACE_EVENT0("webrtc", "PeerConnection::SetConfiguration");
   if (port_allocator_) {
     cricket::ServerAddresses stun_servers;
     std::vector<cricket::RelayServerConfig> turn_servers;
     if (!ParseIceServers(config.servers, &stun_servers, &turn_servers)) {
       return false;
     }
     port_allocator_->SetIceServers(stun_servers, turn_servers);
   }
-  session_->SetIceConfig(session_->ParseIceConfig(config));
-  return session_->SetIceTransports(config.type);
+  session()->SetIceConfig(session()->ParseIceConfig(config));
+  return session()->SetIceTransports(config.type);
 }
 
 bool PeerConnection::AddIceCandidate(
     const IceCandidateInterface* ice_candidate) {
   TRACE_EVENT0("webrtc", "PeerConnection::AddIceCandidate");
-  return session_->ProcessIceMessage(ice_candidate);
+  return session()->ProcessIceMessage(ice_candidate);
 }
 
 void PeerConnection::RegisterUMAObserver(UMAObserver* observer) {
   TRACE_EVENT0("webrtc", "PeerConnection::RegisterUmaObserver");
   uma_observer_ = observer;
 
-  if (session_) {
-    session_->set_metrics_observer(uma_observer_);
+  if (live_session_) {
+    session()->set_metrics_observer(uma_observer_);
   }
 
   // Send information about IPv4/IPv6 status.
   if (uma_observer_ && port_allocator_) {
     if (port_allocator_->flags() & cricket::PORTALLOCATOR_ENABLE_IPV6) {
       uma_observer_->IncrementEnumCounter(
           kEnumCounterAddressFamily, kPeerConnection_IPv6,
           kPeerConnectionAddressFamilyCounter_Max);
     } else {
       uma_observer_->IncrementEnumCounter(
           kEnumCounterAddressFamily, kPeerConnection_IPv4,
           kPeerConnectionAddressFamilyCounter_Max);
     }
   }
 }
 
 const SessionDescriptionInterface* PeerConnection::local_description() const {
-  return session_->local_description();
+  return session()->local_description();
 }
 
 const SessionDescriptionInterface* PeerConnection::remote_description() const {
-  return session_->remote_description();
+  return session()->remote_description();
 }
 
 void PeerConnection::Close() {
   TRACE_EVENT0("webrtc", "PeerConnection::Close");
   // 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();
+  stats()->UpdateStats(kStatsOutputLevelStandard);
+  session()->Close();
+  DestroyLiveSession();
 }
 
 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 37 matching lines @@
     case MSG_CREATE_SESSIONDESCRIPTION_FAILED: {
       CreateSessionDescriptionMsg* param =
           static_cast<CreateSessionDescriptionMsg*>(msg->pdata);
       param->observer->OnFailure(param->error);
       delete param;
       break;
     }
     case MSG_GETSTATS: {
       GetStatsMsg* param = static_cast<GetStatsMsg*>(msg->pdata);
       StatsReports reports;
-      stats_->GetStats(param->track, &reports);
+      stats()->GetStats(param->track, &reports);
       param->observer->OnComplete(reports);
       delete param;
       break;
     }
     case MSG_FREE_DATACHANNELS: {
       sctp_data_channels_to_free_.clear();
       break;
     }
     default:
       RTC_DCHECK(false && "Not implemented");
       break;
   }
 }
 
 void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream,
                                          AudioTrackInterface* audio_track,
                                          uint32_t ssrc) {
   receivers_.push_back(RtpReceiverProxy::Create(
       signaling_thread(),
-      new AudioRtpReceiver(audio_track, ssrc, session_.get())));
+      new AudioRtpReceiver(audio_track, ssrc, session())));
 }
 
 void PeerConnection::CreateVideoReceiver(MediaStreamInterface* stream,
                                          VideoTrackInterface* video_track,
                                          uint32_t ssrc) {
   receivers_.push_back(RtpReceiverProxy::Create(
       signaling_thread(),
-      new VideoRtpReceiver(video_track, ssrc, session_.get())));
+      new VideoRtpReceiver(video_track, ssrc, session())));
 }
 
 // TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
 // description.
 void PeerConnection::DestroyAudioReceiver(MediaStreamInterface* stream,
                                           AudioTrackInterface* audio_track) {
   auto it = FindReceiverForTrack(audio_track);
   if (it == receivers_.end()) {
     LOG(LS_WARNING) << "RtpReceiver for track with id " << audio_track->id()
                     << " doesn't exist.";
@@ skipping 67 matching lines @@
   if (sender != senders_.end()) {
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
     (*sender)->set_stream_id(stream->label());
     return;
   }
 
   // Normal case; we've never seen this track before.
   rtc::scoped_refptr<RtpSenderInterface> new_sender = RtpSenderProxy::Create(
       signaling_thread(),
-      new AudioRtpSender(track, stream->label(), session_.get(), stats_.get()));
+      new AudioRtpSender(track, stream->label(), session(), stats()));
   senders_.push_back(new_sender);
   // If the sender has already been configured in SDP, we call SetSsrc,
   // which will connect the sender to the underlying transport. This can
   // occur if a local session description that contains the ID of the sender
   // is set before AddStream is called. It can also occur if the local
   // session description is not changed and RemoveStream is called, and
   // later AddStream is called again with the same stream.
   const TrackInfo* track_info =
       FindTrackInfo(local_audio_tracks_, stream->label(), track->id());
   if (track_info) {
@@ skipping 21 matching lines @@
   if (sender != senders_.end()) {
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
     (*sender)->set_stream_id(stream->label());
     return;
   }
 
   // Normal case; we've never seen this track before.
   rtc::scoped_refptr<RtpSenderInterface> new_sender = RtpSenderProxy::Create(
       signaling_thread(),
-      new VideoRtpSender(track, stream->label(), session_.get()));
+      new VideoRtpSender(track, stream->label(), session()));
   senders_.push_back(new_sender);
   const TrackInfo* track_info =
       FindTrackInfo(local_video_tracks_, stream->label(), track->id());
   if (track_info) {
     new_sender->SetSsrc(track_info->ssrc);
   }
 }
 
 void PeerConnection::OnVideoTrackRemoved(VideoTrackInterface* track,
                                          MediaStreamInterface* stream) {
@@ skipping 21 matching lines @@
   CreateSessionDescriptionMsg* msg = new CreateSessionDescriptionMsg(observer);
   msg->error = error;
   signaling_thread()->Post(this, MSG_CREATE_SESSIONDESCRIPTION_FAILED, msg);
 }
 
 bool PeerConnection::GetOptionsForOffer(
     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
     cricket::MediaSessionOptions* session_options) {
   // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
   // ContentInfos.
-  if (session_->local_description()) {
+  if (session()->local_description()) {
     for (const cricket::ContentInfo& content :
-         session_->local_description()->description()->contents()) {
+         session()->local_description()->description()->contents()) {
       session_options->transport_options[content.name] =
           cricket::TransportOptions();
     }
   }
   if (!ConvertRtcOptionsForOffer(rtc_options, session_options)) {
     return false;
   }
 
   AddSendStreams(session_options, senders_, rtp_data_channels_);
   // Offer to receive audio/video if the constraint is not set and there are
   // send streams, or we're currently receiving.
   if (rtc_options.offer_to_receive_audio == RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_audio =
         session_options->HasSendMediaStream(cricket::MEDIA_TYPE_AUDIO) ||
         !remote_audio_tracks_.empty();
   }
   if (rtc_options.offer_to_receive_video == RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_video =
         session_options->HasSendMediaStream(cricket::MEDIA_TYPE_VIDEO) ||
         !remote_video_tracks_.empty();
   }
   session_options->bundle_enabled =
       session_options->bundle_enabled &&
       (session_options->has_audio() || session_options->has_video() ||
        session_options->has_data());
 
-  if (session_->data_channel_type() == cricket::DCT_SCTP && HasDataChannels()) {
+  if (session()->data_channel_type() == cricket::DCT_SCTP &&
+      HasDataChannels()) {
     session_options->data_channel_type = cricket::DCT_SCTP;
   }
   return true;
 }
 
 bool PeerConnection::GetOptionsForAnswer(
     const MediaConstraintsInterface* constraints,
     cricket::MediaSessionOptions* session_options) {
   session_options->recv_audio = false;
   session_options->recv_video = false;
   // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
   // ContentInfos.
-  if (session_->remote_description()) {
+  if (session()->remote_description()) {
     // Initialize the transport_options map.
     for (const cricket::ContentInfo& content :
-         session_->remote_description()->description()->contents()) {
+         session()->remote_description()->description()->contents()) {
       session_options->transport_options[content.name] =
           cricket::TransportOptions();
     }
   }
   if (!ParseConstraintsForAnswer(constraints, session_options)) {
     return false;
   }
 
   AddSendStreams(session_options, senders_, rtp_data_channels_);
   session_options->bundle_enabled =
       session_options->bundle_enabled &&
       (session_options->has_audio() || session_options->has_video() ||
        session_options->has_data());
 
   // RTP data channel is handled in MediaSessionOptions::AddStream. SCTP streams
   // are not signaled in the SDP so does not go through that path and must be
   // handled here.
-  if (session_->data_channel_type() == cricket::DCT_SCTP) {
+  if (session()->data_channel_type() == cricket::DCT_SCTP) {
     session_options->data_channel_type = cricket::DCT_SCTP;
   }
   return true;
 }
 
 void PeerConnection::RemoveTracks(cricket::MediaType media_type) {
   UpdateLocalTracks(std::vector<cricket::StreamParams>(), media_type);
   UpdateRemoteStreamsList(std::vector<cricket::StreamParams>(), false,
                           media_type, nullptr);
 }
@@ skipping 28 matching lines @@
     // The sync_label is the MediaStream label and the |stream.id| is the
     // track id.
     const std::string& stream_label = params.sync_label;
     const std::string& track_id = params.id;
     uint32_t ssrc = params.first_ssrc();
 
     rtc::scoped_refptr<MediaStreamInterface> stream =
         remote_streams_->find(stream_label);
     if (!stream) {
       // This is a new MediaStream. Create a new remote MediaStream.
-      stream = remote_stream_factory_->CreateMediaStream(stream_label);
+      stream = remote_stream_factory()->CreateMediaStream(stream_label);
       remote_streams_->AddStream(stream);
       new_streams->AddStream(stream);
     }
 
     const TrackInfo* track_info =
         FindTrackInfo(*current_tracks, stream_label, track_id);
     if (!track_info) {
       current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc));
       OnRemoteTrackSeen(stream_label, track_id, ssrc, media_type);
     }
   }
 
   // Add default track if necessary.
   if (default_track_needed) {
     rtc::scoped_refptr<MediaStreamInterface> default_stream =
         remote_streams_->find(kDefaultStreamLabel);
     if (!default_stream) {
       // Create the new default MediaStream.
       default_stream =
-          remote_stream_factory_->CreateMediaStream(kDefaultStreamLabel);
+          remote_stream_factory()->CreateMediaStream(kDefaultStreamLabel);
       remote_streams_->AddStream(default_stream);
       new_streams->AddStream(default_stream);
     }
     std::string default_track_id = (media_type == cricket::MEDIA_TYPE_AUDIO)
                                        ? kDefaultAudioTrackLabel
                                        : kDefaultVideoTrackLabel;
     const TrackInfo* default_track_info =
         FindTrackInfo(*current_tracks, kDefaultStreamLabel, default_track_id);
     if (!default_track_info) {
       current_tracks->push_back(
           TrackInfo(kDefaultStreamLabel, default_track_id, 0));
       OnRemoteTrackSeen(kDefaultStreamLabel, default_track_id, 0, media_type);
     }
   }
 }
 
 void PeerConnection::OnRemoteTrackSeen(const std::string& stream_label,
                                        const std::string& track_id,
                                        uint32_t ssrc,
                                        cricket::MediaType media_type) {
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
-    AudioTrackInterface* audio_track = remote_stream_factory_->AddAudioTrack(
-        ssrc, session_.get(), stream, track_id);
+    AudioTrackInterface* audio_track = remote_stream_factory()->AddAudioTrack(
+        ssrc, session(), stream, track_id);
     CreateAudioReceiver(stream, audio_track, ssrc);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     VideoTrackInterface* video_track =
-        remote_stream_factory_->AddVideoTrack(stream, track_id);
+        remote_stream_factory()->AddVideoTrack(stream, track_id);
     CreateVideoReceiver(stream, video_track, ssrc);
   } else {
     RTC_DCHECK(false && "Invalid media type");
   }
 }
 
 void PeerConnection::OnRemoteTrackRemoved(const std::string& stream_label,
                                           const std::string& track_id,
                                           cricket::MediaType media_type) {
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
@@ skipping 229 matching lines @@
   observer_->OnDataChannel(
       DataChannelProxy::Create(signaling_thread(), channel));
 }
 
 rtc::scoped_refptr<DataChannel> PeerConnection::InternalCreateDataChannel(
     const std::string& label,
     const InternalDataChannelInit* config) {
   if (IsClosed()) {
     return nullptr;
   }
-  if (session_->data_channel_type() == cricket::DCT_NONE) {
+  if (session()->data_channel_type() == cricket::DCT_NONE) {
     LOG(LS_ERROR)
         << "InternalCreateDataChannel: Data is not supported in this call.";
     return nullptr;
   }
   InternalDataChannelInit new_config =
       config ? (*config) : InternalDataChannelInit();
-  if (session_->data_channel_type() == cricket::DCT_SCTP) {
+  if (session()->data_channel_type() == cricket::DCT_SCTP) {
     if (new_config.id < 0) {
       rtc::SSLRole role;
-      if ((session_->GetSslRole(session_->data_channel(), &role)) &&
+      if ((session()->GetSslRole(session()->data_channel(), &role)) &&
           !sid_allocator_.AllocateSid(role, &new_config.id)) {
         LOG(LS_ERROR) << "No id can be allocated for the SCTP data channel.";
         return nullptr;
       }
     } else if (!sid_allocator_.ReserveSid(new_config.id)) {
       LOG(LS_ERROR) << "Failed to create a SCTP data channel "
                     << "because the id is already in use or out of range.";
       return nullptr;
     }
   }
 
   rtc::scoped_refptr<DataChannel> channel(DataChannel::Create(
-      session_.get(), session_->data_channel_type(), label, new_config));
+      session(), session()->data_channel_type(), label, new_config));
   if (!channel) {
     sid_allocator_.ReleaseSid(new_config.id);
     return nullptr;
   }
 
   if (channel->data_channel_type() == cricket::DCT_RTP) {
     if (rtp_data_channels_.find(channel->label()) != rtp_data_channels_.end()) {
       LOG(LS_ERROR) << "DataChannel with label " << channel->label()
                     << " already exists.";
       return nullptr;
@@ skipping 146 matching lines @@
 
 DataChannel* PeerConnection::FindDataChannelBySid(int sid) const {
   for (const auto& channel : sctp_data_channels_) {
     if (channel->id() == sid) {
       return channel;
     }
   }
   return nullptr;
 }
 
+void PeerConnection::CreateLiveSession() {
+  if (!live_session_) {
+    live_session_.reset(new LiveSession(this, factory_.get(),
+              port_allocator_.get(), media_config_, configuration_,
+              constraints_.get(), std::move(dtls_identity_store_)));
+    session()->set_metrics_observer(uma_observer_);
+  }
+}
+
+void PeerConnection::DestroyLiveSession() {
+  // Need to detach RTP senders/receivers from WebRtcSession,
+  // since it's about to be destroyed.
+  for (const auto& sender : senders_) {
+    sender->Stop();
+  }
+  for (const auto& receiver : receivers_) {
+    receiver->Stop();
+  }
+  live_session_.reset(nullptr);
+}
+
+const WebRtcSession* PeerConnection::session() const {
+  const_cast<PeerConnection*>(this)->CreateLiveSession();
+  return live_session_->session();
+}
+
+RemoteMediaStreamFactory* PeerConnection::remote_stream_factory() {
+  CreateLiveSession();
+  return live_session_->remote_stream_factory();
+}
+
+StatsCollector* PeerConnection::stats() {
+  CreateLiveSession();
+  return live_session_->stats();
+}
+
 }  // namespace webrtc