Convert ignore_limits from a SocketParam to a socket request argument.

net/socket/websocket_transport_client_socket_pool_unittest.cc

 // Copyright 2014 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/websocket_transport_client_socket_pool.h"
 
 #include <queue>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 37 matching lines @@
                                                        period);
   run_loop.Run();
 }
 
 class WebSocketTransportClientSocketPoolTest : public ::testing::Test {
  protected:
   WebSocketTransportClientSocketPoolTest()
       : params_(new TransportSocketParams(
             HostPortPair("www.google.com", 80),
             false,
-            false,
             OnHostResolutionCallback(),
             TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)),
         host_resolver_(new MockHostResolver),
         client_socket_factory_(&net_log_),
         pool_(kMaxSockets,
               kMaxSocketsPerGroup,
               host_resolver_.get(),
               &client_socket_factory_,
               NULL) {}
 
   ~WebSocketTransportClientSocketPoolTest() override {
     RunUntilIdle();
     // ReleaseAllConnections() calls RunUntilIdle() after releasing each
     // connection.
     ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
     EXPECT_TRUE(WebSocketEndpointLockManager::GetInstance()->IsEmpty());
   }
 
   static void RunUntilIdle() { base::RunLoop().RunUntilIdle(); }
 
   int StartRequest(const std::string& group_name, RequestPriority priority) {
     scoped_refptr<TransportSocketParams> params(
         new TransportSocketParams(
             HostPortPair("www.google.com", 80),
             false,
-            false,
             OnHostResolutionCallback(),
             TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
     return test_base_.StartRequestUsingPool(
-        &pool_, group_name, priority, params);
+        &pool_, group_name, priority, ClientSocketPool::IgnoreLimits::DISABLED,
+        params);
   }
 
   int GetOrderOfRequest(size_t index) {
     return test_base_.GetOrderOfRequest(index);
   }
 
   bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
     return test_base_.ReleaseOneConnection(keep_alive);
   }
 
@@ skipping 16 matching lines @@
   ClientSocketPoolTest test_base_;
   ScopedWebSocketEndpointZeroUnlockDelay zero_unlock_delay_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebSocketTransportClientSocketPoolTest);
 };
 
 TEST_F(WebSocketTransportClientSocketPoolTest, Basic) {
   TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init(
-      "a", params_, LOW, callback.callback(), &pool_, BoundNetLog());
+  int rv =
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfoConnectedNotReused(handle);
 }
 
 // Make sure that WebSocketTransportConnectJob passes on its priority to its
 // HostResolver request on Init.
 TEST_F(WebSocketTransportClientSocketPoolTest, SetResolvePriorityOnInit) {
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
     RequestPriority priority = static_cast<RequestPriority>(i);
     TestCompletionCallback callback;
     ClientSocketHandle handle;
     EXPECT_EQ(ERR_IO_PENDING,
-              handle.Init("a",
-                          params_,
-                          priority,
-                          callback.callback(),
-                          &pool_,
-                          BoundNetLog()));
+              handle.Init("a", params_, priority,
+                          ClientSocketPool::IgnoreLimits::DISABLED,
+                          callback.callback(), &pool_, BoundNetLog()));
     EXPECT_EQ(priority, host_resolver_->last_request_priority());
   }
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest, InitHostResolutionFailure) {
   host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name");
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   HostPortPair host_port_pair("unresolvable.host.name", 80);
   scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
-      host_port_pair, false, false, OnHostResolutionCallback(),
+      host_port_pair, false, OnHostResolutionCallback(),
       TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        dest,
-                        kDefaultPriority,
-                        callback.callback(),
-                        &pool_,
-                        BoundNetLog()));
+            handle.Init("a", dest, kDefaultPriority,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), &pool_, BoundNetLog()));
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult());
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest, InitConnectionFailure) {
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET);
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        kDefaultPriority,
-                        callback.callback(),
-                        &pool_,
-                        BoundNetLog()));
+            handle.Init("a", params_, kDefaultPriority,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), &pool_, BoundNetLog()));
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
 
   // Make the host resolutions complete synchronously this time.
   host_resolver_->set_synchronous_mode(true);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
