Convert ignore_limits from a SocketParam to a socket request argument.

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 89 matching lines @@
 
   EXPECT_FALSE(load_timing_info.socket_reused);
   EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
 }
 
 class TestSocketParams : public base::RefCounted<TestSocketParams> {
  public:
-  explicit TestSocketParams(bool ignore_limits)
-      : ignore_limits_(ignore_limits) {}
-
-  bool ignore_limits() { return ignore_limits_; }
+  explicit TestSocketParams() {}
 
  private:
   friend class base::RefCounted<TestSocketParams>;
   ~TestSocketParams() {}
-
-  const bool ignore_limits_;
 };
 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
 
 class MockClientSocket : public StreamSocket {
  public:
   explicit MockClientSocket(net::NetLog* net_log)
       : connected_(false),
         has_unread_data_(false),
         net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
         was_used_to_convey_data_(false) {}
@@ skipping 141 matching lines @@
   // to complete.
   static const int kPendingConnectDelay = 2;
 
   TestConnectJob(JobType job_type,
                  const std::string& group_name,
                  const TestClientSocketPoolBase::Request& request,
                  base::TimeDelta timeout_duration,
                  ConnectJob::Delegate* delegate,
                  MockClientSocketFactory* client_socket_factory,
                  NetLog* net_log)
-      : ConnectJob(group_name, timeout_duration, request.priority(), delegate,
+      : ConnectJob(group_name,
+                   timeout_duration,
+                   request.priority(),
+                   request.ignore_limits(),
+                   delegate,
                    BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
         job_type_(job_type),
         client_socket_factory_(client_socket_factory),
         load_state_(LOAD_STATE_IDLE),
         store_additional_error_state_(false),
-        weak_factory_(this) {
-  }
+        weak_factory_(this) {}
 
   void Signal() {
     DoConnect(waiting_success_, true /* async */, false /* recoverable */);
   }
 
   void set_load_state(LoadState load_state) { load_state_ = load_state; }
 
   // From ConnectJob:
 
   LoadState GetLoadState() const override { return load_state_; }
@@ skipping 199 matching lines @@
               max_sockets_per_group,
               unused_idle_socket_timeout,
               used_idle_socket_timeout,
               connect_job_factory) {}
 
   ~TestClientSocketPool() override {}
 
   int RequestSocket(const std::string& group_name,
                     const void* params,
                     RequestPriority priority,
+                    IgnoreLimits ignore_limits,
                     ClientSocketHandle* handle,
                     const CompletionCallback& callback,
                     const BoundNetLog& net_log) override {
     const scoped_refptr<TestSocketParams>* casted_socket_params =
         static_cast<const scoped_refptr<TestSocketParams>*>(params);
     return base_.RequestSocket(group_name, *casted_socket_params, priority,
-                               handle, callback, net_log);
+                               ignore_limits, handle, callback, net_log);
   }
 
   void RequestSockets(const std::string& group_name,
                       const void* params,
                       int num_sockets,
                       const BoundNetLog& net_log) override {
     const scoped_refptr<TestSocketParams>* casted_params =
         static_cast<const scoped_refptr<TestSocketParams>*>(params);
 
     base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
@@ skipping 131 matching lines @@
   }
 
  private:
   bool have_result_;
   bool waiting_for_result_;
   int result_;
 };
 
 class ClientSocketPoolBaseTest : public testing::Test {
  protected:
-  ClientSocketPoolBaseTest()
-      : params_(new TestSocketParams(false /* ignore_limits */)) {
+  ClientSocketPoolBaseTest() : params_(new TestSocketParams()) {
     connect_backup_jobs_enabled_ =
         internal::ClientSocketPoolBaseHelper::connect_backup_jobs_enabled();
     internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true);
     cleanup_timer_enabled_ =
         internal::ClientSocketPoolBaseHelper::cleanup_timer_enabled();
   }
 
   ~ClientSocketPoolBaseTest() override {
     internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         connect_backup_jobs_enabled_);
@@ skipping 16 matching lines @@
     DCHECK(!pool_.get());
     connect_job_factory_ = new TestConnectJobFactory(&client_socket_factory_,
                                                      &net_log_);
     pool_.reset(new TestClientSocketPool(max_sockets,
                                          max_sockets_per_group,
                                          unused_idle_socket_timeout,
                                          used_idle_socket_timeout,
                                          connect_job_factory_));
   }
 
-  int StartRequestWithParams(
+  int StartRequestWithIgnoreLimits(
       const std::string& group_name,
       RequestPriority priority,
-      const scoped_refptr<TestSocketParams>& params) {
-    return test_base_.StartRequestUsingPool(
-        pool_.get(), group_name, priority, params);
+      ClientSocketPool::IgnoreLimits ignore_limits) {
+    return test_base_.StartRequestUsingPool(pool_.get(), group_name, priority,
+                                            ignore_limits, params_);
   }
 
   int StartRequest(const std::string& group_name, RequestPriority priority) {
-    return StartRequestWithParams(group_name, priority, params_);
+    return StartRequestWithIgnoreLimits(
+        group_name, priority, ClientSocketPool::IgnoreLimits::DISABLED);
   }
 
   int GetOrderOfRequest(size_t index) const {
     return test_base_.GetOrderOfRequest(index);
   }
 
   bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
     return test_base_.ReleaseOneConnection(keep_alive);
   }
 
@@ skipping 18 matching lines @@
   ClientSocketPoolTest test_base_;
 };
 
 // Even though a timeout is specified, it doesn't time out on a synchronous
 // completion.
 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
   TestConnectJobDelegate delegate;
   ClientSocketHandle ignored;
   TestClientSocketPoolBase::Request request(
       &ignored, CompletionCallback(), DEFAULT_PRIORITY,
-      internal::ClientSocketPoolBaseHelper::NORMAL,
-      false, params_, BoundNetLog());
+      ClientSocketPool::IgnoreLimits::DISABLED,
+      internal::ClientSocketPoolBaseHelper::NORMAL, params_, BoundNetLog());
   scoped_ptr<TestConnectJob> job(
       new TestConnectJob(TestConnectJob::kMockJob,
                          "a",
                          request,
                          base::TimeDelta::FromMicroseconds(1),
                          &delegate,
                          &client_socket_factory_,
                          NULL));
   EXPECT_EQ(OK, job->Connect());
 }
 
 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
   TestConnectJobDelegate delegate;
   ClientSocketHandle ignored;
   TestNetLog log;
 
   TestClientSocketPoolBase::Request request(
       &ignored, CompletionCallback(), DEFAULT_PRIORITY,
-      internal::ClientSocketPoolBaseHelper::NORMAL,
-      false, params_, BoundNetLog());
+      ClientSocketPool::IgnoreLimits::DISABLED,
+      internal::ClientSocketPoolBaseHelper::NORMAL, params_, BoundNetLog());
   // Deleted by TestConnectJobDelegate.
   TestConnectJob* job =
       new TestConnectJob(TestConnectJob::kMockPendingJob,
                          "a",
                          request,
                          base::TimeDelta::FromMicroseconds(1),
                          &delegate,
                          &client_socket_factory_,
                          &log);
   ASSERT_EQ(ERR_IO_PENDING, job->Connect());
@@ skipping 21 matching lines @@
 }
 
 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   BoundTestNetLog log;
   TestLoadTimingInfoNotConnected(handle);
 
-  EXPECT_EQ(OK,
-            handle.Init("a",
-                        params_,
-                        DEFAULT_PRIORITY,
-                        callback.callback(),
-                        pool_.get(),
-                        log.bound()));
+  EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY,
+                            ClientSocketPool::IgnoreLimits::DISABLED,
+                            callback.callback(), pool_.get(), log.bound()));
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfoConnectedNotReused(handle);
 
   handle.Reset();
   TestLoadTimingInfoNotConnected(handle);
 
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
 
@@ skipping 17 matching lines @@
   BoundTestNetLog log;
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   // Set the additional error state members to ensure that they get cleared.
   handle.set_is_ssl_error(true);
   HttpResponseInfo info;
   info.headers = new HttpResponseHeaders(std::string());
   handle.set_ssl_error_response_info(info);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
-            handle.Init("a",
-                        params_,
-                        DEFAULT_PRIORITY,
-                        callback.callback(),
-                        pool_.get(),
-                        log.bound()));
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), log.bound()));
   EXPECT_FALSE(handle.socket());
   EXPECT_FALSE(handle.is_ssl_error());
   EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
   TestLoadTimingInfoNotConnected(handle);
 
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
@@ skipping 214 matching lines @@
   EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
 }
 
 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        DEFAULT_PRIORITY,
