[Net] Assert that URLRequests with LOAD_IGNORE_LIMITS have MAXIMUM_PRIORITY

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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 27 matching lines @@
 
 using ::testing::Invoke;
 using ::testing::Return;
 
 namespace net {
 
 namespace {
 
 const int kDefaultMaxSockets = 4;
 const int kDefaultMaxSocketsPerGroup = 2;
-const net::RequestPriority kDefaultPriority = MEDIUM;
 
 // Make sure |handle| sets load times correctly when it has been assigned a
 // reused socket.
 void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) {
   LoadTimingInfo load_timing_info;
   // Only pass true in as |is_reused|, as in general, HttpStream types should
   // have stricter concepts of reuse than socket pools.
   EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info));
 
   EXPECT_EQ(true, load_timing_info.socket_reused);
@@ skipping 34 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:
-  TestSocketParams() : ignore_limits_(false) {}
+  explicit TestSocketParams(bool ignore_limits)
+      : ignore_limits_(ignore_limits) {}
 
-  void set_ignore_limits(bool ignore_limits) {
-    ignore_limits_ = ignore_limits;
-  }
   bool ignore_limits() { return ignore_limits_; }
 
  private:
   friend class base::RefCounted<TestSocketParams>;
   ~TestSocketParams() {}
 
-  bool ignore_limits_;
+  const bool ignore_limits_;
 };
 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
 
 class MockClientSocket : public StreamSocket {
  public:
   explicit MockClientSocket(net::NetLog* net_log)
       : connected_(false),
         net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)),
         was_used_to_convey_data_(false) {
   }
@@ skipping 533 matching lines @@
 
  private:
   bool have_result_;
   bool waiting_for_result_;
   int result_;
 };
 
 class ClientSocketPoolBaseTest : public testing::Test {
  protected:
   ClientSocketPoolBaseTest()
-      : params_(new TestSocketParams()),
+      : params_(new TestSocketParams(false /* ignore_limits */)),
         histograms_("ClientSocketPoolTest") {
     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();
   }
 
   virtual ~ClientSocketPoolBaseTest() {
     internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
@@ skipping 64 matching lines @@
   scoped_ptr<TestClientSocketPool> pool_;
   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(), kDefaultPriority,
+      &ignored, CompletionCallback(), DEFAULT_PRIORITY,
       internal::ClientSocketPoolBaseHelper::NORMAL,
       false, 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;
   CapturingNetLog log;
 
   TestClientSocketPoolBase::Request request(
-      &ignored, CompletionCallback(), kDefaultPriority,
+      &ignored, CompletionCallback(), DEFAULT_PRIORITY,
       internal::ClientSocketPoolBaseHelper::NORMAL,
       false, params_, BoundNetLog());
   // Deleted by TestConnectJobDelegate.
   TestConnectJob* job =
       new TestConnectJob(TestConnectJob::kMockPendingJob,
                          "a",
                          request,
                          base::TimeDelta::FromMicroseconds(1),
                          &delegate,
                          &client_socket_factory_,
@@ skipping 26 matching lines @@
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   CapturingBoundNetLog log;
   TestLoadTimingInfoNotConnected(handle);
 
   EXPECT_EQ(OK,
             handle.Init("a",
                         params_,
-                        kDefaultPriority,
+                        DEFAULT_PRIORITY,
                         callback.callback(),
                         pool_.get(),
                         log.bound()));
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfoConnectedNotReused(handle);
 
   handle.Reset();
   TestLoadTimingInfoNotConnected(handle);
 
@@ skipping 22 matching lines @@
   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_,
-                        kDefaultPriority,
+                        DEFAULT_PRIORITY,
                         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);
 
   CapturingNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsEvent(
       entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 2, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, TotalLimit) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   // TODO(eroman): Check that the NetLog contains this event.
 
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("c", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("d", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("c", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("d", DEFAULT_PRIORITY));
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("f", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("g", kDefaultPriority));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("f", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("g", DEFAULT_PRIORITY));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
   EXPECT_EQ(5, GetOrderOfRequest(5));
   EXPECT_EQ(6, GetOrderOfRequest(6));
   EXPECT_EQ(7, GetOrderOfRequest(7));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
 }
 
 TEST_F(ClientSocketPoolBaseTest, TotalLimitReachedNewGroup) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   // TODO(eroman): Check that the NetLog contains this event.
 
   // Reach all limits: max total sockets, and max sockets per group.
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 
   // Now create a new group and verify that we don't starve it.
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kDefaultPriority));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", DEFAULT_PRIORITY));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
@@ skipping 75 matching lines @@
   EXPECT_EQ(7, GetOrderOfRequest(7));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
 }
 
 // Make sure that we count connecting sockets against the total limit.
 TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("c", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("c", DEFAULT_PRIORITY));
 
   // Create one asynchronous request.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", kDefaultPriority));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", DEFAULT_PRIORITY));
 
   // 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();
 
   // The next synchronous request should wait for its turn.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", kDefaultPriority));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", DEFAULT_PRIORITY));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
   EXPECT_EQ(5, GetOrderOfRequest(5));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(6));
 }
 
 TEST_F(ClientSocketPoolBaseTest, CorrectlyCountStalledGroups) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kDefaultPriority));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", DEFAULT_PRIORITY));
 
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
 
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
   EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
   EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
   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_,
