[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 32 matching lines @@
   LoadTimingInfo load_timing_info;
   EXPECT_FALSE(handle.GetLoadTimingInfo(false, &load_timing_info));
 
   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);
 }
 
+enum LimitsBehavior { IGNORE_LIMITS, RESPECT_LIMITS };
+
 class TestSocketParams : public base::RefCounted<TestSocketParams> {
  public:
-  TestSocketParams() : ignore_limits_(false) {}
+  explicit TestSocketParams(LimitsBehavior behavior) : behavior_(behavior) {}
 
-  void set_ignore_limits(bool ignore_limits) {
-    ignore_limits_ = ignore_limits;
-  }
-  bool ignore_limits() { return ignore_limits_; }
+  bool ignore_limits() { return behavior_ == IGNORE_LIMITS; }

[mmenke, 2013/10/30 15:54:59]

Why the change?  Not strongly opposed, just doesn't seem to get anything, and
adds a new value to be familiar with (RESPECT_LIMITS).

[akalin, 2013/10/30 23:32:16]

Enum params are preferred over bool params in the style guide, I believe. I
dislike passing around just 'true' and 'false' values anyway.

[mmenke, 2013/10/31 15:37:26]

But we weren't passing around raw bools anywhere.  I can understand that if it
were TestSocketParams(true, true, false, KINDA, SORTA, MAYBE, false, INDEED,
VERILY);

But set_ignore_limits(true) is pretty explicit.  And I think RESPECT_LIMITS
everywhere is actually more confusing - adds low value data everywhere.

[akalin, 2013/11/01 07:02:47]

Okay, done.

 
  private:
   friend class base::RefCounted<TestSocketParams>;
   ~TestSocketParams() {}
 
-  bool ignore_limits_;
+  LimitsBehavior behavior_;
 };
 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 531 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(RESPECT_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(RESPECT_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(RESPECT_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,
+    return handle_.Init(group_name_, new TestSocketParams(RESPECT_LIMITS),
+                        DEFAULT_PRIORITY,
                         callback_.callback(), pool, BoundNetLog());
   }
 
   int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
-    params_->set_ignore_limits(true);
-    return handle_.Init(group_name_, params_, kDefaultPriority,
+    return handle_.Init(group_name_, new TestSocketParams(IGNORE_LIMITS),
+                        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(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", DEFAULT_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", DEFAULT_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(IGNORE_LIMITS));
   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_));

[mmenke, 2013/10/30 15:54:59]

These should be MAXIMUM_PRIORITY now.

[akalin, 2013/10/30 23:32:16]

Done.

   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());

[mmenke, 2013/10/30 15:54:59]

WAit...Why is this passing?  I don't see where we put the ignore_limits request
in front of the other request.

[akalin, 2013/10/30 23:32:16]

Did you m ean the previous test (IgnoreLimits)? I'm not exactly sure what this
test (IgnoreLimitsCancelOtherJob) is supposed to be testing, to be honest.

[mmenke, 2013/10/31 15:37:26]

Ah!  I missed the cancel.  Yea, I was thinking this was just like the other
test, except with HIGHEST priority everywhere.

Purpose of this test:  When we cancel requests, in some cases we cancel
ConnectJobs.  We currently just do this in the case there are more requests than
ConnectJobs, but the logic used to be quite different, I believe.  If we end up
cancelling a ConnectJob that is intended to service an ignore_limits request,
that would be bad.

   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