-                        callback.callback(),
-                        pool_.get(),
-                        BoundNetLog()));
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
 
   ClientSocketHandle handles[4];
   for (size_t i = 0; i < arraysize(handles); ++i) {
     TestCompletionCallback callback;
     EXPECT_EQ(ERR_IO_PENDING,
-              handles[i].Init("b",
-                              params_,
-                              DEFAULT_PRIORITY,
-                              callback.callback(),
-                              pool_.get(),
-                              BoundNetLog()));
+              handles[i].Init("b", params_, DEFAULT_PRIORITY,
+                              ClientSocketPool::IgnoreLimits::DISABLED,
+                              callback.callback(), pool_.get(), BoundNetLog()));
   }
 
   // One will be stalled, cancel all the handles now.
   // This should hit the OnAvailableSocketSlot() code where we previously had
   // stalled groups, but no longer have any.
   for (size_t i = 0; i < arraysize(handles); ++i)
     handles[i].Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   {
     ClientSocketHandle handles[kDefaultMaxSockets];
     TestCompletionCallback callbacks[kDefaultMaxSockets];
     for (int i = 0; i < kDefaultMaxSockets; ++i) {
-      EXPECT_EQ(OK, handles[i].Init(base::IntToString(i),
-                                    params_,
-                                    DEFAULT_PRIORITY,
-                                    callbacks[i].callback(),
-                                    pool_.get(),
-                                    BoundNetLog()));
+      EXPECT_EQ(OK, handles[i].Init(
+                        base::IntToString(i), params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callbacks[i].callback(), pool_.get(), BoundNetLog()));
     }
 
     // Force a stalled group.
     ClientSocketHandle stalled_handle;
     TestCompletionCallback callback;
-    EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
-                                                  params_,
-                                                  DEFAULT_PRIORITY,
-                                                  callback.callback(),
-                                                  pool_.get(),
-                                                  BoundNetLog()));
+    EXPECT_EQ(
+        ERR_IO_PENDING,
+        stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
+                            ClientSocketPool::IgnoreLimits::DISABLED,
+                            callback.callback(), pool_.get(), BoundNetLog()));
 
     // Cancel the stalled request.
     stalled_handle.Reset();
 
     EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
     EXPECT_EQ(0, pool_->IdleSocketCount());
 
     // Dropping out of scope will close all handles and return them to idle.
   }
 
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
   EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount());
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   {
     ClientSocketHandle handles[kDefaultMaxSockets];
     for (int i = 0; i < kDefaultMaxSockets; ++i) {
       TestCompletionCallback callback;
-      EXPECT_EQ(ERR_IO_PENDING, handles[i].Init(base::IntToString(i),
-                                                params_,
-                                                DEFAULT_PRIORITY,
-                                                callback.callback(),
-                                                pool_.get(),
-                                                BoundNetLog()));
+      EXPECT_EQ(
+          ERR_IO_PENDING,
+          handles[i].Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
+                          ClientSocketPool::IgnoreLimits::DISABLED,
+                          callback.callback(), pool_.get(), BoundNetLog()));
     }
 
     // Force a stalled group.
     connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
     ClientSocketHandle stalled_handle;
     TestCompletionCallback callback;
-    EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
-                                                  params_,
-                                                  DEFAULT_PRIORITY,
-                                                  callback.callback(),
-                                                  pool_.get(),
-                                                  BoundNetLog()));
+    EXPECT_EQ(
+        ERR_IO_PENDING,
+        stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
+                            ClientSocketPool::IgnoreLimits::DISABLED,
+                            callback.callback(), pool_.get(), BoundNetLog()));
 
     // Since it is stalled, it should have no connect jobs.
     EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
     EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo"));
 
     // Cancel the stalled request.
     handles[0].Reset();
 
     // Now we should have a connect job.
     EXPECT_EQ(1, pool_->NumConnectJobsInGroup("foo"));
@@ skipping 18 matching lines @@
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   ClientSocketHandle stalled_handle;
   TestCompletionCallback callback;
   {
     EXPECT_FALSE(pool_->IsStalled());
     ClientSocketHandle handles[kDefaultMaxSockets];
     for (int i = 0; i < kDefaultMaxSockets; ++i) {
       TestCompletionCallback callback;
-      EXPECT_EQ(OK, handles[i].Init(base::StringPrintf(
-          "Take 2: %d", i),
-          params_,
-          DEFAULT_PRIORITY,
-          callback.callback(),
-          pool_.get(),
-          BoundNetLog()));
+      EXPECT_EQ(
+          OK, handles[i].Init(base::StringPrintf("Take 2: %d", i), params_,
+                              DEFAULT_PRIORITY,
+                              ClientSocketPool::IgnoreLimits::DISABLED,
+                              callback.callback(), pool_.get(), BoundNetLog()));
     }
 
     EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
     EXPECT_EQ(0, pool_->IdleSocketCount());
     EXPECT_FALSE(pool_->IsStalled());
 
     // Now we will hit the socket limit.
-    EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
-                                                  params_,
-                                                  DEFAULT_PRIORITY,
-                                                  callback.callback(),
-                                                  pool_.get(),
-                                                  BoundNetLog()));
+    EXPECT_EQ(
+        ERR_IO_PENDING,
+        stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
+                            ClientSocketPool::IgnoreLimits::DISABLED,
+                            callback.callback(), pool_.get(), BoundNetLog()));
     EXPECT_TRUE(pool_->IsStalled());
 
     // Dropping out of scope will close all handles and return them to idle.
   }
 
   // But if we wait for it, the released idle sockets will be closed in
   // preference of the waiting request.
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
   EXPECT_EQ(3, pool_->IdleSocketCount());
 }
 
 // Regression test for http://crbug.com/40952.
 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   pool_->EnableConnectBackupJobs();
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   for (int i = 0; i < kDefaultMaxSockets; ++i) {
     ClientSocketHandle handle;
     TestCompletionCallback callback;
-    EXPECT_EQ(OK, handle.Init(base::IntToString(i),
-                              params_,
-                              DEFAULT_PRIORITY,
-                              callback.callback(),
-                              pool_.get(),
-                              BoundNetLog()));
+    EXPECT_EQ(OK, handle.Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
+                              ClientSocketPool::IgnoreLimits::DISABLED,
+                              callback.callback(), pool_.get(), BoundNetLog()));
   }
 
   // Flush all the DoReleaseSocket tasks.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Stall a group.  Set a pending job so it'll trigger a backup job if we don't
   // reuse a socket.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
 
   // "0" is special here, since it should be the first entry in the sorted map,
   // which is the one which we would close an idle socket for.  We shouldn't
   // close an idle socket though, since we should reuse the idle socket.
-  EXPECT_EQ(OK, handle.Init("0",
-                            params_,
-                            DEFAULT_PRIORITY,
-                            callback.callback(),
-                            pool_.get(),
-                            BoundNetLog()));
+  EXPECT_EQ(OK, handle.Init("0", params_, DEFAULT_PRIORITY,
+                            ClientSocketPool::IgnoreLimits::DISABLED,
+                            callback.callback(), pool_.get(), BoundNetLog()));
 
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
   EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
 }
 
 TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
@@ skipping 48 matching lines @@
 
 // This test will start up a RequestSocket() and then immediately Cancel() it.
 // The pending connect job will be cancelled and should not call back into
 // ClientSocketPoolBase.
 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,

[eroman, 2016/01/27 20:15:13]

Might consider an overload for Init() that doesn't take IgnoreLimits. Then again
if it is only helpful for unittests, meh.

[mmenke, 2016/01/27 20:37:27]

I prefer to avoid overloads, just because it's easy to get confused about which
is being called, particularly when there are 47-gazillion arguments.

[eroman, 2016/01/27 20:40:21]

ok, i figured as much

+                        callback.callback(), pool_.get(), BoundNetLog()));
   handle.Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
 
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        DEFAULT_PRIORITY,
-                        callback2.callback(),
-                        pool_.get(),
-                        BoundNetLog()));
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback2.callback(), pool_.get(), BoundNetLog()));
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(callback.have_result());
 
   handle.Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
