Emit session-level WINDOW_UPDATEs less frequently.

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 <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 642 matching lines @@
       last_compressed_frame_len_(0),
       check_ping_status_pending_(false),
       send_connection_header_prefix_(false),
       flow_control_state_(FLOW_CONTROL_NONE),
       stream_initial_send_window_size_(GetInitialWindowSize(default_protocol)),
       stream_initial_recv_window_size_(stream_initial_recv_window_size == 0
                                            ? kDefaultInitialRecvWindowSize
                                            : stream_initial_recv_window_size),
       session_send_window_size_(0),
       session_recv_window_size_(0),
+      session_max_recv_window_size_(0),
       session_unacked_recv_window_bytes_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_HTTP2_SESSION)),
       verify_domain_authentication_(verify_domain_authentication),
       enable_sending_initial_data_(enable_sending_initial_data),
       enable_compression_(enable_compression),
       enable_ping_based_connection_checking_(
           enable_ping_based_connection_checking),
       protocol_(default_protocol),
       connection_at_risk_of_loss_time_(
           base::TimeDelta::FromSeconds(kDefaultConnectionAtRiskOfLossSeconds)),
@@ skipping 58 matching lines @@
   DCHECK_LE(protocol_, kProtoSPDYMaximumVersion);
 
   if ((protocol_ >= kProtoSPDY4MinimumVersion) &&
       (protocol_ <= kProtoSPDY4MaximumVersion))
     send_connection_header_prefix_ = true;
 
   if (protocol_ >= kProtoSPDY31) {
     flow_control_state_ = FLOW_CONTROL_STREAM_AND_SESSION;
     session_send_window_size_ = GetInitialWindowSize(protocol_);
     session_recv_window_size_ = GetInitialWindowSize(protocol_);
+    session_max_recv_window_size_ = GetInitialWindowSize(protocol_);
   } else if (protocol_ >= kProtoSPDY3) {
     flow_control_state_ = FLOW_CONTROL_STREAM;
   } else {
     flow_control_state_ = FLOW_CONTROL_NONE;
   }
 
   buffered_spdy_framer_.reset(
       new BufferedSpdyFramer(NextProtoToSpdyMajorVersion(protocol_),
                              enable_compression_));
   buffered_spdy_framer_->set_visitor(this);
@@ skipping 2035 matching lines @@
 
   // Next, notify the server about our initial recv window size.
   if (flow_control_state_ == FLOW_CONTROL_STREAM_AND_SESSION) {
     // Bump up the receive window size to the real initial value. This
     // has to go here since the WINDOW_UPDATE frame sent by
     // IncreaseRecvWindowSize() call uses |buffered_spdy_framer_|.
     DCHECK_GT(kDefaultInitialRecvWindowSize, session_recv_window_size_);
     // This condition implies that |kDefaultInitialRecvWindowSize| -
     // |session_recv_window_size_| doesn't overflow.
     DCHECK_GT(session_recv_window_size_, 0);
-    IncreaseRecvWindowSize(
-        kDefaultInitialRecvWindowSize - session_recv_window_size_);
+    session_max_recv_window_size_ = kDefaultInitialRecvWindowSize;
+    IncreaseRecvWindowSize(session_max_recv_window_size_ -
+                           session_recv_window_size_);
   }
 
   if (protocol_ <= kProtoSPDY31) {
     // Finally, notify the server about the settings they have
     // previously told us to use when communicating with them (after
     // applying them).
     const SettingsMap& server_settings_map =
         http_server_properties_->GetSpdySettings(host_port_pair());
     if (server_settings_map.empty())
       return;
@@ skipping 375 matching lines @@
   DCHECK_GE(delta_window_size, 1);
   // Check for overflow.
   DCHECK_LE(delta_window_size, kint32max - session_recv_window_size_);
 
   session_recv_window_size_ += delta_window_size;
   net_log_.AddEvent(NetLog::TYPE_HTTP2_STREAM_UPDATE_RECV_WINDOW,
                     base::Bind(&NetLogSpdySessionWindowUpdateCallback,
                                delta_window_size, session_recv_window_size_));
 
   session_unacked_recv_window_bytes_ += delta_window_size;
-  if (session_unacked_recv_window_bytes_ >
-      GetInitialWindowSize(protocol_) / 2) {

[Ryan Hamilton, 2015/04/06 16:27:05]

I'm curious why this didn't work. It *looks* like it should work, but clearly
didn't :>

[Bence, 2015/04/07 12:32:16]

Good question.  So GetInitialWindowSize is 64 kB, while
session_max_recv_window_size_ is 10 MB.  So what this bug means is that every
time the window size goes below 10 MB - 32 kB, a WINDOW_UPDATE is sent to bump
it up to 10 MB.  Instead we only want it when the window size goes below 5 MB. 
Also see bug description.

[Ryan Hamilton, 2015/04/07 14:56:39]

Oh, that method was return the protocol default, not the Chrome initial window
size? Gotcha. I read GetInitialWindowSize and expected that to return 10MB, but
I get it now. Thanks.

+  if (session_unacked_recv_window_bytes_ > session_max_recv_window_size_ / 2) {
     SendWindowUpdateFrame(kSessionFlowControlStreamId,
                           session_unacked_recv_window_bytes_,
                           HIGHEST);
     session_unacked_recv_window_bytes_ = 0;
   }
 }
 
 void SpdySession::DecreaseRecvWindowSize(int32 delta_window_size) {
   CHECK(in_io_loop_);
   DCHECK_EQ(flow_control_state_, FLOW_CONTROL_STREAM_AND_SESSION);
@@ skipping 62 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net