[NetInfo] Add MaxBandwidthChanged notification and implement on Android

net/android/java/src/org/chromium/net/NetworkChangeNotifier.java

 // Copyright 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.
 
 package org.chromium.net;
 
 import android.content.Context;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
@@ skipping 55 matching lines @@
     static void resetInstanceForTests(Context context) {
         sInstance = new NetworkChangeNotifier(context);
     }
 
     @CalledByNative
     public int getCurrentConnectionType() {
         return mCurrentConnectionType;
     }
 
     @CalledByNative
     public double getCurrentMaxBandwidth() {

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

Can we add the InMbps suffix to this method similar to its AutoDetect
counterpart?

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

Done.

         return mCurrentMaxBandwidth;
     }
 
     /**
      * Calls a native map lookup of subtype to max bandwidth.
      */
     public static double getMaxBandwidthForConnectionSubtype(int subtype) {
         return nativeGetMaxBandwidthForConnectionSubtype(subtype);
     }
 
@@ skipping 53 matching lines @@
     }
 
     private void setAutoDetectConnectivityStateInternal(
             boolean shouldAutoDetect, boolean alwaysWatchForChanges) {
         if (shouldAutoDetect) {
             if (mAutoDetector == null) {
                 mAutoDetector = new NetworkChangeNotifierAutoDetect(
                     new NetworkChangeNotifierAutoDetect.Observer() {
                         @Override
                         public void onConnectionTypeChanged(int newConnectionType) {
-                            updateCurrentMaxBandwidth(mAutoDetector.getCurrentMaxBandwidthInMbps());
                             updateCurrentConnectionType(newConnectionType);
                         }
+                        @Override
+                        public void onMaxBandwidthChanged(double maxBandwidthMbps) {
+                            updateCurrentMaxBandwidth(maxBandwidthMbps);
+                        }
                     },
                     mContext,
                     alwaysWatchForChanges);
+                updateCurrentConnectionType(mAutoDetector.getCurrentConnectionType());
                 updateCurrentMaxBandwidth(mAutoDetector.getCurrentMaxBandwidthInMbps());
-                updateCurrentConnectionType(mAutoDetector.getCurrentConnectionType());
             }
         } else {
             destroyAutoDetector();
         }
     }
 
     /**
      * Updates the perceived network state when not auto-detecting changes to connectivity.
      *
      * @param networkAvailable True if the NetworkChangeNotifier should perceive a "connected"
      *    state, false implies "disconnected".
      */
     @CalledByNative
     public static void forceConnectivityState(boolean networkAvailable) {
         setAutoDetectConnectivityState(false);
         getInstance().forceConnectivityStateInternal(networkAvailable);
     }
 
     private void forceConnectivityStateInternal(boolean forceOnline) {
         boolean connectionCurrentlyExists =
                 mCurrentConnectionType != ConnectionType.CONNECTION_NONE;
         if (connectionCurrentlyExists != forceOnline) {
-            updateCurrentMaxBandwidth(forceOnline ? Double.POSITIVE_INFINITY : 0.0);
             updateCurrentConnectionType(forceOnline ? ConnectionType.CONNECTION_UNKNOWN
                     : ConnectionType.CONNECTION_NONE);
+            updateCurrentMaxBandwidth(forceOnline ? Double.POSITIVE_INFINITY : 0.0);
         }
     }
 
     private void updateCurrentConnectionType(int newConnectionType) {
         mCurrentConnectionType = newConnectionType;
         notifyObserversOfConnectionTypeChange(newConnectionType);
     }
 
-    private void updateCurrentMaxBandwidth(double maxBandwidth) {
-        mCurrentMaxBandwidth = maxBandwidth;
+    private void updateCurrentMaxBandwidth(double maxBandwidthMbps) {
+        if (maxBandwidthMbps == mCurrentMaxBandwidth) return;
+        mCurrentMaxBandwidth = maxBandwidthMbps;
+        notifyObserversOfMaxBandwidthChange(maxBandwidthMbps);
     }
 
     /**
      * Alerts all observers of a connection change.
      */
     void notifyObserversOfConnectionTypeChange(int newConnectionType) {
         for (Long nativeChangeNotifier : mNativeChangeNotifiers) {
             nativeNotifyConnectionTypeChanged(nativeChangeNotifier, newConnectionType);
         }
         for (ConnectionTypeObserver observer : mConnectionTypeObservers) {
             observer.onConnectionTypeChanged(newConnectionType);
         }
     }
 
     /**
+     * Alerts all observers of a bandwidth change.
+     */
+    void notifyObserversOfMaxBandwidthChange(double maxBandwidthMbps) {
+        for (Long nativeChangeNotifier : mNativeChangeNotifiers) {
+            nativeNotifyMaxBandwidthChanged(nativeChangeNotifier, maxBandwidthMbps);
+        }
+    }
+
+
+    /**
      * Adds an observer for any connection type changes.
      */
     public static void addConnectionTypeObserver(ConnectionTypeObserver observer) {
         getInstance().addConnectionTypeObserverInternal(observer);
     }
 
     private void addConnectionTypeObserverInternal(ConnectionTypeObserver observer) {
         mConnectionTypeObservers.addObserver(observer);
     }
 
     /**
      * Removes an observer for any connection type changes.
      */
     public static void removeConnectionTypeObserver(ConnectionTypeObserver observer) {
         getInstance().removeConnectionTypeObserverInternal(observer);
     }
 
     private void removeConnectionTypeObserverInternal(ConnectionTypeObserver observer) {
         mConnectionTypeObservers.removeObserver(observer);
     }
 
     @NativeClassQualifiedName("NetworkChangeNotifierDelegateAndroid")
     private native void nativeNotifyConnectionTypeChanged(long nativePtr, int newConnectionType);
 
+    @NativeClassQualifiedName("NetworkChangeNotifierDelegateAndroid")
+    private native void nativeNotifyMaxBandwidthChanged(long nativePtr, double maxBandwidthMbps);
+
     private static native double nativeGetMaxBandwidthForConnectionSubtype(int subtype);
 
     // For testing only.
     public static NetworkChangeNotifierAutoDetect getAutoDetectorForTest() {
         return getInstance().mAutoDetector;
     }
 
     /**
      * Checks if there currently is connectivity.
      */
     public static boolean isOnline() {
         int connectionType = getInstance().getCurrentConnectionType();
         return connectionType != ConnectionType.CONNECTION_UNKNOWN
                 && connectionType != ConnectionType.CONNECTION_NONE;
     }
 }