-                        kDefaultPriority,
+                        DEFAULT_PRIORITY,
                         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_,
-                              kDefaultPriority,
+                              DEFAULT_PRIORITY,
                               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_,
-                                    kDefaultPriority,
+                                    DEFAULT_PRIORITY,
                                     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_,
-                                                  kDefaultPriority,
+                                                  DEFAULT_PRIORITY,
                                                   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_,
-                                                kDefaultPriority,
+                                                DEFAULT_PRIORITY,
                                                 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_,
-                                                  kDefaultPriority,
+                                                  DEFAULT_PRIORITY,
                                                   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();
@@ skipping 24 matching lines @@
   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_,
-          kDefaultPriority,
+          DEFAULT_PRIORITY,
           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_,
-                                                  kDefaultPriority,
+                                                  DEFAULT_PRIORITY,
                                                   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_,
-                              kDefaultPriority,
+                              DEFAULT_PRIORITY,
                               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_,
-                            kDefaultPriority,
+                            DEFAULT_PRIORITY,
                             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", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", IDLE));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
 
   ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
 
   EXPECT_EQ(kDefaultMaxSocketsPerGroup,
@@ skipping 10 matching lines @@
   EXPECT_EQ(5, GetOrderOfRequest(7));
   EXPECT_EQ(7, GetOrderOfRequest(8));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(9));
 }
 
 TEST_F(ClientSocketPoolBaseTest, PendingRequests_NoKeepAlive) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
 
   for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i)
     EXPECT_EQ(OK, request(i)->WaitForResult());
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
             completion_count());
 }
 
 // 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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a",
                         params_,
-                        kDefaultPriority,
+                        DEFAULT_PRIORITY,
                         callback2.callback(),
                         pool_.get(),
                         BoundNetLog()));
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(callback.have_result());
 
   handle.Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
 
   // Cancel a request.
   size_t index_to_cancel = kDefaultMaxSocketsPerGroup + 2;
   EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized());
   (*requests())[index_to_cancel]->handle()->Reset();
@@ skipping 52 matching lines @@
       {
         // TODO: Resolve conflicting intentions of stopping recursion with the
         // |!within_callback_| test (above) and the call to |RunUntilIdle()|
         // below.  http://crbug.com/114130.
         base::MessageLoop::ScopedNestableTaskAllower allow(
             base::MessageLoop::current());
         base::MessageLoop::current()->RunUntilIdle();
       }
       within_callback_ = true;
       TestCompletionCallback next_job_callback;
