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

net/spdy/spdy_session.cc

 // 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.
 
 #include "net/spdy/spdy_session.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
@@ skipping 216 matching lines @@
 // static
 size_t SpdySession::init_max_concurrent_streams_ = 10;
 
 // static
 size_t SpdySession::max_concurrent_stream_limit_ = 256;
 
 // static
 bool SpdySession::enable_ping_based_connection_checking_ = true;
 
 // static
-int SpdySession::connection_at_risk_of_loss_ms_ = 0;
+int SpdySession::connection_at_risk_of_loss_seconds_ = 10;
 
 // static
 int SpdySession::trailing_ping_delay_time_ms_ = 1000;
 
 // static
 int SpdySession::hung_interval_ms_ = 10000;
 
 SpdySession::SpdySession(const HostPortProxyPair& host_port_proxy_pair,
                          SpdySessionPool* spdy_session_pool,
                          SpdySettingsStorage* spdy_settings,
@@ skipping 275 matching lines @@
   streams_initiated_count_++;
 
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_SYN_STREAM,
         make_scoped_refptr(
             new NetLogSpdySynParameter(headers, flags, stream_id, 0)));
   }
 
   // Some servers don't like too many pings, so we limit our current sending to
-  // no more than one ping for any syn sent.  To do this, we avoid ever setting
-  // this to true unless we send a syn (which we have just done).  This approach
-  // may change over time as servers change their responses to pings.
+  // no more than two pings for any syn frame or data frame sent.  To do this,
+  // we avoid ever setting this to true unless we send a syn (which we have just
+  // done) or data frame. This approach may change over time as servers change
+  // their responses to pings.
   need_to_send_ping_ = true;
 
   return ERR_IO_PENDING;
 }
 
 int SpdySession::WriteStreamData(spdy::SpdyStreamId stream_id,
                                  net::IOBuffer* data, int len,
                                  spdy::SpdyDataFlags flags) {
   // Find our stream
   DCHECK(IsStreamActive(stream_id));
   scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
   CHECK_EQ(stream->stream_id(), stream_id);
   if (!stream)
     return ERR_INVALID_SPDY_STREAM;
 
-  SendPrefacePingIfNoneInFlight();
-
   if (len > kMaxSpdyFrameChunkSize) {
     len = kMaxSpdyFrameChunkSize;
     flags = static_cast<spdy::SpdyDataFlags>(flags & ~spdy::DATA_FLAG_FIN);
   }
 
   // Obey send window size of the stream if flow control is enabled.
   if (use_flow_control_) {
     if (stream->send_window_size() <= 0) {
       // Because we queue frames onto the session, it is possible that
       // a stream was not flow controlled at the time it attempted the
@@ skipping 15 matching lines @@
     }
     stream->DecreaseSendWindowSize(len);
   }
 
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_SEND_DATA,
         make_scoped_refptr(new NetLogSpdyDataParameter(stream_id, len, flags)));
   }
 
+  // Send PrefacePing for DATA_FRAMEs with nonzero payload size.
+  if (len > 0)
+    SendPrefacePingIfNoneInFlight();
+
   // TODO(mbelshe): reduce memory copies here.
   scoped_ptr<spdy::SpdyDataFrame> frame(
       spdy_framer_.CreateDataFrame(stream_id, data->data(), len, flags));
   QueueFrame(frame.get(), stream->priority(), stream);
+
+  // Some servers don't like too many pings, so we limit our current sending to
+  // no more than two pings for any syn frame or data frame sent.  To do this,
+  // we avoid ever setting this to true unless we send a syn (which we have just
+  // done) or data frame. This approach may change over time as servers change
+  // their responses to pings.
+  if (len > 0)
+    need_to_send_ping_ = true;
+
   return ERR_IO_PENDING;
 }
 
 void SpdySession::CloseStream(spdy::SpdyStreamId stream_id, int status) {
   // TODO(mbelshe): We should send a RST_STREAM control frame here
   //                so that the server can cancel a large send.
 
   DeleteStream(stream_id, status);
 }
 
@@ skipping 931 matching lines @@
     }
   }
 }
 
 void SpdySession::SendPrefacePingIfNoneInFlight() {
   if (pings_in_flight_ || trailing_ping_pending_ ||
       !enable_ping_based_connection_checking_)
     return;
 
   const base::TimeDelta kConnectionAtRiskOfLoss =
-      base::TimeDelta::FromMilliseconds(connection_at_risk_of_loss_ms_);
+      base::TimeDelta::FromSeconds(connection_at_risk_of_loss_seconds_);
 
   base::TimeTicks now = base::TimeTicks::Now();
   // If we haven't heard from server, then send a preface-PING.
   if ((now - received_data_time_) > kConnectionAtRiskOfLoss)
     SendPrefacePing();
 
   PlanToSendTrailingPing();
 }
 
 void SpdySession::SendPrefacePing() {
-  // TODO(rtenneti): Send preface pings when more servers support additional
-  // pings.
-  // WritePingFrame(next_ping_id_);
+  WritePingFrame(next_ping_id_);
 }
 
 void SpdySession::PlanToSendTrailingPing() {
   if (trailing_ping_pending_)
     return;
 
   trailing_ping_pending_ = true;
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(&SpdySession::SendTrailingPing),
@@ skipping 153 matching lines @@
   if (it == pending_callback_map_.end())
     return;
 
   OldCompletionCallback* callback = it->second.callback;
   int result = it->second.result;
   pending_callback_map_.erase(it);
   callback->Run(result);
 }
 
 }  // namespace net