Merging BaseSession code into WebRtcSession.

talk/app/webrtc/webrtcsession.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 45 matching lines @@
 using cricket::ContentInfos;
 using cricket::MediaContentDescription;
 using cricket::SessionDescription;
 using cricket::TransportInfo;
 
 using cricket::LOCAL_PORT_TYPE;
 using cricket::STUN_PORT_TYPE;
 using cricket::RELAY_PORT_TYPE;
 using cricket::PRFLX_PORT_TYPE;
 
+namespace {
+
+enum {
+  MSG_STATE = 0,
+};
+
+}  // namespace
+
 namespace webrtc {
 
 // Error messages
 const char kBundleWithoutRtcpMux[] = "RTCP-MUX must be enabled when BUNDLE "
                                      "is enabled.";
 const char kCreateChannelFailed[] = "Failed to create channels.";
 const char kInvalidCandidates[] = "Description contains invalid candidates.";
 const char kInvalidSdp[] = "Invalid session description.";
 const char kMlineMismatch[] =
     "Offer and answer descriptions m-lines are not matching. Rejecting answer.";
@@ skipping 247 matching lines @@
     }
   }
   return false;
 }
 
 static bool BadSdp(const std::string& source,
                    const std::string& type,
                    const std::string& reason,
                    std::string* err_desc) {
   std::ostringstream desc;
-  desc << "Failed to set " << source << " " << type << " sdp: " << reason;
+  desc << "Failed to set " << source;
+  if (!type.empty()) {
+    desc << " " << type;
+  }
+  desc << " sdp: " << reason;
 
   if (err_desc) {
     *err_desc = desc.str();
   }
   LOG(LS_ERROR) << desc.str();
   return false;
 }
 
 static bool BadSdp(cricket::ContentSource source,
                    const std::string& type,
@@ skipping 30 matching lines @@
   return BadSdp(source, SessionDescriptionInterface::kPrAnswer,
                 reason, err_desc);
 }
 
 static bool BadAnswerSdp(cricket::ContentSource source,
                          const std::string& reason,
                          std::string* err_desc) {
   return BadSdp(source, SessionDescriptionInterface::kAnswer, reason, err_desc);
 }
 
-#define GET_STRING_OF_STATE(state)  \
-  case cricket::BaseSession::state:  \
-    result = #state;  \
+#define GET_STRING_OF_STATE(state)   \
+  case webrtc::WebRtcSession::state: \
+    result = #state;                 \
     break;
 
-static std::string GetStateString(cricket::BaseSession::State state) {
+static std::string GetStateString(webrtc::WebRtcSession::State state) {
   std::string result;
   switch (state) {
     GET_STRING_OF_STATE(STATE_INIT)
     GET_STRING_OF_STATE(STATE_SENTINITIATE)
     GET_STRING_OF_STATE(STATE_RECEIVEDINITIATE)
     GET_STRING_OF_STATE(STATE_SENTPRACCEPT)
     GET_STRING_OF_STATE(STATE_SENTACCEPT)
     GET_STRING_OF_STATE(STATE_RECEIVEDPRACCEPT)
     GET_STRING_OF_STATE(STATE_RECEIVEDACCEPT)
     GET_STRING_OF_STATE(STATE_SENTMODIFY)
     GET_STRING_OF_STATE(STATE_RECEIVEDMODIFY)
     GET_STRING_OF_STATE(STATE_SENTREJECT)
     GET_STRING_OF_STATE(STATE_RECEIVEDREJECT)
     GET_STRING_OF_STATE(STATE_SENTREDIRECT)
     GET_STRING_OF_STATE(STATE_SENTTERMINATE)
     GET_STRING_OF_STATE(STATE_RECEIVEDTERMINATE)
     GET_STRING_OF_STATE(STATE_INPROGRESS)
     GET_STRING_OF_STATE(STATE_DEINIT)
     default:
       ASSERT(false);
       break;
   }
   return result;
 }
 
-#define GET_STRING_OF_ERROR_CODE(err)  \
-  case cricket::BaseSession::err:  \
-    result = #err;  \
+#define GET_STRING_OF_ERROR_CODE(err) \
+  case webrtc::WebRtcSession::err:    \
+    result = #err;                    \
     break;
 
-static std::string GetErrorCodeString(cricket::BaseSession::Error err) {
+static std::string GetErrorCodeString(webrtc::WebRtcSession::Error err) {
   std::string result;
   switch (err) {
     GET_STRING_OF_ERROR_CODE(ERROR_NONE)
-    GET_STRING_OF_ERROR_CODE(ERROR_TIME)
-    GET_STRING_OF_ERROR_CODE(ERROR_RESPONSE)
-    GET_STRING_OF_ERROR_CODE(ERROR_NETWORK)
     GET_STRING_OF_ERROR_CODE(ERROR_CONTENT)
     GET_STRING_OF_ERROR_CODE(ERROR_TRANSPORT)
     default:
-      ASSERT(false);
+      RTC_DCHECK(false);
       break;
   }
   return result;
 }
 
 static std::string MakeErrorString(const std::string& error,
                                    const std::string& desc) {
   std::ostringstream ret;
   ret << error << " " << desc;
   return ret.str();
@@ skipping 88 matching lines @@
         return true;
       }
     }
     return false;
   }
 
  private:
   bool ice_restart_;
 };
 