@@ skipping 43 matching lines @@
                              int first_request_result) {
   EXPECT_EQ(OK, first_request_result);
 
   test_connect_job_factory->set_job_type(next_job_type);
 
   // Don't allow reuse of the socket.  Disconnect it and then release it.
   if (handle->socket())
     handle->socket()->Disconnect();
   handle->Reset();
 
-  scoped_refptr<TestSocketParams> params(
-      new TestSocketParams(false /* ignore_limits */));
+  scoped_refptr<TestSocketParams> params(new TestSocketParams());
   TestCompletionCallback callback;
-  int rv =
-      handle->Init("a", params, LOWEST, nested_callback, pool, BoundNetLog());
+  int rv = handle->Init("a", params, LOWEST,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        nested_callback, pool, BoundNetLog());
   if (rv != ERR_IO_PENDING) {
     DCHECK_EQ(TestConnectJob::kMockJob, next_job_type);
     nested_callback.Run(rv);
   } else {
     DCHECK_EQ(TestConnectJob::kMockPendingJob, next_job_type);
   }
 }
 
 // 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(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback second_result_callback;
   int rv = handle.Init(
-      "a", params_, DEFAULT_PRIORITY,
+      "a", params_, DEFAULT_PRIORITY, ClientSocketPool::IgnoreLimits::DISABLED,
       base::Bind(&RequestSocketOnComplete, &handle, pool_.get(),
                  connect_job_factory_, TestConnectJob::kMockPendingJob,
                  second_result_callback.callback()),
       pool_.get(), BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, second_result_callback.WaitForResult());
 }
 
 // Tests the case where a second socket is requested in a completion callback,
 // and the second socket connects synchronously.  Reuses the same
 // ClientSocketHandle for the second socket, after disconnecting the first.
 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback second_result_callback;
   int rv = handle.Init(
-      "a", params_, DEFAULT_PRIORITY,
+      "a", params_, DEFAULT_PRIORITY, ClientSocketPool::IgnoreLimits::DISABLED,
       base::Bind(&RequestSocketOnComplete, &handle, pool_.get(),
                  connect_job_factory_, TestConnectJob::kMockPendingJob,
                  second_result_callback.callback()),
       pool_.get(), BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, second_result_callback.WaitForResult());
 }
 
 // Make sure that pending requests get serviced after active requests get
@@ skipping 46 matching lines @@
     EXPECT_EQ(ERR_CONNECTION_FAILED, request(i)->WaitForResult());
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a",
-                       params_,
-                       DEFAULT_PRIORITY,
-                       callback.callback(),
-                       pool_.get(),
-                       BoundNetLog());
+  int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the active request.
   handle.Reset();
 
-  rv = handle.Init("a",
-                   params_,
-                   DEFAULT_PRIORITY,
-                   callback.callback(),
-                   pool_.get(),
-                   BoundNetLog());
+  rv = handle.Init("a", params_, DEFAULT_PRIORITY,
+                   ClientSocketPool::IgnoreLimits::DISABLED,
+                   callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_FALSE(handle.is_reused());
   TestLoadTimingInfoConnectedNotReused(handle);
   EXPECT_EQ(2, client_socket_factory_.allocation_count());
 }
 
 // Regression test for http://crbug.com/17985.
 TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) {
@@ skipping 32 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   BoundTestNetLog log;
-  int rv = handle.Init("a",
-                       params_,
-                       LOWEST,
-                       callback.callback(),
-                       pool_.get(),
-                       log.bound());
+  int rv = handle.Init("a", params_, LOWEST,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
   TestLoadTimingInfoNotConnected(handle);
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfoConnectedNotReused(handle);
 
   handle.Reset();
@@ skipping 21 matching lines @@
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   BoundTestNetLog log;
   // Set the additional error state members to ensure that they get cleared.
   handle.set_is_ssl_error(true);
   HttpResponseInfo info;
   info.headers = new HttpResponseHeaders(std::string());
   handle.set_ssl_error_response_info(info);
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        log.bound()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), log.bound()));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_ssl_error());
   EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
 
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
@@ skipping 26 matching lines @@
   //               ordering is difficult, and some may fire during destructor.
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
 
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        DEFAULT_PRIORITY,
-                        callback.callback(),
-                        pool_.get(),
-                        BoundNetLog()));
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   BoundTestNetLog log2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle2.Init("a",
-                         params_,
-                         DEFAULT_PRIORITY,
-                         callback2.callback(),
-                         pool_.get(),
-                         BoundNetLog()));
+            handle2.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback2.callback(), pool_.get(), BoundNetLog()));
 
   handle.Reset();
 
 
   // At this point, request 2 is just waiting for the connect job to finish.
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   handle2.Reset();
 
   // Now request 2 has actually finished.
@@ skipping 26 matching lines @@
 // by whatever comes first.
 TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   // Start job 1 (async OK)
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   std::vector<TestSocketRequest*> request_order;
   size_t completion_count;  // unused
   TestSocketRequest req1(&request_order, &completion_count);
-  int rv = req1.handle()->Init("a",
-                               params_,
-                               DEFAULT_PRIORITY,
-                               req1.callback(), pool_.get(),
-                               BoundNetLog());
+  int rv = req1.handle()->Init("a", params_, DEFAULT_PRIORITY,
+                               ClientSocketPool::IgnoreLimits::DISABLED,
+                               req1.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req1.WaitForResult());
 
   // Job 1 finished OK.  Start job 2 (also async OK).  Request 3 is pending
   // without a job.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   TestSocketRequest req2(&request_order, &completion_count);
-  rv = req2.handle()->Init("a",
-                           params_,
-                           DEFAULT_PRIORITY,
-                           req2.callback(),
-                           pool_.get(),
-                           BoundNetLog());
+  rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY,
+                           ClientSocketPool::IgnoreLimits::DISABLED,
+                           req2.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   TestSocketRequest req3(&request_order, &completion_count);
-  rv = req3.handle()->Init("a",
-                           params_,
-                           DEFAULT_PRIORITY,
-                           req3.callback(),
-                           pool_.get(),
-                           BoundNetLog());
+  rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY,
+                           ClientSocketPool::IgnoreLimits::DISABLED,
+                           req3.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Both Requests 2 and 3 are pending.  We release socket 1 which should
   // service request 2.  Request 3 should still be waiting.
   req1.handle()->Reset();
   // Run the released socket wakeups.
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_TRUE(req2.handle()->socket());
   EXPECT_EQ(OK, req2.WaitForResult());
   EXPECT_FALSE(req3.handle()->socket());
@@ skipping 13 matching lines @@
 // The requests are not coupled to the jobs.  So, the requests should finish in
 // their priority / insertion order.
 TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   // First two jobs are async.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   std::vector<TestSocketRequest*> request_order;
   size_t completion_count;  // unused
   TestSocketRequest req1(&request_order, &completion_count);
-  int rv = req1.handle()->Init("a",
-                               params_,
-                               DEFAULT_PRIORITY,
-                               req1.callback(),
-                               pool_.get(),
-                               BoundNetLog());
+  int rv = req1.handle()->Init("a", params_, DEFAULT_PRIORITY,
+                               ClientSocketPool::IgnoreLimits::DISABLED,
+                               req1.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestSocketRequest req2(&request_order, &completion_count);
-  rv = req2.handle()->Init("a",
-                           params_,
-                           DEFAULT_PRIORITY,
-                           req2.callback(),
-                           pool_.get(),
-                           BoundNetLog());
+  rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY,
+                           ClientSocketPool::IgnoreLimits::DISABLED,
+                           req2.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The pending job is sync.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   TestSocketRequest req3(&request_order, &completion_count);
-  rv = req3.handle()->Init("a",
-                           params_,
-                           DEFAULT_PRIORITY,
-                           req3.callback(),
-                           pool_.get(),
-                           BoundNetLog());
+  rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY,
+                           ClientSocketPool::IgnoreLimits::DISABLED,
+                           req3.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
   EXPECT_EQ(OK, req2.WaitForResult());
   EXPECT_EQ(ERR_CONNECTION_FAILED, req3.WaitForResult());
 
   ASSERT_EQ(3U, request_order.size());
   EXPECT_EQ(&req1, request_order[0]);
   EXPECT_EQ(&req2, request_order[1]);
   EXPECT_EQ(&req3, request_order[2]);
 }
 
 // Test GetLoadState in the case there's only one socket request.
 TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a",
