Remove experimental code to pick the "warmest" socket

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"
 #include "base/callback.h"
-#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
 #include "net/base/load_timing_info.h"
@@ skipping 89 matching lines @@
 
   bool ignore_limits_;
 };
 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
 
 class MockClientSocket : public StreamSocket {
  public:
   explicit MockClientSocket(net::NetLog* net_log)
       : connected_(false),
         net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)),
-        was_used_to_convey_data_(false),
-        num_bytes_read_(0) {
+        was_used_to_convey_data_(false) {
   }
 
   // Socket implementation.
   virtual int Read(
       IOBuffer* /* buf */, int len,
       const CompletionCallback& /* callback */) OVERRIDE {
-    num_bytes_read_ += len;
-    return len;
+    return ERR_UNEXPECTED;
   }
 
   virtual int Write(
       IOBuffer* /* buf */, int len,
       const CompletionCallback& /* callback */) OVERRIDE {
     was_used_to_convey_data_ = true;
     return len;
   }
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; }
   virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; }
@@ skipping 16 matching lines @@
     return ERR_UNEXPECTED;
   }
 
   virtual const BoundNetLog& NetLog() const OVERRIDE {
     return net_log_;
   }
 
   virtual void SetSubresourceSpeculation() OVERRIDE {}
   virtual void SetOmniboxSpeculation() OVERRIDE {}
   virtual bool WasEverUsed() const OVERRIDE {
-    return was_used_to_convey_data_ || num_bytes_read_ > 0;
+    return was_used_to_convey_data_;
   }
   virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
-  virtual int64 NumBytesRead() const OVERRIDE { return num_bytes_read_; }
-  virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE {
-    static const base::TimeDelta kDummyConnectTimeMicros =
-        base::TimeDelta::FromMicroseconds(10);
-    return kDummyConnectTimeMicros;  // Dummy value.
-  }
   virtual bool WasNpnNegotiated() const OVERRIDE {
     return false;
   }
   virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
     return kProtoUnknown;
   }
   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
     return false;
   }
 
  private:
   bool connected_;
   BoundNetLog net_log_;
   bool was_used_to_convey_data_;
-  int num_bytes_read_;
 
   DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
 };
 
 class TestConnectJob;
 
 class MockClientSocketFactory : public ClientSocketFactory {
  public:
   MockClientSocketFactory() : allocation_count_(0) {}
 
@@ skipping 536 matching lines @@
   bool connect_backup_jobs_enabled_;
   bool cleanup_timer_enabled_;
   MockClientSocketFactory client_socket_factory_;
   TestConnectJobFactory* connect_job_factory_;
   scoped_refptr<TestSocketParams> params_;
   ClientSocketPoolHistograms histograms_;
   scoped_ptr<TestClientSocketPool> pool_;
   ClientSocketPoolTest test_base_;
 };
 
-TEST_F(ClientSocketPoolBaseTest, AssignIdleSocketToGroup_WarmestSocket) {
-  CreatePool(4, 4);
-  net::SetSocketReusePolicy(0);
-
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-
-  std::map<int, StreamSocket*> sockets_;
-  for (size_t i = 0; i < test_base_.requests_size(); i++) {
-    TestSocketRequest* req = test_base_.request(i);
-    StreamSocket* s = req->handle()->socket();
-    MockClientSocket* sock = static_cast<MockClientSocket*>(s);
-    CHECK(sock);
-    sockets_[i] = sock;
-    sock->Read(NULL, 1024 - i, CompletionCallback());
-  }
-
-  ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
-
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  TestSocketRequest* req = test_base_.request(test_base_.requests_size() - 1);
-
-  // First socket is warmest.
-  EXPECT_EQ(sockets_[0], req->handle()->socket());
-
-  // Test that NumBytes are as expected.
-  EXPECT_EQ(1024, sockets_[0]->NumBytesRead());
-  EXPECT_EQ(1023, sockets_[1]->NumBytesRead());
-  EXPECT_EQ(1022, sockets_[2]->NumBytesRead());
-  EXPECT_EQ(1021, sockets_[3]->NumBytesRead());
-
-  ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
-}
-
-TEST_F(ClientSocketPoolBaseTest, AssignIdleSocketToGroup_LastAccessedSocket) {
-  CreatePool(4, 4);
-  net::SetSocketReusePolicy(2);
-
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-
-  std::map<int, StreamSocket*> sockets_;
-  for (size_t i = 0; i < test_base_.requests_size(); i++) {
-    TestSocketRequest* req = test_base_.request(i);
-    StreamSocket* s = req->handle()->socket();
-    MockClientSocket* sock = static_cast<MockClientSocket*>(s);
-    CHECK(sock);
-    sockets_[i] = sock;
-    sock->Read(NULL, 1024 - i, CompletionCallback());
-  }
-
-  ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
-
-  EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
-  TestSocketRequest* req = test_base_.request(test_base_.requests_size() - 1);
-
-  // Last socket is most recently accessed.
-  EXPECT_EQ(sockets_[3], req->handle()->socket());
-  ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
-}
-
 // 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,
       internal::ClientSocketPoolBaseHelper::NORMAL,
       false, params_, BoundNetLog());
   scoped_ptr<TestConnectJob> job(
@@ skipping 2810 matching lines @@
   // 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"));
 }
 
 }  // namespace
 
 }  // namespace net