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 312 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_SENTOFFER)
+    GET_STRING_OF_STATE(STATE_RECEIVEDOFFER)
+    GET_STRING_OF_STATE(STATE_SENTPRANSWER)
+    GET_STRING_OF_STATE(STATE_RECEIVEDPRANSWER)
     GET_STRING_OF_STATE(STATE_INPROGRESS)
-    GET_STRING_OF_STATE(STATE_DEINIT)
+    GET_STRING_OF_STATE(STATE_TERMINATED)
     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];
-  }
+
+  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);
+  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() {

[pthatcher1, 2015/10/10 00:07:27]

Can we rename this Close()?

[Taylor Brandstetter, 2015/10/10 00:30:15]

Done.

-  SetState(STATE_RECEIVEDTERMINATE);
+  SetState(STATE_TERMINATED);
   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.
+  // Update the initial_offerer flag if this session is the initial_offerer.
   Action action = GetAction(desc->type());
   if (state() == STATE_INIT && action == kOffer) {
-    set_initiator(true);
+    initial_offerer_ = 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())) {
     // 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());
 
   if (!UpdateSessionState(action, cricket::CS_LOCAL, err_desc)) {
     return false;
   }
 
-  if (remote_description()) {
-    // 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.
+  if (remote_desc_) {
+    // Now that we have a local description, we can push down remote candidates.
     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)) {
+
+  if (local_desc_ && !UseCandidatesInSessionDescription(desc)) {
     return BadRemoteSdp(desc->type(), kInvalidCandidates, err_desc);
   }
 
-  // Copy all saved candidates.
-  CopySavedCandidates(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.
+  // TODO(deadbeef): This goes against the W3C spec which says the remote
+  // description should only contain candidates from the last set remote
+  // description plus any candidates added since then. We should remove this
+  // once we're sure it won't break anything.
   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::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_);
+  }
+}
+
+void WebRtcSession::SetError(Error error, const std::string& error_desc) {
+  ASSERT(signaling_thread_->IsCurrent());
+  if (error != error_) {
+    error_ = error;
+    error_desc_ = error_desc;
+  }
+}
+
 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);
+    SetState(source == cricket::CS_LOCAL ? STATE_SENTOFFER
+                                         : STATE_RECEIVEDOFFER);
     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);
+    SetState(source == cricket::CS_LOCAL ? STATE_SENTPRANSWER
+                                         : STATE_RECEIVEDPRANSWER);
     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);
+        local_desc_->description()->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
     const cricket::ContentGroup* remote_bundle =
-        BaseSession::remote_description()->GetGroupByName(
-            cricket::GROUP_TYPE_BUNDLE);
+        remote_desc_->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);
+    SetState(STATE_INPROGRESS);
     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);
+      return ch->PushdownLocalDescription(local_desc_->description(), action,
+                                          err);
     } else {
-      return ch->PushdownRemoteDescription(
-          base_remote_description(), action, err);
+      return ch->PushdownRemoteDescription(remote_desc_->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(local_desc_->description(), action,
+                                             error_desc);
   }
-  ASSERT(false && "unknown action type");
-  return WebRtcSession::kOffer;
+  return PushdownRemoteTransportDescription(remote_desc_->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 36 matching lines @@
   if (!maybe_set_transport(voice_channel()) ||
       !maybe_set_transport(video_channel()) ||
       !maybe_set_transport(data_channel())) {
     return false;
   }
 
   return true;
 }
 
 bool WebRtcSession::ProcessIceMessage(const IceCandidateInterface* candidate) {
-  if (state() == STATE_INIT) {
-     LOG(LS_ERROR) << "ProcessIceMessage: ICE candidates can't be added "
-                   << "without any offer (local or remote) "
-                   << "session description.";
+  if (!remote_desc_) {
+    LOG(LS_ERROR) << "ProcessIceMessage: ICE candidates can't be added "
+                  << "without any remote session description.";
      return false;
   }
 
   if (!candidate) {
-    LOG(LS_ERROR) << "ProcessIceMessage: Candidate is NULL";
+    LOG(LS_ERROR) << "ProcessIceMessage: Candidate is NULL.";
     return false;
   }
 
   bool valid = false;
-  if (!ReadyToUseRemoteCandidate(candidate, NULL, &valid)) {
-    if (valid) {
-      LOG(LS_INFO) << "ProcessIceMessage: Candidate saved";
-      saved_candidates_.push_back(
-          new JsepIceCandidate(candidate->sdp_mid(),
-                               candidate->sdp_mline_index(),
-                               candidate->candidate()));
-    }
-    return valid;
+  bool ready = ReadyToUseRemoteCandidate(candidate, NULL, &valid);
+  if (!valid) {
+    return false;
   }
 
   // Add this candidate to the remote session description.
   if (!remote_desc_->AddCandidate(candidate)) {
-    LOG(LS_ERROR) << "ProcessIceMessage: Candidate cannot be used";
+    LOG(LS_ERROR) << "ProcessIceMessage: Candidate cannot be used.";
     return false;
   }
 
-  return UseCandidate(candidate);
+  if (ready) {
+    return UseCandidate(candidate);
+  } else {
+    LOG(LS_INFO) << "ProcessIceMessage: Not ready to use candidate.";
+    return true;
+  }
 }
 
 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);
+  }
+  return webrtc::GetTrackIdBySsrc(local_desc_->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);
+  }
+  return webrtc::GetTrackIdBySsrc(remote_desc_->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,
                                     bool enable,
@@ skipping 97 matching lines @@
 
 bool WebRtcSession::CanInsertDtmf(const std::string& track_id) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!voice_channel_) {
     LOG(LS_ERROR) << "CanInsertDtmf: No audio channel exists.";
     return false;
   }
   uint32_t send_ssrc = 0;
   // The Dtmf is negotiated per channel not ssrc, so we only check if the ssrc
   // exists.
