A few updates on connection states

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 42 matching lines @@
 // 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 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 the write state become stale.
+const uint32 CONNECTION_WRITE_STALE_TIMEOUT = 10 * 1000;  // 10 seconds
+
 // The length of time we wait before we become unwritable.
 const uint32 CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000;  // 5 seconds
 
 // The number of pings that must fail to respond before we become unwritable.
 const uint32 CONNECTION_WRITE_CONNECT_FAILURES = 5;
 
 // This is the length of time that we wait for a ping response to come back.
 const int CONNECTION_RESPONSE_TIMEOUT = 5 * 1000;   // 5 seconds
 
 enum RelayType {
@@ skipping 343 matching lines @@
   virtual const Candidate& local_candidate() const;
 
   // Returns the description of the remote port to which we communicate.
   const Candidate& remote_candidate() const { return remote_candidate_; }
 
   // Returns the pair priority.
   uint64 priority() const;
 
   enum WriteState {
     STATE_WRITABLE          = 0,  // we have received ping responses recently
-    STATE_WRITE_UNRELIABLE  = 1,  // we have had a few ping failures
-    STATE_WRITE_INIT        = 2,  // we have yet to receive a ping response
-    STATE_WRITE_TIMEOUT     = 3,  // we have had a large number of ping failures
+    STATE_WRITE_STALE       = 1,  // we have not sent ping recently.
+    STATE_WRITE_UNRELIABLE  = 2,  // we have had a few ping failures
+    STATE_WRITE_INIT        = 3,  // we have yet to receive a ping response
+    STATE_WRITE_TIMEOUT     = 4,  // we have had a large number of ping failures

[pthatcher1, 2015/09/21 23:49:18]

So the only difference between STALE and UNRELIABLE is whether we are sending
them or not?  I wonder if we can think of a better name here, especially when
related to the STRONG/WEAK analogy with receiving.

[honghaiz3, 2015/09/22 19:35:08]

Dropped this change now. 

   };
 
   WriteState write_state() const { return write_state_; }
   bool writable() const { return write_state_ == STATE_WRITABLE; }
+  bool write_timed_out() const { return write_state_ == STATE_WRITE_TIMEOUT; }
   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_; }
 
   // Estimate of the round-trip time over this connection.
   uint32 rtt() const { return rtt_; }
 
   size_t sent_total_bytes();
@@ skipping 30 matching lines @@
 
   // Called when the socket is currently able to send.
   void OnReadyToSend();
 
   // Called when a connection is determined to be no longer useful to us.  We
   // still keep it around in case the other side wants to use it.  But we can
   // safely stop pinging on it and we can allow it to time out if the other
   // side stops using it as well.
   bool pruned() const { return pruned_; }
   void Prune();
+  void Unprune();
 
   bool use_candidate_attr() const { return use_candidate_attr_; }
   void set_use_candidate_attr(bool enable);
 
   bool nominated() const { return nominated_; }
   void set_nominated(bool nominated) { nominated_ = nominated; }
 
   void set_remote_ice_mode(IceMode mode) {
     remote_ice_mode_ = mode;
   }
@@ skipping 70 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,
   // as we will be using aggressive nomination.
   // But when peer is ice-lite, this flag "must" be initialized to false and
   // turn on when connection becomes "best connection".
   bool use_candidate_attr_;
   // Whether this connection has been nominated by the controlling side via
   // the use_candidate attribute.
   bool nominated_;
   IceMode remote_ice_mode_;
   StunRequestManager requests_;
   uint32 rtt_;
+  uint32 time_created_;
   uint32 last_ping_sent_;      // last time we sent a ping to the other side
   uint32 last_ping_received_;  // last time we received a ping from the other
                                // side
   uint32 last_data_received_;
   uint32 last_ping_response_received_;
   std::vector<SentPing> pings_since_last_response_;
 
   rtc::RateTracker recv_rate_tracker_;
   rtc::RateTracker send_rate_tracker_;
   uint32 sent_packets_discarded_;
@@ skipping 21 matching lines @@
                    const rtc::PacketOptions& options);
   virtual int GetError() { return error_; }
 
  private:
   int error_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORT_H_