Use fallback mechanism to obtain connected WiFi information in pre-M devices when Location permissi…

chrome/android/junit/src/org/chromium/chrome/browser/omnibox/geo/PlatformNetworksManagerTest.java

 // Copyright 2017 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.chrome.browser.omnibox.geo;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.argThat;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.Manifest;
 import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.os.Build;
 import android.telephony.CellIdentityCdma;
 import android.telephony.CellIdentityGsm;
 import android.telephony.CellIdentityLte;
 import android.telephony.CellIdentityWcdma;
 import android.telephony.CellInfoCdma;
 import android.telephony.CellInfoGsm;
 import android.telephony.CellInfoLte;
 import android.telephony.CellInfoWcdma;
 import android.telephony.TelephonyManager;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentMatcher;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.annotation.Config;
 import org.robolectric.util.ReflectionHelpers;
 
 import org.chromium.chrome.browser.omnibox.geo.VisibleNetworks.VisibleCell;
 import org.chromium.chrome.browser.omnibox.geo.VisibleNetworks.VisibleWifi;
 import org.chromium.testing.local.LocalRobolectricTestRunner;
 
 import java.util.Arrays;
@@ skipping 87 matching lines @@
     @Mock
     private CellInfoCdma mCellInfoCdma;
     @Mock
     private CellIdentityLte mCellIdentityLte;
     @Mock
     private CellIdentityWcdma mCellIdentityWcdma;
     @Mock
     private CellIdentityGsm mCellIdentityGsm;
     @Mock
     private CellIdentityCdma mCellIdentityCdma;