-  if (!GetAudioSsrcByTrackId(base_local_description(), track_id,
+  if (!local_desc_ ||
+      !GetAudioSsrcByTrackId(local_desc_->description(), track_id,
                              &send_ssrc)) {
     LOG(LS_ERROR) << "CanInsertDtmf: Track does not exist: " << track_id;
     return false;
   }
   return voice_channel_->CanInsertDtmf();
 }
 
 bool WebRtcSession::InsertDtmf(const std::string& track_id,
                                int code, int duration) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!voice_channel_) {
     LOG(LS_ERROR) << "InsertDtmf: No audio channel exists.";
     return false;
   }
   uint32_t send_ssrc = 0;
-  if (!VERIFY(GetAudioSsrcByTrackId(base_local_description(),
-                                    track_id, &send_ssrc))) {
+  if (!VERIFY(local_desc_ && GetAudioSsrcByTrackId(local_desc_->description(),
+                                                   track_id, &send_ssrc))) {
     LOG(LS_ERROR) << "InsertDtmf: Track does not exist: " << track_id;
     return false;
   }
   if (!voice_channel_->InsertDtmf(send_ssrc, code, duration,
                                   cricket::DF_SEND)) {
     LOG(LS_ERROR) << "Failed to insert DTMF to channel.";
     return false;
   }
   return true;
 }
@@ skipping 54 matching lines @@
   data_channel_->RemoveSendStream(sid);
 }
 
 bool WebRtcSession::ReadyToSendData() const {
   return data_channel_ && data_channel_->ready_to_send_data();
 }
 
 rtc::scoped_refptr<DataChannel> WebRtcSession::CreateDataChannel(
     const std::string& label,
     const InternalDataChannelInit* config) {
-  if (state() == STATE_RECEIVEDTERMINATE) {
+  if (state() == STATE_TERMINATED) {
     return NULL;
   }
   if (data_channel_type_ == cricket::DCT_NONE) {
     LOG(LS_ERROR) << "CreateDataChannel: Data is not supported in this call.";
     return NULL;
   }
   InternalDataChannelInit new_config =
       config ? (*config) : InternalDataChannelInit();
   if (data_channel_type_ == cricket::DCT_SCTP) {
     if (new_config.id < 0) {
@@ skipping 25 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();
+  const ContentInfos& contents = local_desc_->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) {
+    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.";
-          saved_candidates_.push_back(
-              new JsepIceCandidate(candidate->sdp_mid(),
-                                   candidate->sdp_mline_index(),
-                                   candidate->candidate()));
+          LOG(LS_INFO) << "UseCandidatesInSessionDescription: Not ready to use "
+                       << "candidate.";
         }
         continue;
       }
       ret = UseCandidate(candidate);
-      if (!ret)
+      if (!ret) {
         break;
+      }
     }
   }
   return ret;
 }
 
 bool WebRtcSession::UseCandidate(
     const IceCandidateInterface* candidate) {

[pthatcher1, 2015/10/10 00:07:27]

In some of these places where you assume the remote_desc_ is non-null or the
local_desc_ is non-null, can you add an RTC_CHECK(remote_desc_) or
RTC_CHECK(local_desc_)?

I know the logic makes sense, but it's easy for logic to change, and an
RTC_CHECK is better than a null pointer deref.

[Taylor Brandstetter, 2015/10/10 00:30:15]

In an earlier code review, tommi told me that RTC_CHECK'ing something that's
going to be dereferenced anyway is discouraged. So... who's right?

[pthatcher1, 2015/10/10 01:59:20]

I'll defer to Tommi on this one.

 
   size_t mediacontent_index = static_cast<size_t>(candidate->sdp_mline_index());
-  size_t remote_content_size = base_remote_description()->contents().size();
+  size_t remote_content_size = remote_desc_->description()->contents().size();
   if (mediacontent_index >= remote_content_size) {
     LOG(LS_ERROR)
         << "UseRemoteCandidateInSession: Invalid candidate media index.";
     return false;
   }
 
   cricket::ContentInfo content =
-      base_remote_description()->contents()[mediacontent_index];
+      remote_desc_->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);
-}
-
-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]);
-    delete saved_candidates_[i];
-  }
-  saved_candidates_.clear();
+  SetError(ERROR_TRANSPORT,
+           rtcp ? kDtlsSetupFailureRtcp : kDtlsSetupFailureRtp);
 }
 
 void WebRtcSession::OnDataChannelMessageReceived(
     cricket::DataChannel* channel,
     const cricket::ReceiveDataParams& params,
     const rtc::Buffer& payload) {
   ASSERT(data_channel_type_ == cricket::DCT_SCTP);
   if (params.type == cricket::DMT_CONTROL &&
       mediastream_signaling_->IsSctpSidAvailable(params.ssrc)) {
     // Received CONTROL on unused sid, process as an OPEN message.
@@ skipping 31 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) ? remote_desc_->description()
+                                      : local_desc_->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) ||
           // update local offer
