Merge changes I54360698,Ic8a3db21

* changes:
  Finish removing N/A DO disclosures from search index
  DO Disclosures: Combine personal and work CA cert

res/values/strings.xml

@@ -8246,10 +8246,8 @@
     <string name="enterprise_privacy_always_on_vpn_work">Always-on VPN turned on in your work profile</string>
     <!-- Label explaining that a global HTTP proxy was set by the admin. [CHAR LIMIT=NONE] -->
     <string name="enterprise_privacy_global_http_proxy">Global HTTP proxy set</string>
-    <!-- Label explaining that the admin installed trusted CA certificates for the current user. [CHAR LIMIT=NONE] -->
+    <!-- Label explaining that the admin installed trusted CA certificates. [CHAR LIMIT=NONE] -->
-    <string name="enterprise_privacy_ca_certs_user">Trusted credentials</string>
+    <string name="enterprise_privacy_ca_certs">Trusted credentials</string>
-    <!-- Label explaining that the admin installed trusted CA certificates for the personal profile. [CHAR LIMIT=NONE] -->
-    <string name="enterprise_privacy_ca_certs_personal">Trusted credentials in your personal profile</string>
     <!-- Summary indicating the number of trusted CA certificates installed by the admin. [CHAR LIMIT=NONE] -->
     <plurals name="enterprise_privacy_number_ca_certs">
         <item quantity="one"><xliff:g id="count">%d</xliff:g> CA certificate</item>
@@ -8260,8 +8258,6 @@
         <item quantity="one"><xliff:g id="count">%d</xliff:g> CA certificate. Tap to view.</item>
         <item quantity="other"><xliff:g id="count">%d</xliff:g> CA certificates. Tap to view.</item>
     </plurals>
-    <!-- Label explaining that the admin installed trusted CA certificates for the work profile. [CHAR LIMIT=NONE] -->
-    <string name="enterprise_privacy_ca_certs_work">Trusted credentials in your work profile</string>
     <!-- Label explaining that the admin can lock the device and change the user's password. [CHAR LIMIT=NONE] -->
     <string name="enterprise_privacy_lock_device">Admin can lock the device and reset password</string>
     <!-- Label explaining that the admin can wipe the device remotely. [CHAR LIMIT=NONE] -->

res/xml/enterprise_privacy_settings.xml

@@ -90,11 +90,8 @@
                 android:title="@string/enterprise_privacy_global_http_proxy"
                 settings:multiLine="true"/>
         <com.android.settings.DividerPreference
-                android:key="ca_certs_current_user"
+                android:key="ca_certs"
-                settings:multiLine="true"/>
+                android:title="@string/enterprise_privacy_ca_certs"
-        <com.android.settings.DividerPreference
-                android:key="ca_certs_managed_profile"
-                android:title="@string/enterprise_privacy_ca_certs_work"
                 settings:multiLine="true"/>
     </PreferenceCategory>
 

src/com/android/settings/applications/ApplicationFeatureProvider.java

