Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2e1da35b authored by Paul Hu's avatar Paul Hu Committed by android-build-merger
Browse files

Merge "Fix hasUseBackgroundNetworksPermission issue." am: 85e8fd5a am: e0ddf49e 

am: 53b38ab9

Change-Id: I8a1575dedd6e3b7a8b60ee2ffd475d790aec55c4
parents bb3c7ac3 53b38ab9

services/core/java/com/android/server/connectivity/PermissionMonitor.java

+19 −34
Original line number Diff line number Diff line
@@ -229,22 +229,22 @@ public class PermissionMonitor { 
    }



    @VisibleForTesting

    boolean hasPermission(PackageInfo app, String permission) {

        if (app.requestedPermissions != null) {

            for (String p : app.requestedPermissions) {

                if (permission.equals(p)) {

                    return true;

                }

            }

        }

    boolean hasPermission(@NonNull final PackageInfo app, @NonNull final String permission) {

        if (app.requestedPermissions == null || app.requestedPermissionsFlags == null) {

            return false;

        }

        final int index = ArrayUtils.indexOf(app.requestedPermissions, permission);

        if (index < 0 || index >= app.requestedPermissionsFlags.length) return false;

        return (app.requestedPermissionsFlags[index] & REQUESTED_PERMISSION_GRANTED) != 0;

    }



    private boolean hasNetworkPermission(PackageInfo app) {

    @VisibleForTesting

    boolean hasNetworkPermission(@NonNull final PackageInfo app) {

        return hasPermission(app, CHANGE_NETWORK_STATE);

    }



    private boolean hasRestrictedNetworkPermission(PackageInfo app) {

    @VisibleForTesting

    boolean hasRestrictedNetworkPermission(@NonNull final PackageInfo app) {

        // TODO : remove this check in the future(b/31479477). All apps should just

        // request the appropriate permission for their use case since android Q.

        if (app.applicationInfo != null) {
@@ -260,33 +260,18 @@ public class PermissionMonitor { 
            }

        }

        return hasPermission(app, CONNECTIVITY_INTERNAL)

                || hasPermission(app, CONNECTIVITY_USE_RESTRICTED_NETWORKS);

    }



    private boolean hasUseBackgroundNetworksPermission(PackageInfo app) {

        // This function defines what it means to hold the permission to use

        // background networks.

        return hasPermission(app, CHANGE_NETWORK_STATE)

                || hasPermission(app, NETWORK_STACK)

                || hasRestrictedNetworkPermission(app);

                || hasPermission(app, CONNECTIVITY_USE_RESTRICTED_NETWORKS);

    }



    public boolean hasUseBackgroundNetworksPermission(int uid) {

        final String[] names = mPackageManager.getPackagesForUid(uid);

        if (null == names || names.length == 0) return false;

        try {

            // Only using the first package name. There may be multiple names if multiple

            // apps share the same UID, but in that case they also share permissions so

            // querying with any of the names will return the same results.

            int userId = UserHandle.getUserId(uid);

            final PackageInfo app = mPackageManager.getPackageInfoAsUser(

                    names[0], GET_PERMISSIONS, userId);

            return hasUseBackgroundNetworksPermission(app);

        } catch (NameNotFoundException e) {

            // App not found.

            loge("NameNotFoundException " + names[0], e);

            return false;

        }

    /** Returns whether the given uid has using background network permission. */

    public synchronized boolean hasUseBackgroundNetworksPermission(final int uid) {

        // Apps with any of the CHANGE_NETWORK_STATE, NETWORK_STACK, CONNECTIVITY_INTERNAL or

        // CONNECTIVITY_USE_RESTRICTED_NETWORKS permission has the permission to use background

        // networks. mApps contains the result of checks for both hasNetworkPermission and

        // hasRestrictedNetworkPermission. If uid is in the mApps list that means uid has one of

        // permissions at least.

        return mApps.containsKey(uid);

    }



    private int[] toIntArray(Collection<Integer> list) {

tests/net/java/com/android/server/ConnectivityServiceTest.java

+21 −1
Original line number Diff line number Diff line
@@ -16,6 +16,9 @@ 


package com.android.server;



import static android.Manifest.permission.CHANGE_NETWORK_STATE;

import static android.Manifest.permission.CONNECTIVITY_USE_RESTRICTED_NETWORKS;

import static android.content.pm.PackageInfo.REQUESTED_PERMISSION_GRANTED;

import static android.content.pm.PackageManager.GET_PERMISSIONS;

import static android.content.pm.PackageManager.MATCH_ANY_USER;

import static android.net.ConnectivityManager.ACTION_CAPTIVE_PORTAL_SIGN_IN;
@@ -2000,9 +2003,17 @@ public class ConnectivityServiceTest { 
        mCm.unregisterNetworkCallback(trackDefaultCallback);

    }



    private void grantUsingBackgroundNetworksPermissionForUid(final int uid) throws Exception {

        final String testPackageName = mContext.getPackageName();

        when(mPackageManager.getPackageInfo(eq(testPackageName), eq(GET_PERMISSIONS)))

                .thenReturn(buildPackageInfo(true, uid));

        mService.mPermissionMonitor.onPackageAdded(testPackageName, uid);

    }



    @Test

    public void testNetworkGoesIntoBackgroundAfterLinger() throws Exception {

        setAlwaysOnNetworks(true);

        grantUsingBackgroundNetworksPermissionForUid(Binder.getCallingUid());

        NetworkRequest request = new NetworkRequest.Builder()

                .clearCapabilities()

                .build();
@@ -3077,6 +3088,7 @@ public class ConnectivityServiceTest { 
        // Create a background request. We can't do this ourselves because ConnectivityService

        // doesn't have an API for it. So just turn on mobile data always on.

        setAlwaysOnNetworks(true);

        grantUsingBackgroundNetworksPermissionForUid(Binder.getCallingUid());

        final NetworkRequest request = new NetworkRequest.Builder().build();

        final NetworkRequest fgRequest = new NetworkRequest.Builder()

                .addCapability(NET_CAPABILITY_FOREGROUND).build();
@@ -3223,6 +3235,7 @@ public class ConnectivityServiceTest { 


    @Test

    public void testMobileDataAlwaysOn() throws Exception {

        grantUsingBackgroundNetworksPermissionForUid(Binder.getCallingUid());

        final TestNetworkCallback cellNetworkCallback = new TestNetworkCallback();

        final NetworkRequest cellRequest = new NetworkRequest.Builder()

                .addTransportType(TRANSPORT_CELLULAR).build();
@@ -6176,7 +6189,14 @@ public class ConnectivityServiceTest { 


    private static PackageInfo buildPackageInfo(boolean hasSystemPermission, int uid) {

        final PackageInfo packageInfo = new PackageInfo();

        if (hasSystemPermission) {

            packageInfo.requestedPermissions = new String[] {

                    CHANGE_NETWORK_STATE, CONNECTIVITY_USE_RESTRICTED_NETWORKS };

            packageInfo.requestedPermissionsFlags = new int[] {

                    REQUESTED_PERMISSION_GRANTED, REQUESTED_PERMISSION_GRANTED };

        } else {

            packageInfo.requestedPermissions = new String[0];

        }

        packageInfo.applicationInfo = new ApplicationInfo();

        packageInfo.applicationInfo.privateFlags = 0;

        packageInfo.applicationInfo.uid = UserHandle.getUid(UserHandle.USER_SYSTEM,

tests/net/java/com/android/server/connectivity/PermissionMonitorTest.java

+138 −67
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ import static android.content.pm.ApplicationInfo.PRIVATE_FLAG_OEM; 
import static android.content.pm.ApplicationInfo.PRIVATE_FLAG_PRODUCT;

import static android.content.pm.ApplicationInfo.PRIVATE_FLAG_VENDOR;

import static android.content.pm.PackageInfo.REQUESTED_PERMISSION_GRANTED;

import static android.content.pm.PackageInfo.REQUESTED_PERMISSION_REQUIRED;

import static android.content.pm.PackageManager.GET_PERMISSIONS;

import static android.content.pm.PackageManager.MATCH_ANY_USER;

import static android.os.Process.SYSTEM_UID;
@@ -36,6 +37,7 @@ import static com.android.server.connectivity.PermissionMonitor.SYSTEM; 


import static junit.framework.Assert.fail;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;
@@ -102,7 +104,6 @@ public class PermissionMonitorTest { 
    private static final String MOCK_PACKAGE2 = "appName2";

    private static final String SYSTEM_PACKAGE1 = "sysName1";

    private static final String SYSTEM_PACKAGE2 = "sysName2";

    private static final String VPN_PACKAGE = "vpnApp";

    private static final String PARTITION_SYSTEM = "system";

    private static final String PARTITION_OEM = "oem";

    private static final String PARTITION_PRODUCT = "product";
@@ -145,28 +146,31 @@ public class PermissionMonitorTest { 
        mObserver = observerCaptor.getValue();

    }



    private boolean hasBgPermission(String partition, int targetSdkVersion, int uid,

            String... permission) throws Exception {

        final PackageInfo packageInfo = packageInfoWithPermissions(permission, partition);

    private boolean hasRestrictedNetworkPermission(String partition, int targetSdkVersion, int uid,

            String... permissions) {

        final PackageInfo packageInfo =

                packageInfoWithPermissions(REQUESTED_PERMISSION_GRANTED, permissions, partition);

        packageInfo.applicationInfo.targetSdkVersion = targetSdkVersion;

        packageInfo.applicationInfo.uid = uid;

        when(mPackageManager.getPackageInfoAsUser(

                eq(MOCK_PACKAGE1), eq(GET_PERMISSIONS), anyInt())).thenReturn(packageInfo);

        when(mPackageManager.getPackagesForUid(anyInt())).thenReturn(new String[] {MOCK_PACKAGE1});

        return mPermissionMonitor.hasUseBackgroundNetworksPermission(uid);

        return mPermissionMonitor.hasRestrictedNetworkPermission(packageInfo);

    }



    private static PackageInfo packageInfoWithPermissions(String[] permissions, String partition) {

        int[] requestedPermissionsFlags = new int[permissions.length];

        for (int i = 0; i < permissions.length; i++) {

            requestedPermissionsFlags[i] = REQUESTED_PERMISSION_GRANTED;

    private static PackageInfo systemPackageInfoWithPermissions(String... permissions) {

        return packageInfoWithPermissions(

                REQUESTED_PERMISSION_GRANTED, permissions, PARTITION_SYSTEM);

    }

        return packageInfoWithPermissions(permissions, partition,

                requestedPermissionsFlags);



    private static PackageInfo vendorPackageInfoWithPermissions(String... permissions) {

        return packageInfoWithPermissions(

                REQUESTED_PERMISSION_GRANTED, permissions, PARTITION_VENDOR);

    }



    private static PackageInfo packageInfoWithPermissions(String[] permissions, String partition,

            int[] requestedPermissionsFlags) {

    private static PackageInfo packageInfoWithPermissions(int permissionsFlags,

            String[] permissions, String partition) {

        int[] requestedPermissionsFlags = new int[permissions.length];

        for (int i = 0; i < permissions.length; i++) {

            requestedPermissionsFlags[i] = permissionsFlags;

        }

        final PackageInfo packageInfo = new PackageInfo();

        packageInfo.requestedPermissions = permissions;

        packageInfo.applicationInfo = new ApplicationInfo();
@@ -190,12 +194,10 @@ public class PermissionMonitorTest { 
    private static PackageInfo buildPackageInfo(boolean hasSystemPermission, int uid, int userId) {

        final PackageInfo pkgInfo;

        if (hasSystemPermission) {

            final String[] systemPermissions = new String[]{

                    CHANGE_NETWORK_STATE, NETWORK_STACK, CONNECTIVITY_USE_RESTRICTED_NETWORKS

            };

            pkgInfo = packageInfoWithPermissions(systemPermissions, PARTITION_SYSTEM);

            pkgInfo = systemPackageInfoWithPermissions(

                    CHANGE_NETWORK_STATE, NETWORK_STACK, CONNECTIVITY_USE_RESTRICTED_NETWORKS);

        } else {

            pkgInfo = packageInfoWithPermissions(new String[] {}, "");

            pkgInfo = packageInfoWithPermissions(REQUESTED_PERMISSION_GRANTED, new String[] {}, "");

        }

        pkgInfo.applicationInfo.uid = UserHandle.getUid(userId, UserHandle.getAppId(uid));

        return pkgInfo;
@@ -203,82 +205,151 @@ public class PermissionMonitorTest { 


    @Test

    public void testHasPermission() {

        PackageInfo app = packageInfoWithPermissions(new String[] {}, PARTITION_SYSTEM);

        PackageInfo app = systemPackageInfoWithPermissions();

        assertFalse(mPermissionMonitor.hasPermission(app, CHANGE_NETWORK_STATE));

        assertFalse(mPermissionMonitor.hasPermission(app, NETWORK_STACK));

        assertFalse(mPermissionMonitor.hasPermission(app, CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertFalse(mPermissionMonitor.hasPermission(app, CONNECTIVITY_INTERNAL));



        app = packageInfoWithPermissions(new String[] {

            CHANGE_NETWORK_STATE, NETWORK_STACK

        }, PARTITION_SYSTEM);

        app = systemPackageInfoWithPermissions(CHANGE_NETWORK_STATE, NETWORK_STACK);

        assertTrue(mPermissionMonitor.hasPermission(app, CHANGE_NETWORK_STATE));

        assertTrue(mPermissionMonitor.hasPermission(app, NETWORK_STACK));

        assertFalse(mPermissionMonitor.hasPermission(app, CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertFalse(mPermissionMonitor.hasPermission(app, CONNECTIVITY_INTERNAL));



        app = packageInfoWithPermissions(new String[] {

            CONNECTIVITY_USE_RESTRICTED_NETWORKS, CONNECTIVITY_INTERNAL

        }, PARTITION_SYSTEM);

        app = systemPackageInfoWithPermissions(

                CONNECTIVITY_USE_RESTRICTED_NETWORKS, CONNECTIVITY_INTERNAL);

        assertFalse(mPermissionMonitor.hasPermission(app, CHANGE_NETWORK_STATE));

        assertFalse(mPermissionMonitor.hasPermission(app, NETWORK_STACK));

        assertTrue(mPermissionMonitor.hasPermission(app, CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertTrue(mPermissionMonitor.hasPermission(app, CONNECTIVITY_INTERNAL));



        app = packageInfoWithPermissions(REQUESTED_PERMISSION_REQUIRED, new String[] {

                CONNECTIVITY_USE_RESTRICTED_NETWORKS, CONNECTIVITY_INTERNAL, NETWORK_STACK },

                PARTITION_SYSTEM);

        assertFalse(mPermissionMonitor.hasPermission(app, CHANGE_NETWORK_STATE));

        assertFalse(mPermissionMonitor.hasPermission(app, NETWORK_STACK));

        assertFalse(mPermissionMonitor.hasPermission(app, CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertFalse(mPermissionMonitor.hasPermission(app, CONNECTIVITY_INTERNAL));



        app = systemPackageInfoWithPermissions(CHANGE_NETWORK_STATE);

        app.requestedPermissions = null;

        assertFalse(mPermissionMonitor.hasPermission(app, CHANGE_NETWORK_STATE));



        app = systemPackageInfoWithPermissions(CHANGE_NETWORK_STATE);

        app.requestedPermissionsFlags = null;

        assertFalse(mPermissionMonitor.hasPermission(app, CHANGE_NETWORK_STATE));

    }



    @Test

    public void testIsVendorApp() {

        PackageInfo app = packageInfoWithPermissions(new String[] {}, PARTITION_SYSTEM);

        PackageInfo app = systemPackageInfoWithPermissions();

        assertFalse(mPermissionMonitor.isVendorApp(app.applicationInfo));

        app = packageInfoWithPermissions(new String[] {}, PARTITION_OEM);

        app = packageInfoWithPermissions(REQUESTED_PERMISSION_GRANTED,

                new String[] {}, PARTITION_OEM);

        assertTrue(mPermissionMonitor.isVendorApp(app.applicationInfo));

        app = packageInfoWithPermissions(new String[] {}, PARTITION_PRODUCT);

        app = packageInfoWithPermissions(REQUESTED_PERMISSION_GRANTED,

                new String[] {}, PARTITION_PRODUCT);

        assertTrue(mPermissionMonitor.isVendorApp(app.applicationInfo));

        app = packageInfoWithPermissions(new String[] {}, PARTITION_VENDOR);

        app = vendorPackageInfoWithPermissions();

        assertTrue(mPermissionMonitor.isVendorApp(app.applicationInfo));

    }



    @Test

    public void testHasUseBackgroundNetworksPermission() throws Exception {

        assertFalse(hasBgPermission(PARTITION_SYSTEM, VERSION_P, MOCK_UID1));

        assertTrue(hasBgPermission(PARTITION_SYSTEM, VERSION_P, MOCK_UID1, CHANGE_NETWORK_STATE));

        assertTrue(hasBgPermission(PARTITION_SYSTEM, VERSION_P, MOCK_UID1, NETWORK_STACK));

        assertTrue(hasBgPermission(PARTITION_SYSTEM, VERSION_P, MOCK_UID1, CONNECTIVITY_INTERNAL));

        assertTrue(hasBgPermission(PARTITION_SYSTEM, VERSION_P, MOCK_UID1,

                CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertFalse(hasBgPermission(PARTITION_SYSTEM, VERSION_P, MOCK_UID1, CHANGE_WIFI_STATE));

    public void testHasNetworkPermission() {

        PackageInfo app = systemPackageInfoWithPermissions();

        assertFalse(mPermissionMonitor.hasNetworkPermission(app));

        app = systemPackageInfoWithPermissions(CHANGE_NETWORK_STATE);

        assertTrue(mPermissionMonitor.hasNetworkPermission(app));

        app = systemPackageInfoWithPermissions(NETWORK_STACK);

        assertFalse(mPermissionMonitor.hasNetworkPermission(app));

        app = systemPackageInfoWithPermissions(CONNECTIVITY_USE_RESTRICTED_NETWORKS);

        assertFalse(mPermissionMonitor.hasNetworkPermission(app));

    }



        assertFalse(hasBgPermission(PARTITION_SYSTEM, VERSION_Q, MOCK_UID1));

        assertFalse(hasBgPermission(PARTITION_SYSTEM, VERSION_Q, MOCK_UID1, CHANGE_WIFI_STATE));

    @Test

    public void testHasRestrictedNetworkPermission() {

        assertFalse(hasRestrictedNetworkPermission(PARTITION_SYSTEM, VERSION_P, MOCK_UID1));

        assertFalse(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_P, MOCK_UID1, CHANGE_NETWORK_STATE));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_P, MOCK_UID1, NETWORK_STACK));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_P, MOCK_UID1, CONNECTIVITY_INTERNAL));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_P, MOCK_UID1, CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertFalse(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_P, MOCK_UID1, CHANGE_WIFI_STATE));



        assertFalse(hasRestrictedNetworkPermission(PARTITION_SYSTEM, VERSION_Q, MOCK_UID1));

        assertFalse(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_Q, MOCK_UID1, CHANGE_WIFI_STATE));

    }



    @Test

    public void testHasUseBackgroundNetworksPermissionSystemUid() throws Exception {

    public void testHasRestrictedNetworkPermissionSystemUid() {

        doReturn(VERSION_P).when(mPermissionMonitor).getDeviceFirstSdkInt();

        assertTrue(hasBgPermission(PARTITION_SYSTEM, VERSION_P, SYSTEM_UID));

        assertTrue(hasBgPermission(PARTITION_SYSTEM, VERSION_P, SYSTEM_UID, CHANGE_WIFI_STATE));

        assertTrue(hasBgPermission(PARTITION_SYSTEM, VERSION_P, SYSTEM_UID,

                CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertTrue(hasRestrictedNetworkPermission(PARTITION_SYSTEM, VERSION_P, SYSTEM_UID));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_P, SYSTEM_UID, CHANGE_WIFI_STATE));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_P, SYSTEM_UID, CONNECTIVITY_USE_RESTRICTED_NETWORKS));



        doReturn(VERSION_Q).when(mPermissionMonitor).getDeviceFirstSdkInt();

        assertFalse(hasBgPermission(PARTITION_SYSTEM, VERSION_Q, SYSTEM_UID));

        assertFalse(hasBgPermission(PARTITION_SYSTEM, VERSION_Q, SYSTEM_UID, CHANGE_WIFI_STATE));

        assertTrue(hasBgPermission(PARTITION_SYSTEM, VERSION_Q, SYSTEM_UID,

                CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertFalse(hasRestrictedNetworkPermission(PARTITION_SYSTEM, VERSION_Q, SYSTEM_UID));

        assertFalse(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_Q, SYSTEM_UID, CHANGE_WIFI_STATE));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_SYSTEM, VERSION_Q, SYSTEM_UID, CONNECTIVITY_USE_RESTRICTED_NETWORKS));

    }



    @Test

    public void testHasUseBackgroundNetworksPermissionVendorApp() throws Exception {

        assertTrue(hasBgPermission(PARTITION_VENDOR, VERSION_P, MOCK_UID1));

        assertTrue(hasBgPermission(PARTITION_VENDOR, VERSION_P, MOCK_UID1, CHANGE_NETWORK_STATE));

        assertTrue(hasBgPermission(PARTITION_VENDOR, VERSION_P, MOCK_UID1, NETWORK_STACK));

        assertTrue(hasBgPermission(PARTITION_VENDOR, VERSION_P, MOCK_UID1, CONNECTIVITY_INTERNAL));

        assertTrue(hasBgPermission(PARTITION_VENDOR, VERSION_P, MOCK_UID1,

                CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertTrue(hasBgPermission(PARTITION_VENDOR, VERSION_P, MOCK_UID1, CHANGE_WIFI_STATE));

    public void testHasRestrictedNetworkPermissionVendorApp() {

        assertTrue(hasRestrictedNetworkPermission(PARTITION_VENDOR, VERSION_P, MOCK_UID1));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_VENDOR, VERSION_P, MOCK_UID1, CHANGE_NETWORK_STATE));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_VENDOR, VERSION_P, MOCK_UID1, NETWORK_STACK));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_VENDOR, VERSION_P, MOCK_UID1, CONNECTIVITY_INTERNAL));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_VENDOR, VERSION_P, MOCK_UID1, CONNECTIVITY_USE_RESTRICTED_NETWORKS));

        assertTrue(hasRestrictedNetworkPermission(

                PARTITION_VENDOR, VERSION_P, MOCK_UID1, CHANGE_WIFI_STATE));



        assertFalse(hasRestrictedNetworkPermission(PARTITION_VENDOR, VERSION_Q, MOCK_UID1));

        assertFalse(hasRestrictedNetworkPermission(

                PARTITION_VENDOR, VERSION_Q, MOCK_UID1, CHANGE_WIFI_STATE));

        assertFalse(hasRestrictedNetworkPermission(

                PARTITION_VENDOR, VERSION_Q, MOCK_UID1, CHANGE_NETWORK_STATE));

    }



    private void assertBackgroundPermission(boolean hasPermission, String name, int uid,

            String... permissions) throws Exception {

        when(mPackageManager.getPackageInfo(eq(name), anyInt()))

                .thenReturn(packageInfoWithPermissions(

                        REQUESTED_PERMISSION_GRANTED, permissions, PARTITION_SYSTEM));

        mPermissionMonitor.onPackageAdded(name, uid);

        assertEquals(hasPermission, mPermissionMonitor.hasUseBackgroundNetworksPermission(uid));

    }



    @Test

    public void testHasUseBackgroundNetworksPermission() throws Exception {

        assertFalse(mPermissionMonitor.hasUseBackgroundNetworksPermission(SYSTEM_UID));

        assertBackgroundPermission(false, SYSTEM_PACKAGE1, SYSTEM_UID);

        assertBackgroundPermission(false, SYSTEM_PACKAGE1, SYSTEM_UID, CHANGE_WIFI_STATE);

        assertBackgroundPermission(true, SYSTEM_PACKAGE1, SYSTEM_UID, CHANGE_NETWORK_STATE);

        assertBackgroundPermission(true, SYSTEM_PACKAGE1, SYSTEM_UID, NETWORK_STACK);



        assertFalse(mPermissionMonitor.hasUseBackgroundNetworksPermission(MOCK_UID1));

        assertBackgroundPermission(false, MOCK_PACKAGE1, MOCK_UID1);

        assertBackgroundPermission(true, MOCK_PACKAGE1, MOCK_UID1,

                CONNECTIVITY_USE_RESTRICTED_NETWORKS);



        assertFalse(hasBgPermission(PARTITION_VENDOR, VERSION_Q, MOCK_UID1));

        assertFalse(hasBgPermission(PARTITION_VENDOR, VERSION_Q, MOCK_UID1, CHANGE_WIFI_STATE));

        assertFalse(mPermissionMonitor.hasUseBackgroundNetworksPermission(MOCK_UID2));

        assertBackgroundPermission(false, MOCK_PACKAGE2, MOCK_UID2);

        assertBackgroundPermission(true, MOCK_PACKAGE2, MOCK_UID2,

                CONNECTIVITY_INTERNAL);

    }



    private class NetdMonitor {
@@ -563,7 +634,8 @@ public class PermissionMonitorTest { 


    private PackageInfo setPackagePermissions(String packageName, int uid, String[] permissions)

            throws Exception {

        PackageInfo packageInfo = packageInfoWithPermissions(permissions, PARTITION_SYSTEM);

        PackageInfo packageInfo = packageInfoWithPermissions(

                REQUESTED_PERMISSION_GRANTED, permissions, PARTITION_SYSTEM);

        when(mPackageManager.getPackageInfo(eq(packageName), anyInt())).thenReturn(packageInfo);

        when(mPackageManager.getPackagesForUid(eq(uid))).thenReturn(new String[]{packageName});

        return packageInfo;
@@ -599,7 +671,7 @@ public class PermissionMonitorTest { 


        // Install another package with the same uid and no permissions should not cause the UID to

        // lose permissions.

        PackageInfo packageInfo2 = packageInfoWithPermissions(new String[]{}, PARTITION_SYSTEM);

        PackageInfo packageInfo2 = systemPackageInfoWithPermissions();

        when(mPackageManager.getPackageInfo(eq(MOCK_PACKAGE2), anyInt())).thenReturn(packageInfo2);

        when(mPackageManager.getPackagesForUid(MOCK_UID1))

              .thenReturn(new String[]{MOCK_PACKAGE1, MOCK_PACKAGE2});
@@ -660,8 +732,7 @@ public class PermissionMonitorTest { 
                | INetd.PERMISSION_UPDATE_DEVICE_STATS, new int[]{MOCK_UID1});



        // Mock another package with the same uid but different permissions.

        PackageInfo packageInfo2 = packageInfoWithPermissions(new String[] {INTERNET},

                PARTITION_SYSTEM);

        PackageInfo packageInfo2 = systemPackageInfoWithPermissions(INTERNET);

        when(mPackageManager.getPackageInfo(eq(MOCK_PACKAGE2), anyInt())).thenReturn(packageInfo2);

        when(mPackageManager.getPackagesForUid(MOCK_UID1)).thenReturn(new String[]{

                MOCK_PACKAGE2});