-      scoped_refptr<TestSocketParams> params(new TestSocketParams());
+      scoped_refptr<TestSocketParams> params(
+          new TestSocketParams(false /* ignore_limits */));
       int rv = handle_->Init("a",
                              params,
-                             kDefaultPriority,
+                             DEFAULT_PRIORITY,
                              next_job_callback.callback(),
                              pool_,
                              BoundNetLog());
       switch (next_job_type_) {
         case TestConnectJob::kMockJob:
           EXPECT_EQ(OK, rv);
           break;
         case TestConnectJob::kMockPendingJob:
           EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 28 matching lines @@
 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_,
       TestConnectJob::kMockPendingJob);
   int rv = handle.Init("a",
                        params_,
-                       kDefaultPriority,
+                       DEFAULT_PRIORITY,
                        callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob);
   int rv = handle.Init("a",
                        params_,
-                       kDefaultPriority,
+                       DEFAULT_PRIORITY,
                        callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Make sure that pending requests get serviced after active requests get
 // cancelled.
 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
 
   // Now, kDefaultMaxSocketsPerGroup requests should be active.
   // Let's cancel them.
   for (int i = 0; i < kDefaultMaxSocketsPerGroup; ++i) {
     ASSERT_FALSE(request(i)->handle()->is_initialized());
     request(i)->handle()->Reset();
   }
 
   // Let's wait for the rest to complete now.
   for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i) {
@@ skipping 10 matching lines @@
   const size_t kMaxSockets = 5;
   CreatePool(kMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   const size_t kNumberOfRequests = 2 * kDefaultMaxSocketsPerGroup + 1;
   ASSERT_LE(kNumberOfRequests, kMaxSockets);  // Otherwise the test will hang.
 
   // Queue up all the requests
   for (size_t i = 0; i < kNumberOfRequests; ++i)
-    EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
+    EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
 
   for (size_t i = 0; i < kNumberOfRequests; ++i)
     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_,
-                       kDefaultPriority,
+                       DEFAULT_PRIORITY,
                        callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the active request.
   handle.Reset();
 
   rv = handle.Init("a",
                    params_,
-                   kDefaultPriority,
+                   DEFAULT_PRIORITY,
                    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) {
   const int kMaxSockets = 3;
   const int kMaxSocketsPerGroup = 2;
   CreatePool(kMaxSockets, kMaxSocketsPerGroup);
 
   const RequestPriority kHighPriority = HIGHEST;
 
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
 
   // This is going to be a pending request in an otherwise empty group.
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
 
   // Reach the maximum socket limit.
-  EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
+  EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
 
   // Create a stalled group with high priorities.
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority));
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority));
 
   // Release the first two sockets from "a".  Because this is a keepalive,
   // the first release will unblock the pending request for "a".  The
   // second release will unblock a request for "c", becaue it is the next
   // high priority socket.
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
@@ skipping 57 matching lines @@
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   CapturingBoundNetLog 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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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);
 
   CapturingNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
@@ skipping 15 matching lines @@
 
   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_,
