Start calculating new combined NetworkChangeNotifier signal

net/base/network_change_notifier.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.
 
 #ifndef NET_BASE_NETWORK_CHANGE_NOTIFIER_H_
 #define NET_BASE_NETWORK_CHANGE_NOTIFIER_H_
 
 #include "base/basictypes.h"
 #include "base/observer_list_threadsafe.h"
 #include "net/base/net_export.h"
@@ skipping 68 matching lines @@
     virtual void OnDNSChanged() = 0;
 
    protected:
     DNSObserver() {}
     virtual ~DNSObserver() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(DNSObserver);
   };
 
+  class NET_EXPORT NetworkChangeObserver {
+   public:
+    // OnNetworkChanged will be called when a change occurs to the host
+    // computer's hardware or software that affects the route network packets
+    // take to any network server. Some examples:
+    //   1. A network connection becoming available or going away. For example
+    //      plugging or unplugging an Ethernet cable, WiFi or cellular modem
+    //      connecting or disconnecting from a network, or a VPN tunnel being
+    //      established or taken down.
+    //   2. An active network connection's IP address changes.
+    //   3. A change to the local IP routing tables.
+    // The signal shall only be produced when the change is complete.  For
+    // example if a new network connection has become available, only give the
+    // signal once we think the O/S has finished establishing the connection
+    // (i.e. DHCP is done) to the point where the new connection is usable.
+    // The signal shall not be produced spuriously as it will be triggering some
+    // expensive operations, like socket pools closing all connections and
+    // sockets and then re-establishing them.
+    // |type| indicates the type of the active primary network connection after
+    // the change.  Observers performing "constructive" activities like trying
+    // to establish a connection to a server should only do so when
+    // |type != CONNECTION_NONE|.  Observers performing "destructive" activities
+    // like resetting already established server connections should only do so
+    // when |type == CONNECTION_NONE|.  OnNetworkChanged will be called with
+    // CONNECTION_NONE immediately prior to being called with an online state;
+    // this is done to make sure that destructive actions take place prior to
+    // constructive actions.
+    virtual void OnNetworkChanged(ConnectionType type) = 0;
+
+   protected:
+    NetworkChangeObserver() {}
+    virtual ~NetworkChangeObserver() {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(NetworkChangeObserver);
+  };
+
   virtual ~NetworkChangeNotifier();
 
   // See the description of NetworkChangeNotifier::GetConnectionType().
   // Implementations must be thread-safe. Implementations must also be
   // cheap as this could be called (repeatedly) from the network thread.
   virtual ConnectionType GetCurrentConnectionType() const = 0;
 
   // Replaces the default class factory instance of NetworkChangeNotifier class.
   // The method will take over the ownership of |factory| object.
   static void SetFactory(NetworkChangeNotifierFactory* factory);
@@ skipping 49 matching lines @@
   static NetworkChangeNotifier* CreateMock();
 
   // Registers |observer| to receive notifications of network changes.  The
   // thread on which this is called is the thread on which |observer| will be
   // called back with notifications.  This is safe to call if Create() has not
   // been called (as long as it doesn't race the Create() call on another
   // thread), in which case it will simply do nothing.
   static void AddIPAddressObserver(IPAddressObserver* observer);
   static void AddConnectionTypeObserver(ConnectionTypeObserver* observer);
   static void AddDNSObserver(DNSObserver* observer);
+  static void AddNetworkChangeObserver(NetworkChangeObserver* observer);
 
   // Unregisters |observer| from receiving notifications.  This must be called
   // on the same thread on which AddObserver() was called.  Like AddObserver(),
   // this is safe to call if Create() has not been called (as long as it doesn't
   // race the Create() call on another thread), in which case it will simply do
   // nothing.  Technically, it's also safe to call after the notifier object has
   // been destroyed, if the call doesn't race the notifier's destruction, but
   // there's no reason to use the API in this risky way, so don't do it.
   static void RemoveIPAddressObserver(IPAddressObserver* observer);
   static void RemoveConnectionTypeObserver(ConnectionTypeObserver* observer);
   static void RemoveDNSObserver(DNSObserver* observer);
+  static void RemoveNetworkChangeObserver(NetworkChangeObserver* observer);
 
   // Allow unit tests to trigger notifications.
   static void NotifyObserversOfIPAddressChangeForTests() {
     NotifyObserversOfIPAddressChange();
   }
 
   // Return a string equivalent to |type|.
   static const char* ConnectionTypeToString(ConnectionType type);
 
   // Let the NetworkChangeNotifier know we received some data.
   // This is used strictly for producing histogram data about the accuracy of
   // the NetworkChangenotifier's online detection.
   static void NotifyDataReceived(const GURL& source);
 
   // Register the Observer callbacks for producing histogram data.  This
   // should be called from the network thread to avoid race conditions.
   static void InitHistogramWatcher();
 
  protected:
-  NetworkChangeNotifier();
+  // Delay arguments control how many milliseconds to delay notifications
+  // so as to combine duplicates.  They should be tuned for the particular
+  // child class implementation.  See NetworkChangeCalculator() for more
+  // details.
+  NetworkChangeNotifier(uint32 ip_address_offline_delay_ms,
+                        uint32 ip_address_online_delay_ms,
+                        uint32 connection_type_offline_delay_ms,
+                        uint32 connection_type_online_delay_ms);

[szym, 2012/11/25 07:37:37]

They should be TimeDelta.

I suggest using four independent setters. This would improve readability, and
allow reasonable default (i.e., 0). If you insist on grouping them together, I
suggest one setter for
struct NetworkChangeCalculatorParams {
  TimeDelta ip_address_offline_delay;
  // ...
};

If this has to be passed at construction time, then you can add static
NetworkChangeCalculatorParams NetworkChangeCalculatorParams::Defaults() (if you
want to keep the struct POD) or a default constructor (if not).

This would also allow you to create constructor functions (in anonymous
namespace) where the constants are well-named and readable.

 
 #if defined(OS_LINUX)
   // Returns the AddressTrackerLinux if present.
   // TODO(szym): Retrieve AddressMap from NetworkState. http://crbug.com/144212
   virtual const internal::AddressTrackerLinux*
       GetAddressTrackerInternal() const;
 #endif
 
   // Broadcasts a notification to all registered observers.  Note that this
   // happens asynchronously, even for observers on the current thread, even in
   // tests.
   static void NotifyObserversOfIPAddressChange();
   static void NotifyObserversOfConnectionTypeChange();
   static void NotifyObserversOfDNSChange();
+  static void NotifyObserversOfNetworkChange(ConnectionType type);
 
   // Stores |config| in NetworkState and notifies observers.
   static void SetDnsConfig(const DnsConfig& config);
 
  private:
   friend class HostResolverImplDnsTest;
   friend class NetworkChangeNotifierAndroidTest;
   friend class NetworkChangeNotifierLinuxTest;
   friend class NetworkChangeNotifierWinTest;
 
   class NetworkState;
+  class NetworkChangeCalculator;
 
   // Allows a second NetworkChangeNotifier to be created for unit testing, so
   // the test suite can create a MockNetworkChangeNotifier, but platform
   // specific NetworkChangeNotifiers can also be created for testing.  To use,
   // create an DisableForTest object, and then create the new
   // NetworkChangeNotifier object.  The NetworkChangeNotifier must be
   // destroyed before the DisableForTest object, as its destruction will restore
   // the original NetworkChangeNotifier.
   class NET_EXPORT_PRIVATE DisableForTest {
    public:
     DisableForTest();
     ~DisableForTest();
 
    private:
     // The original NetworkChangeNotifier to be restored on destruction.
     NetworkChangeNotifier* network_change_notifier_;
   };
 
   const scoped_refptr<ObserverListThreadSafe<IPAddressObserver> >
       ip_address_observer_list_;
   const scoped_refptr<ObserverListThreadSafe<ConnectionTypeObserver> >
       connection_type_observer_list_;
   const scoped_refptr<ObserverListThreadSafe<DNSObserver> >
       resolver_state_observer_list_;
+  const scoped_refptr<ObserverListThreadSafe<NetworkChangeObserver> >
+      network_change_observer_list_;
 
   // The current network state. Hosts DnsConfig, exposed via GetDnsConfig.
   scoped_ptr<NetworkState> network_state_;
 
   // A little-piggy-back observer that simply logs UMA histogram data.
   scoped_ptr<HistogramWatcher> histogram_watcher_;
 
+  // Computes NetworkChange signal from IPAddress and ConnectionType signals.
+  scoped_ptr<NetworkChangeCalculator> network_change_calculator_;
+
   DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifier);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NETWORK_CHANGE_NOTIFIER_H_