Remove experimental code to pick the "warmest" socket

net/socket/client_socket_pool_base.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 <math.h>
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
 #include "base/stl_util.h"
-#include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "net/base/net_log.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_handle.h"
 
 using base::TimeDelta;
 
 namespace {
 
 // Indicate whether we should enable idle socket cleanup timer. When timer is
 // disabled, sockets are closed next time a socket request is made.
 bool g_cleanup_timer_enabled = true;
 
 // The timeout value, in seconds, used to clean up idle sockets that can't be
 // reused.
 //
 // Note: It's important to close idle sockets that have received data as soon
 // as possible because the received data may cause BSOD on Windows XP under
 // some conditions.  See http://crbug.com/4606.
 const int kCleanupInterval = 10;  // DO NOT INCREASE THIS TIMEOUT.
 
 // Indicate whether or not we should establish a new transport layer connection
 // after a certain timeout has passed without receiving an ACK.
 bool g_connect_backup_jobs_enabled = true;
 
-double g_socket_reuse_policy_penalty_exponent = -1;
-int g_socket_reuse_policy = -1;
-
 }  // namespace
 
 namespace net {
 
-int GetSocketReusePolicy() {
-  return g_socket_reuse_policy;
-}
-
-void SetSocketReusePolicy(int policy) {
-  DCHECK_GE(policy, 0);
-  DCHECK_LE(policy, 2);
-  if (policy > 2 || policy < 0) {
-    LOG(ERROR) << "Invalid socket reuse policy";
-    return;
-  }
-
-  double exponents[] = { 0, 0.25, -1 };
-  g_socket_reuse_policy_penalty_exponent = exponents[policy];
-  g_socket_reuse_policy = policy;
-
-  VLOG(1) << "Setting g_socket_reuse_policy_penalty_exponent = "
-          << g_socket_reuse_policy_penalty_exponent;
-}
-
 ConnectJob::ConnectJob(const std::string& group_name,
                        base::TimeDelta timeout_duration,
                        Delegate* delegate,
                        const BoundNetLog& net_log)
     : group_name_(group_name),
       timeout_duration_(timeout_duration),
       delegate_(delegate),
       net_log_(net_log),
       idle_(true) {
   DCHECK(!group_name.empty());
@@ skipping 340 matching lines @@
     }
   }
 
   return rv;
 }
 
 bool ClientSocketPoolBaseHelper::AssignIdleSocketToRequest(
     const Request* request, Group* group) {
   std::list<IdleSocket>* idle_sockets = group->mutable_idle_sockets();
   std::list<IdleSocket>::iterator idle_socket_it = idle_sockets->end();
-  double max_score = -1;
 
   // Iterate through the idle sockets forwards (oldest to newest)
   //   * Delete any disconnected ones.
   //   * If we find a used idle socket, assign to |idle_socket|.  At the end,
   //   the |idle_socket_it| will be set to the newest used idle socket.
   for (std::list<IdleSocket>::iterator it = idle_sockets->begin();
        it != idle_sockets->end();) {
     if (!it->socket->IsConnectedAndIdle()) {
       DecrementIdleCount();
       delete it->socket;
       it = idle_sockets->erase(it);
       continue;
     }
 
     if (it->socket->WasEverUsed()) {
       // We found one we can reuse!
-      double score = 0;
-      int64 bytes_read = it->socket->NumBytesRead();
-      double num_kb = static_cast<double>(bytes_read) / 1024.0;
-      int idle_time_sec = (base::TimeTicks::Now() - it->start_time).InSeconds();
-      idle_time_sec = std::max(1, idle_time_sec);
-
-      if (g_socket_reuse_policy_penalty_exponent >= 0 && num_kb >= 0) {
-        score = num_kb / pow(idle_time_sec,
-                             g_socket_reuse_policy_penalty_exponent);
-      }
-
-      // Equality to prefer recently used connection.
-      if (score >= max_score) {
-        idle_socket_it = it;
-        max_score = score;
-      }
+      idle_socket_it = it;
     }
 
     ++it;
   }
 
   // If we haven't found an idle socket, that means there are no used idle
   // sockets.  Pick the oldest (first) idle socket (FIFO).
 
   if (idle_socket_it == idle_sockets->end() && !idle_sockets->empty())
     idle_socket_it = idle_sockets->begin();
@@ skipping 767 matching lines @@
   STLDeleteElements(&jobs_);
   unassigned_job_count_ = 0;
 
   // Cancel pending backup job.
   weak_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace internal
 
 }  // namespace net