Send preface-PING message once in 10 secs and send PING

net/spdy/spdy_session.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 #pragma once
 
 #include <deque>
 #include <list>
@@ skipping 377 matching lines @@
 
   virtual bool OnControlFrameHeaderData(spdy::SpdyStreamId stream_id,
                                         const char* header_data,
                                         size_t len);
 
   virtual void OnDataFrameHeader(const spdy::SpdyDataFrame* frame);
 
   // --------------------------
   // Helper methods for testing
   // --------------------------
-  static void set_connection_at_risk_of_loss_ms(int duration) {
-    connection_at_risk_of_loss_ms_ = duration;
+  static void set_connection_at_risk_of_loss_seconds(int duration) {
+    connection_at_risk_of_loss_seconds_ = duration;
   }
-  static int connection_at_risk_of_loss_ms() {
-    return connection_at_risk_of_loss_ms_;
+  static int connection_at_risk_of_loss_seconds() {
+    return connection_at_risk_of_loss_seconds_;
   }
 
   static void set_trailing_ping_delay_time_ms(int duration) {
     trailing_ping_delay_time_ms_ = duration;
   }
   static int trailing_ping_delay_time_ms() {
     return trailing_ping_delay_time_ms_;
   }
 
   static void set_hung_interval_ms(int duration) {
@@ skipping 144 matching lines @@
   bool verify_domain_authentication_;
 
   static bool use_ssl_;
   static bool use_flow_control_;
   static size_t init_max_concurrent_streams_;
   static size_t max_concurrent_stream_limit_;
 
   // This enables or disables connection health checking system.
   static bool enable_ping_based_connection_checking_;
 
-  // |connection_at_risk_of_loss_ms_| is an optimization to avoid sending
+  // |connection_at_risk_of_loss_seconds_| is an optimization to avoid sending
   // wasteful preface pings (when we just got some data).
   //
   // If it is zero (the most conservative figure), then we always send the
   // preface ping (when none are in flight).
   //
   // It is common for TCP/IP sessions to time out in about 3-5 minutes.
   // Certainly if it has been more than 3 minutes, we do want to send a preface
   // ping.
   //
   // We don't think any connection will time out in under about 10 seconds. So
   // this might as well be set to something conservative like 10 seconds. Later,
   // we could adjust it to send fewer pings perhaps.
-  static int connection_at_risk_of_loss_ms_;
+  static int connection_at_risk_of_loss_seconds_;
 
   // This is the amount of time (in milliseconds) we wait before sending a
   // trailing ping. We use a trailing ping (sent after all data) to get an
   // effective acknowlegement from the server that it has indeed received all
   // (prior) data frames. With that assurance, we are willing to enter into a
   // wait state for responses to our last data frame(s) without further pings.
   static int trailing_ping_delay_time_ms_;
 
   // The amount of time (in milliseconds) that we are willing to tolerate with
   // no data received (of any form), while there is a ping in flight, before we
@@ skipping 21 matching lines @@
   const spdy::SpdyControlFlags flags_;
   const spdy::SpdyStreamId id_;
   const spdy::SpdyStreamId associated_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogSpdySynParameter);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_