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

5 files changed, 89 insertions, 163 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