-                        kDefaultPriority,
+                        DEFAULT_PRIORITY,
                         callback.callback(),
                         pool_.get(),
                         BoundNetLog()));
   CapturingBoundNetLog log2;
   EXPECT_EQ(ERR_IO_PENDING,
             handle2.Init("a",
                          params_,
-                         kDefaultPriority,
+                         DEFAULT_PRIORITY,
                          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());
@@ skipping 31 matching lines @@
   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_,
-                               kDefaultPriority,
+                               DEFAULT_PRIORITY,
                                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_,
-                           kDefaultPriority,
+                           DEFAULT_PRIORITY,
                            req2.callback(),
                            pool_.get(),
                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   TestSocketRequest req3(&request_order, &completion_count);
   rv = req3.handle()->Init("a",
                            params_,
-                           kDefaultPriority,
+                           DEFAULT_PRIORITY,
                            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();
@@ skipping 18 matching lines @@
 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_,
-                               kDefaultPriority,
+                               DEFAULT_PRIORITY,
                                req1.callback(),
                                pool_.get(),
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestSocketRequest req2(&request_order, &completion_count);
   rv = req2.handle()->Init("a",
                            params_,
-                           kDefaultPriority,
+                           DEFAULT_PRIORITY,
                            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_,
-                           kDefaultPriority,
+                           DEFAULT_PRIORITY,
                            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_,
-                       kDefaultPriority,
+                       DEFAULT_PRIORITY,
                        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.
 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_,
-                       kDefaultPriority,
+                       DEFAULT_PRIORITY,
                        callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
   rv = handle2.Init("a",
                     params_,
-                    kDefaultPriority,
+                    DEFAULT_PRIORITY,
                     callback2.callback(),
                     pool_.get(),
                     BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // If the first Job is in an earlier state than the second, the state of
   // the second job should be used for both handles.
   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
   EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
@@ skipping 62 matching lines @@
 
 // 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_,
-                       kDefaultPriority,
+                       DEFAULT_PRIORITY,
                        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_,
-                    kDefaultPriority,
+                    DEFAULT_PRIORITY,
                     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_,
-                    kDefaultPriority,
+                    DEFAULT_PRIORITY,
                     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());
@@ skipping 13 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_, kDefaultPriority, callback.callback(),
+            handle.Init("a", params_, DEFAULT_PRIORITY, 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_,
-                        kDefaultPriority,
+                        DEFAULT_PRIORITY,
                         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_,
-                        kDefaultPriority,
+                        DEFAULT_PRIORITY,
                         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_,
-                        kDefaultPriority,
+                        DEFAULT_PRIORITY,
                         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);
 }
@@ skipping 347 matching lines @@
     EXPECT_EQ(OK, callback_a[i].WaitForResult());
   }
 }
 
 TEST_F(ClientSocketPoolBaseTest,
        ReleasingDisconnectedSocketsMaintainsPriorityOrder) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
 
   EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
   EXPECT_EQ(OK, (*requests())[1]->WaitForResult());
   EXPECT_EQ(2u, completion_count());
 
   // Releases one connection.
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE));
   EXPECT_EQ(OK, (*requests())[2]->WaitForResult());
 
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE));
@@ skipping 26 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());
+    scoped_refptr<TestSocketParams> con_params(
+        new TestSocketParams(false /* ignore_limits */));
     EXPECT_EQ(expected_result_,
-              handle2_.Init("a", con_params, kDefaultPriority,
+              handle2_.Init("a", con_params, DEFAULT_PRIORITY,
                             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", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
+  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_, kDefaultPriority, req.callback(),
+            req.handle()->Init("a", params_, DEFAULT_PRIORITY, 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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
 }
 
 class ConnectWithinCallback : public TestCompletionCallbackBase {
  public:
   ConnectWithinCallback(
@@ skipping 14 matching lines @@
   }
 
   const CompletionCallback& callback() const { return callback_; }
 
  private:
   void OnComplete(int result) {
     SetResult(result);
     EXPECT_EQ(ERR_IO_PENDING,
               handle_.Init(group_name_,
                            params_,
-                           kDefaultPriority,
+                           DEFAULT_PRIORITY,
                            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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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_,
-                                  kDefaultPriority,
+                                  DEFAULT_PRIORITY,
                                   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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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_,
-                         kDefaultPriority,
+                         DEFAULT_PRIORITY,
                          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_,
-                         kDefaultPriority,
+                         DEFAULT_PRIORITY,
                          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();
@@ skipping 21 matching lines @@
 // 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_,
-                         kDefaultPriority,
+                         DEFAULT_PRIORITY,
                          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_,
-                         kDefaultPriority,
+                         DEFAULT_PRIORITY,
                          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();
@@ skipping 23 matching lines @@
 // 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_,
-                         kDefaultPriority,
+                         DEFAULT_PRIORITY,
                          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_,
-                         kDefaultPriority,
+                         DEFAULT_PRIORITY,
                          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();
@@ skipping 26 matching lines @@
 
   // 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_,
-                         kDefaultPriority,
+                         DEFAULT_PRIORITY,
                          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_,
-                         kDefaultPriority,
+                         DEFAULT_PRIORITY,
                          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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
                                          params_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          callback2.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
   ClientSocketHandle handle3;
   TestCompletionCallback callback3;
   EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
                                          params_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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_,
-                             kDefaultPriority,
+                             DEFAULT_PRIORITY,
                              callback1.callback(),
                              pool_.get(),
                              BoundNetLog()));
   EXPECT_EQ(OK, handle2.Init("a",
                              params_,
-                             kDefaultPriority,
+                             DEFAULT_PRIORITY,
                              callback2.callback(),
                              pool_.get(),
                              BoundNetLog()));
   EXPECT_EQ(OK, handle3.Init("a",
                              params_,
-                             kDefaultPriority,
+                             DEFAULT_PRIORITY,
                              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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
                                          params_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
                                          params_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          callback2.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ClientSocketHandle handle3;
   TestCompletionCallback callback3;
   EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
                                          params_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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());
@@ skipping 61 matching lines @@
 }
 
 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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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"));
@@ skipping 56 matching lines @@
 
   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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
   ASSERT_EQ(OK, callback1.WaitForResult());
 
   ClientSocketHandle handle2;
   TestCompletionCallback callback2;
   int rv = handle2.Init("a",
                         params_,
-                        kDefaultPriority,
+                        DEFAULT_PRIORITY,
                         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"));
@@ skipping 48 matching lines @@
 
   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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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());
 
@@ skipping 14 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"));
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(OK, handle.Init("a",
                             params_,
-                            kDefaultPriority,
+                            DEFAULT_PRIORITY,
                             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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b",
                                          params_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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"));
 
@@ skipping 67 matching lines @@
   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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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"));
   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
 }
 
 class MockLayeredPool : public HigherLayeredPool {
  public:
   MockLayeredPool(TestClientSocketPool* pool,
                   const std::string& group_name)
       : pool_(pool),
-        params_(new TestSocketParams),
         group_name_(group_name),
         can_release_connection_(true) {
     pool_->AddHigherLayeredPool(this);
   }
 
   ~MockLayeredPool() {
     pool_->RemoveHigherLayeredPool(this);
   }
 
   int RequestSocket(TestClientSocketPool* pool) {
-    return handle_.Init(group_name_, params_, kDefaultPriority,
+    scoped_refptr<TestSocketParams> params(
+        new TestSocketParams(false /* ignore_limits */));
+    return handle_.Init(group_name_, params, DEFAULT_PRIORITY,
                         callback_.callback(), pool, BoundNetLog());
   }
 
   int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
-    params_->set_ignore_limits(true);
-    return handle_.Init(group_name_, params_, kDefaultPriority,
+    scoped_refptr<TestSocketParams> params(
+        new TestSocketParams(true /* ignore_limits */));
+    return handle_.Init(group_name_, params, MAXIMUM_PRIORITY,
                         callback_.callback(), pool, BoundNetLog());
   }
 
   bool ReleaseOneConnection() {
     if (!handle_.is_initialized() || !can_release_connection_) {
       return false;
     }
     handle_.socket()->Disconnect();
     handle_.Reset();
     return true;
   }
 
   void set_can_release_connection(bool can_release_connection) {
     can_release_connection_ = can_release_connection;
   }
 
   MOCK_METHOD0(CloseOneIdleConnection, bool());
 
  private:
   TestClientSocketPool* const pool_;
-  scoped_refptr<TestSocketParams> params_;
   ClientSocketHandle handle_;
   TestCompletionCallback callback_;
   const std::string group_name_;
   bool can_release_connection_;
 };
 
 TEST_F(ClientSocketPoolBaseTest, FailToCloseIdleSocketsNotHeldByLayeredPool) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
@@ skipping 24 matching lines @@
 
   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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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_,
-                             kDefaultPriority,
+                             DEFAULT_PRIORITY,
                              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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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_,
-                             kDefaultPriority,
+                             DEFAULT_PRIORITY,
                              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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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_,
-                                         kDefaultPriority,
+                                         DEFAULT_PRIORITY,
                                          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());
 }
@@ skipping 11 matching lines @@
   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_,
-                             kDefaultPriority,
+                             DEFAULT_PRIORITY,
                              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);
@@ skipping 42 matching lines @@
                              &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_,
-                                        kDefaultPriority,
+                                        DEFAULT_PRIORITY,
                                         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());
-  params_ignore_limits->set_ignore_limits(true);
+  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", kDefaultPriority, params_));
+  EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", kDefaultPriority,
+  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
                                                    params_));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", kDefaultPriority,
+  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
                                                    params_ignore_limits));
   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 request with
