Reverting 12470.

caused purify errors
Review URL: http://codereview.chromium.org/45055

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@12479 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 107 insertions, 198 deletions

diff --git a/net/base/client_socket_handle.cc b/net/base/client_socket_handle.cc
index f5ab056..ff81c0a 100644
--- a/net/base/client_socket_handle.cc
+++ b/net/base/client_socket_handle.cc
@@ -18,11 +18,10 @@ ClientSocketHandle::~ClientSocketHandle() {
 }
 
 int ClientSocketHandle::Init(const std::string& group_name,
-                             int priority,
                              CompletionCallback* callback) {
   Reset();
   group_name_ = group_name;
-  return pool_->RequestSocket(this, priority, callback);
+  return pool_->RequestSocket(this, callback);
 }
 
 void ClientSocketHandle::Reset() {
diff --git a/net/base/client_socket_handle.h b/net/base/client_socket_handle.h
index e0d9e73..c107a16 100644
--- a/net/base/client_socket_handle.h
+++ b/net/base/client_socket_handle.h
@@ -32,8 +32,7 @@ class ClientSocketHandle {
 
   // Initializes a ClientSocketHandle object, which involves talking to the
   // ClientSocketPool to locate a socket to possibly reuse.  This method
-  // returns either OK or ERR_IO_PENDING.  On ERR_IO_PENDING, |priority| is
-  // used to determine the placement in ClientSocketPool's wait list.
+  // returns either OK or ERR_IO_PENDING.
   //
   // If this method succeeds, then the socket member will be set to an existing
   // socket if an existing socket was available to reuse.  Otherwise, the
@@ -44,9 +43,7 @@ class ClientSocketHandle {
   //
   // Init may be called multiple times.
   //
-  int Init(const std::string& group_name,
-           int priority,
-           CompletionCallback* callback);
+  int Init(const std::string& group_name, CompletionCallback* callback);
 
   // An initialized handle can be reset, which causes it to return to the
   // un-initialized state.  This releases the underlying socket, which in the
diff --git a/net/base/client_socket_pool.cc b/net/base/client_socket_pool.cc
index 651fbe2..2092017 100644
--- a/net/base/client_socket_pool.cc
+++ b/net/base/client_socket_pool.cc
@@ -41,21 +41,7 @@ ClientSocketPool::~ClientSocketPool() {
   DCHECK(group_map_.empty());
 }
 
-// InsertRequestIntoQueue inserts the request into the queue based on
-// priority.  Highest priorities are closest to the front.  Older requests are
-// prioritized over requests of equal priority.
-//
-// static
-void ClientSocketPool::InsertRequestIntoQueue(const Request& r,
-                                              RequestQueue* pending_requests) {
-  RequestQueue::iterator it = pending_requests->begin();
-  while (it != pending_requests->end() && r.priority <= it->priority)
-    ++it;
-  pending_requests->insert(it, r);
-}
-
 int ClientSocketPool::RequestSocket(ClientSocketHandle* handle,
-                                    int priority,
                                     CompletionCallback* callback) {
   Group& group = group_map_[handle->group_name_];
 
@@ -65,8 +51,7 @@ int ClientSocketPool::RequestSocket(ClientSocketHandle* handle,
     r.handle = handle;
     DCHECK(callback);
     r.callback = callback;
-    r.priority = priority;
-    InsertRequestIntoQueue(r, &group.pending_requests);
+    group.pending_requests.push_back(r);
     return ERR_IO_PENDING;
   }
 
@@ -198,7 +183,7 @@ void ClientSocketPool::DoReleaseSocket(const std::string& group_name,
   if (!group.pending_requests.empty()) {
     Request r = group.pending_requests.front();
     group.pending_requests.pop_front();
-    int rv = RequestSocket(r.handle, r.priority, NULL);
+    int rv = RequestSocket(r.handle, NULL);
     DCHECK(rv == OK);
     r.callback->Run(rv);
     return;
diff --git a/net/base/client_socket_pool.h b/net/base/client_socket_pool.h
index dd08c24..a313a80 100644
--- a/net/base/client_socket_pool.h
+++ b/net/base/client_socket_pool.h
@@ -35,8 +35,7 @@ class ClientSocketPool : public base::RefCounted<ClientSocketPool> {
   // handle will be initialized without a socket such that the consumer needs
   // to supply a socket, or 3) the handle will be added to a wait list until a
   // socket is available to reuse or the opportunity to create a new socket
-  // arises.  The completion callback is notified in the 3rd case.  |priority|
-  // will determine the placement into the wait list.
+  // arises.  The completion callback is notified in the 3rd case.
   //
   // If this function returns OK, then |handle| is initialized upon return.
   // The |handle|'s is_initialized method will return true in this case.  If a
@@ -48,9 +47,7 @@ class ClientSocketPool : public base::RefCounted<ClientSocketPool> {
   // If ERR_IO_PENDING is returned, then the completion callback will be called
   // when |handle| has been initialized.
   //
-  int RequestSocket(ClientSocketHandle* handle,
-                    int priority,
-                    CompletionCallback* callback);
+  int RequestSocket(ClientSocketHandle* handle, CompletionCallback* callback);
 
   // Called to cancel a RequestSocket call that returned ERR_IO_PENDING.  The
   // same handle parameter must be passed to this method as was passed to the
@@ -78,12 +75,30 @@ class ClientSocketPool : public base::RefCounted<ClientSocketPool> {
 
   typedef scoped_ptr<ClientSocket> ClientSocketPtr;
 
+  ~ClientSocketPool();
+
+  // Closes all idle sockets if |force| is true.  Else, only closes idle
+  // sockets that timed out or can't be reused.
+  void CleanupIdleSockets(bool force);
+
+  // Called when the number of idle sockets changes.
+  void IncrementIdleCount();
+  void DecrementIdleCount();
+
+  // Called via PostTask by ReleaseSocket.
+  void DoReleaseSocket(const std::string& group_name, ClientSocketPtr* ptr);
+
+  // Called when timer_ fires.  This method scans the idle sockets removing
+  // sockets that timed out or can't be reused.
+  void OnCleanupTimerFired() {
+    CleanupIdleSockets(false);
+  }
+
   // A Request is allocated per call to RequestSocket that results in
   // ERR_IO_PENDING.
   struct Request {
     ClientSocketHandle* handle;
     CompletionCallback* callback;
-    int priority;
   };
 
   // Entry for a persistent socket which became idle at time |start_time|.
@@ -101,41 +116,16 @@ class ClientSocketPool : public base::RefCounted<ClientSocketPool> {
     bool ShouldCleanup(base::TimeTicks now) const;
   };
 
-  typedef std::deque<Request> RequestQueue;
-
   // A Group is allocated per group_name when there are idle sockets or pending
   // requests.  Otherwise, the Group object is removed from the map.
   struct Group {
     Group() : active_socket_count(0) {}
     std::deque<IdleSocket> idle_sockets;
-    RequestQueue pending_requests;
+    std::deque<Request> pending_requests;
     int active_socket_count;
   };
 
   typedef std::map<std::string, Group> GroupMap;
-
-  ~ClientSocketPool();
-
-  static void InsertRequestIntoQueue(const Request& r,
-                                     RequestQueue* pending_requests);
-
-  // Closes all idle sockets if |force| is true.  Else, only closes idle
-  // sockets that timed out or can't be reused.
-  void CleanupIdleSockets(bool force);
-
-  // Called when the number of idle sockets changes.
-  void IncrementIdleCount();
-  void DecrementIdleCount();
-
-  // Called via PostTask by ReleaseSocket.
-  void DoReleaseSocket(const std::string& group_name, ClientSocketPtr* ptr);
-
-  // Called when timer_ fires.  This method scans the idle sockets removing
-  // sockets that timed out or can't be reused.
-  void OnCleanupTimerFired() {
-    CleanupIdleSockets(false);
-  }
-
   GroupMap group_map_;
 
   // Timer used to periodically prune idle sockets that timed out or can't be
diff --git a/net/base/client_socket_pool_unittest.cc b/net/base/client_socket_pool_unittest.cc
index 8849781..3fb5fd4 100644
--- a/net/base/client_socket_pool_unittest.cc
+++ b/net/base/client_socket_pool_unittest.cc
@@ -11,15 +11,9 @@
 
 namespace {
 
-const int kMaxSocketsPerGroup = 6;
-
-// Note that the first and the last are the same, the first should be handled
-// before the last, since it was inserted first.
-const int kPriorities[10] = { 1, 7, 9, 5, 6, 2, 8, 3, 4, 1 };
+typedef testing::Test ClientSocketPoolTest;
 
-// This is the number of extra requests beyond the first few that use up all
-// available sockets in the socket group.
-const int kNumPendingRequests = arraysize(kPriorities);
+const int kMaxSocketsPerGroup = 6;
 
 class MockClientSocket : public net::ClientSocket {
  public:
@@ -65,16 +59,12 @@ int MockClientSocket::allocation_count = 0;
 
 class TestSocketRequest : public CallbackRunner< Tuple1<int> > {
  public:
-  TestSocketRequest(
-      net::ClientSocketPool* pool,
-      std::vector<TestSocketRequest*>* request_order)
-      : handle(pool), request_order_(request_order) {}
+  explicit TestSocketRequest(net::ClientSocketPool* pool) : handle(pool) {}
 
   net::ClientSocketHandle handle;
 
   void EnsureSocket() {
     DCHECK(handle.is_initialized());
-    request_order_->push_back(this);
     if (!handle.socket()) {
       handle.set_socket(new MockClientSocket());
       handle.socket()->Connect(NULL);
@@ -88,32 +78,20 @@ class TestSocketRequest : public CallbackRunner< Tuple1<int> > {
   }
 
   static int completion_count;
-
- private:
-  std::vector<TestSocketRequest*>* request_order_;
 };
 
 int TestSocketRequest::completion_count = 0;
 
-class ClientSocketPoolTest : public testing::Test {
- protected:
-  ClientSocketPoolTest()
-      : pool_(new net::ClientSocketPool(kMaxSocketsPerGroup)) {}
-
-  virtual void SetUp() {
-    MockClientSocket::allocation_count = 0;
-    TestSocketRequest::completion_count = 0;
-  }
+}  // namespace
 
-  scoped_refptr<net::ClientSocketPool> pool_;
-  std::vector<TestSocketRequest*> request_order_;
-};
+TEST(ClientSocketPoolTest, Basic) {
+  scoped_refptr<net::ClientSocketPool> pool =
+      new net::ClientSocketPool(kMaxSocketsPerGroup);
 
-TEST_F(ClientSocketPoolTest, Basic) {
-  TestSocketRequest r(pool_.get(), &request_order_);
+  TestSocketRequest r(pool);
   int rv;
 
-  rv = r.handle.Init("a", 0, &r);
+  rv = r.handle.Init("a", &r);
   EXPECT_EQ(net::OK, rv);
   EXPECT_TRUE(r.handle.is_initialized());
 
@@ -123,11 +101,14 @@ TEST_F(ClientSocketPoolTest, Basic) {
   MessageLoop::current()->RunAllPending();
 }
 
-TEST_F(ClientSocketPoolTest, WithIdleConnection) {
-  TestSocketRequest r(pool_.get(), &request_order_);
+TEST(ClientSocketPoolTest, WithIdleConnection) {
+  scoped_refptr<net::ClientSocketPool> pool =
+      new net::ClientSocketPool(kMaxSocketsPerGroup);
+
+  TestSocketRequest r(pool);
   int rv;
 
-  rv = r.handle.Init("a", 0, &r);
+  rv = r.handle.Init("a", &r);
   EXPECT_EQ(net::OK, rv);
   EXPECT_TRUE(r.handle.is_initialized());
 
@@ -142,24 +123,27 @@ TEST_F(ClientSocketPoolTest, WithIdleConnection) {
   MessageLoop::current()->RunAllPending();
 }
 
-TEST_F(ClientSocketPoolTest, PendingRequests) {
-  int rv;
+TEST(ClientSocketPoolTest, PendingRequests) {
+  scoped_refptr<net::ClientSocketPool> pool =
+      new net::ClientSocketPool(kMaxSocketsPerGroup);
 
-  scoped_ptr<TestSocketRequest> reqs[kMaxSocketsPerGroup + kNumPendingRequests];
+  int rv;
 
+  scoped_ptr<TestSocketRequest> reqs[kMaxSocketsPerGroup + 10];
   for (size_t i = 0; i < arraysize(reqs); ++i)
-    reqs[i].reset(new TestSocketRequest(pool_.get(), &request_order_));
+    reqs[i].reset(new TestSocketRequest(pool));
+
+  // Reset
+  MockClientSocket::allocation_count = 0;
+  TestSocketRequest::completion_count = 0;
 
   // Create connections or queue up requests.
-  for (int i = 0; i < kMaxSocketsPerGroup; ++i) {
-    rv = reqs[i]->handle.Init("a", 5, reqs[i].get());
-    EXPECT_EQ(net::OK, rv);
-    reqs[i]->EnsureSocket();
-  }
-  for (int i = 0; i < kNumPendingRequests; ++i) {
-    rv = reqs[kMaxSocketsPerGroup + i]->handle.Init(
-        "a", kPriorities[i], reqs[kMaxSocketsPerGroup + i].get());
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  for (size_t i = 0; i < arraysize(reqs); ++i) {
+    rv = reqs[i]->handle.Init("a", reqs[i].get());
+    if (rv != net::ERR_IO_PENDING) {
+      EXPECT_EQ(net::OK, rv);
+      reqs[i]->EnsureSocket();
+    }
   }
 
   // Release any connections until we have no connections.
@@ -176,36 +160,26 @@ TEST_F(ClientSocketPoolTest, PendingRequests) {
   } while (released_one);
 
   EXPECT_EQ(kMaxSocketsPerGroup, MockClientSocket::allocation_count);
-  EXPECT_EQ(kNumPendingRequests, TestSocketRequest::completion_count);
-
-  for (int i = 0; i < kMaxSocketsPerGroup; ++i) {
-    EXPECT_EQ(request_order_[i], reqs[i].get()) <<
-        "Request " << i << " was not in order.";
-  }
-
-  for (int i = 0; i < kNumPendingRequests - 1; ++i) {
-    int index_in_queue = (kNumPendingRequests - 1) - kPriorities[i];
-    EXPECT_EQ(request_order_[kMaxSocketsPerGroup + index_in_queue],
-              reqs[kMaxSocketsPerGroup + i].get()) <<
-        "Request " << kMaxSocketsPerGroup + i << " was not in order.";
-  }
-
-  EXPECT_EQ(request_order_[arraysize(reqs) - 1],
-            reqs[arraysize(reqs) - 1].get()) <<
-      "The last request with priority 1 should not have been inserted "
-      "earlier into the queue.";
+  EXPECT_EQ(10, TestSocketRequest::completion_count);
 }
 
-TEST_F(ClientSocketPoolTest, PendingRequests_NoKeepAlive) {
+TEST(ClientSocketPoolTest, PendingRequests_NoKeepAlive) {
+  scoped_refptr<net::ClientSocketPool> pool =
+      new net::ClientSocketPool(kMaxSocketsPerGroup);
+
   int rv;
 
-  scoped_ptr<TestSocketRequest> reqs[kMaxSocketsPerGroup + kNumPendingRequests];
+  scoped_ptr<TestSocketRequest> reqs[kMaxSocketsPerGroup + 10];
   for (size_t i = 0; i < arraysize(reqs); ++i)
-    reqs[i].reset(new TestSocketRequest(pool_.get(), &request_order_));
+    reqs[i].reset(new TestSocketRequest(pool));
+
+  // Reset
+  MockClientSocket::allocation_count = 0;
+  TestSocketRequest::completion_count = 0;
 
   // Create connections or queue up requests.
   for (size_t i = 0; i < arraysize(reqs); ++i) {
-    rv = reqs[i]->handle.Init("a", 0, reqs[i].get());
+    rv = reqs[i]->handle.Init("a", reqs[i].get());
     if (rv != net::ERR_IO_PENDING) {
       EXPECT_EQ(net::OK, rv);
       reqs[i]->EnsureSocket();
@@ -226,29 +200,31 @@ TEST_F(ClientSocketPoolTest, PendingRequests_NoKeepAlive) {
     }
   } while (released_one);
 
-  EXPECT_EQ(kMaxSocketsPerGroup + kNumPendingRequests,
-            MockClientSocket::allocation_count);
-  EXPECT_EQ(kNumPendingRequests, TestSocketRequest::completion_count);
+  EXPECT_EQ(kMaxSocketsPerGroup + 10, MockClientSocket::allocation_count);
+  EXPECT_EQ(10, TestSocketRequest::completion_count);
 }
 
-TEST_F(ClientSocketPoolTest, CancelRequest) {
-  int rv;
+TEST(ClientSocketPoolTest, CancelRequest) {
+  scoped_refptr<net::ClientSocketPool> pool =
+      new net::ClientSocketPool(kMaxSocketsPerGroup);
 
-  scoped_ptr<TestSocketRequest> reqs[kMaxSocketsPerGroup + kNumPendingRequests];
+  int rv;
 
+  scoped_ptr<TestSocketRequest> reqs[kMaxSocketsPerGroup + 10];
   for (size_t i = 0; i < arraysize(reqs); ++i)
-    reqs[i].reset(new TestSocketRequest(pool_.get(), &request_order_));
+    reqs[i].reset(new TestSocketRequest(pool));
+
+  // Reset
+  MockClientSocket::allocation_count = 0;
+  TestSocketRequest::completion_count = 0;
 
   // Create connections or queue up requests.
-  for (int i = 0; i < kMaxSocketsPerGroup; ++i) {
-    rv = reqs[i]->handle.Init("a", 5, reqs[i].get());
-    EXPECT_EQ(net::OK, rv);
-    reqs[i]->EnsureSocket();
-  }
-  for (int i = 0; i < kNumPendingRequests; ++i) {
-    rv = reqs[kMaxSocketsPerGroup + i]->handle.Init(
-        "a", kPriorities[i], reqs[kMaxSocketsPerGroup + i].get());
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  for (size_t i = 0; i < arraysize(reqs); ++i) {
+    rv = reqs[i]->handle.Init("a", reqs[i].get());
+    if (rv != net::ERR_IO_PENDING) {
+      EXPECT_EQ(net::OK, rv);
+      reqs[i]->EnsureSocket();
+    }
   }
 
   // Cancel a request.
@@ -270,26 +246,5 @@ TEST_F(ClientSocketPoolTest, CancelRequest) {
   } while (released_one);
 
   EXPECT_EQ(kMaxSocketsPerGroup, MockClientSocket::allocation_count);
-  EXPECT_EQ(kNumPendingRequests - 1, TestSocketRequest::completion_count);
-  for (int i = 0; i < kMaxSocketsPerGroup; ++i) {
-    EXPECT_EQ(request_order_[i], reqs[i].get()) <<
-        "Request " << i << " was not in order.";
-  }
-
-  for (int i = 0; i < kNumPendingRequests - 1; ++i) {
-    if (i == 2) continue;
-    int index_in_queue = (kNumPendingRequests - 1) - kPriorities[i];
-    if (kPriorities[i] < kPriorities[index_to_cancel - kMaxSocketsPerGroup])
-      index_in_queue--;
-    EXPECT_EQ(request_order_[kMaxSocketsPerGroup + index_in_queue],
-              reqs[kMaxSocketsPerGroup + i].get()) <<
-        "Request " << kMaxSocketsPerGroup + i << " was not in order.";
-  }
-
-  EXPECT_EQ(request_order_[arraysize(reqs) - 2],
-            reqs[arraysize(reqs) - 1].get()) <<
-      "The last request with priority 1 should not have been inserted "
-      "earlier into the queue.";
+  EXPECT_EQ(9, TestSocketRequest::completion_count);
 }
-
-}  // namespace
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index c7ea56f..ae1d9fd 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -377,7 +377,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_RESOLVE_PROXY:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.resolve_proxy", request_, request_->url.spec());
         rv = DoResolveProxy();
         break;
@@ -386,7 +386,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
         TRACE_EVENT_END("http.resolve_proxy", request_, request_->url.spec());
         break;
       case STATE_INIT_CONNECTION:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.init_conn", request_, request_->url.spec());
         rv = DoInitConnection();
         break;
@@ -395,7 +395,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
         TRACE_EVENT_END("http.init_conn", request_, request_->url.spec());
         break;
       case STATE_RESOLVE_HOST:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.resolve_host", request_, request_->url.spec());
         rv = DoResolveHost();
         break;
@@ -404,7 +404,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
         TRACE_EVENT_END("http.resolve_host", request_, request_->url.spec());
         break;
       case STATE_CONNECT:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.connect", request_, request_->url.spec());
         rv = DoConnect();
         break;
@@ -413,7 +413,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
         TRACE_EVENT_END("http.connect", request_, request_->url.spec());
         break;
       case STATE_SSL_CONNECT_OVER_TUNNEL:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.ssl_tunnel", request_, request_->url.spec());
         rv = DoSSLConnectOverTunnel();
         break;
@@ -422,7 +422,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
         TRACE_EVENT_END("http.ssl_tunnel", request_, request_->url.spec());
         break;
       case STATE_WRITE_HEADERS:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.write_headers", request_, request_->url.spec());
         rv = DoWriteHeaders();
         break;
@@ -431,7 +431,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
         TRACE_EVENT_END("http.write_headers", request_, request_->url.spec());
         break;
       case STATE_WRITE_BODY:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.write_body", request_, request_->url.spec());
         rv = DoWriteBody();
         break;
@@ -440,7 +440,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
         TRACE_EVENT_END("http.write_body", request_, request_->url.spec());
         break;
       case STATE_READ_HEADERS:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.read_headers", request_, request_->url.spec());
         rv = DoReadHeaders();
         break;
@@ -449,7 +449,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
         TRACE_EVENT_END("http.read_headers", request_, request_->url.spec());
         break;
       case STATE_READ_BODY:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.read_body", request_, request_->url.spec());
         rv = DoReadBody();
         break;
@@ -458,7 +458,7 @@ int HttpNetworkTransaction::DoLoop(int result) {
         TRACE_EVENT_END("http.read_body", request_, request_->url.spec());
         break;
       case STATE_DRAIN_BODY_FOR_AUTH_RESTART:
-        DCHECK_EQ(OK, rv);
+        DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.drain_body_for_auth_restart",
                           request_, request_->url.spec());
         rv = DoDrainBodyForAuthRestart();
@@ -527,7 +527,7 @@ int HttpNetworkTransaction::DoInitConnection() {
     connection_group.append(request_->url.GetOrigin().spec());
 
   DCHECK(!connection_group.empty());
-  return connection_.Init(connection_group, request_->priority, &io_callback_);
+  return connection_.Init(connection_group, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoInitConnectionComplete(int result) {
diff --git a/net/http/http_request_info.h b/net/http/http_request_info.h
index 2a8a3f8..de817fa 100644
--- a/net/http/http_request_info.h
+++ b/net/http/http_request_info.h
@@ -5,7 +5,6 @@
 #ifndef NET_HTTP_HTTP_REQUEST_INFO_H__
 #define NET_HTTP_HTTP_REQUEST_INFO_H__
 
-#include <string>
 #include "base/ref_counted.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/upload_data.h"
@@ -38,9 +37,6 @@ class HttpRequestInfo {
 
   // Any load flags (see load_flags.h).
   int load_flags;
-
-  // The priority level for this request.
-  int priority;
 };
 
 }  // namespace net
diff --git a/net/url_request/url_request.cc b/net/url_request/url_request.cc
index 335f974..3de8439 100644
--- a/net/url_request/url_request.cc
+++ b/net/url_request/url_request.cc
@@ -47,8 +47,7 @@ URLRequest::URLRequest(const GURL& url, Delegate* delegate)
       user_data_(NULL),
       enable_profiling_(false),
       redirect_limit_(kMaxRedirects),
-      final_upload_progress_(0),
-      priority_(0) {
+      final_upload_progress_(0) {
   URLREQUEST_COUNT_CTOR();
   SIMPLE_STATS_COUNTER("URLRequestCount");
   origin_pid_ = base::GetCurrentProcId();
diff --git a/net/url_request/url_request.h b/net/url_request/url_request.h
index d45e510..a16080f 100644
--- a/net/url_request/url_request.h
+++ b/net/url_request/url_request.h
@@ -8,7 +8,6 @@
 #include <string>
 #include <vector>
 
-#include "base/logging.h"
 #include "base/ref_counted.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_states.h"
@@ -16,14 +15,16 @@
 #include "net/url_request/url_request_status.h"
 
 namespace base {
-class Time;
-}  // namespace base
+  class Time;
+}
 
 namespace net {
+
 class IOBuffer;
 class UploadData;
 class X509Certificate;
-}  // namespace net
+
+}
 
 class URLRequestContext;
 class URLRequestJob;
@@ -430,20 +431,12 @@ class URLRequest {
   // Returns the expected content size if available
   int64 GetExpectedContentSize() const;
 
-  // Returns the priority level for this request.  A larger value indicates
-  // higher priority.  Negative values are not used.
-  int priority() const { return priority_; }
-  void set_priority(int priority) {
-    DCHECK_GE(priority, 0);
-    priority_ = priority;
-  }
-
  protected:
   // Allow the URLRequestJob class to control the is_pending() flag.
   void set_is_pending(bool value) { is_pending_ = value; }
 
   // Allow the URLRequestJob class to set our status too
-  void set_status(const URLRequestStatus& value) { status_ = value; }
+  void set_status(const URLRequestStatus &value) { status_ = value; }
 
   // Allow the URLRequestJob to redirect this request.  Returns net::OK if
   // successful, otherwise an error code is returned.
@@ -512,10 +505,6 @@ class URLRequest {
   // first transaction in a request involving redirects.
   uint64 final_upload_progress_;
 
-  // The priority level for this request.  Objects like ClientSocketPool use
-  // this to determine which URLRequest to allocate sockets to first.
-  int priority_;
-
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
diff --git a/net/url_request/url_request_http_job.cc b/net/url_request/url_request_http_job.cc
index 4180bef..cf380de 100644
--- a/net/url_request/url_request_http_job.cc
+++ b/net/url_request/url_request_http_job.cc
@@ -111,7 +111,6 @@ void URLRequestHttpJob::Start() {
   request_info_.referrer = referrer;
   request_info_.method = request_->method();
   request_info_.load_flags = request_->load_flags();
-  request_info_.priority = request_->priority();
 
   if (request_->context()) {
     request_info_.user_agent =