@@ -54,9 +54,10 @@ public interface ApplicationFeatureProvider {
      *
      * @param permissions Only consider apps that have been granted one or more of these permissions
      *        by the admin, either at run-time or install-time
+     * @param async Whether to count asynchronously in a background thread
      * @param callback The callback to invoke with the result
      */
-    void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions,
+    void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions, boolean async,
             NumberOfAppsCallback callback);
 
     /**

src/com/android/settings/applications/ApplicationFeatureProviderImpl.java

@@ -69,9 +69,15 @@ public class ApplicationFeatureProviderImpl implements ApplicationFeatureProvide
 
     @Override
     public void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions,
-            NumberOfAppsCallback callback) {
+            boolean async, NumberOfAppsCallback callback) {
-        new AllUserAppWithAdminGrantedPermissionsCounter(mContext, permissions, mPm, mPms, mDpm,
+        final AllUserAppWithAdminGrantedPermissionsCounter counter =
-                callback).execute();
+                new AllUserAppWithAdminGrantedPermissionsCounter(mContext, permissions, mPm, mPms,
+                        mDpm, callback);
+        if (async) {
+            counter.execute();
+        } else {
+            counter.executeInForeground();
+        }
     }
 
     @Override

src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java

@@ -17,14 +17,18 @@ package com.android.settings.enterprise;
 import android.Manifest;
 import android.content.Context;
 
+import com.android.settings.core.lifecycle.Lifecycle;
+
 public class AdminGrantedCameraPermissionPreferenceController extends
         AdminGrantedPermissionsPreferenceControllerBase {
 
     private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_CAMERA_ACCESS_PACKAGES
             = "enterprise_privacy_number_camera_access_packages";
 
-    public AdminGrantedCameraPermissionPreferenceController(Context context) {
+    public AdminGrantedCameraPermissionPreferenceController(Context context, Lifecycle lifecycle,
-        super(context, new String[] {Manifest.permission.CAMERA}, Manifest.permission_group.CAMERA);
+            boolean async) {
+        super(context, lifecycle, async, new String[] {Manifest.permission.CAMERA},
+                Manifest.permission_group.CAMERA);
     }
 
     @Override

src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java

@@ -17,14 +17,17 @@ package com.android.settings.enterprise;
 import android.Manifest;
 import android.content.Context;
 
+import com.android.settings.core.lifecycle.Lifecycle;
+
 public class AdminGrantedLocationPermissionsPreferenceController extends
         AdminGrantedPermissionsPreferenceControllerBase {
 
     private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_LOCATION_ACCESS_PACKAGES
             = "enterprise_privacy_number_location_access_packages";
 
-    public AdminGrantedLocationPermissionsPreferenceController(Context context) {
+    public AdminGrantedLocationPermissionsPreferenceController(Context context, Lifecycle lifecycle,
-        super(context, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION,
+            boolean async) {
+        super(context, lifecycle, async, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION,
                 Manifest.permission.ACCESS_FINE_LOCATION}, Manifest.permission_group.LOCATION);
     }
 

src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java

@@ -17,14 +17,17 @@ package com.android.settings.enterprise;
 import android.Manifest;
 import android.content.Context;
 
+import com.android.settings.core.lifecycle.Lifecycle;
+
 public class AdminGrantedMicrophonePermissionPreferenceController extends
         AdminGrantedPermissionsPreferenceControllerBase {
 
     private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_MICROPHONE_ACCESS_PACKAGES
             = "enterprise_privacy_number_microphone_access_packages";
 
-    public AdminGrantedMicrophonePermissionPreferenceController(Context context) {
+    public AdminGrantedMicrophonePermissionPreferenceController(Context context,
-        super(context, new String[] {Manifest.permission.RECORD_AUDIO},
+            Lifecycle lifecycle, boolean async) {
+        super(context, lifecycle, async, new String[] {Manifest.permission.RECORD_AUDIO},
                 Manifest.permission_group.MICROPHONE);
     }
 

src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java

@@ -1,3 +1,4 @@
+
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -20,28 +21,32 @@ import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
 import com.android.settings.applications.ApplicationFeatureProvider;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public abstract class AdminGrantedPermissionsPreferenceControllerBase extends PreferenceController {
+public abstract class AdminGrantedPermissionsPreferenceControllerBase
+        extends DynamicAvailabilityPreferenceController {
 
     private final String[] mPermissions;
     private final String mPermissionGroup;
     private final ApplicationFeatureProvider mFeatureProvider;
+    private final boolean mAsync;
 
-    public AdminGrantedPermissionsPreferenceControllerBase(Context context,
+    public AdminGrantedPermissionsPreferenceControllerBase(Context context, Lifecycle lifecycle,
-                                                           String[] permissions,
+            boolean async, String[] permissions, String permissionGroup) {
-                                                           String permissionGroup) {
+        super(context, lifecycle);
-        super(context);
         mPermissions = permissions;
         mPermissionGroup = permissionGroup;
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getApplicationFeatureProvider(context);
+        mAsync = async;
     }
 
     @Override
     public void updateState(Preference preference) {
         mFeatureProvider.calculateNumberOfAppsWithAdminGrantedPermissions(mPermissions,
+                true /* async */,
                 (num) -> {
                     if (num == 0) {
                         preference.setVisible(false);
@@ -55,9 +60,24 @@ public abstract class AdminGrantedPermissionsPreferenceControllerBase extends Pr
 
     @Override
     public boolean isAvailable() {
+        if (mAsync) {
+            // When called on the main UI thread, we must not block. Since calculating the number of
+            // apps that the admin has granted a given permissions takes a bit of time, we always
+            // return true here and determine the pref's actual visibility asynchronously in
+            // updateState().
             return true;
         }
 
+        // When called by the search indexer, we are on a background thread that we can block. Also,
+        // changes to the pref's visibility made in updateState() would not be seen by the indexer.
+        // We block and return synchronously whether the admin has granted the given permissions to
+        // any apps or not.
+        final Boolean[] haveAppsWithAdminGrantedPermissions = { null };
+        mFeatureProvider.calculateNumberOfAppsWithAdminGrantedPermissions(mPermissions,
+                false /* async */, (num) -> haveAppsWithAdminGrantedPermissions[0] = num > 0);
+        return haveAppsWithAdminGrantedPermissions[0];
+    }
+
     @Override
     public boolean handlePreferenceTreeClick(Preference preference) {
         if (!getPreferenceKey().equals(preference.getKey())) {

src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java

@@ -14,30 +14,26 @@
 package com.android.settings.enterprise;
 
 import android.content.Context;
-import android.support.v7.preference.Preference;
 
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class AlwaysOnVpnManagedProfilePreferenceController extends PreferenceController {
+public class AlwaysOnVpnManagedProfilePreferenceController
+        extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_ALWAYS_ON_VPN_MANAGED_PROFILE = "always_on_vpn_managed_profile";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public AlwaysOnVpnManagedProfilePreferenceController(Context context) {
+    public AlwaysOnVpnManagedProfilePreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
 
-    @Override
-    public void updateState(Preference preference) {
-        preference.setVisible(mFeatureProvider.isAlwaysOnVpnSetInManagedProfile());
-    }
-
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.isAlwaysOnVpnSetInManagedProfile();
     }
 
     @Override

src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceController.java

@@ -17,16 +17,18 @@ import android.content.Context;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class AlwaysOnVpnPrimaryUserPreferenceController extends PreferenceController {
+public class AlwaysOnVpnPrimaryUserPreferenceController
+        extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_ALWAYS_ON_VPN_PRIMARY_USER = "always_on_vpn_primary_user";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public AlwaysOnVpnPrimaryUserPreferenceController(Context context) {
+    public AlwaysOnVpnPrimaryUserPreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
@@ -36,12 +38,11 @@ public class AlwaysOnVpnPrimaryUserPreferenceController extends PreferenceContro
         preference.setTitle(mFeatureProvider.isInCompMode()
                 ? R.string.enterprise_privacy_always_on_vpn_personal
                 : R.string.enterprise_privacy_always_on_vpn_device);
-        preference.setVisible(mFeatureProvider.isAlwaysOnVpnSetInPrimaryUser());
     }
 
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.isAlwaysOnVpnSetInPrimaryUser();
     }
 
     @Override

src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceController.java

@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the
- * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package com.android.settings.enterprise;
-
-import android.content.Context;
-import android.content.res.Resources;
-import android.support.v7.preference.Preference;
-
-import com.android.settings.R;
-import com.android.settings.core.PreferenceController;
-import com.android.settings.overlay.FeatureFactory;
-
-public class CaCertsCurrentUserPreferenceController extends PreferenceController {
-
-    private static final String CA_CERTS_CURRENT_USER = "ca_certs_current_user";
-    private final EnterprisePrivacyFeatureProvider mFeatureProvider;
-
-    public CaCertsCurrentUserPreferenceController(Context context) {
-        super(context);
-        mFeatureProvider = FeatureFactory.getFactory(context)
-                .getEnterprisePrivacyFeatureProvider(context);
-    }
-
-    @Override
-    public void updateState(Preference preference) {
-        final int certs = mFeatureProvider.getNumberOfOwnerInstalledCaCertsInCurrentUser();
-        if (certs == 0) {
-            preference.setVisible(false);
-            return;
-        }
-        preference.setTitle(mFeatureProvider.isInCompMode()
-                ? R.string.enterprise_privacy_ca_certs_personal
-                : R.string.enterprise_privacy_ca_certs_user);
-        preference.setSummary(mContext.getResources().getQuantityString(
-                R.plurals.enterprise_privacy_number_ca_certs, certs, certs));
-        preference.setVisible(true);
-    }
-
-    @Override
-    public boolean isAvailable() {
-        return true;
-    }
-
-    @Override
-    public String getPreferenceKey() {
-        return CA_CERTS_CURRENT_USER;
-    }
-}

src/com/android/settings/enterprise/CaCertsPreferenceController.java

@@ -19,39 +19,37 @@ import android.content.res.Resources;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class CaCertsManagedProfilePreferenceController extends PreferenceController {
+public class CaCertsPreferenceController extends DynamicAvailabilityPreferenceController {
 
-    private static final String KEY_CA_CERTS_MANAGED_PROFILE = "ca_certs_managed_profile";
+    private static final String CA_CERTS = "ca_certs";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public CaCertsManagedProfilePreferenceController(Context context) {
+    public CaCertsPreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
 
     @Override
     public void updateState(Preference preference) {
-        final int certs = mFeatureProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile();
+        final int certs =
-        if (certs == 0) {
+                mFeatureProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile();
-            preference.setVisible(false);
-            return;
-        }
         preference.setSummary(mContext.getResources().getQuantityString(
                 R.plurals.enterprise_privacy_number_ca_certs, certs, certs));
-        preference.setVisible(true);
     }
 
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()
+                > 0;
     }
 
     @Override
     public String getPreferenceKey() {
-        return KEY_CA_CERTS_MANAGED_PROFILE;
+        return CA_CERTS;
     }
 }

src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java

@@ -98,15 +98,9 @@ public interface EnterprisePrivacyFeatureProvider {
 
     /**
      * Returns the number of CA certificates that the Device Owner or Profile Owner installed in
-     * the current user.
+     * the current user and the user's managed profile (if any).
      */
-    int getNumberOfOwnerInstalledCaCertsInCurrentUser();
+    int getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile();
-
-    /**
-     * Returns the number of CA certificates that the Profile Owner installed in the current user's
-     * managed profile (if any).
-     */
-    int getNumberOfOwnerInstalledCaCertsInManagedProfile();
 
     /**
      * Returns the number of Device Admin apps active in the current user and the user's managed

src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java

@@ -189,19 +189,20 @@ public class EnterprisePrivacyFeatureProviderImpl implements EnterprisePrivacyFe
     }
 
     @Override
-    public int getNumberOfOwnerInstalledCaCertsInCurrentUser() {
+    public int getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile() {
-        final List<String> certs = mDpm.getOwnerInstalledCaCerts(new UserHandle(MY_USER_ID));
+        int num = 0;
-        return certs != null ? certs.size() : 0;
+        List<String> certs = mDpm.getOwnerInstalledCaCerts(new UserHandle(MY_USER_ID));
+        if (certs != null) {
+            num += certs.size();
         }
-
-    @Override
-    public int getNumberOfOwnerInstalledCaCertsInManagedProfile() {
         final int userId = getManagedProfileUserId();
-        if (userId == UserHandle.USER_NULL) {
+        if (userId != UserHandle.USER_NULL) {
-            return 0;
+            certs = mDpm.getOwnerInstalledCaCerts(new UserHandle(userId));
+            if (certs != null) {
+                num += certs.size();
             }
-        final List<String> certs = mDpm.getOwnerInstalledCaCerts(new UserHandle(userId));
+        }
-        return certs != null ? certs.size() : 0;
+        return num;
     }
 
     @Override

src/com/android/settings/enterprise/EnterprisePrivacySettings.java

@@ -64,18 +64,21 @@ public class EnterprisePrivacySettings extends DashboardFragment {
         controllers.add(new SecurityLogsPreferenceController(context));
         controllers.add(new EnterpriseInstalledPackagesPreferenceController(context, lifecycle,
                 async));
-        controllers.add(new AdminGrantedLocationPermissionsPreferenceController(context));
+        controllers.add(new AdminGrantedLocationPermissionsPreferenceController(context, lifecycle,
-        controllers.add(new AdminGrantedMicrophonePermissionPreferenceController(context));
+                async));
-        controllers.add(new AdminGrantedCameraPermissionPreferenceController(context));
+        controllers.add(new AdminGrantedMicrophonePermissionPreferenceController(context, lifecycle,
+                async));
+        controllers.add(new AdminGrantedCameraPermissionPreferenceController(context, lifecycle,
+                async));
         controllers.add(new EnterpriseSetDefaultAppsPreferenceController(context, lifecycle));
-        controllers.add(new AlwaysOnVpnPrimaryUserPreferenceController(context));
+        controllers.add(new AlwaysOnVpnPrimaryUserPreferenceController(context, lifecycle));
-        controllers.add(new AlwaysOnVpnManagedProfilePreferenceController(context));
+        controllers.add(new AlwaysOnVpnManagedProfilePreferenceController(context, lifecycle));
-        controllers.add(new GlobalHttpProxyPreferenceController(context));
+        controllers.add(new GlobalHttpProxyPreferenceController(context, lifecycle));
-        controllers.add(new CaCertsCurrentUserPreferenceController(context));
+        controllers.add(new CaCertsPreferenceController(context, lifecycle));
-        controllers.add(new CaCertsManagedProfilePreferenceController(context));
+        controllers.add(new FailedPasswordWipePrimaryUserPreferenceController(context, lifecycle));
-        controllers.add(new FailedPasswordWipePrimaryUserPreferenceController(context));
+        controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context,
-        controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context));
+                lifecycle));
-        controllers.add(new ImePreferenceController(context));
+        controllers.add(new ImePreferenceController(context, lifecycle));
         return controllers;
     }
 

src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java

@@ -14,6 +14,7 @@
 package com.android.settings.enterprise;
 
 import android.content.Context;
+import com.android.settings.core.lifecycle.Lifecycle;
 
 public class FailedPasswordWipeManagedProfilePreferenceController
         extends FailedPasswordWipePreferenceControllerBase {
@@ -21,8 +22,9 @@ public class FailedPasswordWipeManagedProfilePreferenceController
     private static final String KEY_FAILED_PASSWORD_WIPE_MANAGED_PROFILE
             = "failed_password_wipe_managed_profile";
 
-    public FailedPasswordWipeManagedProfilePreferenceController(Context context) {
+    public FailedPasswordWipeManagedProfilePreferenceController(Context context,
-        super(context);
+            Lifecycle lifecycle) {
+        super(context, lifecycle);
     }
 
     @Override

src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java

@@ -19,15 +19,17 @@ import android.content.res.Resources;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public abstract class FailedPasswordWipePreferenceControllerBase extends PreferenceController {
+public abstract class FailedPasswordWipePreferenceControllerBase
+        extends DynamicAvailabilityPreferenceController {
 
     protected final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public FailedPasswordWipePreferenceControllerBase(Context context) {
+    public FailedPasswordWipePreferenceControllerBase(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
@@ -37,18 +39,13 @@ public abstract class FailedPasswordWipePreferenceControllerBase extends Prefere
     @Override
     public void updateState(Preference preference) {
         final int failedPasswordsBeforeWipe = getMaximumFailedPasswordsBeforeWipe();
-        if (failedPasswordsBeforeWipe == 0) {
-            preference.setVisible(false);
-        } else {
-            preference.setVisible(true);
         preference.setSummary(mContext.getResources().getQuantityString(
                 R.plurals.enterprise_privacy_number_failed_password_wipe,
                 failedPasswordsBeforeWipe, failedPasswordsBeforeWipe));
     }
-    }
 
     @Override
     public boolean isAvailable() {
-        return true;
+        return getMaximumFailedPasswordsBeforeWipe() > 0;
     }
 }

src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceController.java

@@ -15,14 +15,16 @@ package com.android.settings.enterprise;
 
 import android.content.Context;
 
+import com.android.settings.core.lifecycle.Lifecycle;
+
 public class FailedPasswordWipePrimaryUserPreferenceController
         extends FailedPasswordWipePreferenceControllerBase {
 
     private static final String KEY_FAILED_PASSWORD_WIPE_PRIMARY_USER
             = "failed_password_wipe_primary_user";
 
-    public FailedPasswordWipePrimaryUserPreferenceController(Context context) {
+    public FailedPasswordWipePrimaryUserPreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
     }
 
     @Override

src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java

@@ -14,30 +14,25 @@
 package com.android.settings.enterprise;
 
 import android.content.Context;
-import android.support.v7.preference.Preference;
 
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class GlobalHttpProxyPreferenceController extends PreferenceController {
+public class GlobalHttpProxyPreferenceController extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_GLOBAL_HTTP_PROXY = "global_http_proxy";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public GlobalHttpProxyPreferenceController(Context context) {
+    public GlobalHttpProxyPreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
 
-    @Override
-    public void updateState(Preference preference) {
-        preference.setVisible(mFeatureProvider.isGlobalHttpProxySet());
-    }
-
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.isGlobalHttpProxySet();
     }
 
     @Override

src/com/android/settings/enterprise/ImePreferenceController.java

@@ -19,35 +19,31 @@ import android.content.res.Resources;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class ImePreferenceController extends PreferenceController {
+public class ImePreferenceController extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_INPUT_METHOD = "input_method";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public ImePreferenceController(Context context) {
+    public ImePreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
 
     @Override
     public void updateState(Preference preference) {
-        final String ownerSetIme = mFeatureProvider.getImeLabelIfOwnerSet();
-        if (ownerSetIme == null) {
-            preference.setVisible(false);
-            return;
-        }
         preference.setSummary(mContext.getResources().getString(
-            R.string.enterprise_privacy_input_method_name, ownerSetIme));
+            R.string.enterprise_privacy_input_method_name,
-        preference.setVisible(true);
+            mFeatureProvider.getImeLabelIfOwnerSet()));
     }
 
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.getImeLabelIfOwnerSet() != null;
     }
 
     @Override

tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java

@@ -89,8 +89,7 @@ public final class AppWithAdminGrantedPermissionsCounterTest {
         MockitoAnnotations.initMocks(this);
     }
 
-    @Test
+    private void verifyCountInstalledAppsAcrossAllUsers(boolean async) throws Exception {
-    public void testCountInstalledAppsAcrossAllUsers() throws Exception {
         // There are two users.
         mUsersToCount = Arrays.asList(
                 new UserInfo(MAIN_USER_ID, "main", UserInfo.FLAG_ADMIN),
@@ -181,10 +180,14 @@ public final class AppWithAdminGrantedPermissionsCounterTest {
                 .thenReturn(PackageManager.INSTALL_REASON_UNKNOWN);
 
         // Count the number of all apps installed that were granted on or more permissions by the
-        // admin.  Wait for the background task to finish.
+        // admin.
+        if (async) {
             (new AppWithAdminGrantedPermissionsCounterTestable(PERMISSIONS)).execute();
+            // Wait for the background task to finish.
             ShadowApplication.runBackgroundTasks();
-
+        } else {
+            (new AppWithAdminGrantedPermissionsCounterTestable(PERMISSIONS)).executeInForeground();
+        }
         assertThat(mAppCount).isEqualTo(3);
 
         // Verify that installed packages were retrieved for the users returned by
@@ -194,7 +197,16 @@ public final class AppWithAdminGrantedPermissionsCounterTest {
                 eq(MANAGED_PROFILE_ID));
         verify(mPackageManager, atLeast(0)).getInstallReason(anyObject(), anyObject());
         verifyNoMoreInteractions(mPackageManager);
+    }
 
+    @Test
+    public void testCountInstalledAppsAcrossAllUsersSync() throws Exception {
+        verifyCountInstalledAppsAcrossAllUsers(false /* async */);
+    }
+
+    @Test
+    public void testCountInstalledAppsAcrossAllUsersAync() throws Exception {
+        verifyCountInstalledAppsAcrossAllUsers(true /* async */);
     }
 
     private class AppWithAdminGrantedPermissionsCounterTestable extends

tests/robotests/src/com/android/settings/applications/ApplicationFeatureProviderImplTest.java

@@ -88,7 +88,7 @@ public final class ApplicationFeatureProviderImplTest {
                 mPackageManagerService, mDevicePolicyManager);
     }
 
-    private void testCalculateNumberOfInstalledApps(boolean async) {
+    private void verifyCalculateNumberOfInstalledApps(boolean async) {
         setUpUsersAndInstalledApps();
 
         when(mPackageManager.getInstallReason(APP_1, new UserHandle(MAIN_USER_ID)))
@@ -117,16 +117,16 @@ public final class ApplicationFeatureProviderImplTest {
 
     @Test
     public void testCalculateNumberOfInstalledAppsSync() {
-        testCalculateNumberOfInstalledApps(false /* async */);
+        verifyCalculateNumberOfInstalledApps(false /* async */);
     }
 
     @Test
     public void testCalculateNumberOfInstalledAppsAsync() {
-        testCalculateNumberOfInstalledApps(true /* async */);
+        verifyCalculateNumberOfInstalledApps(true /* async */);
     }
 
-    @Test
+    private void verifyCalculateNumberOfAppsWithAdminGrantedPermissions(boolean async)
-    public void testCalculateNumberOfAppsWithAdminGrantedPermissions() throws Exception {
+            throws Exception {
         setUpUsersAndInstalledApps();
 
         when(mDevicePolicyManager.getPermissionGrantState(null, APP_1, PERMISSION))
@@ -143,15 +143,25 @@ public final class ApplicationFeatureProviderImplTest {
                 .thenReturn(PackageManager.INSTALL_REASON_POLICY);
 
         mAppCount = -1;
-        mProvider.calculateNumberOfAppsWithAdminGrantedPermissions(new String[] {PERMISSION},
+        mProvider.calculateNumberOfAppsWithAdminGrantedPermissions(new String[] {PERMISSION}, async,
-                (num) -> {
+                (num) -> mAppCount = num);
-                    mAppCount = num;
+        if (async) {
-                });
             ShadowApplication.runBackgroundTasks();
+        }
         assertThat(mAppCount).isEqualTo(2);
 
     }
 
+    @Test
+    public void testCalculateNumberOfAppsWithAdminGrantedPermissionsSync() throws Exception {
+        verifyCalculateNumberOfAppsWithAdminGrantedPermissions(false /* async */);
+    }
+
+    @Test
+    public void testCalculateNumberOfAppsWithAdminGrantedPermissionsAsync() throws Exception {
+        verifyCalculateNumberOfAppsWithAdminGrantedPermissions(true /* async */);
+    }
+
     @Test
     public void testFindPersistentPreferredActivities() throws Exception {
         when(mUserManager.getUserProfiles()).thenReturn(Arrays.asList(new UserHandle(MAIN_USER_ID),

tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java

@@ -39,8 +39,8 @@ public final class AdminGrantedCameraPermissionPreferenceControllerTest extends
     }
 
     @Override
-    public void setUp() {
+    protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
-        super.setUp();
+        return new AdminGrantedCameraPermissionPreferenceController(mContext,null /* lifecycle */,
-        mController = new AdminGrantedCameraPermissionPreferenceController(mContext);
+                async);
     }
 }

tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java

@@ -40,8 +40,8 @@ public final class AdminGrantedLocationPermissionsPreferenceControllerTest exten
     }
 
     @Override
-    public void setUp() {
+    protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
-        super.setUp();
+        return new AdminGrantedLocationPermissionsPreferenceController(mContext,
-        mController = new AdminGrantedLocationPermissionsPreferenceController(mContext);
+                null /* lifecycle */, async);
     }
 }

tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java

@@ -39,8 +39,8 @@ public final class AdminGrantedMicrophonePermissionPreferenceControllerTest exte
     }
 
     @Override
-    public void setUp() {
+    protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
-        super.setUp();
+        return new AdminGrantedMicrophonePermissionPreferenceController(mContext,
-        mController = new AdminGrantedMicrophonePermissionPreferenceController(mContext);
+                null /* lifecycle */, async);
     }
 }

tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java

@@ -40,17 +40,16 @@ public final class AdminGrantedPermissionsPreferenceControllerBaseTest extends
     }
 
     @Override
-    public void setUp() {
+    protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
-        super.setUp();
+        return new AdminGrantedPermissionsPreferenceControllerBaseTestable(async);
-        mController = new AdminGrantedPermissionsPreferenceControllerBaseTestable();
     }
 
     private class AdminGrantedPermissionsPreferenceControllerBaseTestable extends
             AdminGrantedPermissionsPreferenceControllerBase {
 
-        AdminGrantedPermissionsPreferenceControllerBaseTestable() {
+        AdminGrantedPermissionsPreferenceControllerBaseTestable(boolean async) {
-            super(AdminGrantedPermissionsPreferenceControllerBaseTest.this.mContext, mPermissions,
+            super(AdminGrantedPermissionsPreferenceControllerBaseTest.this.mContext,
-                    mPermissionGroup);
+                    null /* lifecycle */, async, mPermissions, mPermissionGroup);
         }
 
         @Override

tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java

@@ -68,39 +68,56 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
+        mController = createController(true /* async */);
     }
 
-    private void setNumberOfPackagesWithAdminGrantedPermissions(int number) {
+    private void setNumberOfPackagesWithAdminGrantedPermissions(int number, boolean async) {
         doAnswer(new Answer() {
             public Object answer(InvocationOnMock invocation) {
                 ((ApplicationFeatureProvider.NumberOfAppsCallback)
-                        invocation.getArguments()[1]).onNumberOfAppsResult(number);
+                        invocation.getArguments()[2]).onNumberOfAppsResult(number);
                 return null;
             }}).when(mFeatureFactory.applicationFeatureProvider)
                     .calculateNumberOfAppsWithAdminGrantedPermissions(eq(mPermissions),
-                            anyObject());
+                            eq(async), anyObject());
     }
 
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(false);
+        preference.setVisible(true);
 
-        setNumberOfPackagesWithAdminGrantedPermissions(20);
+        setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
+        mController.updateState(preference);
+        assertThat(preference.isVisible()).isFalse();
+
+        setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
         when(mContext.getResources().getQuantityString(
                 R.plurals.enterprise_privacy_number_packages_actionable,20, 20))
                 .thenReturn("20 packages");
         mController.updateState(preference);
         assertThat(preference.getSummary()).isEqualTo("20 packages");
         assertThat(preference.isVisible()).isTrue();
-
-        setNumberOfPackagesWithAdminGrantedPermissions(0);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
     }
 
     @Test
-    public void testIsAvailable() {
+    public void testIsAvailableSync() {
+        final AdminGrantedPermissionsPreferenceControllerBase controller
+                = createController(false /* async */);
+
+        setNumberOfPackagesWithAdminGrantedPermissions(0, false /* async */);
+        assertThat(controller.isAvailable()).isFalse();
+
+        setNumberOfPackagesWithAdminGrantedPermissions(20, false /* async */);
+        assertThat(controller.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void testIsAvailableAsync() {
+        setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
+        assertThat(mController.isAvailable()).isTrue();
+
+        setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
         assertThat(mController.isAvailable()).isTrue();
     }
 
@@ -125,4 +142,7 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
     public void testGetPreferenceKey() {
         assertThat(mController.getPreferenceKey()).isEqualTo(mKey);
     }
+
+    protected abstract AdminGrantedPermissionsPreferenceControllerBase createController(
+            boolean async);
 }

tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java

@@ -52,27 +52,18 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext);
+        mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext,
-    }
+                null /* lifecycle */);
-
-    @Test
-    public void testUpdateState() {
-        final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
-                .thenReturn(false);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
-                .thenReturn(true);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
+                .thenReturn(false);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
+                .thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceControllerTest.java

@@ -56,7 +56,8 @@ public final class AlwaysOnVpnPrimaryUserPreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new AlwaysOnVpnPrimaryUserPreferenceController(mContext);
+        mController = new AlwaysOnVpnPrimaryUserPreferenceController(mContext,
+                null /* lifecycle */);
         when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_device))
                 .thenReturn(VPN_SET_DEVICE);
         when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_personal))
