Increase Chrome SPDY/3 stream receive window to 10MB.

net/spdy/spdy_session.cc

 // Copyright (c) 2012 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 <map>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 282 matching lines @@
   const SpdyStreamId last_stream_id_;
   const int active_streams_;
   const int unclaimed_streams_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogSpdyGoAwayParameter);
 };
 
 NextProto g_default_protocol = kProtoUnknown;
 size_t g_init_max_concurrent_streams = 10;
 size_t g_max_concurrent_stream_limit = 256;
+size_t g_default_initial_rcv_window_size = 10 * 1024 * 1024;  // 10MB
 bool g_enable_ping_based_connection_checking = true;
 
 }  // namespace
 
 // static
 void SpdySession::set_default_protocol(NextProto default_protocol) {
   g_default_protocol = default_protocol;
 }
 
 // static
 void SpdySession::set_max_concurrent_streams(size_t value) {
   g_max_concurrent_stream_limit = value;
 }
 
 // static
+void SpdySession::set_default_initial_recv_window_size(size_t value) {
+  g_default_initial_rcv_window_size = value;
+}
+
+// static
 void SpdySession::set_enable_ping_based_connection_checking(bool enable) {
   g_enable_ping_based_connection_checking = enable;
 }
 
 // static
 void SpdySession::set_init_max_concurrent_streams(size_t value) {
   g_init_max_concurrent_streams =
       std::min(value, g_max_concurrent_stream_limit);
 }
 
 // static
 void SpdySession::ResetStaticSettingsToInit() {
   // WARNING: These must match the initializers above.
   g_default_protocol = kProtoUnknown;
   g_init_max_concurrent_streams = 10;
   g_max_concurrent_stream_limit = 256;
+  g_default_initial_rcv_window_size = kSpdyStreamInitialWindowSize;
   g_enable_ping_based_connection_checking = true;
 }
 
 SpdySession::SpdySession(const HostPortProxyPair& host_port_proxy_pair,
                          SpdySessionPool* spdy_session_pool,
                          HttpServerProperties* http_server_properties,
                          bool verify_domain_authentication,
                          const HostPortPair& trusted_spdy_proxy,
                          NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
@@ skipping 18 matching lines @@
       bytes_received_(0),
       sent_settings_(false),
       received_settings_(false),
       stalled_streams_(0),
       pings_in_flight_(0),
       next_ping_id_(1),
       last_activity_time_(base::TimeTicks::Now()),
       check_ping_status_pending_(false),
       flow_control_(false),
       initial_send_window_size_(kSpdyStreamInitialWindowSize),
-      initial_recv_window_size_(kSpdyStreamInitialWindowSize),
+      initial_recv_window_size_(g_default_initial_rcv_window_size),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SPDY_SESSION)),
       verify_domain_authentication_(verify_domain_authentication),
       credential_state_(SpdyCredentialState::kDefaultNumSlots),
       connection_at_risk_of_loss_time_(
           base::TimeDelta::FromSeconds(kDefaultConnectionAtRiskOfLossSeconds)),
       hung_interval_(
           base::TimeDelta::FromSeconds(kHungIntervalSeconds)),
       trusted_spdy_proxy_(trusted_spdy_proxy) {
   DCHECK(HttpStreamFactory::spdy_enabled());
   net_log_.BeginEvent(
@@ skipping 57 matching lines @@
                                             host_port_pair().ToString()));
   }
 
   DCHECK(protocol >= kProtoSPDY2);
   DCHECK(protocol <= kProtoSPDY3);
   int version = (protocol == kProtoSPDY3) ? 3 : 2;
   flow_control_ = (protocol >= kProtoSPDY3);
 
   buffered_spdy_framer_.reset(new BufferedSpdyFramer(version));
   buffered_spdy_framer_->set_visitor(this);
-  SendSettings();
+  SendInitialSettings();
 
   // Write out any data that we might have to send, such as the settings frame.
   WriteSocketLater();
   net::Error error = ReadSocket();
   if (error == ERR_IO_PENDING)
     return OK;
   return error;
 }
 
 bool SpdySession::VerifyDomainAuthentication(const std::string& domain) {
@@ skipping 1228 matching lines @@
   else if (trial->group_name() == "cwndMin16")
     return std::max(cwnd, 16);
   else if (trial->group_name() == "cwndMin10")
     return std::max(cwnd, 10);
   else if (trial->group_name() == "cwndDynamic")
     return cwnd;
   NOTREACHED();
   return cwnd;
 }
 
