Increase number of max sockets per group for WebSocket connections.

net/http/http_pipelined_network_transaction_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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/address_list.h"
 #include "net/base/host_cache.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/request_priority.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/http/http_auth_handler_mock.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_histograms.h"
+#include "net/socket/client_socket_pool_manager.h"
 #include "net/socket/socket_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::StrEq;
 
 namespace net {
 
 namespace {
 
@@ skipping 234 matching lines @@
     MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
     MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
     MockRead(SYNCHRONOUS, 7, "two.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   CompleteTwoRequests(0, 5);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, ReusesOnSpaceAvailable) {
-  int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group();
-  ClientSocketPoolManager::set_max_sockets_per_group(1);
+  int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group(
+      HttpNetworkSession::NORMAL_SOCKET_POOL);
+  ClientSocketPoolManager::set_max_sockets_per_group(
+      HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   Initialize(false);
 
   MockWrite writes[] = {
     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
     MockWrite(SYNCHRONOUS, 4, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
     MockWrite(SYNCHRONOUS, 7, "GET /three.html HTTP/1.1\r\n"
@@ skipping 14 matching lines @@
     MockRead(SYNCHRONOUS, 10, "Content-Length: 10\r\n\r\n"),
     MockRead(SYNCHRONOUS, 11, "three.html"),
     MockRead(SYNCHRONOUS, 13, "HTTP/1.1 200 OK\r\n"),
     MockRead(SYNCHRONOUS, 14, "Content-Length: 9\r\n\r\n"),
     MockRead(SYNCHRONOUS, 15, "four.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   CompleteFourRequests();
 
-  ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets);
+  ClientSocketPoolManager::set_max_sockets_per_group(
+      HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, UnknownSizeEvictsToNewPipeline) {
   Initialize(false);
 
   MockWrite writes[] = {
     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
@@ skipping 281 matching lines @@
   ExpectResponse("pipelined.html", one_transaction, SYNCHRONOUS);
 
   CompleteTwoRequests(1, 4);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, PipelinesImmediatelyIfKnownGood) {
   // The first request gets us an HTTP/1.1. The next 3 test pipelining. When the
   // 3rd request completes, we know pipelining is safe. After the first 4
   // complete, the 5th and 6th should then be immediately sent pipelined on a
   // new HttpPipelinedConnection.
-  int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group();
-  ClientSocketPoolManager::set_max_sockets_per_group(1);
+  int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group(
+      HttpNetworkSession::NORMAL_SOCKET_POOL);
+  ClientSocketPoolManager::set_max_sockets_per_group(
+      HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   Initialize(false);
 
   MockWrite writes[] = {
     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
     MockWrite(SYNCHRONOUS, 4, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
     MockWrite(SYNCHRONOUS, 7, "GET /three.html HTTP/1.1\r\n"
@@ skipping 50 matching lines @@
 
   data_vector_[0]->RunFor(3);
   EXPECT_EQ(OK, second_one_callback.WaitForResult());
   data_vector_[0]->StopAfter(100);
   ExpectResponse("second-pipeline-one.html", second_one_transaction,
                  SYNCHRONOUS);
   EXPECT_EQ(OK, second_two_callback.WaitForResult());
   ExpectResponse("second-pipeline-two.html", second_two_transaction,
                  SYNCHRONOUS);
 
-  ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets);
+  ClientSocketPoolManager::set_max_sockets_per_group(
+      HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets);
 }
 
 class DataRunnerObserver : public MessageLoop::TaskObserver {
  public:
   DataRunnerObserver(DeterministicSocketData* data, int run_before_task)
       : data_(data),
         run_before_task_(run_before_task),
         current_task_(0) { }
 
   virtual void WillProcessTask(base::TimeTicks) OVERRIDE {
@@ skipping 272 matching lines @@
   EXPECT_EQ(ERR_PIPELINE_EVICTION, two_callback.WaitForResult());
   two_transaction.reset();
   EXPECT_EQ(ERR_PIPELINE_EVICTION, three_callback.WaitForResult());
   three_transaction.reset();
   EXPECT_EQ(ERR_PIPELINE_EVICTION, four_callback.WaitForResult());
 }
 
 }  // anonymous namespace
 
 }  // namespace net