Delete a connection only if it has timed out on writing and not receiving for 10 seconds.

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 783 matching lines @@
       last_ping_sent_(0),
       last_ping_received_(0),
       last_data_received_(0),
       last_ping_response_received_(0),
       recv_rate_tracker_(100u, 10u),
       send_rate_tracker_(100u, 10u),
       sent_packets_discarded_(0),
       sent_packets_total_(0),
       reported_(false),
       state_(STATE_WAITING),
-      receiving_timeout_(WEAK_CONNECTION_RECEIVE_TIMEOUT) {
+      receiving_timeout_(WEAK_CONNECTION_RECEIVE_TIMEOUT),
+      time_created_ms_(rtc::Time()) {
   // All of our connections start in WAITING state.
   // TODO(mallinath) - Start connections from STATE_FROZEN.
   // Wire up to send stun packets
   requests_.SignalSendPacket.connect(this, &Connection::OnSendStunPacket);
   LOG_J(LS_INFO, this) << "Connection created";
 }
 
 Connection::~Connection() {
 }
 
@@ skipping 27 matching lines @@
   return priority;
 }
 
 void Connection::set_write_state(WriteState value) {
   WriteState old_value = write_state_;
   write_state_ = value;
   if (value != old_value) {
     LOG_J(LS_VERBOSE, this) << "set_write_state from: " << old_value << " to "
                             << value;
     SignalStateChange(this);
-    CheckTimeout();
   }
 }
 
 void Connection::set_receiving(bool value) {
   if (value != receiving_) {
     LOG_J(LS_VERBOSE, this) << "set_receiving to " << value;
     receiving_ = value;
     SignalStateChange(this);
-    CheckTimeout();
   }
 }
 
 void Connection::set_state(State state) {
   State old_state = state_;
   state_ = state;
   if (state != old_state) {
     LOG_J(LS_VERBOSE, this) << "set_state";
   }
 }
@@ skipping 210 matching lines @@
                          << now - pings_since_last_response_[0].sent_time
                          << " ms without a response"
                          << ", rtt=" << rtt;
     set_write_state(STATE_WRITE_TIMEOUT);
   }
 
   // Check the receiving state.
   uint32 last_recv_time = last_received();
   bool receiving = now <= last_recv_time + receiving_timeout_;
   set_receiving(receiving);
+  CheckTimeout(now);
 }
 
 void Connection::Ping(uint32 now) {
   last_ping_sent_ = now;
   ConnectionRequest *req = new ConnectionRequest(this);
   pings_since_last_response_.push_back(SentPing(req->id(), now));
   LOG_J(LS_VERBOSE, this) << "Sending STUN ping "
                           << ", id=" << rtc::hex_encode(req->id());
   requests_.Send(req);
   state_ = STATE_INPROGRESS;
@@ skipping 121 matching lines @@
     // Recoverable error, retry
   } else if (error_code == STUN_ERROR_STALE_CREDENTIALS) {
     // Race failure, retry
   } else if (error_code == STUN_ERROR_ROLE_CONFLICT) {
     HandleRoleConflictFromPeer();
   } else {
     // This is not a valid connection.
     LOG_J(LS_ERROR, this) << "Received STUN error response, code="
                           << error_code << "; killing connection";
     set_state(STATE_FAILED);
     set_write_state(STATE_WRITE_TIMEOUT);

[pthatcher1, 2015/09/28 23:07:27]

Should just Destroy here?  We probably don't want to delay if we can an explicit
STUN error repsonse.

[pthatcher1, 2015/09/29 19:51:32]

?

[honghaiz3, 2015/09/29 20:40:42]

Ah. can destroy here. 

   }
 }
 
 void Connection::OnConnectionRequestTimeout(ConnectionRequest* request) {
   // Log at LS_INFO if we miss a ping on a writable connection.
   rtc::LoggingSeverity sev = writable() ? rtc::LS_INFO : rtc::LS_VERBOSE;
   LOG_JV(sev, this) << "Timing-out STUN ping "
                     << rtc::hex_encode(request->id())
                     << " after " << request->Elapsed() << " ms";
 }
 
 void Connection::OnConnectionRequestSent(ConnectionRequest* request) {
   // Log at LS_INFO if we send a ping on an unwritable connection.
   rtc::LoggingSeverity sev = !writable() ? rtc::LS_INFO : rtc::LS_VERBOSE;
   bool use_candidate = use_candidate_attr();
   LOG_JV(sev, this) << "Sent STUN ping"
                     << ", id=" << rtc::hex_encode(request->id())
                     << ", use_candidate=" << use_candidate;
 }
 
