[Android] Introduce RegistrationPolicy for NetworkChangeNotifier.

net/android/javatests/src/org/chromium/net/NetworkChangeNotifierTest.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.annotation.SuppressLint;
 import android.content.Context;
 import android.content.Intent;
 import android.net.ConnectivityManager;
@@ skipping 282 matching lines @@
     @UiThreadTest
     @MediumTest
     @Feature({"Android-AppBase"})
     public void testNetworkChangeNotifierRegistersInConstructor() throws InterruptedException {
         Context context = getInstrumentation().getTargetContext();
 
         NetworkChangeNotifierAutoDetect.Observer observer =
                 new TestNetworkChangeNotifierAutoDetectObserver();
 
         NetworkChangeNotifierAutoDetect receiver = new NetworkChangeNotifierAutoDetect(
-                observer, context, false /* always watch for changes */) {
-            @Override
-            int getApplicationState() {
-                return ApplicationState.HAS_RUNNING_ACTIVITIES;
-            }
-        };
+                observer, context, new RegistrationPolicyApplicationStatus() {
+                    @Override
+                    int getApplicationState() {
+                        return ApplicationState.HAS_RUNNING_ACTIVITIES;
+                    }
+                });
 
         assertTrue(receiver.isReceiverRegisteredForTesting());
     }
 
     /**
      * Tests that the receiver toggles registration for connectivity intents based on activity
      * state.
      */
     @UiThreadTest
     @MediumTest
     @Feature({"Android-AppBase"})
     public void testNetworkChangeNotifierRegistersForIntents() throws InterruptedException {
-        mReceiver.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
+        RegistrationPolicyApplicationStatus policy =
+                (RegistrationPolicyApplicationStatus) mReceiver.getRegistrationPolicy();
+        policy.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
         assertTrue(mReceiver.isReceiverRegisteredForTesting());
 
-        mReceiver.onApplicationStateChange(ApplicationState.HAS_PAUSED_ACTIVITIES);
+        policy.onApplicationStateChange(ApplicationState.HAS_PAUSED_ACTIVITIES);
         assertFalse(mReceiver.isReceiverRegisteredForTesting());
 
-        mReceiver.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
+        policy.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
         assertTrue(mReceiver.isReceiverRegisteredForTesting());
     }
 
     /**
      * Tests that changing the RSSI_CHANGED_ACTION intent updates MaxBandwidth.
      */
     @UiThreadTest
     @MediumTest
     @Feature({"Android-AppBase"})
     public void testNetworkChangeNotifierRSSIEventUpdatesMaxBandwidthForWiFi()
@@ skipping 115 matching lines @@
         assertFalse(observer.hasReceivedNotification());
 
         // Mimic that connectivity has been lost and ensure that Chrome notifies our observer.
         mConnectivityDelegate.setActiveNetworkExists(false);
         Intent noConnectivityIntent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION);
         mReceiver.onReceive(getInstrumentation().getTargetContext(), noConnectivityIntent);
         assertTrue(observer.hasReceivedNotification());
 
         observer.resetHasReceivedNotification();
         // Pretend we got moved to the background.
-        mReceiver.onApplicationStateChange(ApplicationState.HAS_PAUSED_ACTIVITIES);
+        final RegistrationPolicyApplicationStatus policy =
+                (RegistrationPolicyApplicationStatus) mReceiver.getRegistrationPolicy();
+        policy.onApplicationStateChange(ApplicationState.HAS_PAUSED_ACTIVITIES);
         // Change the state.
         mConnectivityDelegate.setActiveNetworkExists(true);
         mConnectivityDelegate.setNetworkType(ConnectivityManager.TYPE_WIFI);
         // The NetworkChangeNotifierAutoDetect doesn't receive any notification while we are in the
         // background, but when we get back to the foreground the state changed should be detected
         // and a notification sent.
-        mReceiver.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
+        policy.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
         assertTrue(observer.hasReceivedNotification());
     }
 
     /**
      * Tests that when setting {@code registerToReceiveNotificationsAlways()},
      * a NetworkChangeNotifierAutoDetect object is successfully created.
      */
     @UiThreadTest
     @MediumTest
     @Feature({"Android-AppBase"})
