diff --git a/res/values/config.xml b/res/values/config.xml
index b7c0bad..205b9b5 100755
--- a/res/values/config.xml
+++ b/res/values/config.xml
@@ -634,9 +634,6 @@
         <item>android.uid.system:1000</item>
     </string-array>
 
-    <!-- The default value for RedactionInterstitial in SUW -->
-    <bool name="default_allow_sensitive_lockscreen_content">true</bool>
-
     <!-- Whether to enable the app battery usage list page feature. -->
     <bool name="config_app_battery_usage_list_enabled">false</bool>
 
diff --git a/src/com/android/settings/notification/RedactionInterstitial.java b/src/com/android/settings/notification/RedactionInterstitial.java
index d6fdaf8..f243250 100644
--- a/src/com/android/settings/notification/RedactionInterstitial.java
+++ b/src/com/android/settings/notification/RedactionInterstitial.java
@@ -189,16 +189,13 @@
         }
 
         private void loadFromSettings() {
-            final boolean showUnRedactedDefault = getContext().getResources().getBoolean(
-                    R.bool.default_allow_sensitive_lockscreen_content);
             final boolean managedProfile = UserManager.get(getContext()).isManagedProfile(mUserId);
             // Hiding all notifications is device-wide setting, managed profiles can only set
             // whether their notifications are show in full or redacted.
             final boolean showNotifications = managedProfile || Settings.Secure.getIntForUser(
                     getContentResolver(), LOCK_SCREEN_SHOW_NOTIFICATIONS, 0, mUserId) != 0;
             final boolean showUnredacted = Settings.Secure.getIntForUser(
-                    getContentResolver(), LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
-                    showUnRedactedDefault ? 1 : 0, mUserId) != 0;
+                    getContentResolver(), LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 1, mUserId) != 0;
 
             int checkedButtonId = R.id.hide_all;
             if (showNotifications) {
diff --git a/tests/robotests/src/com/android/settings/notification/RedactionInterstitialTest.java b/tests/robotests/src/com/android/settings/notification/RedactionInterstitialTest.java
index 9d475b8..5c6da49 100644
--- a/tests/robotests/src/com/android/settings/notification/RedactionInterstitialTest.java
+++ b/tests/robotests/src/com/android/settings/notification/RedactionInterstitialTest.java
@@ -21,7 +21,6 @@
 import com.android.settings.R;
 import com.android.settings.RestrictedRadioButton;
 import com.android.settings.notification.RedactionInterstitial.RedactionInterstitialFragment;
-import com.android.settings.testutils.shadow.SettingsShadowResources;
 import com.android.settings.testutils.shadow.ShadowRestrictedLockUtilsInternal;
 import com.android.settings.testutils.shadow.ShadowUtils;
 
@@ -39,7 +38,6 @@
 @Config(shadows = {
         ShadowUtils.class,
         ShadowRestrictedLockUtilsInternal.class,
-        SettingsShadowResources.class,
 })
 public class RedactionInterstitialTest {
     private RedactionInterstitial mActivity;
@@ -136,28 +134,6 @@
         assertSelectedButton(R.id.redact_sensitive);
     }
 
-    @Test
-    public void defaultShowSensitiveContent_configDeny() {
-        final ContentResolver resolver = RuntimeEnvironment.application.getContentResolver();
-        Settings.Secure.putIntForUser(resolver,
-                LOCK_SCREEN_SHOW_NOTIFICATIONS, 1, UserHandle.myUserId());
-        setupConfig(false);
-        setupActivity();
-
-        assertSelectedButton(R.id.redact_sensitive);
-    }
-
-    @Test
-    public void defaultShowSensitiveContent_configAllow() {
-        final ContentResolver resolver = RuntimeEnvironment.application.getContentResolver();
-        Settings.Secure.putIntForUser(resolver,
-                LOCK_SCREEN_SHOW_NOTIFICATIONS, 1, UserHandle.myUserId());
-        setupConfig(true);
-        setupActivity();
-
-        assertSelectedButton(R.id.show_all);
-    }
-
     private void setupActivity() {
         mActivity = buildActivity(RedactionInterstitial.class, new Intent()).setup().get();
         mFragment = (RedactionInterstitialFragment)
@@ -166,11 +142,6 @@
         assertThat(mFragment).isNotNull();
     }
 
-    private void setupConfig(boolean allowSensitiveContent) {
-        SettingsShadowResources.overrideResource(
-                R.bool.default_allow_sensitive_lockscreen_content, allowSensitiveContent);
-    }
-
     private void setupSettings(int show, int showUnredacted) {
         final ContentResolver resolver = RuntimeEnvironment.application.getContentResolver();
         Settings.Secure.putIntForUser(resolver,