-// |ignore_limits| set triggers creation of a new socket, and gets the socket
-// instead of a request with a higher priority that was issued earlier, but
-// that does not have |ignore_limits| set.
-TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsLowPriority) {
-  scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams());
-  params_ignore_limits->set_ignore_limits(true);
-  CreatePool(1, 1);
-
-  // Issue a request to reach the socket pool limit.
-  EXPECT_EQ(OK, StartRequestWithParams("a", HIGHEST, params_));
-  EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
-
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
-
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
-  EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
-
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", LOW,
-                                                   params_ignore_limits));
-  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 request with
-// |ignore_limits| set triggers creation of a new socket, and gets the socket
-// instead of a request with a higher priority that was issued later and
-// does not have |ignore_limits| set.
-TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsLowPriority2) {
-  scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams());
-  params_ignore_limits->set_ignore_limits(true);
-  CreatePool(1, 1);
-
-  // Issue a request to reach the socket pool limit.
-  EXPECT_EQ(OK, StartRequestWithParams("a", HIGHEST, params_));
-  EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
-
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
-
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", LOW,
-                                                   params_ignore_limits));
-  ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
-
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
-  EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
-
-  EXPECT_EQ(OK, request(1)->WaitForResult());
-  EXPECT_FALSE(request(2)->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());
-  params_ignore_limits->set_ignore_limits(true);
+  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", HIGHEST, params_));
+  EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
+  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
+                                                   params_));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST,
+  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
                                                    params_ignore_limits));
   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());
 }
 