@@ -66,37 +67,27 @@ public final class AlwaysOnVpnPrimaryUserPreferenceControllerTest {
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(false);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
-                .thenReturn(false);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
                 .thenReturn(true);
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(false);
         mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
         assertThat(preference.getTitle()).isEqualTo(VPN_SET_DEVICE);
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
-                .thenReturn(false);
         mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
-                .thenReturn(true);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
         assertThat(preference.getTitle()).isEqualTo(VPN_SET_PERSONAL);
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
+                .thenReturn(false);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
+                .thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceControllerTest.java

@@ -1,139 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.settings.enterprise;
-
-import android.content.Context;
-import android.content.res.Resources;
-import com.android.settings.R;
-import android.support.v7.preference.Preference;
-
-import com.android.settings.SettingsRobolectricTestRunner;
-import com.android.settings.TestConfig;
-import com.android.settings.testutils.FakeFeatureFactory;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Answers;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.robolectric.annotation.Config;
-
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Mockito.when;
-
-/**
- * Tests for {@link CaCertsCurrentUserPreferenceController}.
- */
-@RunWith(SettingsRobolectricTestRunner.class)
-@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
-public final class CaCertsCurrentUserPreferenceControllerTest {
-
-    private final String INSTALLED_CERTS_USER = "trusted credentials";
-    private final String INSTALLED_CERTS_PERSONAL = "trusted credentials in personal profile";
-    private final String NUMBER_INSTALLED_CERTS_1 = "1 cert";
-    private final String NUMBER_INSTALLED_CERTS_10 = "10 certs";
-
-    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-    private Context mContext;
-    private FakeFeatureFactory mFeatureFactory;
-
-    private CaCertsCurrentUserPreferenceController mController;
-
-    @Before
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-        FakeFeatureFactory.setupForTest(mContext);
-        mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new CaCertsCurrentUserPreferenceController(mContext);
-
-        when(mContext.getString(R.string.enterprise_privacy_ca_certs_user))
-                .thenReturn(INSTALLED_CERTS_USER);
-        when(mContext.getString(R.string.enterprise_privacy_ca_certs_personal))
-                .thenReturn(INSTALLED_CERTS_PERSONAL);
-        when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs,
-                1, 1)).thenReturn(NUMBER_INSTALLED_CERTS_1);
-        when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs,
-                10, 10)).thenReturn(NUMBER_INSTALLED_CERTS_10);
-    }
-
-    @Test
-    public void testUpdateState() {
-        final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(false);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider
-                .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(0);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider
-                .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(1);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
-        assertThat(preference.getTitle()).isEqualTo(INSTALLED_CERTS_USER);
-        assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_1);
-
-        preference.setVisible(false);
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider
-                .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(10);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
-        assertThat(preference.getTitle()).isEqualTo(INSTALLED_CERTS_USER);
-        assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_10);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider
-                .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(0);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider
-                .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(1);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
-        assertThat(preference.getTitle()).isEqualTo(INSTALLED_CERTS_PERSONAL);
-        assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_1);
-
-        preference.setVisible(false);
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider
-                .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(10);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
-        assertThat(preference.getTitle()).isEqualTo(INSTALLED_CERTS_PERSONAL);
-        assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_10);
-    }
-
-    @Test
-    public void testIsAvailable() {
-        assertThat(mController.isAvailable()).isTrue();
-    }
-
-    @Test
-    public void testHandlePreferenceTreeClick() {
-        assertThat(mController.handlePreferenceTreeClick(new Preference(mContext, null, 0, 0)))
-                .isFalse();
-    }
-
-    @Test
-    public void testGetPreferenceKey() {
-        assertThat(mController.getPreferenceKey()).isEqualTo("ca_certs_current_user");
-    }
-}

tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java

@@ -37,60 +37,46 @@ import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.when;
 
 /**
- * Tests for {@link CaCertsManagedProfilePreferenceController}.
+ * Tests for {@link CaCertsPreferenceController}.
  */
 @RunWith(SettingsRobolectricTestRunner.class)
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
-public final class CaCertsManagedProfilePreferenceControllerTest {
+public final class CaCertsPreferenceControllerTest {
-
-    private final String NUMBER_INSTALLED_CERTS_1 = "1 cert";
-    private final String NUMBER_INSTALLED_CERTS_10 = "10 certs";
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
 
-    private CaCertsManagedProfilePreferenceController mController;
+    private CaCertsPreferenceController mController;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new CaCertsManagedProfilePreferenceController(mContext);
+        mController = new CaCertsPreferenceController(mContext, null /* lifecycle */);
-
-        when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs,
-                1, 1)).thenReturn(NUMBER_INSTALLED_CERTS_1);
-        when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs,
-                10, 10)).thenReturn(NUMBER_INSTALLED_CERTS_10);
     }
 
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
 
+        when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs,
+                10, 10)).thenReturn("10 certs");
         when(mFeatureFactory.enterprisePrivacyFeatureProvider
-                .getNumberOfOwnerInstalledCaCertsInManagedProfile()).thenReturn(0);
+                .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(10);
         mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
