Implement the "needs-ice-restart" logic for SetConfiguration.

webrtc/p2p/base/transportcontroller.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 62 matching lines @@
       RTC_FROM_HERE,
       rtc::Bind(&TransportController::SetIceConfig_n, this, config));
 }
 
 void TransportController::SetIceRole(IceRole ice_role) {
   network_thread_->Invoke<void>(
       RTC_FROM_HERE,
       rtc::Bind(&TransportController::SetIceRole_n, this, ice_role));
 }
 
+void TransportController::SetNeedsIceRestartFlag() {
+  for (auto& kv : transports_) {
+    kv.second->SetNeedsIceRestartFlag();
+  }
+}
+
+bool TransportController::NeedsIceRestart(
+    const std::string& transport_name) const {
+  const JsepTransport* transport = GetJsepTransport(transport_name);
+  if (!transport) {
+    return false;
+  }
+  return transport->NeedsIceRestart();
+}
+
 bool TransportController::GetSslRole(const std::string& transport_name,
                                      rtc::SSLRole* role) const {
   return network_thread_->Invoke<bool>(
       RTC_FROM_HERE, rtc::Bind(&TransportController::GetSslRole_n, this,
                                transport_name, role));
 }
 
 bool TransportController::SetLocalCertificate(
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
   return network_thread_->Invoke<bool>(
@@ skipping 87 matching lines @@
   RTC_DCHECK(network_thread_->IsCurrent());
 
   RefCountedChannel* existing_channel = GetChannel_n(transport_name, component);
   if (existing_channel) {
     // Channel already exists; increment reference count and return.
     existing_channel->AddRef();
     return existing_channel->dtls();
   }
 
   // Need to create a new channel.
-  JsepTransport* transport = GetOrCreateJsepTransport_n(transport_name);
+  JsepTransport* transport = GetOrCreateJsepTransport(transport_name);
 
   // Create DTLS channel wrapping ICE channel, and configure it.
   TransportChannelImpl* ice =
       CreateIceTransportChannel_n(transport_name, component);
   // TODO(deadbeef): To support QUIC, would need to create a
   // QuicTransportChannel here. What is "dtls" in this file would then become
   // "dtls or quic".
   TransportChannelImpl* dtls =
       CreateDtlsTransportChannel_n(transport_name, component, ice);
   dtls->SetMetricsObserver(metrics_observer_);
@@ skipping 43 matching lines @@
                     << " TransportChannel " << component
                     << ", which doesn't exist.";
     return;
   }
   it->DecRef();
   if (it->ref() > 0) {
     return;
   }
   channels_.erase(it);
 
-  JsepTransport* t = GetJsepTransport_n(transport_name);
+  JsepTransport* t = GetJsepTransport(transport_name);
   bool channel_removed = t->RemoveChannel(component);
   RTC_DCHECK(channel_removed);
   // Just as we create a Transport when its first channel is created,
   // we delete it when its last channel is deleted.
   if (!t->HasChannels()) {
     transports_.erase(transport_name);
   }
 
   // Removing a channel could cause aggregate state to change.
   UpdateAggregateStates_n();
@@ skipping 90 matching lines @@
                                           int component) const {
   RTC_DCHECK(network_thread_->IsCurrent());
   return std::find_if(
       channels_.begin(), channels_.end(),
       [transport_name, component](const RefCountedChannel& channel) {
         return channel.dtls()->transport_name() == transport_name &&
                channel.dtls()->component() == component;
       });
 }
 
