Close idle H2 sockets when SpdySession is initialized.

net/spdy/spdy_session_unittest.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 <memory>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
+#include "base/test/scoped_feature_list.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/proxy_delegate.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_data_stream.h"
 #include "net/base/test_proxy_delegate.h"
 #include "net/cert/ct_policy_status.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source.h"
@@ skipping 5973 matching lines @@
   SSLInfo ssl_info;
   ssl_info.cert = ImportCertFromFile(GetTestCertsDirectory(),
                                      "spdy_pooling.pem");
   ssl_info.is_issued_by_known_root = true;
   ssl_info.public_key_hashes.push_back(test::GetTestHashValue(primary_pin));
 
   EXPECT_TRUE(SpdySession::CanPool(
       &tss, ssl_info, "www.example.org", "mail.example.org"));
 }
 
+class SpdySessionCloseIdleConnectionTest
+    : public SpdySessionTest,
+      public ::testing::WithParamInterface<bool> {
+ protected:
+  SpdySessionCloseIdleConnectionTest() : experiment_enabled_(GetParam()) {}
+  void SetUp() override {
+    if (experiment_enabled_) {
+      scoped_feature_list_.InitFromCommandLine("CloseIdleH2SocketsEarly",
+                                               std::string());
+    }
+  }
+
+ protected:
+  const bool experiment_enabled_;
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+  HttpRequestInfo request_info_;
+};
+
+INSTANTIATE_TEST_CASE_P(/* no prefix */,
+                        SpdySessionCloseIdleConnectionTest,
+                        ::testing::Bool());
+
+TEST_P(SpdySessionCloseIdleConnectionTest, CloseIdleConnectionsInGroup) {
+  session_deps_.host_resolver->set_synchronous_mode(true);
+
+  size_t kNumIdleSockets = 4;

[davidben, 2017/03/02 22:05:52]

Nit: const

[xunjieli, 2017/03/02 23:04:01]

Done.

+  MockRead reads[] = {MockRead(ASYNC, 0, 0)};
+  std::vector<std::unique_ptr<SequencedSocketData>> providers;
+  for (size_t i = 0; i < kNumIdleSockets; i++) {
+    auto provider = base::MakeUnique<SequencedSocketData>(
+        reads, arraysize(reads), nullptr, 0);
+    session_deps_.socket_factory->AddSocketDataProvider(provider.get());
+    providers.push_back(std::move(provider));
+    AddSSLSocketData();
+  }
+
+  CreateNetworkSession();
+
+  // Create some HTTP/2 sockets.
+  std::vector<std::unique_ptr<ClientSocketHandle>> handles;
+  for (size_t i = 0; i < kNumIdleSockets; i++) {
+    scoped_refptr<TransportSocketParams> transport_params(
+        new TransportSocketParams(
+            key_.host_port_pair(), false, OnHostResolutionCallback(),
+            TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
+
+    auto connection = base::MakeUnique<ClientSocketHandle>();
+    TestCompletionCallback callback;
+
+    SSLConfig ssl_config;
+    scoped_refptr<SSLSocketParams> ssl_params(new SSLSocketParams(
+        transport_params, nullptr, nullptr, key_.host_port_pair(), ssl_config,
+        key_.privacy_mode(), 0, false));
+    int rv = connection->Init(
+        key_.host_port_pair().ToString(), ssl_params, MEDIUM,
+        ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
+        http_session_->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL),
+        NetLogWithSource());
+    rv = callback.GetResult(rv);
+    handles.push_back(std::move(connection));
+  }
+
+  // Releases handles now, and these sockets should go into the socket pool.
+  handles.clear();
+  EXPECT_EQ(
+      (int)kNumIdleSockets,

[davidben, 2017/03/02 22:05:52]

Nit: If you make kNumIdleSockets an int, you can probably save all these casts.

(Otherwise (int) => static_cast<int>.)

[xunjieli, 2017/03/02 23:04:01]

Done.

+      http_session_->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)
+          ->IdleSocketCount());
+
+  // The new SpdySession will reuse one socket from the pool.
+  CreateSecureSpdySession();
+

[davidben, 2017/03/02 22:05:52]

Nit: maybe add

// If the experiment is enabled, the SpdySession will close the idle sockets.

[xunjieli, 2017/03/02 23:04:00]

Done.

+  EXPECT_EQ(
+      experiment_enabled_ ? 0 : (int)kNumIdleSockets - 1,
+      http_session_->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)
+          ->IdleSocketCount());
+}
+
 }  // namespace net