Close idle H2 sockets when SpdySession is initialized.

net/socket/client_socket_pool_base_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/socket/client_socket_pool_base.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
@@ skipping 537 matching lines @@
                      int id) override {
     base_.ReleaseSocket(group_name, std::move(socket), id);
   }
 
   void FlushWithError(int error) override { base_.FlushWithError(error); }
 
   bool IsStalled() const override { return base_.IsStalled(); }
 
   void CloseIdleSockets() override { base_.CloseIdleSockets(); }
 
+  void CloseIdleSocketsInGroup(const std::string& group_name) override {
+    base_.CloseIdleSocketsInGroup(group_name);
+  }
+
   int IdleSocketCount() const override { return base_.idle_socket_count(); }
 
   int IdleSocketCountInGroup(const std::string& group_name) const override {
     return base_.IdleSocketCountInGroup(group_name);
   }
 
   LoadState GetLoadState(const std::string& group_name,
                          const ClientSocketHandle* handle) const override {
     return base_.GetLoadState(group_name, handle);
   }
@@ skipping 1154 matching lines @@
                        callback.callback(), pool_.get(), log.bound());
   EXPECT_THAT(rv, IsOk());
   handle.Reset();
   EXPECT_EQ(1, pool_->IdleSocketCount());
   pool_->CloseIdleSockets();
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_CLEAN_UP_FORCED=*/4, 1)));
 }
 
+TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsInGroupForced) {
+  base::HistogramTester histograms;
+  CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
+  TestCompletionCallback callback;
+  BoundTestNetLog log;
+  ClientSocketHandle handle1;
+  int rv = handle1.Init("a", params_, LOWEST,
+                        ClientSocketPool::RespectLimits::ENABLED,
+                        callback.callback(), pool_.get(), log.bound());
+  EXPECT_THAT(rv, IsOk());
+  ClientSocketHandle handle2;
+  rv = handle2.Init("a", params_, LOWEST,
+                    ClientSocketPool::RespectLimits::ENABLED,
+                    callback.callback(), pool_.get(), log.bound());
+  ClientSocketHandle handle3;
+  rv = handle3.Init("b", params_, LOWEST,
+                    ClientSocketPool::RespectLimits::ENABLED,
+                    callback.callback(), pool_.get(), log.bound());
+  EXPECT_THAT(rv, IsOk());
+  handle1.Reset();
+  handle2.Reset();
+  handle3.Reset();
+  EXPECT_EQ(3, pool_->IdleSocketCount());
+  pool_->CloseIdleSocketsInGroup("a");
+  EXPECT_EQ(1, pool_->IdleSocketCount());
+  EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
+              testing::ElementsAre(
+                  base::Bucket(/*IDLE_SOCKET_FATE_CLEAN_UP_FORCED=*/4, 2)));
+}
+
 TEST_F(ClientSocketPoolBaseTest, CleanUpUnusableIdleSockets) {
   base::HistogramTester histograms;
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   BoundTestNetLog log;
   int rv = handle.Init("a", params_, LOWEST,
                        ClientSocketPool::RespectLimits::ENABLED,
                        callback.callback(), pool_.get(), log.bound());
   EXPECT_THAT(rv, IsOk());
@@ skipping 2299 matching lines @@
   request(1)->handle()->Reset();
   ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   EXPECT_THAT(request(2)->WaitForResult(), IsOk());
   EXPECT_FALSE(request(1)->have_result());
 }
 
 }  // namespace
 
 }  // namespace net