-const JsepTransport* TransportController::GetJsepTransport_n(
+const JsepTransport* TransportController::GetJsepTransport(
     const std::string& transport_name) const {
-  RTC_DCHECK(network_thread_->IsCurrent());
   auto it = transports_.find(transport_name);
   return (it == transports_.end()) ? nullptr : it->second.get();
 }
 
-JsepTransport* TransportController::GetJsepTransport_n(
+JsepTransport* TransportController::GetJsepTransport(
     const std::string& transport_name) {
-  RTC_DCHECK(network_thread_->IsCurrent());
   auto it = transports_.find(transport_name);
   return (it == transports_.end()) ? nullptr : it->second.get();
 }
 
 const TransportController::RefCountedChannel* TransportController::GetChannel_n(
     const std::string& transport_name,
     int component) const {
   RTC_DCHECK(network_thread_->IsCurrent());
   auto it = GetChannelIterator_n(transport_name, component);
   return (it == channels_.end()) ? nullptr : &(*it);
 }
 
 TransportController::RefCountedChannel* TransportController::GetChannel_n(
     const std::string& transport_name,
     int component) {
   RTC_DCHECK(network_thread_->IsCurrent());
   auto it = GetChannelIterator_n(transport_name, component);
   return (it == channels_.end()) ? nullptr : &(*it);
 }
 
-JsepTransport* TransportController::GetOrCreateJsepTransport_n(
+JsepTransport* TransportController::GetOrCreateJsepTransport(
     const std::string& transport_name) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
-  JsepTransport* transport = GetJsepTransport_n(transport_name);
+  JsepTransport* transport = GetJsepTransport(transport_name);
   if (transport) {
     return transport;
   }
 
   transport = new JsepTransport(transport_name, certificate_);
   transports_[transport_name] = std::unique_ptr<JsepTransport>(transport);
   return transport;
 }
 
 void TransportController::DestroyAllChannels_n() {
@@ skipping 30 matching lines @@
   ice_role_ = ice_role;
   for (auto& channel : channels_) {
     channel.dtls()->SetIceRole(ice_role_);
   }
 }
 
 bool TransportController::GetSslRole_n(const std::string& transport_name,
                                        rtc::SSLRole* role) const {
   RTC_DCHECK(network_thread_->IsCurrent());
 
-  const JsepTransport* t = GetJsepTransport_n(transport_name);
+  const JsepTransport* t = GetJsepTransport(transport_name);
   if (!t) {
     return false;
   }
   t->GetSslRole(role);
   return true;
 }
 
 bool TransportController::SetLocalCertificate_n(
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
   RTC_DCHECK(network_thread_->IsCurrent());
@@ skipping 15 matching lines @@
     RTC_DCHECK(set_cert_success);
   }
   return true;
 }
 
 bool TransportController::GetLocalCertificate_n(
     const std::string& transport_name,
     rtc::scoped_refptr<rtc::RTCCertificate>* certificate) const {
   RTC_DCHECK(network_thread_->IsCurrent());
 
-  const JsepTransport* t = GetJsepTransport_n(transport_name);
+  const JsepTransport* t = GetJsepTransport(transport_name);
   if (!t) {
     return false;
   }
   return t->GetLocalCertificate(certificate);
 }
 
 std::unique_ptr<rtc::SSLCertificate>
 TransportController::GetRemoteSSLCertificate_n(
     const std::string& transport_name) const {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   // Get the certificate from the RTP channel's DTLS handshake. Should be
   // identical to the RTCP channel's, since they were given the same remote
   // fingerprint.
   const RefCountedChannel* ch = GetChannel_n(transport_name, 1);
   if (!ch) {
     return nullptr;
   }
   return ch->dtls()->GetRemoteSSLCertificate();
 }
 
 bool TransportController::SetLocalTransportDescription_n(
     const std::string& transport_name,
     const TransportDescription& tdesc,
     ContentAction action,
     std::string* err) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
-  JsepTransport* transport = GetJsepTransport_n(transport_name);
+  JsepTransport* transport = GetJsepTransport(transport_name);
   if (!transport) {
     // If we didn't find a transport, that's not an error;
     // it could have been deleted as a result of bundling.
     // TODO(deadbeef): Make callers smarter so they won't attempt to set a
     // description on a deleted transport.
     return true;
   }
 
   // Older versions of Chrome expect the ICE role to be re-determined when an
   // ICE restart occurs, and also don't perform conflict resolution correctly,
@@ skipping 23 matching lines @@
   RTC_DCHECK(network_thread_->IsCurrent());
 
   // If our role is ICEROLE_CONTROLLED and the remote endpoint supports only
   // ice_lite, this local endpoint should take the CONTROLLING role.
   // TODO(deadbeef): This is a session-level attribute, so it really shouldn't
   // be in a TransportDescription in the first place...
   if (ice_role_ == ICEROLE_CONTROLLED && tdesc.ice_mode == ICEMODE_LITE) {
     SetIceRole_n(ICEROLE_CONTROLLING);
   }
 
-  JsepTransport* transport = GetJsepTransport_n(transport_name);
+  JsepTransport* transport = GetJsepTransport(transport_name);
   if (!transport) {
     // If we didn't find a transport, that's not an error;
     // it could have been deleted as a result of bundling.
     // TODO(deadbeef): Make callers smarter so they won't attempt to set a
     // description on a deleted transport.
     return true;
   }
 
   LOG(LS_INFO) << "Set remote transport description on " << transport_name;
   return transport->SetRemoteTransportDescription(tdesc, action, err);
 }
 
 void TransportController::MaybeStartGathering_n() {
   for (auto& channel : channels_) {
     channel.dtls()->MaybeStartGathering();
   }
 }
 
 bool TransportController::AddRemoteCandidates_n(
     const std::string& transport_name,
     const Candidates& candidates,
     std::string* err) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   // Verify each candidate before passing down to the transport layer.
   if (!VerifyCandidates(candidates, err)) {
     return false;
   }
 
