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.
+// The minimum time we will wait before destroying a connection after creating
+// it.
+const uint32 MIN_CONNECTION_LIFETIME = 10 * 1000;  // 10 seconds.
 
 // 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 362 matching lines @@
     STATE_WRITE_TIMEOUT     = 3,  // we have had a large number of ping failures
   };
 
   WriteState write_state() const { return write_state_; }
   bool writable() const { return write_state_ == STATE_WRITABLE; }
   bool receiving() const { return receiving_; }
 
   // Determines whether the connection has finished connecting.  This can only
   // be false for TCP connections.
   bool connected() const { return connected_; }
-
-  bool Weak() const { return !(writable() && receiving() && connected()); }
+  bool weak() const { return !(writable() && receiving() && connected()); }
+  bool active() const {
+    // TODO(honghaiz): Move from using |write_state_| to using |pruned_|.
+    return write_state_ != STATE_WRITE_TIMEOUT;
+  }
+  // A connection is dead if it can be safely deleted.
+  bool dead(uint32 now) const;
 
   // Estimate of the round-trip time over this connection.
   uint32 rtt() const { return rtt_; }
 
   size_t sent_total_bytes();
   size_t sent_bytes_second();
   // Used to track how many packets are discarded in the application socket due
   // to errors.
   size_t sent_discarded_packets();
   size_t sent_total_packets();
@@ skipping 115 matching lines @@
                                         StunMessage* response);
   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 OnMessage(rtc::Message *pmsg);
 
   Port* port_;
   size_t local_candidate_index_;
   Candidate remote_candidate_;
   WriteState write_state_;
   bool receiving_;
   bool connected_;
   bool pruned_;
   // By default |use_candidate_attr_| flag will be true,
@@ skipping 20 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_