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

webrtc/p2p/base/port.h

 /*
  *  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 32 matching lines @@
 extern const char UDP_PROTOCOL_NAME[];
 extern const char TCP_PROTOCOL_NAME[];
 extern const char SSLTCP_PROTOCOL_NAME[];
 
 // RFC 6544, TCP candidate encoding rules.
 extern const int DISCARD_PORT;
 extern const char TCPTYPE_ACTIVE_STR[];
 extern const char TCPTYPE_PASSIVE_STR[];
 extern const char TCPTYPE_SIMOPEN_STR[];
 
-// If a connection does not receive anything for this long, it is considered
-// dead.
-const uint32 DEAD_CONNECTION_RECEIVE_TIMEOUT = 30 * 1000;  // 30 seconds.
+// If a connection does not receive anything for this long and it has timed out
+// on writing, it will be deleted.
+const uint32 DEAD_CONNECTION_RECEIVE_TIMEOUT = 10 * 1000;  // 10 seconds.

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

I think there are actually two different things here, that might want different
values:

1.  "MIN_CONNECTION_LIFETIME", which is the minimum time we will wait before
destroying a connection.  10s.

2.  "DEAD_CONNECTION_RECEIVE_TIMEOUT", which is the time after which we know we
can delete a connection if it hasn't received anything.  30s.


Actually, I think we only want #1 for this CL.  I don't think we need #2 in this
CL.

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

Done.

 
 // The timeout duration when a connection does not receive anything.
 const uint32 WEAK_CONNECTION_RECEIVE_TIMEOUT = 2500;  // 2.5 seconds
 
 // The length of time we wait before timing out writability on a connection.
 const uint32 CONNECTION_WRITE_TIMEOUT = 15 * 1000;  // 15 seconds
 
 // The length of time we wait before we become unwritable.
 const uint32 CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000;  // 5 seconds
 
@@ skipping 500 matching lines @@
   void OnConnectionRequestTimeout(ConnectionRequest* req);
   void OnConnectionRequestSent(ConnectionRequest* req);
 
   // Changes the state and signals if necessary.
   void set_write_state(WriteState value);
   void set_receiving(bool value);
   void set_state(State state);
   void set_connected(bool value);
 
   // Checks if this connection is useless, and hence, should be destroyed.
-  void CheckTimeout();
+  void CheckTimeout(uint32 now);
 
   void OnMessage(rtc::Message *pmsg);
 
   Port* port_;
   size_t local_candidate_index_;
   Candidate remote_candidate_;
   WriteState write_state_;
   bool receiving_;
   bool connected_;
   bool pruned_;
@@ skipping 21 matching lines @@
   uint32 sent_packets_total_;
 
  private:
   void MaybeAddPrflxCandidate(ConnectionRequest* request,
                               StunMessage* response);
 
   bool reported_;
   State state_;
   // Time duration to switch from receiving to not receiving.
   uint32 receiving_timeout_;
+  uint32 time_created_ms_;
 
   friend class Port;
   friend class ConnectionRequest;
 };
 
 // ProxyConnection defers all the interesting work to the port
 class ProxyConnection : public Connection {
  public:
   ProxyConnection(Port* port, size_t index, const Candidate& candidate);
 
   virtual int Send(const void* data, size_t size,
                    const rtc::PacketOptions& options);
   virtual int GetError() { return error_; }
 
  private:
   int error_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORT_H_