Adding GetConfiguration to 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.
  */
 
@@ skipping 618 matching lines @@
       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))));
 
   stats_.reset(new StatsCollector(this));
   stats_collector_ = RTCStatsCollector::Create(this);
 
-  enable_ice_renomination_ = configuration.enable_ice_renomination;
-
   // Initialize the WebRtcSession. It creates transport channels etc.
   if (!session_->Initialize(factory_->options(), std::move(cert_generator),
                             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_->SignalVoiceChannelCreated.connect(
       this, &PeerConnection::OnVoiceChannelCreated);
   session_->SignalVoiceChannelDestroyed.connect(
       this, &PeerConnection::OnVoiceChannelDestroyed);
   session_->SignalVideoChannelCreated.connect(
       this, &PeerConnection::OnVideoChannelCreated);
   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;
   return true;
 }
 
 rtc::scoped_refptr<StreamCollectionInterface>
 PeerConnection::local_streams() {
   return local_streams_;
 }
 
 rtc::scoped_refptr<StreamCollectionInterface>
 PeerConnection::remote_streams() {
@@ skipping 573 matching lines @@
         rtc::scoped_refptr<MediaStreamInterface>(new_stream));
   }
 
   UpdateEndedRemoteMediaStreams();
 
   SetSessionDescriptionMsg* msg = new SetSessionDescriptionMsg(observer);
   signaling_thread()->Post(RTC_FROM_HERE, this,
                            MSG_SET_SESSIONDESCRIPTION_SUCCESS, msg);
 }
 
+PeerConnectionInterface::RTCConfiguration PeerConnection::GetConfiguration() {
+  return configuration_;
+}
+
 bool PeerConnection::SetConfiguration(const RTCConfiguration& configuration) {
   TRACE_EVENT0("webrtc", "PeerConnection::SetConfiguration");
+  // TODO(deadbeef): Return false and log an error if there are any unsupported
+  // modifications.
   if (port_allocator_) {
     if (!network_thread()->Invoke<bool>(
             RTC_FROM_HERE,
             rtc::Bind(&PeerConnection::ReconfigurePortAllocator_n, this,
                       configuration))) {
       return false;
     }
   }
 
   // TODO(deadbeef): Shouldn't have to hop to the worker thread twice...
   session_->SetIceConfig(session_->ParseIceConfig(configuration));
 
-  enable_ice_renomination_ = configuration.enable_ice_renomination;
+  configuration_ = configuration;
   return true;
 }
 
 bool PeerConnection::AddIceCandidate(
     const IceCandidateInterface* ice_candidate) {
   TRACE_EVENT0("webrtc", "PeerConnection::AddIceCandidate");
   if (IsClosed()) {
     return false;
   }
   return session_->ProcessIceMessage(ice_candidate);
@@ skipping 334 matching lines @@
     cricket::MediaSessionOptions* session_options) {
   // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
   // ContentInfos.
   if (session_->local_description()) {
     for (const cricket::ContentInfo& content :
          session_->local_description()->description()->contents()) {
       session_options->transport_options[content.name] =
           cricket::TransportOptions();
     }
   }
-  session_options->enable_ice_renomination = enable_ice_renomination_;
+  session_options->enable_ice_renomination =
+      configuration_.enable_ice_renomination;
 
   if (!ExtractMediaSessionOptions(rtc_options, true, 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 =
@@ skipping 22 matching lines @@
 
   session_options->rtcp_cname = rtcp_cname_;
   session_options->crypto_options = factory_->options().crypto_options;
   return true;
 }
 
 void PeerConnection::InitializeOptionsForAnswer(
     cricket::MediaSessionOptions* session_options) {
   session_options->recv_audio = false;
   session_options->recv_video = false;
-  session_options->enable_ice_renomination = enable_ice_renomination_;
+  session_options->enable_ice_renomination =
+      configuration_.enable_ice_renomination;
 }
 
 void PeerConnection::FinishOptionsForAnswer(
     cricket::MediaSessionOptions* session_options) {
   // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
   // ContentInfos.
   if (session_->remote_description()) {
     // Initialize the transport_options map.
     for (const cricket::ContentInfo& content :
          session_->remote_description()->description()->contents()) {
@@ skipping 661 matching lines @@
 
 bool PeerConnection::StartRtcEventLog_w(rtc::PlatformFile file,
                                         int64_t max_size_bytes) {
   return event_log_->StartLogging(file, max_size_bytes);
 }
 
 void PeerConnection::StopRtcEventLog_w() {
   event_log_->StopLogging();
 }
 }  // namespace webrtc