[DO NOT MERGE] Rollup Cert-related changes from R

This change includes the following commits from internal R branch
which are related to certificate management:

0206e76f46 CredentialStorage: Install keys using KeyChain
09ceea53d9 Added functionality to select type of certificate to be installed from the Settings app
3acf3f5433 WiFi certificates installable from Wifi sub-preference
8439fd15f7 Fix strings for certificate installation in Settings

Bug: 161347472
Test: builds & manual testing
Change-Id: Ia59dc4780254fab4f34c2f61b25f3b4e56ed7b77

tests/robotests/src/com/android/settings/security/InstallCertificateFromStorageTest.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2019 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.security;
+
+import static com.android.settings.security.InstallCertificateFromStorage.SEARCH_INDEX_DATA_PROVIDER;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.app.admin.DevicePolicyManager;
+import android.app.settings.SettingsEnums;
+import android.content.Context;
+import android.os.UserManager;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.shadows.ShadowApplication;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(RobolectricTestRunner.class)
+public class InstallCertificateFromStorageTest {
+
+    @Mock
+    private UserManager mUserManager;
+
+    @Mock
+    private DevicePolicyManager mDevicePolicyManager;
+
+    private Context mContext;
+
+    private List<String> mTestKeys;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        ShadowApplication application = ShadowApplication.getInstance();
+        application.setSystemService(Context.DEVICE_POLICY_SERVICE, mDevicePolicyManager);
+        application.setSystemService(Context.USER_SERVICE, mUserManager);
+        mContext = RuntimeEnvironment.application;
+        setUpTestKeys();
+    }
+
+    private void setUpTestKeys() {
+        mTestKeys = new ArrayList<>();
+        mTestKeys.add("install_certificate_from_storage");
+        mTestKeys.add("certificate_types");
+        mTestKeys.add("install_ca_certificate");
+        mTestKeys.add("install_user_certificate");
+        mTestKeys.add("install_wifi_certificate");
+    }
+
+    @Test
+    public void getMetricsCategory_shouldReturnInstallCertificateFromStorage() {
+        InstallCertificateFromStorage fragment = new InstallCertificateFromStorage();
+        assertThat(fragment.getMetricsCategory()).isEqualTo(
+                SettingsEnums.INSTALL_CERTIFICATE_FROM_STORAGE);
+    }
+
+    @Test
+    public void getNonIndexableKeys_existInXmlLayout() {
+        final List<String> nonIndexableKeys =
+                SEARCH_INDEX_DATA_PROVIDER.getNonIndexableKeys(mContext);
+
+        assertThat(nonIndexableKeys).containsAllIn(mTestKeys);
+    }
+
+}

tests/robotests/src/com/android/settings/security/RestrictedEncryptionPreferenceControllerTest.java

@@ -40,9 +40,12 @@ public class RestrictedEncryptionPreferenceControllerTest {
     private Context mContext;
     private ShadowUserManager mUserManager;
     private CredentialStoragePreferenceController mCredentialStoragePreferenceController;
-    private InstallCredentialsPreferenceController mInstallCredentialsPreferenceController;
+    private InstallCertificatePreferenceController mInstallCertificatePreferenceController;
     private ResetCredentialsPreferenceController mResetCredentialsPreferenceController;
     private UserCredentialsPreferenceController mUserCredentialsPreferenceController;
+    private InstallCaCertificatePreferenceController mInstallCaCertificatePreferenceController;
+    private InstallUserCertificatePreferenceController mInstallUserCertificatePreferenceController;
+    private InstallWifiCertificatePreferenceController mInstallWifiCertificatePreferenceController;
     private Lifecycle mLifecycle;
     private LifecycleOwner mLifecycleOwner;
 
@@ -53,21 +56,30 @@ public class RestrictedEncryptionPreferenceControllerTest {
         mLifecycle = new Lifecycle(mLifecycleOwner);
         mCredentialStoragePreferenceController =
                 new CredentialStoragePreferenceController(mContext);
-        mInstallCredentialsPreferenceController =
-                new InstallCredentialsPreferenceController(mContext);
+        mInstallCertificatePreferenceController =
+                new InstallCertificatePreferenceController(mContext);
         mResetCredentialsPreferenceController =
                 new ResetCredentialsPreferenceController(mContext, mLifecycle);
         mUserCredentialsPreferenceController =
                 new UserCredentialsPreferenceController(mContext);
+        mInstallCaCertificatePreferenceController =
+                new InstallCaCertificatePreferenceController(mContext);
+        mInstallUserCertificatePreferenceController =
+                new InstallUserCertificatePreferenceController(mContext);
+        mInstallWifiCertificatePreferenceController =
+                new InstallWifiCertificatePreferenceController(mContext);
         mUserManager = ShadowUserManager.getShadow();
     }
 
     @Test
     public void isAvailable_noRestriction_shouldReturnTrue() {
         assertThat(mCredentialStoragePreferenceController.isAvailable()).isTrue();
-        assertThat(mInstallCredentialsPreferenceController.isAvailable()).isTrue();
+        assertThat(mInstallCertificatePreferenceController.isAvailable()).isTrue();
         assertThat(mResetCredentialsPreferenceController.isAvailable()).isTrue();
         assertThat(mUserCredentialsPreferenceController.isAvailable()).isTrue();
+        assertThat(mInstallCaCertificatePreferenceController.isAvailable()).isTrue();
+        assertThat(mInstallUserCertificatePreferenceController.isAvailable()).isTrue();
+        assertThat(mInstallWifiCertificatePreferenceController.isAvailable()).isTrue();
     }
 
     @Test
@@ -75,8 +87,11 @@ public class RestrictedEncryptionPreferenceControllerTest {
         mUserManager.addBaseUserRestriction(UserManager.DISALLOW_CONFIG_CREDENTIALS);
 
         assertThat(mCredentialStoragePreferenceController.isAvailable()).isFalse();
-        assertThat(mInstallCredentialsPreferenceController.isAvailable()).isFalse();
+        assertThat(mInstallCertificatePreferenceController.isAvailable()).isFalse();
         assertThat(mResetCredentialsPreferenceController.isAvailable()).isFalse();
         assertThat(mUserCredentialsPreferenceController.isAvailable()).isFalse();
+        assertThat(mInstallCaCertificatePreferenceController.isAvailable()).isFalse();
+        assertThat(mInstallUserCertificatePreferenceController.isAvailable()).isFalse();
+        assertThat(mInstallWifiCertificatePreferenceController.isAvailable()).isFalse();
     }
 }