-void SpdySession::SendSettings() {
+void SpdySession::SendInitialSettings() {
+  SettingsMap settings_to_send;
+
+  // First notify the server about the settings they should use when
+  // communicating with use.
+  if (GetProtocolVersion() > 2 &&
+      initial_recv_window_size_ != kSpdyStreamInitialWindowSize) {
+    // Create a new settings frame notifying the sever of our
+    // initial window size.

[ramant (doing other things), 2012/06/04 20:22:35]

nit: could we update the comment (because initial window size could be
overwritten by what is persisted).

[Ryan Hamilton, 2012/06/04 20:48:50]

Ugh.  That would be a bug.  We do not want to overwrite *our* window size with
the server's window size.  We need two frames.

+    settings_to_send[SETTINGS_INITIAL_WINDOW_SIZE] =
+        SettingsFlagsAndValue(SETTINGS_FLAG_NONE, initial_recv_window_size_);
+    /*
+    net_log_.AddEvent(
+        NetLog::TYPE_SPDY_SESSION_SEND_SETTINGS,
+        make_scoped_refptr(new NetLogSpdySettingsParameter(settings_map)));
+
+    // Create the SETTINGS frame and send it.
+    DCHECK(buffered_spdy_framer_.get());
+    scoped_ptr<SpdySettingsControlFrame> settings_frame(
+        buffered_spdy_framer_->CreateSettings(settings_map));
+    sent_settings_ = true;
+    QueueFrame(settings_frame.get(), HIGHEST, NULL);

[ramant (doing other things), 2012/06/04 20:22:35]

nit: Should we delete the commented out code?

[Ryan Hamilton, 2012/06/04 20:48:50]

Whoops!  Done.  (Now factored into a new helper method)

+    */
+  }
+
   const SettingsMap& settings_map =
       http_server_properties_->GetSpdySettings(host_port_pair());
-  if (settings_map.empty())
-    return;
 
-  // Record Histogram Data and Apply the SpdyCwnd FieldTrial if applicable.
-  const SpdySettingsIds id = SETTINGS_CURRENT_CWND;
-  SettingsMap::const_iterator it = settings_map.find(id);
-  uint32 value = 0;
-  if (it != settings_map.end())
-    value = it->second.second;
-  uint32 cwnd = ApplyCwndFieldTrialPolicy(value);
-  UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySettingsCwndSent", cwnd, 1, 200, 100);
-  if (cwnd != value) {
-    http_server_properties_->SetSpdySetting(
-        host_port_pair(), id, SETTINGS_FLAG_PLEASE_PERSIST, cwnd);
+  // Next notify the server about the settings they have previously
+  // told use to use when communicating with them.

[ramant (doing other things), 2012/06/04 20:22:35]

nit: could we update this comment because we are not sending two SETTING frames?
thanks

[Ryan Hamilton, 2012/06/04 20:48:50]

Since I had to change the code, I kept the comment at as.

+  if (!settings_map.empty()) {
+    // Record Histogram Data and Apply the SpdyCwnd FieldTrial if applicable.
+    const SpdySettingsIds id = SETTINGS_CURRENT_CWND;
+    SettingsMap::const_iterator it = settings_map.find(id);
+    uint32 value = 0;
+    if (it != settings_map.end())
+      value = it->second.second;
+    uint32 cwnd = ApplyCwndFieldTrialPolicy(value);
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySettingsCwndSent", cwnd, 1, 200, 100);
+    if (cwnd != value) {
+      http_server_properties_->SetSpdySetting(
+          host_port_pair(), id, SETTINGS_FLAG_PLEASE_PERSIST, cwnd);
+    }
+
+    const SettingsMap& settings_map_new =
+        http_server_properties_->GetSpdySettings(host_port_pair());
+    for (SettingsMap::const_iterator i = settings_map_new.begin(),
+             end = settings_map_new.end(); i != end; ++i) {
+      const SpdySettingsIds new_id = i->first;
+      const uint32 new_val = i->second.second;
+      HandleSetting(new_id, new_val);
+      settings_to_send[i->first] = i->second;
+    }
   }
 
-  const SettingsMap& settings_map_new =
-      http_server_properties_->GetSpdySettings(host_port_pair());
-  for (SettingsMap::const_iterator i = settings_map_new.begin(),
-           end = settings_map_new.end(); i != end; ++i) {
-    const SpdySettingsIds new_id = i->first;
-    const uint32 new_val = i->second.second;
-    HandleSetting(new_id, new_val);
-  }
+  if (settings_to_send.empty())
+    return;
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_SEND_SETTINGS,
-      make_scoped_refptr(new NetLogSpdySettingsParameter(settings_map_new)));
+      make_scoped_refptr(new NetLogSpdySettingsParameter(settings_to_send)));
 
   // Create the SETTINGS frame and send it.
   DCHECK(buffered_spdy_framer_.get());
   scoped_ptr<SpdySettingsControlFrame> settings_frame(
-      buffered_spdy_framer_->CreateSettings(settings_map_new));
+      buffered_spdy_framer_->CreateSettings(settings_to_send));
   sent_settings_ = true;
   QueueFrame(settings_frame.get(), HIGHEST, NULL);
 }
 
 void SpdySession::HandleSetting(uint32 id, uint32 value) {
   switch (id) {
     case SETTINGS_MAX_CONCURRENT_STREAMS:
       max_concurrent_streams_ = std::min(static_cast<size_t>(value),
                                          g_max_concurrent_stream_limit);
       ProcessPendingCreateStreams();
@@ skipping 201 matching lines @@
 SSLClientSocket* SpdySession::GetSSLClientSocket() const {
   if (!is_secure_)
     return NULL;
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   DCHECK(ssl_socket);
   return ssl_socket;
 }
 
 }  // namespace net