Convert ignore_limits from a SocketParam to a socket request argument.

net/socket/socks_client_socket_pool_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/socks_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/time/time.h"
 #include "net/base/load_timing_info.h"
@@ skipping 25 matching lines @@
   EXPECT_FALSE(load_timing_info.socket_reused);
 
   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
                               CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
 }
 
 
 scoped_refptr<TransportSocketParams> CreateProxyHostParams() {
   return new TransportSocketParams(
-      HostPortPair("proxy", 80), false, false, OnHostResolutionCallback(),
+      HostPortPair("proxy", 80), false, OnHostResolutionCallback(),
       TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT);
 }
 
 scoped_refptr<SOCKSSocketParams> CreateSOCKSv4Params() {
   return new SOCKSSocketParams(
       CreateProxyHostParams(), false /* socks_v5 */,
       HostPortPair("host", 80));
 }
 
 scoped_refptr<SOCKSSocketParams> CreateSOCKSv5Params() {
@@ skipping 38 matching lines @@
         pool_(kMaxSockets,
               kMaxSocketsPerGroup,
               &host_resolver_,
               &transport_socket_pool_,
               NULL) {}
 
   ~SOCKSClientSocketPoolTest() override {}
 
   int StartRequestV5(const std::string& group_name, RequestPriority priority) {
     return test_base_.StartRequestUsingPool(
-        &pool_, group_name, priority, CreateSOCKSv5Params());
+        &pool_, group_name, priority, ClientSocketPool::IgnoreLimits::DISABLED,
+        CreateSOCKSv5Params());
   }
 
   int GetOrderOfRequest(size_t index) const {
     return test_base_.GetOrderOfRequest(index);
   }
 
   std::vector<scoped_ptr<TestSocketRequest>>* requests() {
     return test_base_.requests();
   }
 
   MockClientSocketFactory transport_client_socket_factory_;
   MockTransportClientSocketPool transport_socket_pool_;
 
   MockHostResolver host_resolver_;
   SOCKSClientSocketPool pool_;
   ClientSocketPoolTest test_base_;
 };
 
 TEST_F(SOCKSClientSocketPoolTest, Simple) {
   SOCKS5MockData data(SYNCHRONOUS);
   data.data_provider()->set_connect_data(MockConnect(SYNCHRONOUS, OK));
   transport_client_socket_factory_.AddSocketDataProvider(data.data_provider());
 
   ClientSocketHandle handle;
-  int rv = handle.Init("a", CreateSOCKSv5Params(), LOW, CompletionCallback(),
-                       &pool_, BoundNetLog());
+  int rv = handle.Init("a", CreateSOCKSv5Params(), LOW,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       CompletionCallback(), &pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfo(handle);
 }
 
 // Make sure that SOCKSConnectJob passes on its priority to its
 // socket request on Init.
 TEST_F(SOCKSClientSocketPoolTest, SetSocketRequestPriorityOnInit) {
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
     RequestPriority priority = static_cast<RequestPriority>(i);
     SOCKS5MockData data(SYNCHRONOUS);
     data.data_provider()->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     transport_client_socket_factory_.AddSocketDataProvider(
         data.data_provider());
 
     ClientSocketHandle handle;
-    EXPECT_EQ(OK,
-              handle.Init("a", CreateSOCKSv5Params(), priority,
-                          CompletionCallback(), &pool_, BoundNetLog()));
+    EXPECT_EQ(OK, handle.Init("a", CreateSOCKSv5Params(), priority,
+                              ClientSocketPool::IgnoreLimits::DISABLED,
+                              CompletionCallback(), &pool_, BoundNetLog()));
     EXPECT_EQ(priority, transport_socket_pool_.last_request_priority());
     handle.socket()->Disconnect();
   }
 }
 
 // Make sure that SOCKSConnectJob passes on its priority to its
 // HostResolver request (for non-SOCKS5) on Init.
 TEST_F(SOCKSClientSocketPoolTest, SetResolvePriorityOnInit) {
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
     RequestPriority priority = static_cast<RequestPriority>(i);
     SOCKS5MockData data(SYNCHRONOUS);
     data.data_provider()->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     transport_client_socket_factory_.AddSocketDataProvider(
         data.data_provider());
 
     ClientSocketHandle handle;
     EXPECT_EQ(ERR_IO_PENDING,
               handle.Init("a", CreateSOCKSv4Params(), priority,
+                          ClientSocketPool::IgnoreLimits::DISABLED,
                           CompletionCallback(), &pool_, BoundNetLog()));
     EXPECT_EQ(priority, transport_socket_pool_.last_request_priority());
     EXPECT_EQ(priority, host_resolver_.last_request_priority());
     EXPECT_TRUE(handle.socket() == NULL);
   }
 }
 
 TEST_F(SOCKSClientSocketPoolTest, Async) {
   SOCKS5MockData data(ASYNC);
   transport_client_socket_factory_.AddSocketDataProvider(data.data_provider());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("a", CreateSOCKSv5Params(), LOW, callback.callback(),
-                       &pool_, BoundNetLog());
+  int rv = handle.Init("a", CreateSOCKSv5Params(), 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());
   TestLoadTimingInfo(handle);
 }
 
 TEST_F(SOCKSClientSocketPoolTest, TransportConnectError) {
   StaticSocketDataProvider socket_data;
   socket_data.set_connect_data(MockConnect(SYNCHRONOUS,
                                            ERR_CONNECTION_REFUSED));
   transport_client_socket_factory_.AddSocketDataProvider(&socket_data);
 
   ClientSocketHandle handle;
-  int rv = handle.Init("a", CreateSOCKSv5Params(), LOW, CompletionCallback(),
-                       &pool_, BoundNetLog());
+  int rv = handle.Init("a", CreateSOCKSv5Params(), LOW,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       CompletionCallback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 }
 
 TEST_F(SOCKSClientSocketPoolTest, AsyncTransportConnectError) {
   StaticSocketDataProvider socket_data;
   socket_data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
   transport_client_socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
-  int rv = handle.Init("a", CreateSOCKSv5Params(), LOW, callback.callback(),
-                       &pool_, BoundNetLog());
+  int rv = handle.Init("a", CreateSOCKSv5Params(), 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(ERR_PROXY_CONNECTION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 }
 
 TEST_F(SOCKSClientSocketPoolTest, SOCKSConnectError) {
   MockRead failed_read[] = {
     MockRead(SYNCHRONOUS, 0),
   };
   StaticSocketDataProvider socket_data(
       failed_read, arraysize(failed_read), NULL, 0);
   socket_data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   transport_client_socket_factory_.AddSocketDataProvider(&socket_data);
 
   ClientSocketHandle handle;
   EXPECT_EQ(0, transport_socket_pool_.release_count());
-  int rv = handle.Init("a", CreateSOCKSv5Params(), LOW, CompletionCallback(),
-                       &pool_, BoundNetLog());
+  int rv = handle.Init("a", CreateSOCKSv5Params(), LOW,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       CompletionCallback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_SOCKS_CONNECTION_FAILED, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_EQ(1, transport_socket_pool_.release_count());
 }
 
 TEST_F(SOCKSClientSocketPoolTest, AsyncSOCKSConnectError) {
   MockRead failed_read[] = {
     MockRead(ASYNC, 0),
   };
   StaticSocketDataProvider socket_data(
         failed_read, arraysize(failed_read), NULL, 0);
   socket_data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   transport_client_socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   EXPECT_EQ(0, transport_socket_pool_.release_count());
-  int rv = handle.Init("a", CreateSOCKSv5Params(), LOW, callback.callback(),
-                       &pool_, BoundNetLog());
+  int rv = handle.Init("a", CreateSOCKSv5Params(), 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(ERR_SOCKS_CONNECTION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_EQ(1, transport_socket_pool_.release_count());
 }
 
@@ skipping 64 matching lines @@
 
   (*requests())[0]->handle()->Reset();
   (*requests())[1]->handle()->Reset();
 }
 
 // It would be nice to also test the timeouts in SOCKSClientSocketPool.
 
 }  // namespace
 
 }  // namespace net