-                       params_,
-                       DEFAULT_PRIORITY,
-                       callback.callback(),
-                       pool_.get(),
-                       BoundNetLog());
+  int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
 
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
   EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
 
   // No point in completing the connection, since ClientSocketHandles only
   // expect the LoadState to be checked while connecting.
 }
 
 // Test GetLoadState in the case there are two socket requests.
 // Only the first connection in the pool should affect the pool's load status.
 TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) {
   CreatePool(2, 2);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(),
-                       pool_.get(), BoundNetLog());
+  int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  rv = handle2.Init("a", params_, DEFAULT_PRIORITY, callback2.callback(),
-                    pool_.get(), BoundNetLog());
+  rv = handle2.Init("a", params_, DEFAULT_PRIORITY,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback2.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST);
 
   // Check that both handles report the state of the first job.
   EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle.GetLoadState());
   EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle2.GetLoadState());
 
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_CONNECTING);
 
   // Check that both handles change to LOAD_STATE_CONNECTING.
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
 }
 
 // Test that the second connection request does not affect the pool's load
 // status.
 TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequestsChangeSecondRequestState) {
   CreatePool(2, 2);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(),
-                       pool_.get(), BoundNetLog());
+  int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  rv = handle2.Init("a", params_, DEFAULT_PRIORITY, callback2.callback(),
-                    pool_.get(), BoundNetLog());
+  rv = handle2.Init("a", params_, DEFAULT_PRIORITY,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback2.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST);
 
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
 
   // First job connects and the first request gets the socket.  The
   // second handle switches to the state of the remaining ConnectJob.
   client_socket_factory_.SignalJob(0);
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle2.GetLoadState());
 }
 
 // Test GetLoadState in the case the per-group limit is reached.
 TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) {
   CreatePool(2, 1);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a",
-                       params_,
-                       MEDIUM,
-                       callback.callback(),
-                       pool_.get(),
-                       BoundNetLog());
+  int rv = handle.Init("a", params_, MEDIUM,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
 
   // Request another socket from the same pool, buth with a higher priority.
   // The first request should now be stalled at the socket group limit.
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  rv = handle2.Init("a",
-                    params_,
-                    HIGHEST,
-                    callback2.callback(),
-                    pool_.get(),
-                    BoundNetLog());
+  rv = handle2.Init("a", params_, HIGHEST,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback2.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
 
   // The first handle should remain stalled as the other socket goes through
   // the connect process.
 
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
   EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState());
 
   client_socket_factory_.SignalJob(0);
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
 
   // Closing the second socket should cause the stalled handle to finally get a
   // ConnectJob.
   handle2.socket()->Disconnect();
   handle2.Reset();
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
 }
 
 // Test GetLoadState in the case the per-pool limit is reached.
 TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
   CreatePool(2, 2);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a",
-                       params_,
-                       DEFAULT_PRIORITY,
-                       callback.callback(),
-                       pool_.get(),
-                       BoundNetLog());
+  int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Request for socket from another pool.
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  rv = handle2.Init("b",
-                    params_,
-                    DEFAULT_PRIORITY,
-                    callback2.callback(),
-                    pool_.get(),
-                    BoundNetLog());
+  rv = handle2.Init("b", params_, DEFAULT_PRIORITY,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback2.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Request another socket from the first pool.  Request should stall at the
   // socket pool limit.
   ClientSocketHandle handle3;
   TestCompletionCallback callback3;
-  rv = handle3.Init("a",
-                    params_,
-                    DEFAULT_PRIORITY,
-                    callback2.callback(),
-                    pool_.get(),
-                    BoundNetLog());
+  rv = handle3.Init("a", params_, DEFAULT_PRIORITY,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback2.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The third handle should remain stalled as the other sockets in its group
   // goes through the connect process.
 
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
 
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
   EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
@@ skipping 10 matching lines @@
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle3.GetLoadState());
 }
 
 TEST_F(ClientSocketPoolBaseTest, Recoverable) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockRecoverableJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED,
-            handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(),
-                        pool_.get(), BoundNetLog()));
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 }
 
 TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockPendingRecoverableJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        DEFAULT_PRIORITY,
-                        callback.callback(),
-                        pool_.get(),
-                        BoundNetLog()));
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 }
 
 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockAdditionalErrorStateJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_CONNECTION_FAILED,
-            handle.Init("a",
-                        params_,
-                        DEFAULT_PRIORITY,
-                        callback.callback(),
-                        pool_.get(),
-                        BoundNetLog()));
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_TRUE(handle.is_ssl_error());
   EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
 }
 
 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockPendingAdditionalErrorStateJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a",
-                        params_,
-                        DEFAULT_PRIORITY,
-                        callback.callback(),
-                        pool_.get(),
-                        BoundNetLog()));
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_TRUE(handle.is_ssl_error());
   EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
 }
 
 // Make sure we can reuse sockets when the cleanup timer is disabled.
 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerReuse) {
   // Disable cleanup timer.
   internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false);
 
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a",
-                       params_,
-                       LOWEST,
-                       callback.callback(),
-                       pool_.get(),
-                       BoundNetLog());
+  int rv = handle.Init("a", params_, LOWEST,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
   ASSERT_EQ(OK, callback.WaitForResult());
 
   // Use and release the socket.
   EXPECT_EQ(1, handle.socket()->Write(NULL, 1, CompletionCallback()));
   TestLoadTimingInfoConnectedNotReused(handle);
   handle.Reset();
 
   // Should now have one idle socket.
   ASSERT_EQ(1, pool_->IdleSocketCount());
 
   // Request a new socket. This should reuse the old socket and complete
   // synchronously.
   BoundTestNetLog log;
-  rv = handle.Init("a",
-                   params_,
-                   LOWEST,
-                   CompletionCallback(),
-                   pool_.get(),
-                   log.bound());
+  rv = handle.Init("a", params_, LOWEST,
+                   ClientSocketPool::IgnoreLimits::DISABLED,
+                   CompletionCallback(), pool_.get(), log.bound());
   ASSERT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_reused());
   TestLoadTimingInfoConnectedReused(handle);
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
 
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
@@ skipping 16 matching lines @@
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately
       base::TimeDelta());  // Time out used sockets immediately
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   // Startup two mock pending connect jobs, which will sit in the MessageLoop.
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a",
-                       params_,
-                       LOWEST,
-                       callback.callback(),
-                       pool_.get(),
-                       BoundNetLog());
+  int rv = handle.Init("a", params_, LOWEST,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  rv = handle2.Init("a",
-                    params_,
-                    LOWEST,
-                    callback2.callback(),
-                    pool_.get(),
-                    BoundNetLog());
+  rv = handle2.Init("a", params_, LOWEST,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback2.callback(), pool_.get(), BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
 
   // Cancel one of the requests.  Wait for the other, which will get the first
   // job.  Release the socket.  Run the loop again to make sure the second
   // socket is sitting idle and the first one is released (since ReleaseSocket()
   // just posts a DoReleaseSocket() task).
 
   handle.Reset();
   ASSERT_EQ(OK, callback2.WaitForResult());
   // Use the socket.
   EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback()));
   handle2.Reset();
 
   // We post all of our delayed tasks with a 2ms delay. I.e. they don't
   // actually become pending until 2ms after they have been created. In order
   // to flush all tasks, we need to wait so that we know there are no
   // soon-to-be-pending tasks waiting.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
   base::MessageLoop::current()->RunUntilIdle();
 
   // Both sockets should now be idle.
   ASSERT_EQ(2, pool_->IdleSocketCount());
 
   // Request a new socket. This should cleanup the unused and timed out ones.
   // A new socket will be created rather than reusing the idle one.
   BoundTestNetLog log;
   TestCompletionCallback callback3;
-  rv = handle.Init("a",
-                   params_,
-                   LOWEST,
-                   callback3.callback(),
-                   pool_.get(),
-                   log.bound());
+  rv = handle.Init("a", params_, LOWEST,
+                   ClientSocketPool::IgnoreLimits::DISABLED,
+                   callback3.callback(), pool_.get(), log.bound());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   ASSERT_EQ(OK, callback3.WaitForResult());
   EXPECT_FALSE(handle.is_reused());
 
   // Make sure the idle socket is closed.
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
 
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
   EXPECT_FALSE(LogContainsEntryWithType(
       entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
 }
 
 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   // Startup two mock pending connect jobs, which will sit in the MessageLoop.
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a",
-                       params_,
-                       LOWEST,
-                       callback.callback(),
-                       pool_.get(),
-                       BoundNetLog());
+  int rv = handle.Init("a", params_, LOWEST,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  rv = handle2.Init("a",
-                    params_,
-                    LOWEST,
-                    callback2.callback(),
-                    pool_.get(),
-                    BoundNetLog());
+  rv = handle2.Init("a", params_, LOWEST,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback2.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
 
   // Cancel one of the requests.  Wait for the other, which will get the first
   // job.  Release the socket.  Run the loop again to make sure the second
   // socket is sitting idle and the first one is released (since ReleaseSocket()
   // just posts a DoReleaseSocket() task).
 
   handle.Reset();
   EXPECT_EQ(OK, callback2.WaitForResult());
   // Use the socket.
   EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback()));
   handle2.Reset();
 
   // We post all of our delayed tasks with a 2ms delay. I.e. they don't
   // actually become pending until 2ms after they have been created. In order
   // to flush all tasks, we need to wait so that we know there are no
   // soon-to-be-pending tasks waiting.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(2, pool_->IdleSocketCount());
 
   // Invoke the idle socket cleanup check.  Only one socket should be left, the
   // used socket.  Request it to make sure that it's used.
 
   pool_->CleanupTimedOutIdleSockets();
   BoundTestNetLog log;