-void Connection::CheckTimeout() {
-  // If write has timed out and it is not receiving, remove the connection.
+void Connection::CheckTimeout(uint32 now) {

[pthatcher1, 2015/09/28 23:07:27]

If this is now called in only one place, why not remove this method and simply
call it in that one place?

[honghaiz3, 2015/09/29 18:47:50]

Done.

   if (!receiving_ && write_state_ == STATE_WRITE_TIMEOUT) {
-    Destroy();
+    // Remove the connection only if it has timed out on writing and it has
+    // not received anything for a long time. If the connection has never
+    // received anything before, |last_received()| will return 0. In this case,
+    // use the connection creation time as the base to compute the timeout.

[pthatcher1, 2015/09/28 23:07:27]

I think this comment ought to say something more like "Don't destroy a
connection until N seconds have passed since it was created.  We do this to
prevent connections from being pruned too quickly during a network change event
when two networks would be up simultaneously but only for a brief period."

[honghaiz3, 2015/09/29 18:47:49]

Done.

+    uint32 base_for_timeout = std::max(time_created_ms_, last_received());

[pthatcher1, 2015/09/28 23:07:27]

I think call this "receiving_deadline" would be a bit better:

uint32 receiving_deadline = std::max(time_created_ms_, last_received()) +
DEAD_CONNECTION_RECEIVE_TIMEOUT.

[honghaiz3, 2015/09/29 18:47:50]

Done.

+    if (now > base_for_timeout + DEAD_CONNECTION_RECEIVE_TIMEOUT) {
+      Destroy();
+    }
   }

[pthatcher1, 2015/09/28 23:07:27]

This would be more clear with early returns.  

[honghaiz3, 2015/09/29 18:47:49]

Done.

 }

[pthatcher1, 2015/09/28 23:07:27]

I think this would be more clear with a helper method called something like
"Dead":  I also think we could combine all my other comments into something like
this:


void Connection::UpdateState(uint32 now) {
  ...
  if (Dead(now)) {
    Destroy();
  }
}

void Connection::Active() {
  // TODO: Move from using the write_state_ to using pruned_.
  return write_state_ != STATE_WRITE_TIMEOUT;
}

bool Connection::Dead(uint32 now) {
  if (now < (time_created_ms_ + MIN_CONNECTION_LIFETIME)) {
    // A connection that hasn't passed its minimum lifetime is still alive.  
    // We do this to prevent connections from being pruned too quickly 
    // during a network change event when two networks would be up 
    // simultaneously but only for a brief period.
    return false;
  }
  
  if (receiving_) {
    // A connection that is receiving is alive.
    return false;
  }

  // A connection is alive until it is inactive.
  return !Active();

  // TODO: Move from using the write_state_ to using the receiving state with
something like the following:
  // return (now > (last_received() + DEAD_CONNECTION_RECEIVE_TIMEOUT));
}

[honghaiz3, 2015/09/29 18:47:50]

Done.

 
 void Connection::HandleRoleConflictFromPeer() {
   port_->SignalRoleConflict(port_);
 }
 
 void Connection::MaybeSetRemoteIceCredentials(const std::string& ice_ufrag,
                                               const std::string& ice_pwd) {
   if (remote_candidate_.username() == ice_ufrag &&
       remote_candidate_.password().empty()) {
     remote_candidate_.set_password(ice_pwd);
@@ skipping 132 matching lines @@
     ASSERT(sent < 0);
     error_ = port_->GetError();
     sent_packets_discarded_++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket