Close idle H2 sockets when SpdySession is initialized.

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>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 42 matching lines @@
 
 // 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;
 
+// Experiment to close idle H2 sockets when SpdySession is initialized.
+const base::Feature kCloseIdleH2SocketsEarlyExperiment{
+    "CloseIdleH2SocketsEarly", base::FEATURE_DISABLED_BY_DEFAULT};
+
 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;
@@ skipping 619 matching lines @@
           new_hostname, ssl_info.cert.get(), ssl_info.public_key_hashes)) {
     return false;
   }
 
   return true;
 }
 
 SpdySession::SpdySession(const SpdySessionKey& spdy_session_key,
                          HttpServerProperties* http_server_properties,
                          TransportSecurityState* transport_security_state,
+                         HttpNetworkSession* http_network_session,
                          bool enable_sending_initial_data,
                          bool enable_ping_based_connection_checking,
                          size_t session_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),
+      http_network_session_(http_network_session),
       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),
@@ skipping 145 matching lines @@
   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;
 
+  if (base::FeatureList::IsEnabled(kCloseIdleH2SocketsEarlyExperiment)) {
+    // Close idle sockets in this group, since subsequent requests will go over
+    // this HTTP/2 connection.
+    http_network_session_->CloseIdleConnectionsInGroup(
+        connection_->group_name());
+  }
+
   // Bootstrap the read loop.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&SpdySession::PumpReadLoop, weak_factory_.GetWeakPtr(),
                  READ_STATE_DO_READ, OK));
 }
 
 bool SpdySession::VerifyDomainAuthentication(const std::string& domain) {
   if (availability_state_ == STATE_DRAINING)
     return false;
@@ skipping 2227 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net