Add config to prune TURN ports

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 107 matching lines @@
 }
 
 // Add the allocator session to our list so that we know which sessions
 // are still active.
 void P2PTransportChannel::AddAllocatorSession(
     std::unique_ptr<PortAllocatorSession> session) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   session->set_generation(static_cast<uint32_t>(allocator_sessions_.size()));
   session->SignalPortReady.connect(this, &P2PTransportChannel::OnPortReady);
+  session->SignalPortPruned.connect(this, &P2PTransportChannel::OnPortPruned);
   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.
   removed_ports_.insert(removed_ports_.end(), ports_.begin(), ports_.end());
   ports_.clear();
@@ skipping 1460 matching lines @@
 // connection attempts.
 void P2PTransportChannel::OnPortDestroyed(PortInterface* port) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Remove this port from the lists (if we didn't drop it already).
   ports_.erase(std::remove(ports_.begin(), ports_.end(), port), ports_.end());
   removed_ports_.erase(
       std::remove(removed_ports_.begin(), removed_ports_.end(), port),
       removed_ports_.end());
 
-  LOG(INFO) << "Removed port from p2p socket: "
+  LOG(INFO) << "Removed port because it is destroyed: "
             << static_cast<int>(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);
-  // Don't need to do anything if the port has been deleted from the port list.
-  if (it == ports_.end()) {
+  if (!RemovePort(port)) {
     return;
   }
-  removed_ports_.push_back(*it);
-  ports_.erase(it);
-  LOG(INFO) << "Removed port due to inactive networks: " << ports_.size()
-            << " remaining";
+  LOG(INFO) << "Removed port because its network is inactive : "
+            << port->ToString() << " " << ports_.size() << " remaining";
   std::vector<Candidate> candidates = port->Candidates();
   for (Candidate& candidate : candidates) {
     candidate.set_transport_name(transport_name());
   }
   SignalCandidatesRemoved(this, candidates);
 }
 
+void P2PTransportChannel::OnPortPruned(PortAllocatorSession* session,
+                                       PortInterface* port) {
+  if (RemovePort(port)) {

[Taylor Brandstetter, 2016/06/29 20:57:35]

If a port is pruned and it doesn't have any connections, should it just be
destroyed?

[honghaiz3, 2016/06/29 22:53:29]

Since the candidates of the port may have been sent, there is a potential risk
that the remote-side (especially if that is the controlling side) may create
connection and use that connection for a short-period of time. 
So I think it is safer just to let the port destroy itself after having no
connection for a period of time. 

+    LOG(INFO) << "Removed port because it is pruned: " << port->ToString()
+              << " " << ports_.size() << " remaining";
+  }
+}
+
+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);
+  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());
 
   // Do not deliver, if packet doesn't belong to the correct transport channel.
   if (!FindConnection(connection))
     return;
@@ 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