-  rv = handle.Init("a",
-                   params_,
-                   LOWEST,
-                   callback.callback(),
-                   pool_.get(),
-                   log.bound());
+  rv = handle.Init("a", params_, LOWEST,
+                   ClientSocketPool::IgnoreLimits::DISABLED,
+                   callback.callback(), pool_.get(), log.bound());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_reused());
 
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEntryWithType(
       entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
 }
 
 // Make sure that we process all pending requests even when we're stalling
 // because of multiple releasing disconnected sockets.
 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   // Startup 4 connect jobs.  Two of them will be pending.
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  int rv = handle.Init("a",
-                       params_,
-                       LOWEST,
-                       callback.callback(),
-                       pool_.get(),
-                       BoundNetLog());
+  int rv = handle.Init("a", params_, LOWEST,
+                       ClientSocketPool::IgnoreLimits::DISABLED,
+                       callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  rv = handle2.Init("a",
-                    params_,
-                    LOWEST,
-                    callback2.callback(),
-                    pool_.get(),
-                    BoundNetLog());
+  rv = handle2.Init("a", params_, LOWEST,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback2.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   ClientSocketHandle handle3;
   TestCompletionCallback callback3;
-  rv = handle3.Init("a",
-                    params_,
-                    LOWEST,
-                    callback3.callback(),
-                    pool_.get(),
-                    BoundNetLog());
+  rv = handle3.Init("a", params_, LOWEST,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback3.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ClientSocketHandle handle4;
   TestCompletionCallback callback4;
-  rv = handle4.Init("a",
-                    params_,
-                    LOWEST,
-                    callback4.callback(),
-                    pool_.get(),
-                    BoundNetLog());
+  rv = handle4.Init("a", params_, LOWEST,
+                    ClientSocketPool::IgnoreLimits::DISABLED,
+                    callback4.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Release two disconnected sockets.
 
   handle.socket()->Disconnect();
   handle.Reset();
   handle2.socket()->Disconnect();
   handle2.Reset();
 
   EXPECT_EQ(OK, callback3.WaitForResult());
@@ skipping 14 matching lines @@
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   // Max out the socket limit with 2 per group.
 
   ClientSocketHandle handle_a[4];
   TestCompletionCallback callback_a[4];
   ClientSocketHandle handle_b[4];
   TestCompletionCallback callback_b[4];
 
   for (int i = 0; i < 2; ++i) {
-    EXPECT_EQ(OK, handle_a[i].Init("a",
-                                   params_,
-                                   LOWEST,
-                                   callback_a[i].callback(),
-                                   pool_.get(),
+    EXPECT_EQ(OK, handle_a[i].Init("a", params_, LOWEST,
+                                   ClientSocketPool::IgnoreLimits::DISABLED,
+                                   callback_a[i].callback(), pool_.get(),
                                    BoundNetLog()));
-    EXPECT_EQ(OK, handle_b[i].Init("b",
-                                   params_,
-                                   LOWEST,
-                                   callback_b[i].callback(),
-                                   pool_.get(),
+    EXPECT_EQ(OK, handle_b[i].Init("b", params_, LOWEST,
+                                   ClientSocketPool::IgnoreLimits::DISABLED,
+                                   callback_b[i].callback(), pool_.get(),
                                    BoundNetLog()));
   }
 
   // Make 4 pending requests, 2 per group.
 
   for (int i = 2; i < 4; ++i) {
-    EXPECT_EQ(ERR_IO_PENDING,
-              handle_a[i].Init("a",
-                               params_,
-                               LOWEST,
-                               callback_a[i].callback(),
-                               pool_.get(),
-                               BoundNetLog()));
-    EXPECT_EQ(ERR_IO_PENDING,
-              handle_b[i].Init("b",
-                               params_,
-                               LOWEST,
-                               callback_b[i].callback(),
-                               pool_.get(),
-                               BoundNetLog()));
+    EXPECT_EQ(
+        ERR_IO_PENDING,
+        handle_a[i].Init("a", params_, LOWEST,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback_a[i].callback(), pool_.get(), BoundNetLog()));
+    EXPECT_EQ(
+        ERR_IO_PENDING,
+        handle_b[i].Init("b", params_, LOWEST,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback_b[i].callback(), pool_.get(), BoundNetLog()));
   }
 
   // Release b's socket first.  The order is important, because in
   // DoReleaseSocket(), we'll process b's released socket, and since both b and
   // a are stalled, but 'a' is lower lexicographically, we'll process group 'a'
   // first, which has a releasing socket, so it refuses to start up another
   // ConnectJob.  So, we used to infinite loop on this.
   handle_b[0].socket()->Disconnect();
   handle_b[0].Reset();
   handle_a[0].socket()->Disconnect();
@@ skipping 62 matching lines @@
   ClientSocketHandle* handle() { return &handle_; }
 
   const CompletionCallback& callback() const { return callback_; }
 
  private:
   void OnComplete(int result) {
     SetResult(result);
     if (reset_releasing_handle_)
       handle_.Reset();
 
-    scoped_refptr<TestSocketParams> con_params(
-        new TestSocketParams(false /* ignore_limits */));
+    scoped_refptr<TestSocketParams> con_params(new TestSocketParams());
     EXPECT_EQ(expected_result_,
               handle2_.Init("a", con_params, DEFAULT_PRIORITY,
+                            ClientSocketPool::IgnoreLimits::DISABLED,
                             callback2_.callback(), pool_, BoundNetLog()));
   }
 
   TestClientSocketPool* const pool_;
   int expected_result_;
   bool reset_releasing_handle_;
   ClientSocketHandle handle_;
   ClientSocketHandle handle2_;
   CompletionCallback callback_;
   TestCompletionCallback callback2_;
 };
 
 
 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
   EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
 
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockPendingAdditionalErrorStateJob);
   TestReleasingSocketRequest req(pool_.get(), OK, false);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", params_, DEFAULT_PRIORITY, req.callback(),
-                               pool_.get(), BoundNetLog()));
+            req.handle()->Init("a", params_, DEFAULT_PRIORITY,
+                               ClientSocketPool::IgnoreLimits::DISABLED,
+                               req.callback(), pool_.get(), BoundNetLog()));
   // The next job should complete synchronously
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
   EXPECT_FALSE(req.handle()->is_initialized());
   EXPECT_FALSE(req.handle()->socket());
   EXPECT_TRUE(req.handle()->is_ssl_error());
   EXPECT_FALSE(req.handle()->ssl_error_response_info().headers.get() == NULL);
 }
 
 // http://crbug.com/44724 regression test.
 // We start releasing the pool when we flush on network change.  When that
 // happens, the only active references are in the ClientSocketHandles.  When a
 // ConnectJob completes and calls back into the last ClientSocketHandle, that
 // callback can release the last reference and delete the pool.  After the
 // callback finishes, we go back to the stack frame within the now-deleted pool.
 // Executing any code that refers to members of the now-deleted pool can cause
 // crashes.
 TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
 
   pool_->FlushWithError(ERR_NETWORK_CHANGED);
 
   // We'll call back into this now.
   callback.WaitForResult();
 }
 
 TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
 
   pool_->FlushWithError(ERR_NETWORK_CHANGED);
 
   handle.Reset();
   base::MessageLoop::current()->RunUntilIdle();
 
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
 }
 
 class ConnectWithinCallback : public TestCompletionCallbackBase {
  public:
   ConnectWithinCallback(
       const std::string& group_name,
       const scoped_refptr<TestSocketParams>& params,
       TestClientSocketPool* pool)
       : group_name_(group_name),
         params_(params),
         pool_(pool),
         callback_(base::Bind(&ConnectWithinCallback::OnComplete,
                              base::Unretained(this))) {
   }
 
   ~ConnectWithinCallback() override {}
 
   int WaitForNestedResult() {
     return nested_callback_.WaitForResult();
   }
 
   const CompletionCallback& callback() const { return callback_; }
 
  private:
   void OnComplete(int result) {
     SetResult(result);
     EXPECT_EQ(ERR_IO_PENDING,
-              handle_.Init(group_name_,
-                           params_,
-                           DEFAULT_PRIORITY,
-                           nested_callback_.callback(),
-                           pool_,
-                           BoundNetLog()));
+              handle_.Init(group_name_, params_, DEFAULT_PRIORITY,
+                           ClientSocketPool::IgnoreLimits::DISABLED,
+                           nested_callback_.callback(), pool_, BoundNetLog()));
   }
 
   const std::string group_name_;
   const scoped_refptr<TestSocketParams> params_;
   TestClientSocketPool* const pool_;
   ClientSocketHandle handle_;
   CompletionCallback callback_;
   TestCompletionCallback nested_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectWithinCallback);
 };
 
 TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   // First job will be waiting until it gets aborted.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   ClientSocketHandle handle;
   ConnectWithinCallback callback("a", params_, pool_.get());
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
 
   // Second job will be started during the first callback, and will
   // asynchronously complete with OK.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   pool_->FlushWithError(ERR_NETWORK_CHANGED);
   EXPECT_EQ(ERR_NETWORK_CHANGED, callback.WaitForResult());
   EXPECT_EQ(OK, callback.WaitForNestedResult());
 }
 
 // Cancel a pending socket request while we're at max sockets,
 // and verify that the backup socket firing doesn't cause a crash.
 TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
   // Max 4 sockets globally, max 4 sockets per group.
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   pool_->EnableConnectBackupJobs();
 
   // Create the first socket and set to ERR_IO_PENDING.  This starts the backup
   // timer.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("bar", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
 
   // Start (MaxSockets - 1) connected sockets to reach max sockets.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
   ClientSocketHandle handles[kDefaultMaxSockets];
   for (int i = 1; i < kDefaultMaxSockets; ++i) {
     TestCompletionCallback callback;
-    EXPECT_EQ(OK, handles[i].Init("bar",
-                                  params_,
-                                  DEFAULT_PRIORITY,
-                                  callback.callback(),
-                                  pool_.get(),
-                                  BoundNetLog()));
+    EXPECT_EQ(OK,
+              handles[i].Init("bar", params_, DEFAULT_PRIORITY,
+                              ClientSocketPool::IgnoreLimits::DISABLED,
+                              callback.callback(), pool_.get(), BoundNetLog()));
   }
 
   base::MessageLoop::current()->RunUntilIdle();
 
   // Cancel the pending request.
   handle.Reset();
 
   // Wait for the backup timer to fire (add some slop to ensure it fires)
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
       ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
 
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   pool_->EnableConnectBackupJobs();
 
   // Create the first socket and set to ERR_IO_PENDING.  This starts the backup
   // timer.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("bar", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   ASSERT_TRUE(pool_->HasGroup("bar"));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("bar"));
 
   // Cancel the socket request.  This should cancel the backup timer.  Wait for
   // the backup time to see if it indeed got canceled.
   handle.Reset();
   // Wait for the backup timer to fire (add some slop to ensure it fires)
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
       ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_TRUE(pool_->HasGroup("bar"));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   pool_->EnableConnectBackupJobs();
 
   // Create the first socket and set to ERR_IO_PENDING.  This starts the backup
   // timer.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("bar", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  EXPECT_EQ(ERR_IO_PENDING, handle2.Init("bar",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback2.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle2.Init("bar", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback2.callback(), pool_.get(), BoundNetLog()));
   ASSERT_TRUE(pool_->HasGroup("bar"));
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar"));
 
   // Cancel request 1 and then complete request 2.  With the requests finished,
   // the backup timer should be cancelled.
   handle.Reset();
   EXPECT_EQ(OK, callback2.WaitForResult());
   // Wait for the backup timer to fire (add some slop to ensure it fires)
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
       ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // Test delayed socket binding for the case where we have two connects,
 // and while one is waiting on a connect, the other frees up.
 // The socket waiting on a connect should switch immediately to the freed
 // up socket.
 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle1.Init("a",
-                         params_,
-                         DEFAULT_PRIORITY,
-                         callback.callback(),
-                         pool_.get(),
-                         BoundNetLog()));
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // No idle sockets, no pending jobs.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   // Create a second socket to the same host, but this one will wait.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle2.Init("a",
-                         params_,
-                         DEFAULT_PRIORITY,
-                         callback.callback(),
-                         pool_.get(),
-                         BoundNetLog()));
+            handle2.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback.callback(), pool_.get(), BoundNetLog()));
   // No idle sockets, and one connecting job.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   // Return the first handle to the pool.  This will initiate the delayed
   // binding.
   handle1.Reset();
 
   base::MessageLoop::current()->RunUntilIdle();
 
