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

net/socket/client_socket_pool_base.h

 // 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.
 //
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets for reuse.
 // Subclasses of ClientSocketPool should compose ClientSocketPoolBase to handle
 // the core logic of (1) restricting the number of active (connected or
 // connecting) sockets per "group" (generally speaking, the hostname), (2)
 // maintaining a per-group list of idle, persistent sockets for reuse, and (3)
@@ skipping 320 matching lines @@
   // NetworkChangeNotifier::IPAddressObserver methods:
   virtual void OnIPAddressChanged() OVERRIDE;
 
  private:
   friend class base::RefCounted<ClientSocketPoolBaseHelper>;
 
   // Entry for a persistent socket which became idle at time |start_time|.
   struct IdleSocket {
     IdleSocket() : socket(NULL) {}
 
+    // An idle socket can't be reused if it is disconnected or has been used
+    // before and has received data unexpectedly (hence no longer idle).  The
+    // unread data would be mistaken for the beginning of the next response if
+    // we were to reuse the socket for a new request.
+    //
+    // Note that a preconnected socket (one that has never been used before)

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

Suggest rephrasing this to be "Note that a socket that has never been used
before (like a preconnected socket) with unread data may be resued."  While
preconnects are the primary source, there may be other cases (We normally cancel
connect jobs when requests are cancelled, but there may be other ways to get
such a socket...Maybe if we have a single requests, the initial connect job
takes too long, we start a backup connect job, and the request is cancelled, so
we kill a connect job, but just one of them?  Not positive about that case, but
I think the other phrasing is more future proof).

[davidben, 2014/02/27 16:36:35]

Done.

+    // with unread data may be reused.  This may be, e.g., a SPDY SETTINGS
+    // frame.
+    bool IsReusable() const;
+
     // An idle socket should be removed if it can't be reused, or has been idle
     // for too long. |now| is the current time value (TimeTicks::Now()).
     // |timeout| is the length of time to wait before timing out an idle socket.
-    //
-    // An idle socket can't be reused if it is disconnected or has received
-    // data unexpectedly (hence no longer idle).  The unread data would be
-    // mistaken for the beginning of the next response if we were to reuse the
-    // socket for a new request.
     bool ShouldCleanup(base::TimeTicks now, base::TimeDelta timeout) const;
 
     StreamSocket* socket;
     base::TimeTicks start_time;
   };
 
   typedef PriorityQueue<const Request*> RequestQueue;
   typedef std::map<const ClientSocketHandle*, const Request*> RequestMap;
 
   // A Group is allocated per group_name when there are idle sockets or pending
@@ skipping 507 matching lines @@
   // Histograms for the pool
   ClientSocketPoolHistograms* const histograms_;
   internal::ClientSocketPoolBaseHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_