-// More involved test of ignore limits. Issues a bunch of requests and later
-// checks the order in which they receive sockets.
-TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsOrder) {
-  scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams());
-  params_ignore_limits->set_ignore_limits(true);
-  CreatePool(1, 1);
-
-  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
-
-  // Requests 0 and 1 do not have ignore_limits set, so they finish last. Since
-  // the maximum number of sockets per pool is 1, the second requests does not
-  // trigger a ConnectJob.
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
-  EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
-
-  // Requests 2 and 3 have ignore_limits set, but have a low priority, so they
-  // finish just before the first two.
-  EXPECT_EQ(ERR_IO_PENDING,
-            StartRequestWithParams("a", LOW, params_ignore_limits));
-  EXPECT_EQ(ERR_IO_PENDING,
-            StartRequestWithParams("a", LOW, params_ignore_limits));
-
-  // Request 4 finishes first, since it is high priority and ignores limits.
-  EXPECT_EQ(ERR_IO_PENDING,
-            StartRequestWithParams("a", HIGHEST, params_ignore_limits));
-
-  // Request 5 and 6 are cancelled right after starting. This should result in
-  // creating two ConnectJobs. Since only one request (Request 1) did not
-  // result in creating a ConnectJob, only one of the ConnectJobs should be
-  // cancelled when the requests are.
-  EXPECT_EQ(ERR_IO_PENDING,
-            StartRequestWithParams("a", HIGHEST, params_ignore_limits));
-  EXPECT_EQ(ERR_IO_PENDING,
-            StartRequestWithParams("a", HIGHEST, params_ignore_limits));
-  EXPECT_EQ(6, pool_->NumConnectJobsInGroup("a"));
-  request(5)->handle()->Reset();
-  EXPECT_EQ(6, pool_->NumConnectJobsInGroup("a"));
-  request(6)->handle()->Reset();
-  ASSERT_EQ(5, pool_->NumConnectJobsInGroup("a"));
-
-  // Wait for the last request to get a socket.
-  EXPECT_EQ(OK, request(1)->WaitForResult());
-
-  // Check order in which requests received sockets.
-  // These are 1-based indices, while request(x) uses 0-based indices.
-  EXPECT_EQ(1, GetOrderOfRequest(5));
-  EXPECT_EQ(2, GetOrderOfRequest(3));
-  EXPECT_EQ(3, GetOrderOfRequest(4));
-  EXPECT_EQ(4, GetOrderOfRequest(1));
-  EXPECT_EQ(5, GetOrderOfRequest(2));
-}
-
 }  // namespace
 
 }  // namespace net