Send PING to check the status of the SPDY connection.

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 86 matching lines @@
                                   bool is_secure,
                                   int certificate_error_code);
 
   // Check to see if this SPDY session can support an additional domain.
   // If the session is un-authenticated, then this call always returns true.
   // For SSL-based sessions, verifies that the certificate in use by this
   // session provides authentication for the domain.
   // NOTE:  This function can have false negatives on some platforms.
   bool VerifyDomainAuthentication(const std::string& domain);
 
-  // Send the SYN frame for |stream_id|.
+  // Send the SYN frame for |stream_id|. This also sends PING message to check
+  // the status of the connection.
   int WriteSynStream(
       spdy::SpdyStreamId stream_id,
       RequestPriority priority,
       spdy::SpdyControlFlags flags,
       const linked_ptr<spdy::SpdyHeaderBlock>& headers);
 
   // Write a data frame to the stream.
   // Used to create and queue a data frame for the given stream.
   int WriteStreamData(spdy::SpdyStreamId stream_id, net::IOBuffer* data,
                       int len,
@@ skipping 152 matching lines @@
 
   // Control frame handlers.
   void OnSyn(const spdy::SpdySynStreamControlFrame& frame,
              const linked_ptr<spdy::SpdyHeaderBlock>& headers);
   void OnSynReply(const spdy::SpdySynReplyControlFrame& frame,
                   const linked_ptr<spdy::SpdyHeaderBlock>& headers);
   void OnHeaders(const spdy::SpdyHeadersControlFrame& frame,
                  const linked_ptr<spdy::SpdyHeaderBlock>& headers);
   void OnRst(const spdy::SpdyRstStreamControlFrame& frame);
   void OnGoAway(const spdy::SpdyGoAwayControlFrame& frame);
+  void OnPing(const spdy::SpdyPingControlFrame& frame);
   void OnSettings(const spdy::SpdySettingsControlFrame& frame);
   void OnWindowUpdate(const spdy::SpdyWindowUpdateControlFrame& frame);
 
   // IO Callbacks
   void OnReadComplete(int result);
   void OnWriteComplete(int result);
 
   // Send relevant SETTINGS.  This is generally called on connection setup.
   void SendSettings();
 
   // Handle SETTINGS.  Either when we send settings, or when we receive a
   // SETTINGS ontrol frame, update our SpdySession accordingly.
   void HandleSettings(const spdy::SpdySettings& settings);
 
+  // Send the PING (pre-PING and post-PING) frames for |stream_id|.
+  int SendPing(spdy::SpdyStreamId stream_id);

[willchan no longer on Chromium, 2011/10/13 15:47:17]

SendPing() shouldn't be tied to a |stream_id|. It should take a unique_id. The
only caller right now should be the code that happens to use a unique_id that
equals the stream_id.

Same thing applies for the rest of these Send/Write methods.

[ramant (doing other things), 2011/10/13 21:41:14]

Dropped the stream_id argument. As you had suggested earlier, didn't want to use
stream_id for unique_id. Added unique_id_counter_ to determine the unique_id.
Hope that is ok. thanks. 

Done.

+
+  // Send PING if there are no PINGs in flight and we haven't heard from server.
+  int SendPrePing(spdy::SpdyStreamId stream_id);
+
+  // Send a delayed PING if there is no |follower_ping_pending_|. This PING
+  // makes sure the request has been received by the server.
+  int SendPostPing(spdy::SpdyStreamId stream_id);
+
+  // Send the PING frame for |stream_id|.
+  int WritePingFrame(spdy::SpdyStreamId stream_id);
+
+  // Check the status of the connection. It does |DeleteStream| if we haven't
+  // received any data in |kHungInterval|.
+  void CheckStatus(spdy::SpdyStreamId stream_id,
+                   base::TimeTicks last_check_time);
+
   // Start reading from the socket.
   // Returns OK on success, or an error on failure.
   net::Error ReadSocket();
 
   // Write current data to the socket.
   void WriteSocketLater();
   void WriteSocket();
 
   // Get a new stream id.
   int GetNewStreamId();
@@ skipping 126 matching lines @@
   int streams_pushed_count_;
   int streams_pushed_and_claimed_count_;
   int streams_abandoned_count_;
   int frames_received_;
   int bytes_received_;
   bool sent_settings_;      // Did this session send settings when it started.
   bool received_settings_;  // Did this session receive at least one settings
                             // frame.
   int stalled_streams_;     // Count of streams that were ever stalled.
 
+  // This list keeps track of all pings (unique_ids) that are in flight.
+  int64 pings_in_flight_;
+
+  // This is the next unique_id to be sent in PING frame.
+  uint32  unique_id_counter_;
+
+  // This is the last time we had received data.
+  base::TimeTicks received_data_time_;
+
+  // Flag if we have a pending follower ping.
+  bool follower_ping_pending_;
+
   // Initial send window size for the session; can be changed by an
   // arriving SETTINGS frame; newly created streams use this value for the
   // initial send window size.
   int initial_send_window_size_;
 
   // Initial receive window size for the session; there are plans to add a
   // command line switch that would cause a SETTINGS frame with window size
   // announcement to be sent on startup; newly created streams will use
   // this value for the initial receive window size.
   int initial_recv_window_size_;
@@ skipping 29 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_