-          (action == kOffer && state() == STATE_SENTINITIATE) ||
+          (action == kOffer && state() == STATE_SENTOFFER) ||
           // update the current ongoing session.
-          (action == kOffer && state() == STATE_RECEIVEDACCEPT) ||
-          (action == kOffer && state() == STATE_SENTACCEPT) ||
           (action == kOffer && state() == STATE_INPROGRESS) ||
           // accept remote offer
-          (action == kAnswer && state() == STATE_RECEIVEDINITIATE) ||
-          (action == kAnswer && state() == STATE_SENTPRACCEPT) ||
-          (action == kPrAnswer && state() == STATE_RECEIVEDINITIATE) ||
-          (action == kPrAnswer && state() == STATE_SENTPRACCEPT));
+          (action == kAnswer && state() == STATE_RECEIVEDOFFER) ||
+          (action == kAnswer && state() == STATE_SENTPRANSWER) ||
+          (action == kPrAnswer && state() == STATE_RECEIVEDOFFER) ||
+          (action == kPrAnswer && state() == STATE_SENTPRANSWER));
 }
 
 bool WebRtcSession::ExpectSetRemoteDescription(Action action) {
   return ((action == kOffer && state() == STATE_INIT) ||
           // update remote offer
-          (action == kOffer && state() == STATE_RECEIVEDINITIATE) ||
+          (action == kOffer && state() == STATE_RECEIVEDOFFER) ||
           // update the current ongoing session
-          (action == kOffer && state() == STATE_RECEIVEDACCEPT) ||
-          (action == kOffer && state() == STATE_SENTACCEPT) ||
           (action == kOffer && state() == STATE_INPROGRESS) ||
           // accept local offer
-          (action == kAnswer && state() == STATE_SENTINITIATE) ||
-          (action == kAnswer && state() == STATE_RECEIVEDPRACCEPT) ||
-          (action == kPrAnswer && state() == STATE_SENTINITIATE) ||
-          (action == kPrAnswer && state() == STATE_RECEIVEDPRACCEPT));
+          (action == kAnswer && state() == STATE_SENTOFFER) ||
+          (action == kAnswer && state() == STATE_RECEIVEDPRANSWER) ||
+          (action == kPrAnswer && state() == STATE_SENTOFFER) ||
+          (action == kPrAnswer && state() == STATE_RECEIVEDPRANSWER));
 }
 
 std::string WebRtcSession::GetSessionErrorMsg() {
   std::ostringstream desc;
   desc << kSessionError << GetErrorCodeString(error()) << ". ";
   desc << kSessionErrorDesc << error_desc() << ".";
   return desc.str();
 }
 
 // We need to check the local/remote description for the Transport instead of
 // the session, because a new Transport added during renegotiation may have
 // 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