Implement HTTP/2 settings field trial parameters.

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 <limits>
 #include <map>
 #include <utility>
@@ skipping 51 matching lines @@
 
 namespace {
 
 const int kReadBufferSize = 8 * 1024;
 const int kDefaultConnectionAtRiskOfLossSeconds = 10;
 const int kHungIntervalSeconds = 10;
 
 // Minimum seconds that unclaimed pushed streams will be kept in memory.
 const int kMinPushedStreamLifetimeSeconds = 300;
 
+// Default initial value for HTTP/2 SETTINGS.
+const uint32_t kDefaultInitialHeaderTableSize = 4096;
+const uint32_t kDefaultInitialEnablePush = 1;
+const uint32_t kDefaultInitialInitialWindowSize = 65535;
+const uint32_t kDefaultInitialMaxFrameSize = 16384;
+
+bool IsSpdySettingAtDefaultInitialValue(SpdySettingsIds setting_id,
+                                        uint32_t value) {
+  switch (setting_id) {
+    case SETTINGS_HEADER_TABLE_SIZE:
+      return value == kDefaultInitialHeaderTableSize;
+    case SETTINGS_ENABLE_PUSH:
+      return value == kDefaultInitialEnablePush;
+    case SETTINGS_MAX_CONCURRENT_STREAMS:
+      // There is no initial limit on the number of concurrent streams.
+      return false;
+    case SETTINGS_INITIAL_WINDOW_SIZE:
+      return value == kDefaultInitialInitialWindowSize;
+    case SETTINGS_MAX_FRAME_SIZE:
+      return value == kDefaultInitialMaxFrameSize;
+    case SETTINGS_MAX_HEADER_LIST_SIZE:
+      // There is no initial limit on the size of the header list.
+      return false;
+    default:
+      // Undefined parameters have no initial value.
+      return false;
+  }
+}
+
 std::unique_ptr<base::Value> NetLogSpdyHeadersSentCallback(
     const SpdyHeaderBlock* headers,
     bool fin,
     SpdyStreamId stream_id,
     bool has_priority,
     int weight,
     SpdyStreamId parent_stream_id,
     bool exclusive,
     NetLogCaptureMode capture_mode) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
@@ skipping 566 matching lines @@
 
   return true;
 }
 
 SpdySession::SpdySession(const SpdySessionKey& spdy_session_key,
                          HttpServerProperties* http_server_properties,
                          TransportSecurityState* transport_security_state,
                          bool enable_sending_initial_data,
                          bool enable_ping_based_connection_checking,
                          size_t session_max_recv_window_size,
-                         size_t stream_max_recv_window_size,
+                         const SettingsMap& initial_settings,
                          TimeFunc time_func,
                          ServerPushDelegate* push_delegate,
                          ProxyDelegate* proxy_delegate,
                          NetLog* net_log)
     : in_io_loop_(false),
       spdy_session_key_(spdy_session_key),
       pool_(NULL),
       http_server_properties_(http_server_properties),
       transport_security_state_(transport_security_state),
       read_buffer_(new IOBuffer(kReadBufferSize)),
       stream_hi_water_mark_(kFirstStreamId),
       last_accepted_push_stream_id_(0),
       unclaimed_pushed_streams_(this),
       push_delegate_(push_delegate),
       num_pushed_streams_(0u),
       num_active_pushed_streams_(0u),
       bytes_pushed_count_(0u),
       bytes_pushed_and_unclaimed_count_(0u),
       in_flight_write_frame_type_(DATA),
       in_flight_write_frame_size_(0),
       is_secure_(false),
       availability_state_(STATE_AVAILABLE),
       read_state_(READ_STATE_DO_READ),
       write_state_(WRITE_STATE_IDLE),
       error_on_close_(OK),
+      initial_settings_(initial_settings),
       max_concurrent_streams_(kInitialMaxConcurrentStreams),
-      max_concurrent_pushed_streams_(kMaxConcurrentPushedStreams),
+      max_concurrent_pushed_streams_(
+          initial_settings.at(SETTINGS_MAX_CONCURRENT_STREAMS)),
       streams_initiated_count_(0),
       streams_pushed_count_(0),
       streams_pushed_and_claimed_count_(0),
       streams_abandoned_count_(0),
       pings_in_flight_(0),
       next_ping_id_(1),
       last_activity_time_(time_func()),
       last_compressed_frame_len_(0),
       check_ping_status_pending_(false),
       session_send_window_size_(0),
       session_max_recv_window_size_(session_max_recv_window_size),
       session_recv_window_size_(0),
       session_unacked_recv_window_bytes_(0),
       stream_initial_send_window_size_(kDefaultInitialWindowSize),
