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

net/base/client_socket_pool.cc

 // 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.
 
 #include "net/base/client_socket_pool.h"
 
 #include "base/message_loop.h"
 #include "net/base/client_socket.h"
 #include "net/base/client_socket_handle.h"
 #include "net/base/net_errors.h"
 
 using base::TimeDelta;
 
 namespace {
 
-// The timeout value, in seconds, used to clean up disconnected idle sockets.
+// The timeout value, in seconds, used to clean up idle sockets that can't be
+// reused.
 const int kCleanupInterval = 10;
 
 // The maximum duration, in seconds, to keep idle persistent sockets alive.
-const int kIdleTimeout = 300; // 5 minutes.
+const int kIdleTimeout = 300;  // 5 minutes.
 
 }  // namespace
 
 namespace net {
 
 ClientSocketPool::ClientSocketPool(int max_sockets_per_group)
     : idle_socket_count_(0),
       max_sockets_per_group_(max_sockets_per_group) {
 }
 
@@ skipping 16 matching lines @@
     DCHECK(callback);
     r.callback = callback;
     group.pending_requests.push_back(r);
     return ERR_IO_PENDING;
   }
 
   // OK, we are going to activate one.
   group.active_socket_count++;
 
   // Use idle sockets in LIFO order because they're more likely to be
-  // still connected.
+  // still reusable.
   while (!group.idle_sockets.empty()) {
     IdleSocket idle_socket = group.idle_sockets.back();
     group.idle_sockets.pop_back();
     DecrementIdleCount();
-    if ((*idle_socket.ptr)->IsConnected()) {
+    if ((*idle_socket.ptr)->IsConnectedAndIdle()) {
       // We found one we can reuse!
       handle->socket_ = idle_socket.ptr;
       return OK;
     }
     delete idle_socket.ptr;
   }
 
   handle->socket_ = new ClientSocketPtr();
   return OK;
 }
@@ skipping 23 matching lines @@
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &ClientSocketPool::DoReleaseSocket, handle->group_name_,
       handle->socket_));
 }
 
 void ClientSocketPool::CloseIdleSockets() {
   CleanupIdleSockets(true);
 }
 
 bool ClientSocketPool::IdleSocket::ShouldCleanup(base::TimeTicks now) const {
-  bool timed_out = (now - start_time) >= 
+  bool timed_out = (now - start_time) >=
       base::TimeDelta::FromSeconds(kIdleTimeout);
-  return timed_out || !(*ptr)->IsConnected();
+  return timed_out || !(*ptr)->IsConnectedAndIdle();
 }
 
 void ClientSocketPool::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 36 matching lines @@
 void ClientSocketPool::DoReleaseSocket(const std::string& group_name,
                                        ClientSocketPtr* ptr) {
   GroupMap::iterator i = group_map_.find(group_name);
   DCHECK(i != group_map_.end());
 
   Group& group = i->second;
 
   DCHECK(group.active_socket_count > 0);
   group.active_socket_count--;
 
-  bool can_reuse = ptr->get() && (*ptr)->IsConnected();
+  bool can_reuse = ptr->get() && (*ptr)->IsConnectedAndIdle();
   if (can_reuse) {
     IdleSocket idle_socket;
     idle_socket.ptr = ptr;
     idle_socket.start_time = base::TimeTicks::Now();
 
     group.idle_sockets.push_back(idle_socket);
     IncrementIdleCount();
   } else {
     delete ptr;
   }
@@ skipping 10 matching lines @@
 
   // Delete group if no longer needed.
   if (group.active_socket_count == 0 && group.idle_sockets.empty()) {
     DCHECK(group.pending_requests.empty());
     group_map_.erase(i);
   }
 }
 
 }  // namespace net