Use sockets with unread data if they've never been used before.

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 "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 431 matching lines @@
     const Request& request, Group* group) {
   std::list<IdleSocket>* idle_sockets = group->mutable_idle_sockets();
   std::list<IdleSocket>::iterator idle_socket_it = idle_sockets->end();
 
   // 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()) {
+    if (!it->IsReusable()) {
       DecrementIdleCount();
       delete it->socket;
       it = idle_sockets->erase(it);
       continue;
     }
 
     if (it->socket->WasEverUsed()) {
       // We found one we can reuse!
       idle_socket_it = it;
     }
@@ skipping 172 matching lines @@
                                max_sockets_per_group_));
     group_dict->SetBoolean("backup_job_timer_is_running",
                            group->BackupJobTimerIsRunning());
 
     all_groups_dict->SetWithoutPathExpansion(it->first, group_dict);
   }
   dict->Set("groups", all_groups_dict);
   return dict;
 }
 
+bool ClientSocketPoolBaseHelper::IdleSocket::IsReusable() const {
+  if (socket->WasEverUsed())
+    return socket->IsConnectedAndIdle();
+  return socket->IsConnected();
+}
+
 bool ClientSocketPoolBaseHelper::IdleSocket::ShouldCleanup(
     base::TimeTicks now,
     base::TimeDelta timeout) const {
   bool timed_out = (now - start_time) >= timeout;
   if (timed_out)
     return true;
-  if (socket->WasEverUsed())
-    return !socket->IsConnectedAndIdle();
-  return !socket->IsConnected();
+  return !IsReusable();

[mmenke, 2014/02/25 17:01:53]

Hmm...So the old extra check here was useless, given AssignIdleSocketToRequest's
behavior?  The inconsistency was presumably due to a bug fix, which this is
effectively undoing.

Digging through the history gets us all the way back to
https://codereview.chromium.org/21501 (http://crbug.com/4606).  The bug mentions
an SSL socket receiving data when the server is closing a connection.  The
server will, apparently, send the data and wait for a response.  This may mean
this fix is going in the wrong direction.  Should talk to wtc about this.

 }
 
 void ClientSocketPoolBaseHelper::CleanupIdleSockets(bool force) {
   if (idle_socket_count_ == 0)
     return;
 
   // Current time value. Retrieving it once at the function start rather than
   // inside the inner loop, since it shouldn't change by any meaningful amount.
   base::TimeTicks now = base::TimeTicks::Now();
 
@@ skipping 648 matching lines @@
   pending_requests_.Erase(pointer);
   // If there are no more requests, kill the backup timer.
   if (pending_requests_.empty())
     backup_job_timer_.Stop();
   return request.Pass();
 }
 
 }  // namespace internal
 
 }  // namespace net