[NetInfo] Add MaxBandwidthChanged notification and implement on Android

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/time.h"
@@ skipping 156 matching lines @@
     virtual void OnNetworkChanged(ConnectionType type) = 0;
 
    protected:
     NetworkChangeObserver() {}
     virtual ~NetworkChangeObserver() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(NetworkChangeObserver);
   };
 
+  class NET_EXPORT MaxBandwidthChangeObserver {

[pauljensen, 2014/12/11 16:13:57]

Can we remove the "Change" from this name...and everything else?  Since
"MaxBandwidth" is exactly what is being "Observed" I don't think we need the
word "Change" in there.  "NetworkChangeObserver" is different because
"Oberserving" a "Network" is a very ambiguous action, whereas "Observing"
"MaxBandwidth" is not ambiguous.

[jkarlin, 2014/12/15 19:43:55]

I've renamed the observer, but not "NotifyMaxBandwidthChanged" or
"OnMaxBandwidthChanged".

+   public:
+    // Will be called when a change occurs to the network's maximum bandwidth as
+    // defined in http://w3c.github.io/netinfo/. Generally this will only be
+    // called on bandwidth changing network connection/disconnection events.
+    // Some platforms may call it more frequently, such as when WiFi signal
+    // strength changes.
+    // TODO(jkarlin): This is currently only implemented for Android. Implement
+    // on every platform.
+    virtual void OnMaxBandwidthChanged(double max_bandwidth_mbps) = 0;
+
+   protected:
+    MaxBandwidthChangeObserver() {}
+    virtual ~MaxBandwidthChangeObserver() {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(MaxBandwidthChangeObserver);
+  };
+
   virtual ~NetworkChangeNotifier();
 
   // See the description of NetworkChangeNotifier::GetConnectionType().
   // Implementations must be thread-safe. Implementations must also be
   // cheap as it is called often.
   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 58 matching lines @@
 
   // 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);
+  static void AddMaxBandwidthChangeObserver(
+      MaxBandwidthChangeObserver* 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);
+  static void RemoveMaxBandwidthChangeObserver(
+      MaxBandwidthChangeObserver* observer);
 
   // Allow unit tests to trigger notifications.
   static void NotifyObserversOfIPAddressChangeForTests();
   static void NotifyObserversOfConnectionTypeChangeForTests(
       ConnectionType type);
   static void NotifyObserversOfNetworkChangeForTests(ConnectionType type);
 
   // Enable or disable notifications from the host. After setting to true, be
   // sure to pump the RunLoop until idle to finish any preexisting
   // notifications.
@@ skipping 82 matching lines @@
   // the NetInfo spec: http://w3c.github.io/netinfo/.
   static double GetMaxBandwidthForConnectionSubtype(ConnectionSubtype subtype);
 
   // 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);
+  static void NotifyObserversOfMaxBandwidthChange(double max_bandwidth_mbps);
 
   // 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;
 
   void NotifyObserversOfIPAddressChangeImpl();
   void NotifyObserversOfConnectionTypeChangeImpl(ConnectionType type);
   void NotifyObserversOfDNSChangeImpl();
   void NotifyObserversOfNetworkChangeImpl(ConnectionType type);
+  void NotifyObserversOfMaxBandwidthChangeImpl(double max_bandwidth_mbps);
 
-  const scoped_refptr<ObserverListThreadSafe<IPAddressObserver> >
+  const scoped_refptr<ObserverListThreadSafe<IPAddressObserver>>
       ip_address_observer_list_;
-  const scoped_refptr<ObserverListThreadSafe<ConnectionTypeObserver> >
+  const scoped_refptr<ObserverListThreadSafe<ConnectionTypeObserver>>
       connection_type_observer_list_;
-  const scoped_refptr<ObserverListThreadSafe<DNSObserver> >
+  const scoped_refptr<ObserverListThreadSafe<DNSObserver>>
       resolver_state_observer_list_;
-  const scoped_refptr<ObserverListThreadSafe<NetworkChangeObserver> >
+  const scoped_refptr<ObserverListThreadSafe<NetworkChangeObserver>>
       network_change_observer_list_;
+  const scoped_refptr<ObserverListThreadSafe<MaxBandwidthChangeObserver>>
+      max_bandwidth_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_;
 
   // Set true to disable non-test notifications (to prevent flakes in tests).
   bool test_notifications_only_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifier);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NETWORK_CHANGE_NOTIFIER_H_