Massively simplify the NetworkChangeNotifier infrastructure:...

net/socket/client_socket_pool_base.h

 // 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.
 //
 // 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 156 matching lines @@
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
   ClientSocketPoolBaseHelper(
       int max_sockets,
       int max_sockets_per_group,
       base::TimeDelta unused_idle_socket_timeout,
       base::TimeDelta used_idle_socket_timeout,
-      ConnectJobFactory* connect_job_factory,
-      NetworkChangeNotifier* network_change_notifier);
+      ConnectJobFactory* connect_job_factory);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   // ClientSocketPoolBaseHelper takes ownership of |request|, which must be
   // heap allocated.
   int RequestSocket(const std::string& group_name, const Request* request);
 
   // See ClientSocketPool::CancelRequest for documentation on this function.
   void CancelRequest(const std::string& group_name,
                      const ClientSocketHandle* handle);
 
@@ skipping 24 matching lines @@
   int ConnectRetryIntervalMs() const {
     // TODO(mbelshe): Make this tuned dynamically based on measured RTT.
     //                For now, just use the max retry interval.
     return ClientSocketPool::kMaxConnectRetryIntervalMs;
   }
 
   // ConnectJob::Delegate methods:
   virtual void OnConnectJobComplete(int result, ConnectJob* job);
 
   // NetworkChangeNotifier::Observer methods:
-  virtual void OnIPAddressChanged() { Flush(); }
+  virtual void OnIPAddressChanged();
 
   // For testing.
   bool may_have_stalled_group() const { return may_have_stalled_group_; }
 
   int NumConnectJobsInGroup(const std::string& group_name) const {
     return group_map_.find(group_name)->second.jobs.size();
   }
 
   // Closes all idle sockets if |force| is true.  Else, only closes idle
   // sockets that timed out or can't be reused.  Made public for testing.
@@ skipping 219 matching lines @@
   // requests, we may reach the situation where we have the maximum number of
   // sockets, but no request is stalled because of the global socket limit
   // (although some requests may be blocked on the socket per group limit).
   // We don't strictly maintain |may_have_stalled_group_|, since that would
   // require a linear search through all groups in |group_map_| to see if one
   // of them is stalled.
   bool may_have_stalled_group_;
 
   const scoped_ptr<ConnectJobFactory> connect_job_factory_;
 
-  NetworkChangeNotifier* const network_change_notifier_;
-
   // TODO(vandebo) Remove when backup jobs move to TCPClientSocketPool
   bool backup_jobs_enabled_;
 
   // A factory to pin the backup_job tasks.
   ScopedRunnableMethodFactory<ClientSocketPoolBaseHelper> method_factory_;
 
   // A unique id for the pool.  It gets incremented every time we Flush() the
   // pool.  This is so that when sockets get released back to the pool, we can
   // make sure that they are discarded rather than reused.
   int pool_generation_number_;
@@ skipping 45 matching lines @@
   // sockets a "group" can have.  |unused_idle_socket_timeout| specifies how
   // long to leave an unused idle socket open before closing it.
   // |used_idle_socket_timeout| specifies how long to leave a previously used
   // idle socket open before closing it.
   ClientSocketPoolBase(
       int max_sockets,
       int max_sockets_per_group,
       const scoped_refptr<ClientSocketPoolHistograms>& histograms,
       base::TimeDelta unused_idle_socket_timeout,
       base::TimeDelta used_idle_socket_timeout,
-      ConnectJobFactory* connect_job_factory,
-      NetworkChangeNotifier* network_change_notifier)
+      ConnectJobFactory* connect_job_factory)
       : histograms_(histograms),
         helper_(new internal::ClientSocketPoolBaseHelper(
           max_sockets, max_sockets_per_group,
           unused_idle_socket_timeout, used_idle_socket_timeout,
-          new ConnectJobFactoryAdaptor(connect_job_factory),
-          network_change_notifier)) {}
+          new ConnectJobFactoryAdaptor(connect_job_factory))) {}
 
   virtual ~ClientSocketPoolBase() {}
 
   // These member functions simply forward to ClientSocketPoolBaseHelper.
 
   // RequestSocket bundles up the parameters into a Request and then forwards to
   // ClientSocketPoolBaseHelper::RequestSocket().  Note that the memory
   // ownership is transferred in the asynchronous (ERR_IO_PENDING) case.
   int RequestSocket(const std::string& group_name,
                     const SocketParams& params,
@@ skipping 99 matching lines @@
   // the posting of the task and the execution, then we'll hit the DCHECK that
   // |ClientSocketPoolBaseHelper::group_map_| is empty.
   scoped_refptr<internal::ClientSocketPoolBaseHelper> helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_