@@ skipping 16 matching lines @@
 
 // Test delayed socket binding when a group is at capacity and one
 // of the group's sockets frees up.
 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle1.Init("a",
-                         params_,
-                         DEFAULT_PRIORITY,
-                         callback.callback(),
-                         pool_.get(),
-                         BoundNetLog()));
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // No idle sockets, no pending jobs.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   // Create a second socket to the same host, but this one will wait.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle2.Init("a",
-                         params_,
-                         DEFAULT_PRIORITY,
-                         callback.callback(),
-                         pool_.get(),
-                         BoundNetLog()));
+            handle2.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback.callback(), pool_.get(), BoundNetLog()));
   // No idle sockets, and one connecting job.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   // Return the first handle to the pool.  This will initiate the delayed
   // binding.
   handle1.Reset();
 
   base::MessageLoop::current()->RunUntilIdle();
 
@@ skipping 18 matching lines @@
 // connecting, when the first socket finishes and goes idle.
 // Although the second connection is pending, the second request
 // should complete, by taking the first socket's idle socket.
 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle1.Init("a",
-                         params_,
-                         DEFAULT_PRIORITY,
-                         callback.callback(),
-                         pool_.get(),
-                         BoundNetLog()));
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // No idle sockets, no pending jobs.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   // Create a second socket to the same host, but this one will wait.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle2.Init("a",
-                         params_,
-                         DEFAULT_PRIORITY,
-                         callback.callback(),
-                         pool_.get(),
-                         BoundNetLog()));
+            handle2.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback.callback(), pool_.get(), BoundNetLog()));
   // No idle sockets, and one connecting job.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   // Return the first handle to the pool.  This will initiate the delayed
   // binding.
   handle1.Reset();
 
   base::MessageLoop::current()->RunUntilIdle();
 
@@ skipping 21 matching lines @@
   const int kOneSocketPerGroup = 1;
   CreatePool(kUnlimitedSockets, kOneSocketPerGroup);
 
   // Make the first request asynchronous fail.
   // This will free up a socket slot later.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle1.Init("a",
-                         params_,
-                         DEFAULT_PRIORITY,
-                         callback1.callback(),
-                         pool_.get(),
-                         BoundNetLog()));
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   // Make the second request synchronously fail.  This should make the Group
   // empty.
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
   // It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail
   // when created.
   EXPECT_EQ(ERR_IO_PENDING,
-            handle2.Init("a",
-                         params_,
-                         DEFAULT_PRIORITY,
-                         callback2.callback(),
-                         pool_.get(),
-                         BoundNetLog()));
+            handle2.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback2.callback(), pool_.get(), BoundNetLog()));
 
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback1.WaitForResult());
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback2.WaitForResult());
   EXPECT_FALSE(pool_->HasGroup("a"));
 }
 
 TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback2.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle2.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback2.callback(), pool_.get(), BoundNetLog()));
   ClientSocketHandle handle3;
   TestCompletionCallback callback3;
-  EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback3.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle3.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback3.callback(), pool_.get(), BoundNetLog()));
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(OK, callback3.WaitForResult());
 
   // Use the socket.
   EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, CompletionCallback()));
   EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, CompletionCallback()));
 
   handle1.Reset();
   handle2.Reset();
   handle3.Reset();
 
-  EXPECT_EQ(OK, handle1.Init("a",
-                             params_,
-                             DEFAULT_PRIORITY,
-                             callback1.callback(),
-                             pool_.get(),
-                             BoundNetLog()));
-  EXPECT_EQ(OK, handle2.Init("a",
-                             params_,
-                             DEFAULT_PRIORITY,
-                             callback2.callback(),
-                             pool_.get(),
-                             BoundNetLog()));
-  EXPECT_EQ(OK, handle3.Init("a",
-                             params_,
-                             DEFAULT_PRIORITY,
-                             callback3.callback(),
-                             pool_.get(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, handle1.Init("a", params_, DEFAULT_PRIORITY,
+                             ClientSocketPool::IgnoreLimits::DISABLED,
+                             callback1.callback(), pool_.get(), BoundNetLog()));
+  EXPECT_EQ(OK, handle2.Init("a", params_, DEFAULT_PRIORITY,
+                             ClientSocketPool::IgnoreLimits::DISABLED,
+                             callback2.callback(), pool_.get(), BoundNetLog()));
+  EXPECT_EQ(OK, handle3.Init("a", params_, DEFAULT_PRIORITY,
+                             ClientSocketPool::IgnoreLimits::DISABLED,
+                             callback3.callback(), pool_.get(), BoundNetLog()));
 
   EXPECT_TRUE(handle1.socket()->WasEverUsed());
   EXPECT_TRUE(handle2.socket()->WasEverUsed());
   EXPECT_FALSE(handle3.socket()->WasEverUsed());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback2.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle2.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback2.callback(), pool_.get(), BoundNetLog()));
 
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ(OK, callback2.WaitForResult());
   handle1.Reset();
   handle2.Reset();
 
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
 
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback2.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle2.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback2.callback(), pool_.get(), BoundNetLog()));
 
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ(OK, callback2.WaitForResult());
   handle1.Reset();
   handle2.Reset();
 
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
 }
 
 TEST_F(ClientSocketPoolBaseTest,
        RequestSocketsWhenAlreadyHaveMultipleConnectJob) {
   CreatePool(4, 4);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback2.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle2.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback2.callback(), pool_.get(), BoundNetLog()));
 
   ClientSocketHandle handle3;
   TestCompletionCallback callback3;
-  EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback3.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle3.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback3.callback(), pool_.get(), BoundNetLog()));
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
 
   EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ skipping 56 matching lines @@
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b"));
   EXPECT_FALSE(pool_->IsStalled());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
   CreatePool(4, 4);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
   ASSERT_EQ(OK, callback1.WaitForResult());
   handle1.Reset();
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
 
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
   CreatePool(4, 4);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
   ASSERT_EQ(OK, callback1.WaitForResult());
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
 