+        assertThat(preference.getSummary()).isEqualTo("10 certs");
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider
-                .getNumberOfOwnerInstalledCaCertsInManagedProfile()).thenReturn(1);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
-        assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_1);
-
-        preference.setVisible(false);
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider
-                .getNumberOfOwnerInstalledCaCertsInManagedProfile()).thenReturn(10);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
-        assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_10);
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider
+                .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(0);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider
+                .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(10);
         assertThat(mController.isAvailable()).isTrue();
     }
 
@@ -102,6 +88,6 @@ public final class CaCertsManagedProfilePreferenceControllerTest {
 
     @Test
     public void testGetPreferenceKey() {
-        assertThat(mController.getPreferenceKey()).isEqualTo("ca_certs_managed_profile");
+        assertThat(mController.getPreferenceKey()).isEqualTo("ca_certs");
     }
 }

tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java

@@ -96,7 +96,7 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
 
     @Test
     public void testIsAvailableSync() {
-        EnterpriseInstalledPackagesPreferenceController controller
+        final EnterpriseInstalledPackagesPreferenceController controller
                 = new EnterpriseInstalledPackagesPreferenceController(mContext,
                         null /* lifecycle */, false /* async */);
 

tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java

@@ -268,39 +268,45 @@ public final class EnterprisePrivacyFeatureProviderImplTest {
     }
 
     @Test
-    public void testGetNumberOfOwnerInstalledCaCertsInCurrentUser() {
+    public void testGetNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile() {
         final UserHandle userHandle = new UserHandle(UserHandle.USER_SYSTEM);
-
+        final UserHandle managedProfileUserHandle = new UserHandle(MANAGED_PROFILE_USER_ID);
-        when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle))
-                .thenReturn(null);
-        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInCurrentUser()).isEqualTo(0);
-        when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle))
-                .thenReturn(new ArrayList<String>());
-        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInCurrentUser()).isEqualTo(0);
-        when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle))
-                .thenReturn(Arrays.asList(new String[] {"ca1", "ca2"}));
-        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInCurrentUser()).isEqualTo(2);
-    }
-
-    @Test
-    public void testGetNumberOfOwnerInstalledCaCertsInManagedProfile() {
-        final UserHandle userHandle = new UserHandle(MANAGED_PROFILE_USER_ID);
         final UserInfo managedProfile =
                 new UserInfo(MANAGED_PROFILE_USER_ID, "", "", UserInfo.FLAG_MANAGED_PROFILE);
 
-        mProfiles.add(managedProfile);
+        when(mDevicePolicyManager.getOwnerInstalledCaCerts(managedProfileUserHandle))
+                .thenReturn(Arrays.asList(new String[] {"ca1", "ca2"}));
+
         when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle))
                 .thenReturn(null);
