Remove ports that are not used by any channel after timeout

webrtc/p2p/base/port.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 180 matching lines @@
   // relies on it.  If the username_fragment and password are empty,
   // we should just create one.
   if (ice_username_fragment_.empty()) {
     ASSERT(password_.empty());
     ice_username_fragment_ = rtc::CreateRandomString(ICE_UFRAG_LENGTH);
     password_ = rtc::CreateRandomString(ICE_PWD_LENGTH);
   }
   network_->SignalTypeChanged.connect(this, &Port::OnNetworkTypeChanged);
   network_cost_ = network_->GetCost();
 
+  thread_->PostDelayed(RTC_FROM_HERE, timeout_delay_, this, MSG_CHECK_DEAD);
   LOG_J(LS_INFO, this) << "Port created with network cost " << network_cost_;
 }
 
 Port::~Port() {
   // Delete all of the remaining connections.  We copy the list up front
   // because each deletion will cause it to be modified.
 
   std::vector<Connection*> list;
 
   AddressMap::iterator iter = connections_.begin();
@@ skipping 426 matching lines @@
 
   // Send the response message.
   rtc::ByteBufferWriter buf;
   response.Write(&buf);
   rtc::PacketOptions options(DefaultDscpValue());
   SendTo(buf.Data(), buf.Length(), addr, options, false);
   LOG_J(LS_INFO, this) << "Sending STUN binding error: reason=" << reason
                        << " to " << addr.ToSensitiveString();
 }
 
+void Port::BecomeReady() {
+  // If it is pruned, we won't bring it up again.

[pthatcher1, 2016/07/28 19:35:05]

We should probably RTC_DCHECK(state_ == State::INIT).

[honghaiz3, 2016/07/28 22:51:44]

It may happen that it was pruned first then it become ready, because we don't
stop a session when ICE restart (if it has not been started). 
We could change that behavior, but we should keep it at a separate CL. 

+  if (state_ == State::INIT) {
+    state_ = State::READY;
+  }
+}
+
+void Port::Prune() {
+  state_ = State::PRUNED;
+  thread_->Post(RTC_FROM_HERE, this, MSG_CHECK_DEAD);
+}
+
 void Port::OnMessage(rtc::Message *pmsg) {
-  ASSERT(pmsg->message_id == MSG_DEAD);
+  ASSERT(pmsg->message_id == MSG_CHECK_DEAD);
   if (dead()) {

[pthatcher1, 2016/07/28 19:35:05]

Since there is only one place calling dead() now, I suggest we just inline it.  

[honghaiz3, 2016/07/28 22:51:44]

Done.

     Destroy();
   }
 }
 
+bool Port::dead() const {
+  return state_ != State::READY && connections_.empty();

[pthatcher1, 2016/07/28 19:35:05]

I think (state_ == INIT || state_ == PRUNED) && connections_.empty() would be
more readable, and more careful to adding more states later.

[honghaiz3, 2016/07/28 22:51:44]

Done.

+}
+
 void Port::OnNetworkTypeChanged(const rtc::Network* network) {
   ASSERT(network == network_);
 
   UpdateNetworkCost();
 }
 
 std::string Port::ToString() const {
   std::stringstream ss;
   ss << "Port[" << std::hex << this << std::dec << ":" << content_name_ << ":"
      << component_ << ":" << generation_ << ":" << type_ << ":"
@@ skipping 28 matching lines @@
   enable_port_packets_ = true;
 }
 
 void Port::OnConnectionDestroyed(Connection* conn) {
   AddressMap::iterator iter =
       connections_.find(conn->remote_candidate().address());
   ASSERT(iter != connections_.end());
   connections_.erase(iter);
   HandleConnectionDestroyed(conn);
 
-  // On the controlled side, ports time out after all connections fail.
+  // Ports time out after all connections fail if it is not ready.
   // Note: If a new connection is added after this message is posted, but it
-  // fails and is removed before kPortTimeoutDelay, then this message will
+  // fails and is removed before timeout_delay_, then this message will
   // still cause the Port to be destroyed.
-  if (dead()) {
-    thread_->PostDelayed(RTC_FROM_HERE, timeout_delay_, this, MSG_DEAD);
+  if (connections_.empty()) {
+    thread_->PostDelayed(RTC_FROM_HERE, timeout_delay_, this, MSG_CHECK_DEAD);
   }
 }
 
 void Port::Destroy() {
   ASSERT(connections_.empty());
   LOG_J(LS_INFO, this) << "Port deleted";
   SignalDestroyed(this);
   delete this;
 }
 
@@ skipping 812 matching lines @@
     ASSERT(sent < 0);
     error_ = port_->GetError();
     stats_.sent_discarded_packets++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket