Switch from OnIPAddressChanged and OnConnectionTypeChange to OnNetworkChanged

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 "base/time.h"
 #include "net/base/net_export.h"
+#if defined(OS_WIN)
+#include "net/dns/dns_config_service_win.h"
+#endif
 
 class GURL;
 
+// Temporary layering violation to allow existing users of a deprecated
+// interface.
+class IOThreadLoggingNetworkChangeObserver;
+
+class NetWatcher;
+
 namespace net {
 
 struct DnsConfig;
-class HistogramWatcher;
 class NetworkChangeNotifierFactory;
 
 #if defined(OS_LINUX)
 namespace internal {
 class AddressTrackerLinux;
 }
 #endif
 
 // NetworkChangeNotifier monitors the system for network changes, and notifies
 // registered observers of those events.  Observers may register on any thread,
 // and will be called back on the thread from which they registered.
 // NetworkChangeNotifiers are threadsafe, though they must be created and
 // destroyed on the same thread.
 class NET_EXPORT NetworkChangeNotifier {
  public:
   // Using the terminology of the Network Information API:
   // http://www.w3.org/TR/netinfo-api.
   enum ConnectionType {
     CONNECTION_UNKNOWN = 0, // A connection exists, but its type is unknown.
     CONNECTION_ETHERNET = 1,
     CONNECTION_WIFI = 2,
     CONNECTION_2G = 3,
     CONNECTION_3G = 4,
     CONNECTION_4G = 5,
     CONNECTION_NONE = 6     // No connection.
   };
 
+  class HistogramWatcher;
+  class NetworkChangeCalculator;
+
   class NET_EXPORT IPAddressObserver {
    public:
     // Will be called when the IP address of the primary interface changes.
     // This includes when the primary interface itself changes.
     virtual void OnIPAddressChanged() = 0;
 
    protected:
     IPAddressObserver() {}
     virtual ~IPAddressObserver() {}
 
@@ skipping 127 matching lines @@
 
   // Like Create(), but for use in tests.  The mock object doesn't monitor any
   // events, it merely rebroadcasts notifications when requested.
   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);
+  // IPAddress and ConnectionType notifications are now only used for logging
+  // and calculation of NetworkChanged signal.  Users are explicitly friended.
+  class NET_EXPORT Deprecated {
+   private:
+    // TODO(pauljensen): Delete these 6-12 months after transition to
+    // NetworkChange signal when they are no longer needed.
+    friend class HistogramWatcher;
+    friend class ::IOThreadLoggingNetworkChangeObserver;
+    friend class ::NetWatcher;
+    // TODO(pauljensen): Change this to a direct call instead of Observer once
+    // it's the only remaining Deprecated user.
+    friend class NetworkChangeCalculator;
+    // TODO(pauljensen): This should either become a direct call from
+    // NetworkChangeNotifierWin or use NotifyAddrChange() itself.

[szym, 2013/01/20 06:52:08]

I suggest you file a bug specifically for that. You can assign it to me.

+#if defined(OS_WIN)
+    friend class internal::DnsConfigServiceWin::Watcher;
+#endif
+
+    static void AddIPAddressObserver(IPAddressObserver* observer);
+    static void AddConnectionTypeObserver(ConnectionTypeObserver* observer);
+
+    DISALLOW_IMPLICIT_CONSTRUCTORS(Deprecated);
+  };
 
   // 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);
@@ skipping 63 matching lines @@
   static void SetDnsConfig(const DnsConfig& config);
 
  private:
   friend class HostResolverImplDnsTest;
   friend class NetworkChangeNotifierAndroidTest;
   friend class NetworkChangeNotifierLinuxTest;
   friend class NetworkChangeNotifierWinTest;
   friend class URLFetcherMockDnsTest;
 
   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_;
   };
 
+  // Allow unit tests to reset parameters for NetworkChangeCalculator.
+  void ResetNetworkChangeCalculatorParamsForTest(
+      NetworkChangeCalculatorParams params);
+
   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_