-        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile()).isEqualTo(0);
+        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile())
+                .isEqualTo(0);
         when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle))
                 .thenReturn(new ArrayList<String>());
-        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile()).isEqualTo(0);
+        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile())
+                .isEqualTo(0);
         when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle))
                 .thenReturn(Arrays.asList(new String[] {"ca1", "ca2"}));
-        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile()).isEqualTo(2);
+        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile())
+                .isEqualTo(2);
+
+        mProfiles.add(managedProfile);
+        when(mDevicePolicyManager.getOwnerInstalledCaCerts(managedProfileUserHandle))
+                .thenReturn(null);
+        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile())
+                .isEqualTo(2);
+        when(mDevicePolicyManager.getOwnerInstalledCaCerts(managedProfileUserHandle))
+                .thenReturn(new ArrayList<String>());
+        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile())
+                .isEqualTo(2);
+        when(mDevicePolicyManager.getOwnerInstalledCaCerts(managedProfileUserHandle))
+                .thenReturn(Arrays.asList(new String[] {"ca1", "ca2"}));
+        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile())
+                .isEqualTo(4);
 
         mProfiles.remove(managedProfile);
-        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile()).isEqualTo(0);
+        assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile())
+                .isEqualTo(2);
     }
 
     @Test

tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java

@@ -117,7 +117,7 @@ public final class EnterprisePrivacySettingsTest {
 
     private void verifyPreferenceControllers(List<PreferenceController> controllers) {
         assertThat(controllers).isNotNull();
-        assertThat(controllers.size()).isEqualTo(17);
+        assertThat(controllers.size()).isEqualTo(16);
         assertThat(controllers.get(0)).isInstanceOf(InstalledPackagesPreferenceController.class);
         assertThat(controllers.get(1)).isInstanceOf(NetworkLogsPreferenceController.class);
         assertThat(controllers.get(2)).isInstanceOf(BugReportsPreferenceController.class);
@@ -137,13 +137,11 @@ public final class EnterprisePrivacySettingsTest {
         assertThat(controllers.get(10)).isInstanceOf(
                 AlwaysOnVpnManagedProfilePreferenceController.class);
         assertThat(controllers.get(11)).isInstanceOf(GlobalHttpProxyPreferenceController.class);
-        assertThat(controllers.get(12)).isInstanceOf(CaCertsCurrentUserPreferenceController.class);
+        assertThat(controllers.get(12)).isInstanceOf(CaCertsPreferenceController.class);
         assertThat(controllers.get(13)).isInstanceOf(
-                CaCertsManagedProfilePreferenceController.class);
-        assertThat(controllers.get(14)).isInstanceOf(
                 FailedPasswordWipePrimaryUserPreferenceController.class);
-        assertThat(controllers.get(15)).isInstanceOf(
+        assertThat(controllers.get(14)).isInstanceOf(
                 FailedPasswordWipeManagedProfilePreferenceController.class);
-        assertThat(controllers.get(16)).isInstanceOf(ImePreferenceController.class);
+        assertThat(controllers.get(15)).isInstanceOf(ImePreferenceController.class);
     }
 }

tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java

@@ -43,7 +43,8 @@ public final class FailedPasswordWipeManagedProfilePreferenceControllerTest exte
     @Override
     public void setUp() {
         super.setUp();
-        mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext);
+        mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext,
+                null /* lifecycle */);
     }
 
     @Override

tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java

@@ -50,7 +50,8 @@ public final class FailedPasswordWipePreferenceControllerBaseTest extends
     private class FailedPasswordWipePreferenceControllerBaseTestable extends
             FailedPasswordWipePreferenceControllerBase {
         FailedPasswordWipePreferenceControllerBaseTestable() {
-            super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext);
+            super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext,
+                    null /* lifecycle */);
         }
 
         @Override

tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java

@@ -61,7 +61,6 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(false);
 
         setMaximumFailedPasswordsBeforeWipe(10);
         when(mContext.getResources().getQuantityString(
@@ -69,14 +68,14 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
                 .thenReturn("10 attempts");
         mController.updateState(preference);
         assertThat(preference.getSummary()).isEqualTo("10 attempts");
-
-        setMaximumFailedPasswordsBeforeWipe(0);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
     }
 
     @Test
     public void testIsAvailable() {
+        setMaximumFailedPasswordsBeforeWipe(0);
+        assertThat(mController.isAvailable()).isFalse();
+
+        setMaximumFailedPasswordsBeforeWipe(10);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceControllerTest.java

@@ -43,7 +43,8 @@ public final class FailedPasswordWipePrimaryUserPreferenceControllerTest extends
     @Override
     public void setUp() {
         super.setUp();
-        mController = new FailedPasswordWipePrimaryUserPreferenceController(mContext);
+        mController = new FailedPasswordWipePrimaryUserPreferenceController(mContext,
+                null /* lifecycle */);
     }
 
     @Override

tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java

@@ -51,27 +51,17 @@ public final class GlobalHttpProxyPreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new GlobalHttpProxyPreferenceController(mContext);
+        mController = new GlobalHttpProxyPreferenceController(mContext, null /* lifecycle */);
-    }
-
-    @Test
-    public void testUpdateState() {
-        final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
-                .thenReturn(false);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
-                .thenReturn(true);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
+                .thenReturn(false);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
+                .thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java

@@ -57,7 +57,7 @@ public final class ImePreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new ImePreferenceController(mContext);
+        mController = new ImePreferenceController(mContext, null /* lifecycle */);
         when(mContext.getResources().getString(R.string.enterprise_privacy_input_method_name,
                 DEFAULT_IME_LABEL)).thenReturn(DEFAULT_IME_TEXT);
     }
@@ -65,22 +65,21 @@ public final class ImePreferenceControllerTest {
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
-            .thenReturn(null);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
             .thenReturn(DEFAULT_IME_LABEL);
         mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
         assertThat(preference.getSummary()).isEqualTo(DEFAULT_IME_TEXT);
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
+            .thenReturn(null);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
+            .thenReturn(DEFAULT_IME_LABEL);
         assertThat(mController.isAvailable()).isTrue();
     }