Update from https://crrev.com/306655

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 15 matching lines @@
 @JNINamespace("net")
 public class NetworkChangeNotifier {
     /**
      * Alerted when the connection type of the network changes.
      * The alert is fired on the UI thread.
      */
     public interface ConnectionTypeObserver {
         public void onConnectionTypeChanged(int connectionType);
     }
 
-    // These constants must always match the ones in network_change_notifier.h.
-    public static final int CONNECTION_UNKNOWN = 0;
-    public static final int CONNECTION_ETHERNET = 1;
-    public static final int CONNECTION_WIFI = 2;
-    public static final int CONNECTION_2G = 3;
-    public static final int CONNECTION_3G = 4;
-    public static final int CONNECTION_4G = 5;
-    public static final int CONNECTION_NONE = 6;
-    public static final int CONNECTION_BLUETOOTH = 7;
-
     private final Context mContext;
     private final ArrayList<Long> mNativeChangeNotifiers;
     private final ObserverList<ConnectionTypeObserver> mConnectionTypeObservers;
     private NetworkChangeNotifierAutoDetect mAutoDetector;
-    private int mCurrentConnectionType = CONNECTION_UNKNOWN;
+    private int mCurrentConnectionType = ConnectionType.CONNECTION_UNKNOWN;
+    private double mCurrentMaxBandwidth = Double.POSITIVE_INFINITY;
 
     private static NetworkChangeNotifier sInstance;
 
     private NetworkChangeNotifier(Context context) {
         mContext = context.getApplicationContext();
         mNativeChangeNotifiers = new ArrayList<Long>();
         mConnectionTypeObservers = new ObserverList<ConnectionTypeObserver>();
     }
 
     /**
@@ skipping 13 matching lines @@
 
     static void resetInstanceForTests(Context context) {
         sInstance = new NetworkChangeNotifier(context);
     }
 
     @CalledByNative
     public int getCurrentConnectionType() {
         return mCurrentConnectionType;
     }
 
+    @CalledByNative
+    public double getCurrentMaxBandwidth() {
+        return mCurrentMaxBandwidth;
+    }
+
+    /**
+     * Calls a native map lookup of subtype to max bandwidth.
+     */
+    public static double getMaxBandwidthForConnectionSubtype(int subtype) {
+        return nativeGetMaxBandwidthForConnectionSubtype(subtype);
+    }
+
     /**
      * Adds a native-side observer.
      */
     @CalledByNative
     public void addNativeObserver(long nativeChangeNotifier) {
         mNativeChangeNotifiers.add(nativeChangeNotifier);
     }
 
     /**
      * Removes a native-side observer.
@@ skipping 43 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);
                         }
                     },
                     mContext,
                     alwaysWatchForChanges);
+                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 != CONNECTION_NONE;
+        boolean connectionCurrentlyExists =
+                mCurrentConnectionType != ConnectionType.CONNECTION_NONE;
         if (connectionCurrentlyExists != forceOnline) {
-            updateCurrentConnectionType(forceOnline ? CONNECTION_UNKNOWN : CONNECTION_NONE);
+            updateCurrentMaxBandwidth(forceOnline ? Double.POSITIVE_INFINITY : 0.0);
+            updateCurrentConnectionType(forceOnline ? ConnectionType.CONNECTION_UNKNOWN
+                    : ConnectionType.CONNECTION_NONE);
         }
     }
 
     private void updateCurrentConnectionType(int newConnectionType) {
         mCurrentConnectionType = newConnectionType;
         notifyObserversOfConnectionTypeChange(newConnectionType);
     }
 
+    private void updateCurrentMaxBandwidth(double maxBandwidth) {
+        mCurrentMaxBandwidth = maxBandwidth;
+    }
+
     /**
      * 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);
         }
@@ skipping 17 matching lines @@
         getInstance().removeConnectionTypeObserverInternal(observer);
     }
 
     private void removeConnectionTypeObserverInternal(ConnectionTypeObserver observer) {
         mConnectionTypeObservers.removeObserver(observer);
     }
 
     @NativeClassQualifiedName("NetworkChangeNotifierDelegateAndroid")
     private native void nativeNotifyConnectionTypeChanged(long nativePtr, int newConnectionType);
 
+    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 != CONNECTION_UNKNOWN && connectionType != CONNECTION_NONE;
+        return connectionType != ConnectionType.CONNECTION_UNKNOWN
+                && connectionType != ConnectionType.CONNECTION_NONE;
     }
 }