diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index bc159d6..6b83516 100755
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -204,6 +204,7 @@
 
     <!-- WiFi Preferences -->
     <dimen name="wifi_divider_height">1px</dimen>
+    <dimen name="wifi_picker_icon_size">32dp</dimen>
 
     <!-- Color picker -->
     <dimen name="color_swatch_size">16dp</dimen>
diff --git a/src/com/android/settings/MasterClear.java b/src/com/android/settings/MasterClear.java
index 4ed38d1..d643468 100644
--- a/src/com/android/settings/MasterClear.java
+++ b/src/com/android/settings/MasterClear.java
@@ -326,11 +326,13 @@
     @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container,
             Bundle savedInstanceState) {
-        final EnforcedAdmin admin = RestrictedLockUtils.checkIfRestrictionEnforced(
-                getActivity(), UserManager.DISALLOW_FACTORY_RESET, UserHandle.myUserId());
-        final UserManager um = UserManager.get(getActivity());
-        if (!um.isAdminUser() || RestrictedLockUtils.hasBaseUserRestriction(getActivity(),
-                UserManager.DISALLOW_FACTORY_RESET, UserHandle.myUserId())) {
+        final Context context = getContext();
+        final EnforcedAdmin admin = RestrictedLockUtils.checkIfRestrictionEnforced(context,
+                UserManager.DISALLOW_FACTORY_RESET, UserHandle.myUserId());
+        final UserManager um = UserManager.get(context);
+        final boolean disallow = !um.isAdminUser() || RestrictedLockUtils.hasBaseUserRestriction(
+                context, UserManager.DISALLOW_FACTORY_RESET, UserHandle.myUserId());
+        if (disallow && !Utils.isCarrierDemoUser(context)) {
             return inflater.inflate(R.layout.master_clear_disallowed_screen, null);
         } else if (admin != null) {
             View view = inflater.inflate(R.layout.admin_support_details_empty_view, null);
diff --git a/src/com/android/settings/SettingsActivity.java b/src/com/android/settings/SettingsActivity.java
index c2060ce..8869c5d 100644
--- a/src/com/android/settings/SettingsActivity.java
+++ b/src/com/android/settings/SettingsActivity.java
@@ -968,7 +968,8 @@
 
         // Enable/disable backup settings depending on whether the user is admin.
         setTileEnabled(new ComponentName(packageName,
-                BackupSettingsActivity.class.getName()), true, isAdmin);
+                BackupSettingsActivity.class.getName()), true,
+                isAdmin || Utils.isCarrierDemoUser(this));
         setTileEnabled(new ComponentName(packageName,
                 "com.android.settings.BackupResetDashboardAlias"), true, isAdmin);
 
diff --git a/src/com/android/settings/Utils.java b/src/com/android/settings/Utils.java
index f5bd2ce..803b8e5 100644
--- a/src/com/android/settings/Utils.java
+++ b/src/com/android/settings/Utils.java
@@ -1245,4 +1245,13 @@
         }
     }
 
+    public static boolean isCarrierDemoUser(Context context) {
+        final String carrierDemoModeSetting =
+                context.getString(com.android.internal.R.string.config_carrierDemoModeSetting);
+        return UserManager.isDeviceInDemoMode(context)
+                && getUserManager(context).isDemoUser()
+                && !TextUtils.isEmpty(carrierDemoModeSetting)
+                && (Settings.Secure.getInt(context.getContentResolver(),
+                        carrierDemoModeSetting, 0) == 1);
+    }
 }
diff --git a/src/com/android/settings/wifi/LongPressAccessPointPreference.java b/src/com/android/settings/wifi/LongPressAccessPointPreference.java
index 79f29ef..b22e8f1 100644
--- a/src/com/android/settings/wifi/LongPressAccessPointPreference.java
+++ b/src/com/android/settings/wifi/LongPressAccessPointPreference.java
@@ -18,7 +18,8 @@
 import android.app.Fragment;
 import android.content.Context;
 import android.support.v7.preference.PreferenceViewHolder;
-import android.util.AttributeSet;
+import android.widget.ImageView;
+import com.android.settings.R;
 import com.android.settingslib.wifi.AccessPoint;
 import com.android.settingslib.wifi.AccessPointPreference;
 
@@ -26,12 +27,6 @@
 
     private final Fragment mFragment;
 
-    // Used for dummy pref.
-    public LongPressAccessPointPreference(Context context, AttributeSet attrs) {
-        super(context, attrs);
-        mFragment = null;
-    }
-
     public LongPressAccessPointPreference(AccessPoint accessPoint, Context context,
             UserBadgeCache cache, boolean forSavedNetworks, Fragment fragment) {
         super(accessPoint, context, cache, forSavedNetworks);
@@ -52,5 +47,11 @@
             view.itemView.setTag(this);
             view.itemView.setLongClickable(true);
         }
+
+        ImageView iconImageView = (ImageView) view.findViewById(com.android.internal.R.id.icon);
+        int imageSize = getContext().getResources().getDimensionPixelSize(
+                R.dimen.wifi_picker_icon_size);
+        iconImageView.setMinimumHeight(imageSize);
+        iconImageView.setMinimumWidth(imageSize);
     }
 }
