[Android] Introduce RegistrationPolicy for NetworkChangeNotifier.

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.ObserverList;
 import org.chromium.base.annotations.CalledByNative;
@@ skipping 93 matching lines @@
      * Returns the singleton instance.
      */
     public static NetworkChangeNotifier getInstance() {
         assert sInstance != null;
         return sInstance;
     }
 
     /**
      * Enables auto detection of the current network state based on notifications from the system.
      * Note that passing true here requires the embedding app have the platform ACCESS_NETWORK_STATE
-     * permission.
+     * permission. Also note that in this case the auto detection is enabled based on the status of
+     * the application (@see ApplicationStatus).
      *
      * @param shouldAutoDetect true if the NetworkChangeNotifier should listen for system changes in
      *    network connectivity.
      */
     public static void setAutoDetectConnectivityState(boolean shouldAutoDetect) {
-        getInstance().setAutoDetectConnectivityStateInternal(shouldAutoDetect, false);
-    }
-
-    private void destroyAutoDetector() {
-        if (mAutoDetector != null) {
-            mAutoDetector.destroy();
-            mAutoDetector = null;
-        }
+        getInstance().setAutoDetectConnectivityStateInternal(
+                shouldAutoDetect, new RegistrationPolicyApplicationStatus());
     }
 
     /**
      * Registers to always receive network change notifications no matter if
      * the app is in the background or foreground.
      * Note that in normal circumstances, chrome embedders should use
      * {@code setAutoDetectConnectivityState} to listen to network changes only
      * when the app is in the foreground, because network change observers
      * might perform expensive work depending on the network connectivity.
      */
     public static void registerToReceiveNotificationsAlways() {
-        getInstance().setAutoDetectConnectivityStateInternal(true, true);
+        getInstance().setAutoDetectConnectivityStateInternal(
+                true, new RegistrationPolicyAlwaysRegister());
+    }
+
+    /**
+     * Registers to receive network change notification based on the provided registration policy.
+     */
+    public static void setAutoDetectConnectivityState(RegistrationPolicy policy) {
+        getInstance().setAutoDetectConnectivityStateInternal(true, policy);
+    }
+
+    private void destroyAutoDetector() {
+        if (mAutoDetector != null) {
+            mAutoDetector.destroy();
+            mAutoDetector = null;
+        }
     }
 
     private void setAutoDetectConnectivityStateInternal(
-            boolean shouldAutoDetect, boolean alwaysWatchForChanges) {
-        if (shouldAutoDetect) {
-            if (mAutoDetector == null) {
-                mAutoDetector = new NetworkChangeNotifierAutoDetect(
-                    new NetworkChangeNotifierAutoDetect.Observer() {
-                        @Override
-                        public void onConnectionTypeChanged(int newConnectionType) {
-                            updateCurrentConnectionType(newConnectionType);
-                        }
-                        @Override
-                        public void onMaxBandwidthChanged(double maxBandwidthMbps) {
-                            updateCurrentMaxBandwidth(maxBandwidthMbps);
-                        }
-                    },
-                    mContext,
-                    alwaysWatchForChanges);
-                final NetworkChangeNotifierAutoDetect.NetworkState networkState =
-                        mAutoDetector.getCurrentNetworkState();
-                updateCurrentConnectionType(mAutoDetector.getCurrentConnectionType(networkState));
-                updateCurrentMaxBandwidth(mAutoDetector.getCurrentMaxBandwidthInMbps(networkState));
-            }
-        } else {
+            boolean shouldAutoDetect, RegistrationPolicy policy) {

[pauljensen, 2015/10/01 12:06:36]

It looks like you refactored the body of this function.  I'm not sure I'm a big
fan of the refactor:  the two conditionals are now negated which is harder to
read/understand, and the two early returns make it harder to understand the
control flow.  Can we put it back at least for this CL?  Let's leave the
refactor for another CL.

[timvolodine, 2015/10/05 17:26:45]

sure no problem, this is not essential anyway. done.

+        if (!shouldAutoDetect) {
             destroyAutoDetector();
+            return;
         }
+        if (mAutoDetector != null) return;
+
+        mAutoDetector =
+                new NetworkChangeNotifierAutoDetect(new NetworkChangeNotifierAutoDetect.Observer() {
+                    @Override
+                    public void onConnectionTypeChanged(int newConnectionType) {
+                        updateCurrentConnectionType(newConnectionType);
+                    }
+                    @Override
+                    public void onMaxBandwidthChanged(double maxBandwidthMbps) {
+                        updateCurrentMaxBandwidth(maxBandwidthMbps);
+                    }
+                }, mContext, policy);
+        final NetworkChangeNotifierAutoDetect.NetworkState networkState =
+                mAutoDetector.getCurrentNetworkState();
+        updateCurrentConnectionType(mAutoDetector.getCurrentConnectionType(networkState));
+        updateCurrentMaxBandwidth(mAutoDetector.getCurrentMaxBandwidthInMbps(networkState));
     }
 
     /**
      * 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) {
@@ skipping 80 matching lines @@
 
     /**
      * Checks if there currently is connectivity.
      */
     public static boolean isOnline() {
         int connectionType = getInstance().getCurrentConnectionType();
         return connectionType != ConnectionType.CONNECTION_UNKNOWN
                 && connectionType != ConnectionType.CONNECTION_NONE;
     }
 }