Remove ports that are not used by any channel after timeout

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 127 matching lines @@
   session->SignalPortReady.connect(this, &P2PTransportChannel::OnPortReady);
   session->SignalPortsRemoved.connect(this,
                                       &P2PTransportChannel::OnPortsRemoved);
   session->SignalPortPruned.connect(this, &P2PTransportChannel::OnPortPruned);
   session->SignalCandidatesReady.connect(
       this, &P2PTransportChannel::OnCandidatesReady);
   session->SignalCandidatesRemoved.connect(
       this, &P2PTransportChannel::OnCandidatesRemoved);
   session->SignalCandidatesAllocationDone.connect(
       this, &P2PTransportChannel::OnCandidatesAllocationDone);
+  allocator_sessions_.push_back(std::move(session));
 
   // 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.
+  for (PortInterface* port : ports_) {
+    port->StopBeingUsed();
+  }

[pthatcher1, 2016/07/27 18:33:15]

for (PortAllocatorSession session : allocator_sessions_) {
  session->PruneAllPorts();
}

Would seem good.

[honghaiz3, 2016/07/28 01:22:49]

Done. Only need to do the last one. 

   removed_ports_.insert(removed_ports_.end(), ports_.begin(), ports_.end());
   ports_.clear();

[pthatcher1, 2016/07/27 18:33:15]

Can we move this into a method called RemoveAllPorts and put it next to
RemovePort?

Better yet, call them PrunePort and PruneAllPorts :).

[honghaiz3, 2016/07/28 01:22:49]

You suggested a different name in another pending CL. 
"RemovePort =>OnPortPruned"
I am merging the change from that one but taking the name PrunePort. 

-
-  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(
@@ skipping 298 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_);
+  port->StartBeingUsed();

[pthatcher1, 2016/07/27 18:33:15]

Like we mentioned in person, I think this could either be done by the session or
just by the port itself when it has a candidate ready.

[honghaiz3, 2016/07/28 01:22:49]

Done.

   ports_.push_back(port);
   port->SignalUnknownAddress.connect(
       this, &P2PTransportChannel::OnUnknownAddress);
   port->SignalDestroyed.connect(this, &P2PTransportChannel::OnPortDestroyed);
 
   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 1255 matching lines @@
 }
 
 bool P2PTransportChannel::RemovePort(PortInterface* port) {
   auto it = std::find(ports_.begin(), ports_.end(), port);
   // Don't need to do anything if the port has been deleted from the port list.
   if (it == ports_.end()) {
     return false;
   }
   ports_.erase(it);
   removed_ports_.push_back(port);
+  port->StopBeingUsed();

[pthatcher1, 2016/07/27 18:33:15]

Like we talked about in person, having this be Port::Prune and perhaps be called
by Session would make sense.

[honghaiz3, 2016/07/28 01:22:49]

Done.

   return true;
 }
 
 // We data is available, let listeners know
 void P2PTransportChannel::OnReadPacket(Connection* connection,
                                        const char* data,
                                        size_t len,
                                        const rtc::PacketTime& packet_time) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
@@ skipping 134 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