Emit session-level WINDOW_UPDATEs less frequently.

net/spdy/spdy_session.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 40 matching lines @@
 // sends a SETTINGS frame with a different value.
 const size_t kInitialMaxConcurrentStreams = 100;
 
 // Specifies the maxiumum concurrent streams server could send (via push).
 const int kMaxConcurrentPushedStreams = 1000;
 
 // Specifies the maximum number of bytes to read synchronously before
 // yielding.
 const int kMaxReadBytesWithoutYielding = 32 * 1024;
 
-// The initial receive window size for both streams and sessions.
-const int32 kDefaultInitialRecvWindowSize = 10 * 1024 * 1024;  // 10MB
-
 // First and last valid stream IDs. As we always act as the client,
 // start at 1 for the first stream id.
 const SpdyStreamId kFirstStreamId = 1;
 const SpdyStreamId kLastStreamId = 0x7fffffff;
 
 class BoundNetLog;
 struct LoadTimingInfo;
 class SpdyStream;
 class SSLInfo;
 class TransportSecurityState;
@@ skipping 164 matching lines @@
   // |session| is the HttpNetworkSession.  |net_log| is the NetLog that we log
   // network events to.
   SpdySession(const SpdySessionKey& spdy_session_key,
               const base::WeakPtr<HttpServerProperties>& http_server_properties,
               TransportSecurityState* transport_security_state,
               bool verify_domain_authentication,
               bool enable_sending_initial_data,
               bool enable_compression,
               bool enable_ping_based_connection_checking,
               NextProto default_protocol,
-              size_t stream_initial_recv_window_size,
+              size_t session_max_recv_window_size,
+              size_t stream_max_recv_window_size,
               size_t initial_max_concurrent_streams,
               size_t max_concurrent_streams_limit,
               TimeFunc time_func,
               const HostPortPair& trusted_spdy_proxy,
               NetLog* net_log);
 
   ~SpdySession() override;
 
   const HostPortPair& host_port_pair() const {
     return spdy_session_key_.host_port_proxy_pair().first;
@@ skipping 197 matching lines @@
   // Returns the (version-dependent) flow control state.
   FlowControlState flow_control_state() const {
     return flow_control_state_;
   }
 
   // Returns the current |stream_initial_send_window_size_|.
   int32 stream_initial_send_window_size() const {
     return stream_initial_send_window_size_;
   }
 
-  // Returns the current |stream_initial_recv_window_size_|.
-  int32 stream_initial_recv_window_size() const {
-    return stream_initial_recv_window_size_;
+  // Returns the current |stream_max_recv_window_size_|.
+  int32 stream_max_recv_window_size() const {
+    return stream_max_recv_window_size_;
   }
 
   // Returns true if no stream in the session can send data due to
   // session flow control.
   bool IsSendStalled() const {
     return
         flow_control_state_ == FLOW_CONTROL_STREAM_AND_SESSION &&
         session_send_window_size_ == 0;
   }
 
@@ skipping 626 matching lines @@
   // Indicate if we have already scheduled a delayed task to check the ping
   // status.
   bool check_ping_status_pending_;
 
   // Whether to send the (HTTP/2) connection header prefix.
   bool send_connection_header_prefix_;
 
   // The (version-dependent) flow control state.
   FlowControlState flow_control_state_;
 
+  // Current send window size.  Zero unless session flow control is turned on.
+  int32 session_send_window_size_;
+
+  // Maximum receive window size.  Each time a WINDOW_UPDATE is sent, it
+  // restores the receive window size to this value.  Zero unless session flow
+  // control is turned on.
+  int32 session_max_recv_window_size_;
+
+  // Sum of |session_unacked_recv_window_bytes_| and current receive window
+  // size.  Zero unless session flow control is turned on.
+  // TODO(bnc): Rename or change semantics so that |window_size_| is actual
+  // window size.
+  int32 session_recv_window_size_;
+
+  // When bytes are consumed, SpdyIOBuffer destructor calls back to SpdySession,
+  // and this member keeps count of them until the corresponding WINDOW_UPDATEs
+  // are sent.  Zero unless session flow control is turned on.
+  int32 session_unacked_recv_window_bytes_;
+
   // Initial send window size for this session's streams. Can be
   // changed by an arriving SETTINGS frame. Newly created streams use
   // this value for the initial send window size.
   int32 stream_initial_send_window_size_;
 
   // Initial receive window size for this session's streams. 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.
-  int32 stream_initial_recv_window_size_;
-
-  // Session flow control variables. All zero unless session flow
-  // control is turned on.
-  int32 session_send_window_size_;
-  int32 session_recv_window_size_;
-  int32 session_unacked_recv_window_bytes_;
+  int32 stream_max_recv_window_size_;
 
   // A queue of stream IDs that have been send-stalled at some point
   // in the past.
   std::deque<SpdyStreamId> stream_send_unstall_queue_[NUM_PRIORITIES];
 
   BoundNetLog net_log_;
 
   // Outside of tests, these should always be true.
   bool verify_domain_authentication_;
   bool enable_sending_initial_data_;
@@ skipping 35 matching lines @@
   // Used for posting asynchronous IO tasks.  We use this even though
   // SpdySession is refcounted because we don't need to keep the SpdySession
   // alive if the last reference is within a RunnableMethod.  Just revoke the
   // method.
   base::WeakPtrFactory<SpdySession> weak_factory_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_