If an idle socket has received data unexpectedly, we...

net/base/client_socket_pool.h

 // Copyright (c) 2006-2008 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.
 
 #ifndef NET_BASE_CLIENT_SOCKET_POOL_H_
 #define NET_BASE_CLIENT_SOCKET_POOL_H_
 
 #include <deque>
 #include <map>
 #include <string>
@@ skipping 59 matching lines @@
   }
 
  private:
   friend class base::RefCounted<ClientSocketPool>;
 
   typedef scoped_ptr<ClientSocket> ClientSocketPtr;
 
   ~ClientSocketPool();
 
   // Closes all idle sockets if |force| is true.  Else, only closes idle
-  // sockets that are disconnected or timed out.
+  // 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 are disconnected or timed out.
+  // 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;
   };
 
   // Entry for a persistent socket which became idle at time |start_time|.
   struct IdleSocket {
     ClientSocketPtr* ptr;
     base::TimeTicks start_time;
 
-    // An idle socket should be removed if it is disconnected, or has been idle
+    // 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()).
+    //
+    // 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) const;
   };
 
   // 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;
     std::deque<Request> pending_requests;
     int active_socket_count;
   };
 
   typedef std::map<std::string, Group> GroupMap;
   GroupMap group_map_;
 
-  // Timer used to periodically prune idle sockets that are disconnected or
-  // timed out.
+  // Timer used to periodically prune idle sockets that timed out or can't be
+  // reused.
   base::RepeatingTimer<ClientSocketPool> timer_;
 
   // The total number of idle sockets in the system.
   int idle_socket_count_;
 
   // The maximum number of sockets kept per group.
   int max_sockets_per_group_;
-  
+
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPool);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_CLIENT_SOCKET_POOL_H_