Replace readable with receiving where receiving means receiving anything (stun ping, response or da…

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[];
 
-// The length of time we wait before timing out readability on a connection.
-const uint32 CONNECTION_READ_TIMEOUT = 30 * 1000;   // 30 seconds
+// 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 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;
 
@@ skipping 345 matching lines @@
 
   // Returns the description of the local port
   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 ReadState {
-    STATE_READ_INIT    = 0,  // we have yet to receive a ping
-    STATE_READABLE     = 1,  // we have received pings recently
-    STATE_READ_TIMEOUT = 2,  // we haven't received pings in a while
-  };
-
-  ReadState read_state() const { return read_state_; }
-  bool readable() const { return read_state_ == STATE_READABLE; }
-
   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
   };
 
   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_; }
 
   // Estimate of the round-trip time over this connection.
   uint32 rtt() const { return rtt_; }
 
   size_t sent_total_bytes();
   size_t sent_bytes_second();
@@ skipping 11 matching lines @@
 
   // The connection can send and receive packets asynchronously.  This matches
   // the interface of AsyncPacketSocket, which may use UDP or TCP under the
   // covers.
   virtual int Send(const void* data, size_t size,
                    const rtc::PacketOptions& options) = 0;
 
   // Error if Send() returns < 0
   virtual int GetError() = 0;
 
-  sigslot::signal4<Connection*, const char*, size_t,
-                   const rtc::PacketTime&> SignalReadPacket;
+  sigslot::signal4<Connection*, const char*, size_t, const rtc::PacketTime&>
+      SignalReadPacket;
 
   sigslot::signal1<Connection*> SignalReadyToSend;
 
   // Called when a packet is received on this connection.
   void OnReadPacket(const char* data, size_t size,
                     const rtc::PacketTime& packet_time);
 
   // 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();
 
   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;
   }
 
+  void set_receiving_timeout(uint32 receiving_timeout_ms) {
+    receiving_timeout_ = receiving_timeout_ms;
+  }
+
   // Makes the connection go away.
   void Destroy();
 
   // Checks that the state of this connection is up-to-date.  The argument is
   // the current time, which is compared against various timeouts.
   void UpdateState(uint32 now);
 
   // Called when this connection should try checking writability again.
   uint32 last_ping_sent() const { return last_ping_sent_; }
   void Ping(uint32 now);
@@ skipping 50 matching lines @@
 
   // Callbacks from ConnectionRequest
   virtual void OnConnectionRequestResponse(ConnectionRequest* req,
                                            StunMessage* response);
   void OnConnectionRequestErrorResponse(ConnectionRequest* req,
                                         StunMessage* response);
   void OnConnectionRequestTimeout(ConnectionRequest* req);
   void OnConnectionRequestSent(ConnectionRequest* req);
 
   // Changes the state and signals if necessary.
-  void set_read_state(ReadState value);
   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_;
-  ReadState read_state_;
   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_;
@@ skipping 11 matching lines @@
   rtc::RateTracker send_rate_tracker_;
   uint32 sent_packets_discarded_;
   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_;
 
   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_