-  JsepTransport* transport = GetJsepTransport_n(transport_name);
+  JsepTransport* transport = GetJsepTransport(transport_name);
   if (!transport) {
     // If we didn't find a transport, that's not an error;
     // it could have been deleted as a result of bundling.
     return true;
   }
 
   for (const Candidate& candidate : candidates) {
     RefCountedChannel* channel =
         GetChannel_n(transport_name, candidate.component());
     if (!channel) {
@@ skipping 18 matching lines @@
   std::map<std::string, Candidates> candidates_by_transport_name;
   for (const Candidate& cand : candidates) {
     RTC_DCHECK(!cand.transport_name().empty());
     candidates_by_transport_name[cand.transport_name()].push_back(cand);
   }
 
   bool result = true;
   for (const auto& kv : candidates_by_transport_name) {
     const std::string& transport_name = kv.first;
     const Candidates& candidates = kv.second;
-    JsepTransport* transport = GetJsepTransport_n(transport_name);
+    JsepTransport* transport = GetJsepTransport(transport_name);
     if (!transport) {
       // If we didn't find a transport, that's not an error;
       // it could have been deleted as a result of bundling.
       continue;
     }
     for (const Candidate& candidate : candidates) {
       RefCountedChannel* channel =
           GetChannel_n(transport_name, candidate.component());
       if (channel) {
         channel->dtls()->RemoveRemoteCandidate(candidate);
       }
     }
   }
   return result;
 }
 
 bool TransportController::ReadyForRemoteCandidates_n(
     const std::string& transport_name) const {
   RTC_DCHECK(network_thread_->IsCurrent());
 
-  const JsepTransport* transport = GetJsepTransport_n(transport_name);
+  const JsepTransport* transport = GetJsepTransport(transport_name);
   if (!transport) {
     return false;
   }
   return transport->ready_for_remote_candidates();
 }
 
 bool TransportController::GetStats_n(const std::string& transport_name,
                                      TransportStats* stats) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
-  JsepTransport* transport = GetJsepTransport_n(transport_name);
+  JsepTransport* transport = GetJsepTransport(transport_name);
   if (!transport) {
     return false;
   }
   return transport->GetStats(stats);
 }
 
 void TransportController::SetMetricsObserver_n(
     webrtc::MetricsObserverInterface* metrics_observer) {
   RTC_DCHECK(network_thread_->IsCurrent());
   metrics_observer_ = metrics_observer;
@@ skipping 139 matching lines @@
         RTC_FROM_HERE, this, MSG_ICEGATHERINGSTATE,
         new rtc::TypedMessageData<IceGatheringState>(new_gathering_state));
   }
 }
 
 void TransportController::OnDtlsHandshakeError(rtc::SSLHandshakeError error) {
   SignalDtlsHandshakeError(error);
 }
 
 }  // namespace cricket