-      stream_max_recv_window_size_(stream_max_recv_window_size),
+      max_header_table_size_(initial_settings.at(SETTINGS_HEADER_TABLE_SIZE)),
+      stream_max_recv_window_size_(
+          initial_settings.at(SETTINGS_INITIAL_WINDOW_SIZE)),
       net_log_(
           NetLogWithSource::Make(net_log, NetLogSourceType::HTTP2_SESSION)),
       enable_sending_initial_data_(enable_sending_initial_data),
       enable_ping_based_connection_checking_(
           enable_ping_based_connection_checking),
       connection_at_risk_of_loss_time_(
           base::TimeDelta::FromSeconds(kDefaultConnectionAtRiskOfLossSeconds)),
       hung_interval_(base::TimeDelta::FromSeconds(kHungIntervalSeconds)),
       proxy_delegate_(proxy_delegate),
       time_func_(time_func),
       weak_factory_(this) {
   net_log_.BeginEvent(
       NetLogEventType::HTTP2_SESSION,
       base::Bind(&NetLogSpdySessionCallback, &host_port_proxy_pair()));
   next_unclaimed_push_stream_sweep_time_ = time_func_() +
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
+
+  DCHECK(base::ContainsKey(initial_settings_, SETTINGS_HEADER_TABLE_SIZE));
+  DCHECK(base::ContainsKey(initial_settings_, SETTINGS_MAX_CONCURRENT_STREAMS));
+  DCHECK(base::ContainsKey(initial_settings_, SETTINGS_INITIAL_WINDOW_SIZE));
+
   // TODO(mbelshe): consider randomization of the stream_hi_water_mark.
 }
 
 SpdySession::~SpdySession() {
   CHECK(!in_io_loop_);
   DcheckDraining();
 
   // TODO(akalin): Check connection->is_initialized() instead. This
   // requires re-working CreateFakeSpdySession(), though.
   DCHECK(connection_->socket());
@@ skipping 21 matching lines @@
 
   connection_ = std::move(connection);
   is_secure_ = is_secure;
 
   session_send_window_size_ = kDefaultInitialWindowSize;
   session_recv_window_size_ = kDefaultInitialWindowSize;
 
   buffered_spdy_framer_.reset(new BufferedSpdyFramer());
   buffered_spdy_framer_->set_visitor(this);
   buffered_spdy_framer_->set_debug_visitor(this);
-  buffered_spdy_framer_->UpdateHeaderDecoderTableSize(kMaxHeaderTableSize);
+  buffered_spdy_framer_->UpdateHeaderDecoderTableSize(max_header_table_size_);
 
   net_log_.AddEvent(NetLogEventType::HTTP2_SESSION_INITIALIZED,
                     base::Bind(&NetLogSpdyInitializedCallback,
                                connection_->socket()->NetLog().source()));
 
   DCHECK_EQ(availability_state_, STATE_AVAILABLE);
   connection_->AddHigherLayeredPool(this);
   if (enable_sending_initial_data_)
     SendInitialData();
   pool_ = pool;
@@ skipping 1870 matching lines @@
 
   std::unique_ptr<SpdySerializedFrame> connection_header_prefix_frame(
       new SpdySerializedFrame(const_cast<char*>(kHttp2ConnectionHeaderPrefix),
                               kHttp2ConnectionHeaderPrefixSize,
                               false /* take_ownership */));
   // Count the prefix as part of the subsequent SETTINGS frame.
   EnqueueSessionWrite(HIGHEST, SETTINGS,
                       std::move(connection_header_prefix_frame));
 
   // First, notify the server about the settings they should use when
-  // communicating with us.
+  // communicating with us.  Only send settings that have a value different from
+  // the protocol default value.
   SettingsMap settings_map;
-  settings_map[SETTINGS_HEADER_TABLE_SIZE] = kMaxHeaderTableSize;
-  settings_map[SETTINGS_MAX_CONCURRENT_STREAMS] = kMaxConcurrentPushedStreams;
-  if (stream_max_recv_window_size_ != kDefaultInitialWindowSize) {
-    settings_map[SETTINGS_INITIAL_WINDOW_SIZE] = stream_max_recv_window_size_;
+  for (auto setting : initial_settings_) {
+    if (!IsSpdySettingAtDefaultInitialValue(setting.first, setting.second)) {
+      settings_map.insert(setting);
+    }
   }
   SendSettings(settings_map);
 
   // Next, notify the server about our initial recv window size.
   // 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_|.
   // This condition implies that |session_max_recv_window_size_| -
   // |session_recv_window_size_| doesn't overflow.
   DCHECK_GE(session_max_recv_window_size_, session_recv_window_size_);
@@ skipping 363 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net