+    @Mock
+    private Intent mNetworkStateChangedIntent;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         PlatformNetworksManager.sTimeProvider = new PlatformNetworksManager.TimeProvider() {
             @Override
             public long getCurrentTime() {
                 return CURRENT_TIME_MS;
             }
             @Override
@@ skipping 60 matching lines @@
         when(mCellIdentityCdma.getNetworkId()).thenReturn(CDMA_CELL.locationAreaCode().intValue());
         when(mCellIdentityCdma.getSystemId()).thenReturn(CDMA_CELL.mobileNetworkCode().intValue());
         when(mCellInfoCdma.getCellIdentity()).thenReturn(mCellIdentityCdma);
         when(mCellInfoCdma.isRegistered()).thenReturn(false);
         when(mCellInfoCdma.getTimeStamp())
                 .thenReturn(TimeUnit.MILLISECONDS.toNanos(CURRENT_ELAPSED_TIME_MS - CDMA_CELL_AGE));
         when(mTelephonyManager.getAllCellInfo())
                 .thenReturn(
                         Arrays.asList(mCellInfoLte, mCellInfoWcdma, mCellInfoGsm, mCellInfoCdma));
         allPermissionsGranted();
+
+        when(mContext.registerReceiver(eq(null), any(IntentFilter.class)))
+                .thenReturn(mNetworkStateChangedIntent);
+        when(mNetworkStateChangedIntent.getParcelableExtra(eq(WifiManager.EXTRA_WIFI_INFO)))
+                .thenReturn(mWifiInfo);
     }
 
     @Test
     public void testGetConnectedCell_JBMR1() {
         ReflectionHelpers.setStaticField(
                 Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.JELLY_BEAN_MR1);
         VisibleCell visibleCell =
                 PlatformNetworksManager.getConnectedCell(mContext, mTelephonyManager);
         assertEquals(LTE_CELL, visibleCell);
         assertEquals(visibleCell.timestampMs(), Long.valueOf(CURRENT_TIME_MS - LTE_CELL_AGE));
@@ skipping 128 matching lines @@
     public void testGetConnectedWifi_allPermissionsDenied() {
         ReflectionHelpers.setStaticField(Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.M);
         allPermissionsDenied();
         VisibleWifi visibleWifi = PlatformNetworksManager.getConnectedWifi(mContext, mWifiManager);
         assertEquals(UNKNOWN_VISIBLE_WIFI, visibleWifi);
         assertNull(visibleWifi.timestampMs());
     }
 
     @Test
     public void testGetConnectedWifi_locationGrantedWifiDenied() {
-        ReflectionHelpers.setStaticField(Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.M);
+        ReflectionHelpers.setStaticField(
+                Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.LOLLIPOP);
         locationGrantedWifiDenied();
         VisibleWifi visibleWifi = PlatformNetworksManager.getConnectedWifi(mContext, mWifiManager);
+        assertEquals(CONNECTED_WIFI, visibleWifi);
+        assertEquals(Long.valueOf(CURRENT_TIME_MS), visibleWifi.timestampMs());
+        verifyNetworkStateAction();
+    }
+
+    @Test
+    public void testGetConnectedWifi_locationGrantedWifiDenied_noWifiInfo() {
+        ReflectionHelpers.setStaticField(
+                Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.LOLLIPOP);
+        locationGrantedWifiDenied();
+        when(mNetworkStateChangedIntent.getParcelableExtra(eq(WifiManager.EXTRA_WIFI_INFO)))
+                .thenReturn(null);
+        VisibleWifi visibleWifi = PlatformNetworksManager.getConnectedWifi(mContext, mWifiManager);
         assertEquals(UNKNOWN_VISIBLE_WIFI, visibleWifi);
         assertNull(visibleWifi.timestampMs());
+        verifyNetworkStateAction();
     }
 
     @Test
     public void testGetConnectedWifi_locationDeniedWifiGranted() {
         ReflectionHelpers.setStaticField(Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.M);
         locationDeniedWifiGranted();
         VisibleWifi visibleWifi = PlatformNetworksManager.getConnectedWifi(mContext, mWifiManager);
         assertEquals(UNKNOWN_VISIBLE_WIFI, visibleWifi);
         assertNull(visibleWifi.timestampMs());
     }
@@ skipping 95 matching lines @@
                 mContext, true /* includeAllVisibleNotConnectedNetworks */);
 
         assertTrue(visibleNetworks.isEmpty());
     }
 
     @Test
     public void testComputeVisibleNetworks_locationGrantedWifiDenied() {
         Set<VisibleCell> expectedVisibleCells =
                 new HashSet<VisibleCell>(Arrays.asList(LTE_CELL, WCDMA_CELL, GSM_CELL, CDMA_CELL));
         Set<VisibleWifi> expectedVisibleWifis = Collections.emptySet();
-        VisibleNetworks expectedVisibleNetworks =
-                VisibleNetworks.create(null, LTE_CELL, expectedVisibleWifis, expectedVisibleCells);
+        VisibleNetworks expectedVisibleNetworks = VisibleNetworks.create(
+                CONNECTED_WIFI, LTE_CELL, expectedVisibleWifis, expectedVisibleCells);
         locationGrantedWifiDenied();
 
         VisibleNetworks visibleNetworks = PlatformNetworksManager.computeVisibleNetworks(
                 mContext, true /* includeAllVisibleNotConnectedNetworks */);
 
         assertEquals(expectedVisibleNetworks, visibleNetworks);
+        verifyNetworkStateAction();
     }
 
     @Test
     public void testComputeVisibleNetworks_locationDeniedWifiGranted() {
         Set<VisibleCell> expectedVisibleCells = Collections.emptySet();
         Set<VisibleWifi> expectedVisibleWifis = Collections.emptySet();
         locationDeniedWifiGranted();
         VisibleNetworks expectedVisibleNetworks =
                 VisibleNetworks.create(null, null, expectedVisibleWifis, expectedVisibleCells);
 
@@ skipping 31 matching lines @@
         when(mContext.checkPermission(eq(Manifest.permission.ACCESS_COARSE_LOCATION),
                      any(Integer.class), any(Integer.class)))
                 .thenReturn(coarseLocationPermission);
         when(mContext.checkPermission(eq(Manifest.permission.ACCESS_FINE_LOCATION),
                      any(Integer.class), any(Integer.class)))
                 .thenReturn(fineLocationPermission);
         when(mContext.checkPermission(eq(Manifest.permission.ACCESS_WIFI_STATE), any(Integer.class),
                      any(Integer.class)))
                 .thenReturn(wifiStatePermission);
     }
+
+    private void verifyNetworkStateAction() {
+        verify(mContext).registerReceiver(eq(null), argThat(new ArgumentMatcher<IntentFilter>() {
+            @Override
+            public boolean matches(IntentFilter intentFilter) {
+                return intentFilter.hasAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+            }
+        }));
+    }
 }