-WebRtcSession::WebRtcSession(
-    cricket::ChannelManager* channel_manager,
-    rtc::Thread* signaling_thread,
-    rtc::Thread* worker_thread,
-    cricket::PortAllocator* port_allocator,
-    MediaStreamSignaling* mediastream_signaling)
-    : cricket::BaseSession(signaling_thread,
-                           worker_thread,
-                           port_allocator,
-                           rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX),
-                           false),
+WebRtcSession::WebRtcSession(cricket::ChannelManager* channel_manager,
+                             rtc::Thread* signaling_thread,
+                             rtc::Thread* worker_thread,
+                             cricket::PortAllocator* port_allocator,
+                             MediaStreamSignaling* mediastream_signaling)
+    : 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)),
       channel_manager_(channel_manager),
       mediastream_signaling_(mediastream_signaling),
       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()->SignalConnectionState.connect(
+  transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLED);
+  transport_controller_->SignalConnectionState.connect(
       this, &WebRtcSession::OnTransportControllerConnectionState);
-  transport_controller()->SignalReceiving.connect(
+  transport_controller_->SignalReceiving.connect(
       this, &WebRtcSession::OnTransportControllerReceiving);
-  transport_controller()->SignalGatheringState.connect(
+  transport_controller_->SignalGatheringState.connect(
       this, &WebRtcSession::OnTransportControllerGatheringState);
-  transport_controller()->SignalCandidatesGathered.connect(
+  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_) {
     SignalVideoChannelDestroyed();
     channel_manager_->DestroyVideoChannel(video_channel_.release());
   }
   if (voice_channel_) {
     SignalVoiceChannelDestroyed();
     channel_manager_->DestroyVoiceChannel(voice_channel_.release());
   }
   if (data_channel_) {
     SignalDataChannelDestroyed();
     channel_manager_->DestroyDataChannel(data_channel_.release());
   }
   for (size_t i = 0; i < saved_candidates_.size(); ++i) {
     delete saved_candidates_[i];
   }
+
+  RTC_DCHECK(state_ != STATE_DEINIT);
+  LogState(state_, STATE_DEINIT);
+  state_ = STATE_DEINIT;
+  SignalState(this, state_);
 }
 
 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);
+  transport_controller_->SetSslMaxProtocolVersion(options.ssl_max_version);
 
   // 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];
   }
 
@@ skipping 163 matching lines @@
         port_allocator()->flags() |
         cricket::PORTALLOCATOR_ENABLE_LOCALHOST_CANDIDATE);
   }
 
   media_controller_.reset(MediaControllerInterface::Create(
       worker_thread(), channel_manager_->media_engine()->GetVoE()));
 
   return true;
 }
 
