Update ICE role on all ports, not just ones used for new connections.

webrtc/p2p/base/p2ptransportchannel.cc

 /*
  *  Copyright 2004 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 261 matching lines @@
   session->set_generation(static_cast<uint32_t>(allocator_sessions_.size()));
   session->SignalPortReady.connect(this, &P2PTransportChannel::OnPortReady);
   session->SignalCandidatesReady.connect(
       this, &P2PTransportChannel::OnCandidatesReady);
   session->SignalCandidatesAllocationDone.connect(
       this, &P2PTransportChannel::OnCandidatesAllocationDone);
 
   // We now only want to apply new candidates that we receive to the ports
   // created by this new session because these are replacing those of the
   // previous sessions.
-  ports_.clear();
+  inactive_ports_.insert(inactive_ports_.end(), active_ports_.begin(),
+                         active_ports_.end());
+  active_ports_.clear();
 
   allocator_sessions_.push_back(std::move(session));
 }
 
 void P2PTransportChannel::AddConnection(Connection* connection) {
   connections_.push_back(connection);
   unpinged_connections_.insert(connection);
   connection->set_remote_ice_mode(remote_ice_mode_);
   connection->set_receiving_timeout(config_.receiving_timeout);
   connection->SignalReadPacket.connect(
       this, &P2PTransportChannel::OnReadPacket);
   connection->SignalReadyToSend.connect(
       this, &P2PTransportChannel::OnReadyToSend);
   connection->SignalStateChange.connect(
       this, &P2PTransportChannel::OnConnectionStateChange);
   connection->SignalDestroyed.connect(
       this, &P2PTransportChannel::OnConnectionDestroyed);
   connection->SignalNominated.connect(this, &P2PTransportChannel::OnNominated);
   had_connection_ = true;
 }
 
 void P2PTransportChannel::SetIceRole(IceRole ice_role) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   if (ice_role_ != ice_role) {
     ice_role_ = ice_role;
-    for (std::vector<PortInterface *>::iterator it = ports_.begin();
-         it != ports_.end(); ++it) {
-      (*it)->SetIceRole(ice_role);
+    for (PortInterface* port : active_ports_) {
+      port->SetIceRole(ice_role);
+    }
+    for (PortInterface* port : inactive_ports_) {
+      port->SetIceRole(ice_role);
     }
   }
 }
 
 void P2PTransportChannel::SetIceTiebreaker(uint64_t tiebreaker) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
-  if (!ports_.empty()) {
+  if (!active_ports_.empty() || !inactive_ports_.empty()) {
     LOG(LS_ERROR)
         << "Attempt to change tiebreaker after Port has been allocated.";
     return;
   }
 
   tiebreaker_ = tiebreaker;
 }
 
 TransportChannelState P2PTransportChannel::GetState() const {
   return state_;
@@ skipping 181 matching lines @@
                               << ") failed: " << port->GetError();
     }
   }
 
   // Remember the ports and candidates, and signal that candidates are ready.
   // The session will handle this, and send an initiate/accept/modify message
   // if one is pending.
 
   port->SetIceRole(ice_role_);
   port->SetIceTiebreaker(tiebreaker_);
-  ports_.push_back(port);
+  active_ports_.push_back(port);
   port->SignalUnknownAddress.connect(
       this, &P2PTransportChannel::OnUnknownAddress);
   port->SignalDestroyed.connect(this, &P2PTransportChannel::OnPortDestroyed);
   port->SignalNetworkInactive.connect(
       this, &P2PTransportChannel::OnPortNetworkInactive);
   port->SignalRoleConflict.connect(
       this, &P2PTransportChannel::OnRoleConflict);
   port->SignalSentPacket.connect(this, &P2PTransportChannel::OnSentPacket);
 
   // Attempt to create a connection from this new port to all of the remote
@@ skipping 290 matching lines @@
     return true;
   }
 
   // Add a new connection for this candidate to every port that allows such a
   // connection (i.e., if they have compatible protocols) and that does not
   // already have a connection to an equivalent candidate.  We must be careful
   // to make sure that the origin port is included, even if it was pruned,
   // since that may be the only port that can create this connection.
   bool created = false;
   std::vector<PortInterface *>::reverse_iterator it;
-  for (it = ports_.rbegin(); it != ports_.rend(); ++it) {
+  for (it = active_ports_.rbegin(); it != active_ports_.rend(); ++it) {
     if (CreateConnection(*it, remote_candidate, origin_port)) {
       if (*it == origin_port)
         created = true;
     }
   }
 
   if ((origin_port != NULL) &&
-      std::find(ports_.begin(), ports_.end(), origin_port) == ports_.end()) {
+      std::find(active_ports_.begin(), active_ports_.end(), origin_port) ==
+          active_ports_.end()) {
     if (CreateConnection(origin_port, remote_candidate, origin_port))
       created = true;
   }
 
   // Remember this remote candidate so that we can add it to future ports.
   RememberRemoteCandidate(remote_candidate, origin_port);
 
   return created;
 }
 
@@ skipping 111 matching lines @@
   ASSERT(worker_thread_ == rtc::Thread::Current());
   OptionMap::iterator it = options_.find(opt);
   if (it == options_.end()) {
     options_.insert(std::make_pair(opt, value));
   } else if (it->second == value) {
     return 0;
   } else {
     it->second = value;
   }
 
-  for (size_t i = 0; i < ports_.size(); ++i) {
-    int val = ports_[i]->SetOption(opt, value);
+  for (PortInterface* port : active_ports_) {
+    int val = port->SetOption(opt, value);
     if (val < 0) {
       // Because this also occurs deferred, probably no point in reporting an
       // error
-      LOG(WARNING) << "SetOption(" << opt << ", " << value << ") failed: "
-                   << ports_[i]->GetError();
+      LOG(WARNING) << "SetOption(" << opt << ", " << value
+                   << ") failed: " << port->GetError();
     }
   }
   return 0;
 }
 
 bool P2PTransportChannel::GetOption(rtc::Socket::Option opt, int* value) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   const auto& found = options_.find(opt);
   if (found == options_.end()) {
@@ skipping 519 matching lines @@
 
   UpdateState();
 }
 
 // When a port is destroyed remove it from our list of ports to use for
 // connection attempts.
 void P2PTransportChannel::OnPortDestroyed(PortInterface* port) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Remove this port from the list (if we didn't drop it already).
-  std::vector<PortInterface*>::iterator iter =
-      std::find(ports_.begin(), ports_.end(), port);
-  if (iter != ports_.end())
-    ports_.erase(iter);
+  active_ports_.erase(
+      std::remove(active_ports_.begin(), active_ports_.end(), port));
+  inactive_ports_.erase(
+      std::remove(inactive_ports_.begin(), inactive_ports_.end(), port));
 
   LOG(INFO) << "Removed port from p2p socket: "
-            << static_cast<int>(ports_.size()) << " remaining";
+            << static_cast<int>(active_ports_.size()) << " remaining";
 }
 
 void P2PTransportChannel::OnPortNetworkInactive(PortInterface* port) {
   // If it does not gather continually, the port will be removed from the list
   // when ICE restarts.
   if (!config_.gather_continually) {
     return;
   }
-  auto it = std::find(ports_.begin(), ports_.end(), port);
+  auto it = std::find(active_ports_.begin(), active_ports_.end(), port);
   // Don't need to do anything if the port has been deleted from the port list.
-  if (it == ports_.end()) {
+  if (it == active_ports_.end()) {
     return;
   }
-  ports_.erase(it);
-  LOG(INFO) << "Removed port due to inactive networks: " << ports_.size()
+  inactive_ports_.push_back(*it);
+  active_ports_.erase(it);
+  LOG(INFO) << "Removed port due to inactive networks: " << active_ports_.size()
             << " remaining";
   std::vector<Candidate> candidates = port->Candidates();
   for (Candidate& candidate : candidates) {
     candidate.set_transport_name(transport_name());
   }
   SignalCandidatesRemoved(this, candidates);
 }
 
 // We data is available, let listeners know
 void P2PTransportChannel::OnReadPacket(Connection* connection,
@@ skipping 140 matching lines @@
 
   // During the initial state when nothing has been pinged yet, return the first
   // one in the ordered |connections_|.
   return *(std::find_if(connections_.begin(), connections_.end(),
                         [conn1, conn2](Connection* conn) {
                           return conn == conn1 || conn == conn2;
                         }));
 }
 
 }  // namespace cricket