-            handle.Init("a",
-                        params_,
-                        kDefaultPriority,
-                        callback.callback(),
-                        &pool_,
-                        BoundNetLog()));
+            handle.Init("a", params_, kDefaultPriority,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), &pool_, BoundNetLog()));
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest, PendingRequestsFinishFifo) {
   // First request finishes asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
   EXPECT_EQ(OK, request(0)->WaitForResult());
 
   // Make all subsequent host resolutions complete synchronously.
   host_resolver_->set_synchronous_mode(true);
 
@@ skipping 54 matching lines @@
   EXPECT_EQ(6U, completion_count());
 }
 
 // This test will start up a RequestSocket() and then immediately Cancel() it.
 // The pending host resolution will eventually complete, and destroy the
 // ClientSocketPool which will crash if the group was not cleared properly.
 TEST_F(WebSocketTransportClientSocketPoolTest, CancelRequestClearGroup) {
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        kDefaultPriority,
-                        callback.callback(),
-                        &pool_,
-                        BoundNetLog()));
+            handle.Init("a", params_, kDefaultPriority,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), &pool_, BoundNetLog()));
   handle.Reset();
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest, TwoRequestsCancelOne) {
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
 
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        kDefaultPriority,
-                        callback.callback(),
-                        &pool_,
-                        BoundNetLog()));
+            handle.Init("a", params_, kDefaultPriority,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), &pool_, BoundNetLog()));
   EXPECT_EQ(ERR_IO_PENDING,
-            handle2.Init("a",
-                         params_,
-                         kDefaultPriority,
-                         callback2.callback(),
-                         &pool_,
-                         BoundNetLog()));
+            handle2.Init("a", params_, kDefaultPriority,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback2.callback(), &pool_, BoundNetLog()));
 
   handle.Reset();
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   handle2.Reset();
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest, ConnectCancelConnect) {
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        kDefaultPriority,
-                        callback.callback(),
-                        &pool_,
-                        BoundNetLog()));
+            handle.Init("a", params_, kDefaultPriority,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), &pool_, BoundNetLog()));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        kDefaultPriority,
-                        callback2.callback(),
-                        &pool_,
-                        BoundNetLog()));
+            handle.Init("a", params_, kDefaultPriority,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback2.callback(), &pool_, BoundNetLog()));
 
   host_resolver_->set_synchronous_mode(true);
   // At this point, handle has two ConnectingSockets out for it.  Due to the
   // setting the mock resolver into synchronous mode, the host resolution for
   // both will return in the same loop of the MessageLoop.  The client socket
   // is a pending socket, so the Connect() will asynchronously complete on the
   // next loop of the MessageLoop.  That means that the first
   // ConnectingSocket will enter OnIOComplete, and then the second one will.
   // If the first one is not cancelled, it will advance the load state, and
   // then the second one will crash.
@@ skipping 49 matching lines @@
                              WebSocketTransportClientSocketPool* pool,
                              const CompletionCallback& nested_callback,
                              int first_request_result) {
   EXPECT_EQ(OK, first_request_result);
 
   // Don't allow reuse of the socket.  Disconnect it and then release it.
   handle->socket()->Disconnect();
   handle->Reset();
 
   scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
-      HostPortPair("www.google.com", 80), false, false,
-      OnHostResolutionCallback(),
+      HostPortPair("www.google.com", 80), false, OnHostResolutionCallback(),
       TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
   int rv =
-      handle->Init("a", dest, LOWEST, nested_callback, pool, BoundNetLog());
+      handle->Init("a", dest, LOWEST, ClientSocketPool::IgnoreLimits::DISABLED,
+                   nested_callback, pool, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   if (ERR_IO_PENDING != rv)
     nested_callback.Run(rv);
 }
 
 // Tests the case where a second socket is requested in a completion callback,
 // and the second socket connects asynchronously.  Reuses the same
 // ClientSocketHandle for the second socket, after disconnecting the first.
 TEST_F(WebSocketTransportClientSocketPoolTest, RequestTwice) {
   ClientSocketHandle handle;
   scoped_refptr<TransportSocketParams> dest(
       new TransportSocketParams(
           HostPortPair("www.google.com", 80),
           false,
-          false,
           OnHostResolutionCallback(),
           TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
   TestCompletionCallback second_result_callback;
-  int rv = handle.Init("a", dest, LOWEST,
-                       base::Bind(&RequestSocketOnComplete, &handle, &pool_,
-                                  second_result_callback.callback()),
-                       &pool_, BoundNetLog());
+  int rv =
+      handle.Init("a", dest, LOWEST, ClientSocketPool::IgnoreLimits::DISABLED,
+                  base::Bind(&RequestSocketOnComplete, &handle, &pool_,
+                             second_result_callback.callback()),
+                  &pool_, BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, second_result_callback.WaitForResult());
 
   handle.Reset();
 }
 
 // Make sure that pending requests get serviced after active requests get
 // cancelled.
 TEST_F(WebSocketTransportClientSocketPoolTest,
        CancelActiveRequestWithPendingRequests) {
@@ skipping 50 matching lines @@
   EXPECT_FALSE(request(1)->handle()->is_initialized());
   request(0)->handle()->Reset();
   RunUntilIdle();
   EXPECT_TRUE(request(1)->handle()->is_initialized());
 }
 
 // The lock on the endpoint is released when a ClientSocketHandle is deleted.
 TEST_F(WebSocketTransportClientSocketPoolTest, LockReleasedOnHandleDelete) {
   TestCompletionCallback callback;
   scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle);
-  int rv = handle->Init(
-      "a", params_, LOW, callback.callback(), &pool_, BoundNetLog());
+  int rv =
+      handle->Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                   callback.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_FALSE(request(0)->handle()->is_initialized());
   handle.reset();
   RunUntilIdle();
   EXPECT_TRUE(request(0)->handle()->is_initialized());
 }
 
@@ skipping 46 matching lines @@
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
 
   // Resolve an AddressList with an IPv6 address first and then an IPv4 address.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,2.2.2.2", std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv =
-      handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv4AddressSize, endpoint.address().size());
@@ skipping 21 matching lines @@
   client_socket_factory_.set_delay(base::TimeDelta::FromMilliseconds(
       TransportConnectJobHelper::kIPv6FallbackTimerInMs + 50));
 
   // Resolve an AddressList with an IPv6 address first and then an IPv4 address.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,2.2.2.2", std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv =
-      handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv6AddressSize, endpoint.address().size());
@@ skipping 11 matching lines @@
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET);
 
   // Resolve an AddressList with only IPv6 addresses.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv =
-      handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv6AddressSize, endpoint.address().size());
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest, IPv4HasNoFallback) {
   WebSocketTransportClientSocketPool pool(kMaxSockets,
                                           kMaxSocketsPerGroup,
                                           host_resolver_.get(),
                                           &client_socket_factory_,
                                           NULL);
 
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET);
 
   // Resolve an AddressList with only IPv4 addresses.
   host_resolver_->rules()->AddIPLiteralRule("*", "1.1.1.1", std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv =
-      handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv4AddressSize, endpoint.address().size());
@@ skipping 20 matching lines @@
   client_socket_factory_.set_client_socket_types(case_types,
                                                  arraysize(case_types));
 
   // Resolve an AddressList with two IPv6 addresses and then an IPv4 address.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,2:abcd::3:5:ff,2.2.2.2", std::string());
   host_resolver_->set_synchronous_mode(true);
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv =
-      handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool, BoundNetLog());
   EXPECT_EQ(OK, rv);
   ASSERT_TRUE(handle.socket());
 
   IPEndPoint endpoint;
   handle.socket()->GetPeerAddress(&endpoint);
   EXPECT_EQ("2.2.2.2", endpoint.ToStringWithoutPort());
 }
 
 // If all IPv6 addresses fail before the IPv4 fallback timeout, then the IPv4
 // connections proceed immediately.
@@ skipping 15 matching lines @@
   client_socket_factory_.set_client_socket_types(case_types,
                                                  arraysize(case_types));
 
   // Resolve an AddressList with two IPv6 addresses and then an IPv4 address.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,2:abcd::3:5:ff,2.2.2.2", std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv =
-      handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.socket());
 
   base::TimeTicks start(base::TimeTicks::Now());
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_LT(base::TimeTicks::Now() - start,
             base::TimeDelta::FromMilliseconds(
                 TransportConnectJobHelper::kIPv6FallbackTimerInMs));
   ASSERT_TRUE(handle.socket());
 
@@ skipping 15 matching lines @@
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_TRIGGERABLE_CLIENT_SOCKET);
 
   // Resolve an AddressList with an IPv6 addresses and an IPv4 address.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,2.2.2.2", std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv =
-      handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   ASSERT_FALSE(handle.socket());
 
   base::Closure ipv6_connect_trigger =
       client_socket_factory_.WaitForTriggerableSocketCreation();
   base::Closure ipv4_connect_trigger =
       client_socket_factory_.WaitForTriggerableSocketCreation();
 
   ipv4_connect_trigger.Run();
   ipv6_connect_trigger.Run();
@@ skipping 31 matching lines @@
   // After 100ms: Connect to 1:abcd::3:4:ff times out
   // After 200ms: Connect to 2:abcd::3:4:ff times out
   // After 300ms: Connect to 3:abcd::3:4:ff times out, IPv4 fallback starts
   // After 400ms: Connect to 4:abcd::3:4:ff and 1.1.1.1 time out
   // After 500ms: Connect to 2.2.2.2 times out
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   base::TimeTicks start(base::TimeTicks::Now());
   int rv =
-      handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
 
   EXPECT_GE(base::TimeTicks::Now() - start, delay * 5);
 }
 
 // Global timeout for all connects applies. This test is disabled by default
 // because it takes 4 minutes. Run with --gtest_also_run_disabled_tests if you
 // want to run it.
@@ skipping 16 matching lines @@
                                             "3:abcd::3:4:ff,4:abcd::3:4:ff,"
                                             "5:abcd::3:4:ff,6:abcd::3:4:ff,"
                                             "1.1.1.1,2.2.2.2,3.3.3.3,"
                                             "4.4.4.4,5.5.5.5,6.6.6.6",
                                             std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
 
   int rv =
-      handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
+      handle.Init("a", params_, LOW, ClientSocketPool::IgnoreLimits::DISABLED,
+                  callback.callback(), &pool, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_TIMED_OUT, callback.WaitForResult());
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest, MaxSocketsEnforced) {
   host_resolver_->set_synchronous_mode(true);
   for (int i = 0; i < kMaxSockets; ++i) {
     ASSERT_EQ(OK, StartRequest("a", kDefaultPriority));
     WebSocketTransportClientSocketPool::UnlockEndpoint(request(i)->handle());
@@ skipping 232 matching lines @@
   EXPECT_EQ(OK, request(1)->WaitForResult());
   // Third socket should still be waiting for endpoint.
   ASSERT_FALSE(request(2)->handle()->is_initialized());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET,
             request(2)->handle()->GetLoadState());
 }
 
 }  // namespace
 
 }  // namespace net