-cricket::IceConfig WebRtcSession::ParseIceConfig(
-    const PeerConnectionInterface::RTCConfiguration& config) const {
-  cricket::IceConfig ice_config;
-  ice_config.receiving_timeout_ms = config.ice_connection_receiving_timeout;
-  ice_config.gather_continually = (config.continual_gathering_policy ==
-                                   PeerConnectionInterface::GATHER_CONTINUALLY);
-  return ice_config;
-}
-
 void WebRtcSession::Terminate() {
   SetState(STATE_RECEIVEDTERMINATE);
   RemoveUnusedChannels(NULL);
   ASSERT(!voice_channel_);
   ASSERT(!video_channel_);
   ASSERT(!data_channel_);
 }
 
 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();
 }
 
 bool WebRtcSession::GetSslRole(rtc::SSLRole* role) {
-  if (local_description() == NULL || remote_description() == NULL) {
+  if (!local_desc_ || !remote_desc_) {
     LOG(LS_INFO) << "Local and Remote descriptions must be applied to get "
                  << "SSL Role of the session.";
     return false;
   }
 
-  return transport_controller()->GetSslRole(role);
+  return transport_controller_->GetSslRole(role);
 }
 
 void WebRtcSession::CreateOffer(
     CreateSessionDescriptionObserver* observer,
     const PeerConnectionInterface::RTCOfferAnswerOptions& options) {
   webrtc_session_desc_factory_->CreateOffer(observer, options);
 }
 
 void WebRtcSession::CreateAnswer(CreateSessionDescriptionObserver* observer,
                                  const MediaConstraintsInterface* constraints) {
   webrtc_session_desc_factory_->CreateAnswer(observer, constraints);
 }
 
 bool WebRtcSession::SetLocalDescription(SessionDescriptionInterface* desc,
                                         std::string* err_desc) {
   ASSERT(signaling_thread()->IsCurrent());
 
   // Takes the ownership of |desc| regardless of the result.
   rtc::scoped_ptr<SessionDescriptionInterface> desc_temp(desc);
 
   // Validate SDP.
   if (!ValidateSessionDescription(desc, cricket::CS_LOCAL, err_desc)) {
     return false;
   }
 
   // Update the initiator flag if this session is the initiator.
   Action action = GetAction(desc->type());
   if (state() == STATE_INIT && action == kOffer) {
-    set_initiator(true);
+    initiator_ = true;
+    transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLING);
   }
 
   cricket::SecurePolicy sdes_policy =
       webrtc_session_desc_factory_->SdesPolicy();
   cricket::CryptoType crypto_required = dtls_enabled_ ?
       cricket::CT_DTLS : (sdes_policy == cricket::SEC_REQUIRED ?
           cricket::CT_SDES : cricket::CT_NONE);
   // Update the MediaContentDescription crypto settings as per the policy set.
   UpdateSessionDescriptionSecurePolicy(crypto_required, desc->description());
 
-  set_local_description(desc->description()->Copy());
   local_desc_.reset(desc_temp.release());
 
   // Transport and Media channels will be created only when offer is set.
-  if (action == kOffer && !CreateChannels(local_desc_->description())) {
+  if (action == kOffer && !CreateChannels(base_local_description())) {
     // TODO(mallinath) - Handle CreateChannel failure, as new local description
     // is applied. Restore back to old description.
     return BadLocalSdp(desc->type(), kCreateChannelFailed, err_desc);
   }
 
   // Remove unused channels if MediaContentDescription is rejected.
-  RemoveUnusedChannels(local_desc_->description());
+  RemoveUnusedChannels(base_local_description());
 
   if (!UpdateSessionState(action, cricket::CS_LOCAL, err_desc)) {
     return false;
   }
 
-  if (remote_description()) {
+  if (remote_desc_) {
     // Now that we have a local description, we can push down remote candidates
     // that we stored, and those from the remote description.
     if (!saved_candidates_.empty()) {
       // If there are saved candidates which arrived before the local
       // description was set, copy those to the remote description.
       CopySavedCandidates(remote_desc_.get());
     }
     // Push remote candidates in remote description to transport channels.
     UseCandidatesInSessionDescription(remote_desc_.get());
   }
 
   // Update state and SSRC of local MediaStreams and DataChannels based on the
   // local session description.
   mediastream_signaling_->OnLocalDescriptionChanged(local_desc_.get());
 
   rtc::SSLRole role;
   if (data_channel_type_ == cricket::DCT_SCTP && GetSslRole(&role)) {
     mediastream_signaling_->OnDtlsRoleReadyForSctp(role);
   }
-  if (error() != cricket::BaseSession::ERROR_NONE) {
+  if (error() != ERROR_NONE) {
     return BadLocalSdp(desc->type(), GetSessionErrorMsg(), err_desc);
   }
   return true;
 }
 
 bool WebRtcSession::SetRemoteDescription(SessionDescriptionInterface* desc,
                                          std::string* err_desc) {
   ASSERT(signaling_thread()->IsCurrent());
 
   // Takes the ownership of |desc| regardless of the result.
   rtc::scoped_ptr<SessionDescriptionInterface> desc_temp(desc);
 
   // Validate SDP.
   if (!ValidateSessionDescription(desc, cricket::CS_REMOTE, err_desc)) {
     return false;
   }
 
+  rtc::scoped_ptr<SessionDescriptionInterface> old_remote_desc(
+      remote_desc_.release());
+  remote_desc_.reset(desc_temp.release());
+
   // Transport and Media channels will be created only when offer is set.
   Action action = GetAction(desc->type());
   if (action == kOffer && !CreateChannels(desc->description())) {
     // TODO(mallinath) - Handle CreateChannel failure, as new local description
     // is applied. Restore back to old description.
     return BadRemoteSdp(desc->type(), kCreateChannelFailed, err_desc);
   }
 
   // Remove unused channels if MediaContentDescription is rejected.
   RemoveUnusedChannels(desc->description());
 
   // NOTE: Candidates allocation will be initiated only when SetLocalDescription
   // is called.
-  set_remote_description(desc->description()->Copy());
   if (!UpdateSessionState(action, cricket::CS_REMOTE, err_desc)) {
     return false;
   }
 
   // Update remote MediaStreams.
   mediastream_signaling_->OnRemoteDescriptionChanged(desc);
-  if (local_description() && !UseCandidatesInSessionDescription(desc)) {
-    return BadRemoteSdp(desc->type(), kInvalidCandidates, err_desc);
-  }
 
   // Copy all saved candidates.
   CopySavedCandidates(desc);
 
+  if (local_desc_ && !UseCandidatesInSessionDescription(desc)) {
+    return BadRemoteSdp(desc->type(), kInvalidCandidates, err_desc);
+  }
+
   // Check if this new SessionDescription contains new ice ufrag and password
   // that indicates the remote peer requests ice restart.
   bool ice_restart =
-      ice_restart_latch_->CheckForRemoteIceRestart(remote_desc_.get(), desc);
+      ice_restart_latch_->CheckForRemoteIceRestart(old_remote_desc.get(), desc);
   // We retain all received candidates only if ICE is not restarted.
   // When ICE is restarted, all previous candidates belong to an old generation
   // and should not be kept.
   if (!ice_restart) {
     WebRtcSessionDescriptionFactory::CopyCandidatesFromSessionDescription(
-        remote_desc_.get(), desc);
+        old_remote_desc.get(), desc);
   }
 
-  remote_desc_.reset(desc_temp.release());
-
   rtc::SSLRole role;
   if (data_channel_type_ == cricket::DCT_SCTP && GetSslRole(&role)) {
     mediastream_signaling_->OnDtlsRoleReadyForSctp(role);
   }
 
-  if (error() != cricket::BaseSession::ERROR_NONE) {
+  if (error() != ERROR_NONE) {
     return BadRemoteSdp(desc->type(), GetSessionErrorMsg(), err_desc);
   }
 
   // Set the the ICE connection state to connecting since the connection may
   // become writable with peer reflexive candidates before any remote candidate
   // is signaled.
   // TODO(pthatcher): This is a short-term solution for crbug/446908. A real fix
   // is to have a new signal the indicates a change in checking state from the
   // transport and expose a new checking() member from transport that can be
   // read to determine the current checking state. The existing SignalConnecting
   // actually means "gathering candidates", so cannot be be used here.
   if (desc->type() != SessionDescriptionInterface::kOffer &&
       ice_connection_state_ == PeerConnectionInterface::kIceConnectionNew) {
     SetIceConnectionState(PeerConnectionInterface::kIceConnectionChecking);
   }
   return true;
 }
 
+void WebRtcSession::OnMessage(rtc::Message* pmsg) {
+  switch (pmsg->message_id) {
+    case MSG_STATE:
+      switch (state_) {
+        case STATE_SENTACCEPT:
+        case STATE_RECEIVEDACCEPT:
+          SetState(STATE_INPROGRESS);
+          break;
+
+        default:
+          // Explicitly ignoring some states here.
+          break;
+      }
+      break;
+  }
+}
+
+void WebRtcSession::LogState(State old_state, State new_state) {
+  LOG(LS_INFO) << "Session:" << id()
+               << " Old state:" << GetStateString(old_state)
+               << " New state:" << GetStateString(new_state);
+}
+
+void WebRtcSession::SetState(State state) {
+  ASSERT(signaling_thread_->IsCurrent());
+  if (state != state_) {
+    LogState(state_, state);
+    state_ = state;
+    SignalState(this, state_);
+    signaling_thread_->Post(this, MSG_STATE);

[pthatcher1, 2015/10/09 03:28:57]

The whole point of this is to convert STATE_SENTACCEPT or STATE_RECEIVEDACCEPT
into STATE_INPROGRESS.    I'm pretty sure we could just skip to
STATE_INPROGRESS.

[Taylor Brandstetter, 2015/10/09 23:02:06]

Done.

+  }
+}
+
+void WebRtcSession::SetError(Error error, const std::string& error_desc) {
+  ASSERT(signaling_thread_->IsCurrent());
+  if (error != error_) {
+    error_ = error;
+    error_desc_ = error_desc;
+    SignalError(this, error);
+  }
+}
+
 bool WebRtcSession::UpdateSessionState(
     Action action, cricket::ContentSource source,
     std::string* err_desc) {
   ASSERT(signaling_thread()->IsCurrent());
 
   // If there's already a pending error then no state transition should happen.
   // But all call-sites should be verifying this before calling us!
-  ASSERT(error() == cricket::BaseSession::ERROR_NONE);
+  ASSERT(error() == ERROR_NONE);
   std::string td_err;
   if (action == kOffer) {
     if (!PushdownTransportDescription(source, cricket::CA_OFFER, &td_err)) {
       return BadOfferSdp(source, MakeTdErrorString(td_err), err_desc);
     }
     SetState(source == cricket::CS_LOCAL ?
         STATE_SENTINITIATE : STATE_RECEIVEDINITIATE);
     if (!PushdownMediaDescription(cricket::CA_OFFER, source, err_desc)) {
-      SetError(BaseSession::ERROR_CONTENT, *err_desc);
+      SetError(ERROR_CONTENT, *err_desc);
     }
-    if (error() != cricket::BaseSession::ERROR_NONE) {
+    if (error() != ERROR_NONE) {
       return BadOfferSdp(source, GetSessionErrorMsg(), err_desc);
     }
   } else if (action == kPrAnswer) {
     if (!PushdownTransportDescription(source, cricket::CA_PRANSWER, &td_err)) {
       return BadPranswerSdp(source, MakeTdErrorString(td_err), err_desc);
     }
     EnableChannels();
     SetState(source == cricket::CS_LOCAL ?
         STATE_SENTPRACCEPT : STATE_RECEIVEDPRACCEPT);
     if (!PushdownMediaDescription(cricket::CA_PRANSWER, source, err_desc)) {
-      SetError(BaseSession::ERROR_CONTENT, *err_desc);
+      SetError(ERROR_CONTENT, *err_desc);
     }
-    if (error() != cricket::BaseSession::ERROR_NONE) {
+    if (error() != ERROR_NONE) {
       return BadPranswerSdp(source, GetSessionErrorMsg(), err_desc);
     }
   } else if (action == kAnswer) {
     if (!PushdownTransportDescription(source, cricket::CA_ANSWER, &td_err)) {
       return BadAnswerSdp(source, MakeTdErrorString(td_err), err_desc);
     }
     const cricket::ContentGroup* local_bundle =
-        BaseSession::local_description()->GetGroupByName(
-            cricket::GROUP_TYPE_BUNDLE);
+        base_local_description()->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
     const cricket::ContentGroup* remote_bundle =
-        BaseSession::remote_description()->GetGroupByName(
-            cricket::GROUP_TYPE_BUNDLE);
+        base_remote_description()->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
     if (local_bundle && remote_bundle) {
       // The answerer decides the transport to bundle on
       const cricket::ContentGroup* answer_bundle =
           (source == cricket::CS_LOCAL ? local_bundle : remote_bundle);
       if (!EnableBundle(*answer_bundle)) {
         LOG(LS_WARNING) << "Failed to enable BUNDLE.";
         return BadAnswerSdp(source, kEnableBundleFailed, err_desc);
       }
     }
     EnableChannels();
     SetState(source == cricket::CS_LOCAL ?
         STATE_SENTACCEPT : STATE_RECEIVEDACCEPT);
     if (!PushdownMediaDescription(cricket::CA_ANSWER, source, err_desc)) {
-      SetError(BaseSession::ERROR_CONTENT, *err_desc);
+      SetError(ERROR_CONTENT, *err_desc);
     }
-    if (error() != cricket::BaseSession::ERROR_NONE) {
+    if (error() != ERROR_NONE) {
       return BadAnswerSdp(source, GetSessionErrorMsg(), err_desc);
     }
   }
   return true;
 }
 
+WebRtcSession::Action WebRtcSession::GetAction(const std::string& type) {
+  if (type == SessionDescriptionInterface::kOffer) {
+    return WebRtcSession::kOffer;
+  } else if (type == SessionDescriptionInterface::kPrAnswer) {
+    return WebRtcSession::kPrAnswer;
+  } else if (type == SessionDescriptionInterface::kAnswer) {
+    return WebRtcSession::kAnswer;
+  }
+  ASSERT(false && "unknown action type");
+  return WebRtcSession::kOffer;
+}
+
 bool WebRtcSession::PushdownMediaDescription(
     cricket::ContentAction action,
     cricket::ContentSource source,
     std::string* err) {
   auto set_content = [this, action, source, err](cricket::BaseChannel* ch) {
     if (!ch) {
       return true;
     } else if (source == cricket::CS_LOCAL) {
       return ch->PushdownLocalDescription(
           base_local_description(), action, err);
     } else {
       return ch->PushdownRemoteDescription(
           base_remote_description(), action, err);
     }
   };
 
   return (set_content(voice_channel()) &&
           set_content(video_channel()) &&
           set_content(data_channel()));
 }
 
-WebRtcSession::Action WebRtcSession::GetAction(const std::string& type) {
-  if (type == SessionDescriptionInterface::kOffer) {
-    return WebRtcSession::kOffer;
-  } else if (type == SessionDescriptionInterface::kPrAnswer) {
-    return WebRtcSession::kPrAnswer;
-  } else if (type == SessionDescriptionInterface::kAnswer) {
-    return WebRtcSession::kAnswer;
+bool WebRtcSession::PushdownTransportDescription(cricket::ContentSource source,
+                                                 cricket::ContentAction action,
+                                                 std::string* error_desc) {
+  RTC_DCHECK(signaling_thread()->IsCurrent());
+
+  if (source == cricket::CS_LOCAL) {
+    return PushdownLocalTransportDescription(base_local_description(), action,
+                                             error_desc);
   }
-  ASSERT(false && "unknown action type");
-  return WebRtcSession::kOffer;
+  return PushdownRemoteTransportDescription(base_remote_description(), action,
+                                            error_desc);
 }
 
-bool WebRtcSession::GetTransportStats(cricket::SessionStats* stats) {
+bool WebRtcSession::PushdownLocalTransportDescription(
+    const SessionDescription* sdesc,
+    cricket::ContentAction action,
+    std::string* err) {
+  RTC_DCHECK(signaling_thread()->IsCurrent());
+
+  if (!sdesc) {
+    return false;
+  }
+
+  for (const TransportInfo& tinfo : sdesc->transport_infos()) {
+    if (!transport_controller_->SetLocalTransportDescription(
+            tinfo.content_name, tinfo.description, action, err)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool WebRtcSession::PushdownRemoteTransportDescription(
+    const SessionDescription* sdesc,
+    cricket::ContentAction action,
+    std::string* err) {
+  RTC_DCHECK(signaling_thread()->IsCurrent());
+
+  if (!sdesc) {
+    return false;
+  }
+
+  for (const TransportInfo& tinfo : sdesc->transport_infos()) {
+    if (!transport_controller_->SetRemoteTransportDescription(
+            tinfo.content_name, tinfo.description, action, err)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool WebRtcSession::GetTransportDescription(
+    const SessionDescription* description,
+    const std::string& content_name,
+    cricket::TransportDescription* tdesc) {
+  if (!description || !tdesc) {
+    return false;
+  }
+  const TransportInfo* transport_info =
+      description->GetTransportInfoByName(content_name);
+  if (!transport_info) {
+    return false;
+  }
+  *tdesc = transport_info->description;
+  return true;
+}
+
+bool WebRtcSession::GetTransportStats(SessionStats* stats) {
   ASSERT(signaling_thread()->IsCurrent());
   return (GetChannelTransportStats(voice_channel(), stats) &&
           GetChannelTransportStats(video_channel(), stats) &&
           GetChannelTransportStats(data_channel(), stats));
 }
 
 bool WebRtcSession::GetChannelTransportStats(cricket::BaseChannel* ch,
-                                             cricket::SessionStats* stats) {
+                                             SessionStats* stats) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!ch) {
     // Not using this channel.
     return true;
   }
 
   const std::string& content_name = ch->content_name();
   const std::string& transport_name = ch->transport_name();
   stats->proxy_to_transport[content_name] = transport_name;
   if (stats->transport_stats.find(transport_name) !=
       stats->transport_stats.end()) {
     // Transport stats already done for this transport.
     return true;
   }
 
   cricket::TransportStats tstats;
-  if (!transport_controller()->GetStats(transport_name, &tstats)) {
+  if (!transport_controller_->GetStats(transport_name, &tstats)) {
     return false;
   }
 
   stats->transport_stats[transport_name] = tstats;
   return true;
 }
 
 bool WebRtcSession::GetLocalCertificate(
     const std::string& transport_name,
     rtc::scoped_refptr<rtc::RTCCertificate>* certificate) {
   ASSERT(signaling_thread()->IsCurrent());
-  return transport_controller()->GetLocalCertificate(transport_name,
-                                                     certificate);
+  return transport_controller_->GetLocalCertificate(transport_name,
+                                                    certificate);
 }
 
 bool WebRtcSession::GetRemoteSSLCertificate(const std::string& transport_name,
                                             rtc::SSLCertificate** cert) {
   ASSERT(signaling_thread()->IsCurrent());
-  return transport_controller()->GetRemoteSSLCertificate(transport_name, cert);
+  return transport_controller_->GetRemoteSSLCertificate(transport_name, cert);
 }
 
 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 75 matching lines @@
 
   return UseCandidate(candidate);
 }
 
 bool WebRtcSession::SetIceTransports(
     PeerConnectionInterface::IceTransportsType type) {
   return port_allocator()->set_candidate_filter(
         ConvertIceTransportTypeToCandidateFilter(type));
 }
 
+cricket::IceConfig WebRtcSession::ParseIceConfig(
+    const PeerConnectionInterface::RTCConfiguration& config) const {
+  cricket::IceConfig ice_config;
+  ice_config.receiving_timeout_ms = config.ice_connection_receiving_timeout;
+  ice_config.gather_continually = (config.continual_gathering_policy ==
+                                   PeerConnectionInterface::GATHER_CONTINUALLY);
+  return ice_config;
+}
+
+void WebRtcSession::SetIceConfig(const cricket::IceConfig& config) {
+  transport_controller_->SetIceConfig(config);
+}
+
+void WebRtcSession::MaybeStartGathering() {
+  transport_controller_->MaybeStartGathering();
+}
+
 bool WebRtcSession::GetLocalTrackIdBySsrc(uint32_t ssrc,
                                           std::string* track_id) {
-  if (!base_local_description())
+  if (!local_desc_) {
     return false;
+  }
   return webrtc::GetTrackIdBySsrc(base_local_description(), ssrc, track_id);
 }
 
 bool WebRtcSession::GetRemoteTrackIdBySsrc(uint32_t ssrc,
                                            std::string* track_id) {
-  if (!base_remote_description())
+  if (!remote_desc_) {
     return false;
+  }
   return webrtc::GetTrackIdBySsrc(base_remote_description(), ssrc, track_id);
 }
 
 std::string WebRtcSession::BadStateErrMsg(State state) {
   std::ostringstream desc;
   desc << "Called in wrong state: " << GetStateString(state);
   return desc.str();
 }
 
 void WebRtcSession::SetAudioPlayout(uint32_t ssrc,
@@ skipping 236 matching lines @@
 bool WebRtcSession::IceRestartPending() const {
   return ice_restart_latch_->Get();
 }
 
 void WebRtcSession::ResetIceRestartLatch() {
   ice_restart_latch_->Reset();
 }
 
 void WebRtcSession::OnCertificateReady(
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
-  transport_controller()->SetLocalCertificate(certificate);
+  transport_controller_->SetLocalCertificate(certificate);
 }
 
 bool WebRtcSession::waiting_for_certificate_for_testing() const {
   return webrtc_session_desc_factory_->waiting_for_certificate_for_testing();
 }
 
 const rtc::scoped_refptr<rtc::RTCCertificate>&
 WebRtcSession::certificate_for_testing() {
-  return transport_controller()->certificate_for_testing();
+  return transport_controller_->certificate_for_testing();
 }
 
 void WebRtcSession::SetIceConnectionState(
       PeerConnectionInterface::IceConnectionState state) {
   if (ice_connection_state_ == state) {
     return;
   }
 
   // ASSERT that the requested transition is allowed.  Note that
   // WebRtcSession does not implement "kIceConnectionClosed" (that is handled
@@ skipping 132 matching lines @@
   if (video_channel_ && !video_channel_->enabled())
     video_channel_->Enable(true);
 
   if (data_channel_ && !data_channel_->enabled())
     data_channel_->Enable(true);
 }
 
 // Returns the media index for a local ice candidate given the content name.
 bool WebRtcSession::GetLocalCandidateMediaIndex(const std::string& content_name,
                                                 int* sdp_mline_index) {
-  if (!base_local_description() || !sdp_mline_index)
+  if (!local_desc_ || !sdp_mline_index) {
     return false;
+  }
 
   bool content_found = false;
   const ContentInfos& contents = base_local_description()->contents();
   for (size_t index = 0; index < contents.size(); ++index) {
     if (contents[index].name == content_name) {
       *sdp_mline_index = static_cast<int>(index);
       content_found = true;
       break;
     }
   }
   return content_found;
 }
 
 bool WebRtcSession::UseCandidatesInSessionDescription(
     const SessionDescriptionInterface* remote_desc) {
-  if (!remote_desc)
+  if (!remote_desc) {
     return true;
+  }
   bool ret = true;
 
   for (size_t m = 0; m < remote_desc->number_of_mediasections(); ++m) {
     const IceCandidateCollection* candidates = remote_desc->candidates(m);
     for  (size_t n = 0; n < candidates->count(); ++n) {
       const IceCandidateInterface* candidate = candidates->at(n);
       bool valid = false;
       if (!ReadyToUseRemoteCandidate(candidate, remote_desc, &valid)) {
         if (valid) {
           LOG(LS_INFO) << "UseCandidatesInSessionDescription: Candidate saved.";
@@ skipping 22 matching lines @@
         << "UseRemoteCandidateInSession: Invalid candidate media index.";
     return false;
   }
 
   cricket::ContentInfo content =
       base_remote_description()->contents()[mediacontent_index];
   std::vector<cricket::Candidate> candidates;
   candidates.push_back(candidate->candidate());
   // Invoking BaseSession method to handle remote candidates.
   std::string error;
-  if (transport_controller()->AddRemoteCandidates(content.name, candidates,
-                                                  &error)) {
+  if (transport_controller_->AddRemoteCandidates(content.name, candidates,
+                                                 &error)) {
     // Candidates successfully submitted for checking.
     if (ice_connection_state_ == PeerConnectionInterface::kIceConnectionNew ||
         ice_connection_state_ ==
             PeerConnectionInterface::kIceConnectionDisconnected) {
       // If state is New, then the session has just gotten its first remote ICE
       // candidates, so go to Checking.
       // If state is Disconnected, the session is re-using old candidates or
       // receiving additional ones, so go to Checking.
       // If state is Connected, stay Connected.
       // TODO(bemasc): If state is Connected, and the new candidates are for a
@@ skipping 94 matching lines @@
       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(
-      media_controller_.get(), transport_controller(), content->name, true,
+      media_controller_.get(), transport_controller_.get(), content->name, true,
       audio_options_));
   if (!voice_channel_) {
     return false;
   }
 
   voice_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
   return true;
 }
 
 bool WebRtcSession::CreateVideoChannel(const cricket::ContentInfo* content) {
   video_channel_.reset(channel_manager_->CreateVideoChannel(
-      media_controller_.get(), transport_controller(), content->name, true,
+      media_controller_.get(), transport_controller_.get(), content->name, true,
       video_options_));
   if (!video_channel_) {
     return false;
   }
 
   video_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
   return true;
 }
 
 bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content) {
   bool sctp = (data_channel_type_ == cricket::DCT_SCTP);
   data_channel_.reset(channel_manager_->CreateDataChannel(
-      transport_controller(), content->name, !sctp, data_channel_type_));
+      transport_controller_.get(), content->name, !sctp, data_channel_type_));
   if (!data_channel_) {
     return false;
   }
 
   if (sctp) {
     mediastream_signaling_->OnDataTransportCreatedForSctp();
     data_channel_->SignalDataReceived.connect(
         this, &WebRtcSession::OnDataChannelMessageReceived);
     data_channel_->SignalStreamClosedRemotely.connect(
         mediastream_signaling_,
         &MediaStreamSignaling::OnRemoteSctpDataChannelClosed);
   }
 
   data_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
   return true;
 }
 
 void WebRtcSession::OnDtlsSetupFailure(cricket::BaseChannel*, bool rtcp) {
-  SetError(BaseSession::ERROR_TRANSPORT, rtcp ? kDtlsSetupFailureRtcp :
-           kDtlsSetupFailureRtp);
+  SetError(ERROR_TRANSPORT,
+           rtcp ? kDtlsSetupFailureRtcp : kDtlsSetupFailureRtp);
 }
 
 void WebRtcSession::CopySavedCandidates(
     SessionDescriptionInterface* dest_desc) {
   if (!dest_desc) {
     ASSERT(false);
     return;
   }
   for (size_t i = 0; i < saved_candidates_.size(); ++i) {
     dest_desc->AddCandidate(saved_candidates_[i]);
@@ skipping 44 matching lines @@
     const cricket::ContentInfo* content) {
   const cricket::MediaContentDescription* description =
       static_cast<cricket::MediaContentDescription*>(content->description);
   return description->rtcp_mux();
 }
 
 bool WebRtcSession::ValidateSessionDescription(
     const SessionDescriptionInterface* sdesc,
     cricket::ContentSource source, std::string* err_desc) {
   std::string type;
-  if (error() != cricket::BaseSession::ERROR_NONE) {
+  if (error() != ERROR_NONE) {
     return BadSdp(source, type, GetSessionErrorMsg(), err_desc);
   }
 
   if (!sdesc || !sdesc->description()) {
     return BadSdp(source, type, kInvalidSdp, err_desc);
   }
 
   type = sdesc->type();
   Action action = GetAction(sdesc->type());
   if (source == cricket::CS_LOCAL) {
@@ skipping 17 matching lines @@
     return BadSdp(source, type, kSdpWithoutIceUfragPwd, err_desc);
   }
 
   if (!ValidateBundleSettings(sdesc->description())) {
     return BadSdp(source, type, kBundleWithoutRtcpMux, err_desc);
   }
 
   // Verify m-lines in Answer when compared against Offer.
   if (action == kAnswer) {
     const cricket::SessionDescription* offer_desc =
-        (source == cricket::CS_LOCAL) ? remote_description()->description() :
-            local_description()->description();
+        (source == cricket::CS_LOCAL) ? base_remote_description()
+                                      : base_local_description();
     if (!VerifyMediaDescriptions(sdesc->description(), offer_desc)) {
       return BadAnswerSdp(source, kMlineMismatch, err_desc);
     }
   }
 
   return true;
 }
 
 bool WebRtcSession::ExpectSetLocalDescription(Action action) {
   return ((action == kOffer && state() == STATE_INIT) ||
@@ skipping 37 matching lines @@
 // them unset while the session has them set from the previous negotiation.
 // Not doing so may trigger the auto generation of transport description and
 // mess up DTLS identity information, ICE credential, etc.
 bool WebRtcSession::ReadyToUseRemoteCandidate(
     const IceCandidateInterface* candidate,
     const SessionDescriptionInterface* remote_desc,
     bool* valid) {
   *valid = true;;
 
   const SessionDescriptionInterface* current_remote_desc =
-      remote_desc ? remote_desc : remote_description();
+      remote_desc ? remote_desc : remote_desc_.get();
 
-  if (!current_remote_desc)
+  if (!current_remote_desc) {
     return false;
+  }
 
   size_t mediacontent_index =
       static_cast<size_t>(candidate->sdp_mline_index());
   size_t remote_content_size =
       current_remote_desc->description()->contents().size();
   if (mediacontent_index >= remote_content_size) {
     LOG(LS_ERROR)
         << "ReadyToUseRemoteCandidate: Invalid candidate media index.";
 
     *valid = false;
     return false;
   }
 
   cricket::ContentInfo content =
       current_remote_desc->description()->contents()[mediacontent_index];
   cricket::BaseChannel* channel = GetChannel(content.name);
   if (!channel) {
     return false;
   }
 
-  return transport_controller()->ReadyForRemoteCandidates(
+  return transport_controller_->ReadyForRemoteCandidates(
       channel->transport_name());
 }
 
 void WebRtcSession::OnTransportControllerGatheringState(
     cricket::IceGatheringState state) {
   ASSERT(signaling_thread()->IsCurrent());
   if (state == cricket::kIceGatheringGathering) {
     if (ice_observer_) {
       ice_observer_->OnIceGatheringChange(
           PeerConnectionInterface::kIceGatheringGathering);
@@ skipping 15 matching lines @@
     transport_names.insert(voice_channel()->transport_name());
   }
   if (video_channel()) {
     transport_names.insert(video_channel()->transport_name());
   }
   if (data_channel()) {
     transport_names.insert(data_channel()->transport_name());
   }
   for (const auto& name : transport_names) {
     cricket::TransportStats stats;
-    if (transport_controller()->GetStats(name, &stats)) {
+    if (transport_controller_->GetStats(name, &stats)) {
       ReportBestConnectionState(stats);
       ReportNegotiatedCiphers(stats);
     }
   }
 }
 // Walk through the ConnectionInfos to gather best connection usage
 // for IPv4 and IPv6.
 void WebRtcSession::ReportBestConnectionState(
     const cricket::TransportStats& stats) {
   RTC_DCHECK(metrics_observer_ != NULL);
@@ skipping 76 matching lines @@
   if (!srtp_cipher.empty()) {
     metrics_observer_->IncrementSparseEnumCounter(
         srtp_counter_type, rtc::GetSrtpCryptoSuiteFromName(srtp_cipher));
   }
   if (ssl_cipher) {
     metrics_observer_->IncrementSparseEnumCounter(ssl_counter_type, ssl_cipher);
   }
 }
 
 }  // namespace webrtc