@@ skipping 51 matching lines @@
   EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
   ASSERT_EQ(OK, callback1.WaitForResult());
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  int rv = handle2.Init("a",
-                        params_,
-                        DEFAULT_PRIORITY,
-                        callback2.callback(),
-                        pool_.get(),
-                        BoundNetLog());
+  int rv = handle2.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback2.callback(), pool_.get(), BoundNetLog());
   if (rv != OK) {
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_EQ(OK, callback2.WaitForResult());
   }
 
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
@@ skipping 43 matching lines @@
 
   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
 
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ASSERT_EQ(OK, callback1.WaitForResult());
 
   // Make sure if a preconnected socket is not fully connected when a request
   // starts, it has a connect start time.
   TestLoadTimingInfoConnectedNotReused(handle1);
   handle1.Reset();
 
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 }
 
 // Checks that fully connected preconnect jobs have no connect times, and are
 // marked as reused.
 TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(OK, handle.Init("a",
-                            params_,
-                            DEFAULT_PRIORITY,
-                            callback.callback(),
-                            pool_.get(),
-                            BoundNetLog()));
+  EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY,
+                            ClientSocketPool::IgnoreLimits::DISABLED,
+                            callback.callback(), pool_.get(), BoundNetLog()));
 
   // Make sure the idle socket was used.
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   TestLoadTimingInfoConnectedReused(handle);
   handle.Reset();
   TestLoadTimingInfoNotConnected(handle);
 }
 
 // http://crbug.com/64940 regression test.
 TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
   const int kMaxTotalSockets = 3;
   const int kMaxSocketsPerGroup = 2;
   CreatePool(kMaxTotalSockets, kMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   // Note that group name ordering matters here.  "a" comes before "b", so
   // CloseOneIdleSocket() will try to close "a"'s idle socket.
 
   // Set up one idle socket in "a".
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("a", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
 
   ASSERT_EQ(OK, callback1.WaitForResult());
   handle1.Reset();
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 
   // Set up two active sockets in "b".
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
-  EXPECT_EQ(ERR_IO_PENDING, handle1.Init("b",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback1.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
-  EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback2.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle1.Init("b", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback1.callback(), pool_.get(), BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle2.Init("b", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback2.callback(), pool_.get(), BoundNetLog()));
 
   ASSERT_EQ(OK, callback1.WaitForResult());
   ASSERT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
   EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b"));
 
   // Now we have 1 idle socket in "a" and 2 active sockets in "b".  This means
   // we've maxed out on sockets, since we set |kMaxTotalSockets| to 3.
   // Requesting 2 preconnected sockets for "a" should fail to allocate any more
@@ skipping 61 matching lines @@
   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   base::MessageLoop::current()->RunUntilIdle();
 
   // Make the backup job be a pending job, so it completes normally.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   // Timer has started, but the backup connect job shouldn't be created yet.
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
   ASSERT_EQ(OK, callback.WaitForResult());
 
   // The hung connect job should still be there, but everything else should be
   // complete.
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ skipping 13 matching lines @@
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 
   // Fail future jobs to be sure that handle receives the preconnected socket
   // rather than closing it and making a new one.
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(OK, handle.Init("a",
-                             params_,
-                             DEFAULT_PRIORITY,
-                             callback.callback(),
-                             pool_.get(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY,
+                            ClientSocketPool::IgnoreLimits::DISABLED,
+                            callback.callback(), pool_.get(), BoundNetLog()));
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   // Drain the pending read.
   EXPECT_EQ(1, handle.socket()->Read(NULL, 1, CompletionCallback()));
 
   TestLoadTimingInfoConnectedReused(handle);
@@ skipping 11 matching lines @@
         group_name_(group_name),
         can_release_connection_(true) {
     pool_->AddHigherLayeredPool(this);
   }
 
   ~MockLayeredPool() {
     pool_->RemoveHigherLayeredPool(this);
   }
 
   int RequestSocket(TestClientSocketPool* pool) {
-    scoped_refptr<TestSocketParams> params(
-        new TestSocketParams(false /* ignore_limits */));
+    scoped_refptr<TestSocketParams> params(new TestSocketParams());
     return handle_.Init(group_name_, params, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
                         callback_.callback(), pool, BoundNetLog());
   }
 
   int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
-    scoped_refptr<TestSocketParams> params(
-        new TestSocketParams(true /* ignore_limits */));
+    scoped_refptr<TestSocketParams> params(new TestSocketParams());
     return handle_.Init(group_name_, params, MAXIMUM_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::ENABLED,
                         callback_.callback(), pool, BoundNetLog());
   }
 
   bool ReleaseOneConnection() {
     if (!handle_.is_initialized() || !can_release_connection_) {
       return false;
     }
     handle_.socket()->Disconnect();
     handle_.Reset();
     return true;
@@ skipping 42 matching lines @@
   CreatePool(1, 1);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   MockLayeredPool mock_layered_pool(pool_.get(), "foo");
   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
       .WillOnce(Invoke(&mock_layered_pool,
                        &MockLayeredPool::ReleaseOneConnection));
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Same as above, but the idle socket is in the same group as the stalled
 // socket, and closes the only other request in its group when closing requests
 // in higher layered pools.  This generally shouldn't happen, but it may be
 // possible if a higher level pool issues a request and the request is
 // subsequently cancelled.  Even if it's not possible, best not to crash.
 TEST_F(ClientSocketPoolBaseTest,
        CloseIdleSocketsHeldByLayeredPoolWhenNeededSameGroup) {
   CreatePool(2, 2);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   // Need a socket in another group for the pool to be stalled (If a group
   // has the maximum number of connections already, it's not stalled).
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(OK, handle1.Init("group1",
-                             params_,
-                             DEFAULT_PRIORITY,
-                             callback1.callback(),
-                             pool_.get(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
+                             ClientSocketPool::IgnoreLimits::DISABLED,
+                             callback1.callback(), pool_.get(), BoundNetLog()));
 
   MockLayeredPool mock_layered_pool(pool_.get(), "group2");
   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
       .WillOnce(Invoke(&mock_layered_pool,
                        &MockLayeredPool::ReleaseOneConnection));
   ClientSocketHandle handle;
   TestCompletionCallback callback2;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("group2",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback2.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("group2", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback2.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback2.WaitForResult());
 }
 
 // Tests the case when an idle socket can be closed when a new request is
 // issued, and the new request belongs to a group that was previously stalled.
 TEST_F(ClientSocketPoolBaseTest,
        CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded) {
   CreatePool(2, 2);
   std::list<TestConnectJob::JobType> job_types;
   job_types.push_back(TestConnectJob::kMockJob);
   job_types.push_back(TestConnectJob::kMockJob);
   job_types.push_back(TestConnectJob::kMockJob);
   job_types.push_back(TestConnectJob::kMockJob);
   connect_job_factory_->set_job_types(&job_types);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(OK, handle1.Init("group1",
-                             params_,
-                             DEFAULT_PRIORITY,
-                             callback1.callback(),
-                             pool_.get(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
+                             ClientSocketPool::IgnoreLimits::DISABLED,
+                             callback1.callback(), pool_.get(), BoundNetLog()));
 
   MockLayeredPool mock_layered_pool(pool_.get(), "group2");
   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
       .WillRepeatedly(Invoke(&mock_layered_pool,
                              &MockLayeredPool::ReleaseOneConnection));
   mock_layered_pool.set_can_release_connection(false);
 
   // The third request is made when the socket pool is in a stalled state.
   ClientSocketHandle handle3;
   TestCompletionCallback callback3;
-  EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback3.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle3.Init("group3", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback3.callback(), pool_.get(), BoundNetLog()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback3.have_result());
 
   // The fourth request is made when the pool is no longer stalled.  The third
   // request should be serviced first, since it was issued first and has the
   // same priority.
   mock_layered_pool.set_can_release_connection(true);
   ClientSocketHandle handle4;
   TestCompletionCallback callback4;
-  EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
-                                         params_,
-                                         DEFAULT_PRIORITY,
-                                         callback4.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle4.Init("group3", params_, DEFAULT_PRIORITY,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback4.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_FALSE(callback4.have_result());
 
   // Closing a handle should free up another socket slot.
   handle1.Reset();
   EXPECT_EQ(OK, callback4.WaitForResult());
 }
 
 // Tests the case when an idle socket can be closed when a new request is
 // issued, and the new request belongs to a group that was previously stalled.
 //
 // The two differences from the above test are that the stalled requests are not
 // in the same group as the layered pool's request, and the the fourth request
 // has a higher priority than the third one, so gets a socket first.
 TEST_F(ClientSocketPoolBaseTest,
        CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded2) {
   CreatePool(2, 2);
   std::list<TestConnectJob::JobType> job_types;
   job_types.push_back(TestConnectJob::kMockJob);
   job_types.push_back(TestConnectJob::kMockJob);
   job_types.push_back(TestConnectJob::kMockJob);
   job_types.push_back(TestConnectJob::kMockJob);
   connect_job_factory_->set_job_types(&job_types);
 
   ClientSocketHandle handle1;
   TestCompletionCallback callback1;
-  EXPECT_EQ(OK, handle1.Init("group1",
-                             params_,
-                             DEFAULT_PRIORITY,
-                             callback1.callback(),
-                             pool_.get(),
-                             BoundNetLog()));
+  EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
+                             ClientSocketPool::IgnoreLimits::DISABLED,
+                             callback1.callback(), pool_.get(), BoundNetLog()));
 
   MockLayeredPool mock_layered_pool(pool_.get(), "group2");
   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
       .WillRepeatedly(Invoke(&mock_layered_pool,
                              &MockLayeredPool::ReleaseOneConnection));
   mock_layered_pool.set_can_release_connection(false);
 
   // The third request is made when the socket pool is in a stalled state.
   ClientSocketHandle handle3;
   TestCompletionCallback callback3;
-  EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3",
-                                         params_,
-                                         MEDIUM,
-                                         callback3.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle3.Init("group3", params_, MEDIUM,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback3.callback(), pool_.get(), BoundNetLog()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback3.have_result());
 
   // The fourth request is made when the pool is no longer stalled.  This
   // request has a higher priority than the third request, so is serviced first.
   mock_layered_pool.set_can_release_connection(true);
   ClientSocketHandle handle4;
   TestCompletionCallback callback4;
-  EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
-                                         params_,
-                                         HIGHEST,
-                                         callback4.callback(),
-                                         pool_.get(),
-                                         BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle4.Init("group3", params_, HIGHEST,
+                         ClientSocketPool::IgnoreLimits::DISABLED,
+                         callback4.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback4.WaitForResult());
   EXPECT_FALSE(callback3.have_result());
 
   // Closing a handle should free up another socket slot.
   handle1.Reset();
   EXPECT_EQ(OK, callback3.WaitForResult());
 }
 
 TEST_F(ClientSocketPoolBaseTest,
        CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) {
   CreatePool(1, 1);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   MockLayeredPool mock_layered_pool1(pool_.get(), "foo");
   EXPECT_EQ(OK, mock_layered_pool1.RequestSocket(pool_.get()));
   EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection())
       .WillRepeatedly(Invoke(&mock_layered_pool1,
                              &MockLayeredPool::ReleaseOneConnection));
   MockLayeredPool mock_layered_pool2(pool_.get(), "bar");
   EXPECT_EQ(OK, mock_layered_pool2.RequestSocketWithoutLimits(pool_.get()));
   EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection())
       .WillRepeatedly(Invoke(&mock_layered_pool2,
                              &MockLayeredPool::ReleaseOneConnection));
   ClientSocketHandle handle;
   TestCompletionCallback callback;
-  EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
-                                        params_,
-                                        DEFAULT_PRIORITY,
-                                        callback.callback(),
-                                        pool_.get(),
-                                        BoundNetLog()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle.Init("a", params_, DEFAULT_PRIORITY,
+                        ClientSocketPool::IgnoreLimits::DISABLED,
+                        callback.callback(), pool_.get(), BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Test that when a socket pool and group are at their limits, a request
 // with |ignore_limits| triggers creation of a new socket, and gets the socket
 // instead of a request with the same priority that was issued earlier, but
 // that does not have |ignore_limits| set.
 TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) {
-  scoped_refptr<TestSocketParams> params_ignore_limits(
-      new TestSocketParams(true /* ignore_limits */));
   CreatePool(1, 1);
 
   // Issue a request to reach the socket pool limit.
-  EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
+  EXPECT_EQ(
+      OK, StartRequestWithIgnoreLimits(
+              "a", MAXIMUM_PRIORITY, ClientSocketPool::IgnoreLimits::DISABLED));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
-                                                   params_));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits(
+                                "a", MAXIMUM_PRIORITY,
+                                ClientSocketPool::IgnoreLimits::DISABLED));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
-                                                   params_ignore_limits));
+  // Issue a request that ignores the limits, so a new ConnectJob is
+  // created.
+  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits(
+                                "a", MAXIMUM_PRIORITY,
+                                ClientSocketPool::IgnoreLimits::ENABLED));
   ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   EXPECT_EQ(OK, request(2)->WaitForResult());
   EXPECT_FALSE(request(1)->have_result());
 }
 
 // Test that when a socket pool and group are at their limits, a ConnectJob
 // issued for a request with |ignore_limits| set is not cancelled when a request
 // without |ignore_limits| issued to the same group is cancelled.
 TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsCancelOtherJob) {
-  scoped_refptr<TestSocketParams> params_ignore_limits(
-      new TestSocketParams(true /* ignore_limits */));
   CreatePool(1, 1);
 
   // Issue a request to reach the socket pool limit.
-  EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
+  EXPECT_EQ(
+      OK, StartRequestWithIgnoreLimits(
+              "a", MAXIMUM_PRIORITY, ClientSocketPool::IgnoreLimits::DISABLED));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
-                                                   params_));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits(
+                                "a", MAXIMUM_PRIORITY,
+                                ClientSocketPool::IgnoreLimits::DISABLED));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
-                                                   params_ignore_limits));
+  // Issue a request that ignores the limits, so a new ConnectJob is
+  // created.
+  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits(
+                                "a", MAXIMUM_PRIORITY,
+                                ClientSocketPool::IgnoreLimits::ENABLED));
   ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   // Cancel the pending request without ignore_limits set. The ConnectJob
   // should not be cancelled.
   request(1)->handle()->Reset();
   ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   EXPECT_EQ(OK, request(2)->WaitForResult());
   EXPECT_FALSE(request(1)->have_result());
 }
 
 }  // namespace
 
 }  // namespace net