@@ skipping 39 matching lines @@
      * Tests that NetworkChangeNotifierAutoDetect queryable APIs don't crash. This test cannot rely
      * on having any active network connections so it cannot usefully check results, but it can at
      * least check that the functions don't crash.
      */
     @UiThreadTest
     @MediumTest
     @Feature({"Android-AppBase"})
     public void testQueryableAPIsDoNotCrash() {
         NetworkChangeNotifierAutoDetect.Observer observer =
                 new TestNetworkChangeNotifierAutoDetectObserver();
-        NetworkChangeNotifierAutoDetect ncn = new NetworkChangeNotifierAutoDetect(
-                observer, getInstrumentation().getTargetContext(), true);
+        NetworkChangeNotifierAutoDetect ncn = new NetworkChangeNotifierAutoDetect(observer,
+                getInstrumentation().getTargetContext(), new RegistrationPolicyAlwaysRegister());
         ncn.getNetworksAndTypes();
         ncn.getDefaultNetId();
     }
 
     /**
      * Tests that callbacks are issued to Observers when NetworkChangeNotifierAutoDetect receives
      * the right signals (via its NetworkCallback).
      */
     @MediumTest
     @Feature({"Android-AppBase"})
     public void testNetworkCallbacks() throws Exception {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
             return;
         }
         // Setup NetworkChangeNotifierAutoDetect
         final Context context = getInstrumentation().getTargetContext();
         final TestNetworkChangeNotifierAutoDetectObserver observer =
                 new TestNetworkChangeNotifierAutoDetectObserver();
         Callable<NetworkChangeNotifierAutoDetect> callable =
                 new Callable<NetworkChangeNotifierAutoDetect>() {
                     public NetworkChangeNotifierAutoDetect call() {
                         return new NetworkChangeNotifierAutoDetect(
-                                observer, context, false /* always watch for changes */) {
-                            // This override prevents NetworkChangeNotifierAutoDetect from
-                            // registering for events right off the bat. We'll delay this
-                            // until our MockConnectivityManagerDelegate is first installed
-                            // to prevent inadvertent communication with the real
-                            // ConnectivityManager.
-                            @Override
-                            int getApplicationState() {
-                                return ApplicationState.HAS_PAUSED_ACTIVITIES;
-                            }
-                        };
+                                observer, context, new RegistrationPolicyApplicationStatus() {
+                                    // This override prevents NetworkChangeNotifierAutoDetect from
+                                    // registering for events right off the bat. We'll delay this
+                                    // until our MockConnectivityManagerDelegate is first installed
+                                    // to prevent inadvertent communication with the real
+                                    // ConnectivityManager.
+                                    @Override
+                                    int getApplicationState() {
+                                        return ApplicationState.HAS_PAUSED_ACTIVITIES;
+                                    }
+                                });
                     }
                 };
         FutureTask<NetworkChangeNotifierAutoDetect> task =
                 new FutureTask<NetworkChangeNotifierAutoDetect>(callable);
         ThreadUtils.postOnUiThread(task);
         NetworkChangeNotifierAutoDetect ncn = task.get();
 
         // Insert mock ConnectivityDelegate
         mConnectivityDelegate = new MockConnectivityManagerDelegate();
         ncn.setConnectivityManagerDelegateForTests(mConnectivityDelegate);
         // Now that mock ConnectivityDelegate is inserted, pretend app is foregrounded
         // so NetworkChangeNotifierAutoDetect will register its NetworkCallback.
         assertFalse(ncn.isReceiverRegisteredForTesting());
-        ncn.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
+
+        RegistrationPolicyApplicationStatus policy =
+                (RegistrationPolicyApplicationStatus) mReceiver.getRegistrationPolicy();
+        policy.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
         assertTrue(ncn.isReceiverRegisteredForTesting());
 
         // Find NetworkChangeNotifierAutoDetect's NetworkCallback, which should have been registered
         // with mConnectivityDelegate.
         NetworkCallback networkCallback = mConnectivityDelegate.getLastRegisteredNetworkCallback();
         assertNotNull(networkCallback);
 
         // First thing we'll receive is a purge to initialize any network lists.
         observer.assertLastChange(ChangeType.PURGE_LIST, NetId.INVALID);
 
         // Test connected signal is passed along.
         networkCallback.onAvailable(netIdToNetwork(100));
         observer.assertLastChange(ChangeType.CONNECT, 100);
 
         // Test soon-to-be-disconnected signal is passed along.
         networkCallback.onLosing(netIdToNetwork(101), 30);
         observer.assertLastChange(ChangeType.SOON_TO_DISCONNECT, 101);
 
         // Test connected signal is passed along.
         networkCallback.onLost(netIdToNetwork(102));
         observer.assertLastChange(ChangeType.DISCONNECT, 102);
 
         // Simulate app backgrounding then foregrounding.
         assertTrue(ncn.isReceiverRegisteredForTesting());
-        ncn.onApplicationStateChange(ApplicationState.HAS_PAUSED_ACTIVITIES);
+        policy.onApplicationStateChange(ApplicationState.HAS_PAUSED_ACTIVITIES);
         assertFalse(ncn.isReceiverRegisteredForTesting());
-        ncn.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
+        policy.onApplicationStateChange(ApplicationState.HAS_RUNNING_ACTIVITIES);
         assertTrue(ncn.isReceiverRegisteredForTesting());
         // Verify network list purged.
         observer.assertLastChange(ChangeType.PURGE_LIST, NetId.INVALID);
     }
 }