Do not attempt to reuse active sockets after a socket pool flush (usually a network change).

net/socket/client_socket_pool_base.cc

 // Copyright (c) 2010 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/message_loop.h"
 #include "base/stats_counters.h"
@@ skipping 124 matching lines @@
       handed_out_socket_count_(0),
       num_releasing_sockets_(0),
       max_sockets_(max_sockets),
       max_sockets_per_group_(max_sockets_per_group),
       unused_idle_socket_timeout_(unused_idle_socket_timeout),
       used_idle_socket_timeout_(used_idle_socket_timeout),
       may_have_stalled_group_(false),
       connect_job_factory_(connect_job_factory),
       network_change_notifier_(network_change_notifier),
       backup_jobs_enabled_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+      pool_generation_number_(0) {
   DCHECK_LE(0, max_sockets_per_group);
   DCHECK_LE(max_sockets_per_group, max_sockets);
 
   if (network_change_notifier_)
     network_change_notifier_->AddObserver(this);
 }
 
 ClientSocketPoolBaseHelper::~ClientSocketPoolBaseHelper() {
   CancelAllConnectJobs();
 
@@ skipping 207 matching lines @@
         // TODO(willchan): Cancel the job in the earliest LoadState.
         RemoveConnectJob(*group.jobs.begin(), &group);
         OnAvailableSocketSlot(group_name, &group);
       }
       return;
     }
   }
 }
 
 void ClientSocketPoolBaseHelper::ReleaseSocket(const std::string& group_name,
-                                               ClientSocket* socket) {
+                                               ClientSocket* socket,
+                                               int id) {
   Group& group = group_map_[group_name];
   group.num_releasing_sockets++;
   num_releasing_sockets_++;
   DCHECK_LE(group.num_releasing_sockets, group.active_socket_count);
   // Run this asynchronously to allow the caller to finish before we let
   // another to begin doing work.  This also avoids nasty recursion issues.
   // NOTE: We cannot refer to the handle argument after this method returns.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &ClientSocketPoolBaseHelper::DoReleaseSocket, group_name, socket));
+      this, &ClientSocketPoolBaseHelper::DoReleaseSocket, group_name, socket, id));
 }
 
 void ClientSocketPoolBaseHelper::CloseIdleSockets() {
   CleanupIdleSockets(true);
 }
 
 int ClientSocketPoolBaseHelper::IdleSocketCountInGroup(
     const std::string& group_name) const {
   GroupMap::const_iterator i = group_map_.find(group_name);
   CHECK(i != group_map_.end());
@@ skipping 83 matching lines @@
     timer_.Start(TimeDelta::FromSeconds(kCleanupInterval), this,
                  &ClientSocketPoolBaseHelper::OnCleanupTimerFired);
 }
 
 void ClientSocketPoolBaseHelper::DecrementIdleCount() {
   if (--idle_socket_count_ == 0)
     timer_.Stop();
 }
 
 void ClientSocketPoolBaseHelper::DoReleaseSocket(const std::string& group_name,
-                                                 ClientSocket* socket) {
+                                                 ClientSocket* socket,
+                                                 int id) {
   // Running callbacks can cause the last outside reference to be released.
   // Hold onto a reference.
   scoped_refptr<ClientSocketPoolBaseHelper> ref_holder(this);
 
   GroupMap::iterator i = group_map_.find(group_name);
   CHECK(i != group_map_.end());
 
   Group& group = i->second;
 
   group.num_releasing_sockets--;
   DCHECK_GE(group.num_releasing_sockets, 0);
 
   CHECK_GT(handed_out_socket_count_, 0);
   handed_out_socket_count_--;
 
   CHECK_GT(group.active_socket_count, 0);
   group.active_socket_count--;
 
   CHECK_GT(num_releasing_sockets_, 0);
   num_releasing_sockets_--;
 
-  const bool can_reuse = socket->IsConnectedAndIdle();
+  const bool can_reuse = socket->IsConnectedAndIdle() &&
+      id == pool_generation_number_;
   if (can_reuse) {
     AddIdleSocket(socket, true /* used socket */, &group);
   } else {
     delete socket;
   }
 
   // If there are no more releasing sockets, then we might have to process
   // multiple available socket slots, since we stalled their processing until
   // all sockets have been released.  Note that ProcessPendingRequest() will
   // invoke user callbacks, so |num_releasing_sockets_| may change.
@@ skipping 103 matching lines @@
           group.pending_requests.begin(), &group.pending_requests));
       LogBoundConnectJobToRequest(job_log.source(), r.get());
       r->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL,
                             new NetLogIntegerParameter("net_error", result));
       r->callback()->Run(result);
     }
     MaybeOnAvailableSocketSlot(group_name);
   }
 }
 
-void ClientSocketPoolBaseHelper::OnIPAddressChanged() {
+void ClientSocketPoolBaseHelper::Flush() {
+  pool_generation_number_++;
   CancelAllConnectJobs();
   CloseIdleSockets();
 }
 
 void ClientSocketPoolBaseHelper::RemoveConnectJob(const ConnectJob *job,
                                                   Group* group) {
   CHECK_GT(connecting_socket_count_, 0);
   connecting_socket_count_--;
 
   DCHECK(job);
@@ skipping 62 matching lines @@
     ClientSocket* socket,
     bool reused,
     ClientSocketHandle* handle,
     base::TimeDelta idle_time,
     Group* group,
     const BoundNetLog& net_log) {
   DCHECK(socket);
   handle->set_socket(socket);
   handle->set_is_reused(reused);
   handle->set_idle_time(idle_time);
+  handle->set_pool_id(pool_generation_number_);
 
   if (reused) {
     net_log.AddEvent(
         NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET,
         new NetLogIntegerParameter(
             "idle_ms", static_cast<int>(idle_time.InMilliseconds())));
   }
 
   net_log.AddEvent(NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
                    new NetLogSourceParameter(
@@ skipping 41 matching lines @@
   DCHECK_LE(total, max_sockets_);
   if (total < max_sockets_)
     return false;
   LOG(WARNING) << "ReachedMaxSocketsLimit: " << total << "/" << max_sockets_;
   return true;
 }
 
 }  // namespace internal
 
 }  // namespace net