diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index 7df1ebe..2159cf4 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -7030,6 +7030,8 @@
          */
         public static final String DISPLAY_DENSITY_FORCED = "display_density_forced";
 
+        static final Validator DISPLAY_DENSITY_FORCED_VALIDATOR = NON_NEGATIVE_INTEGER_VALIDATOR;
+
         /**
          * Setting to always use the default text-to-speech settings regardless
          * of the application settings.
@@ -9083,8 +9085,22 @@
         };
 
         /**
-         * All settings in {@link SETTINGS_TO_BACKUP} array *must* have a non-null validator,
-         * otherwise they won't be restored.
+         * The settings values which should only be restored if the target device is the
+         * same as the source device
+         *
+         * NOTE: Settings are backed up and restored in the order they appear
+         *       in this array. If you have one setting depending on another,
+         *       make sure that they are ordered appropriately.
+         *
+         * @hide
+         */
+        public static final String[] DEVICE_SPECIFIC_SETTINGS_TO_BACKUP = {
+                DISPLAY_DENSITY_FORCED,
+        };
+
+        /**
+         * All settings in {@link SETTINGS_TO_BACKUP} and {@link DEVICE_SPECIFIC_SETTINGS_TO_BACKUP}
+         * array *must* have a non-null validator, otherwise they won't be restored.
          *
          * @hide
          */
@@ -9276,6 +9292,7 @@
             VALIDATORS.put(UI_NIGHT_MODE, UI_NIGHT_MODE_VALIDATOR);
             VALIDATORS.put(GLOBAL_ACTIONS_PANEL_ENABLED, GLOBAL_ACTIONS_PANEL_ENABLED_VALIDATOR);
             VALIDATORS.put(AWARE_LOCK_ENABLED, AWARE_LOCK_ENABLED_VALIDATOR);
+            VALIDATORS.put(DISPLAY_DENSITY_FORCED, DISPLAY_DENSITY_FORCED_VALIDATOR);
         }
 
         /**
@@ -13819,6 +13836,9 @@
          *       in this array. If you have one setting depending on another,
          *       make sure that they are ordered appropriately.
          *
+         * NOTE: This table should only be used for settings which should be restored
+         *       between different types of devices {@see #DEVICE_SPECIFIC_SETTINGS_TO_BACKUP}
+         *
          * @hide
          */
         public static final String[] SETTINGS_TO_BACKUP = {
@@ -13863,6 +13883,7 @@
          * @hide
          */
         public static final Map<String, Validator> VALIDATORS = new ArrayMap<>();
+
         static {
             VALIDATORS.put(APPLY_RAMPING_RINGER, APPLY_RAMPING_RINGER_VALIDATOR);
             VALIDATORS.put(BUGREPORT_IN_POWER_MENU, BUGREPORT_IN_POWER_MENU_VALIDATOR);
diff --git a/core/tests/coretests/src/android/provider/SettingsBackupTest.java b/core/tests/coretests/src/android/provider/SettingsBackupTest.java
index 89ba3df..bdbf368 100644
--- a/core/tests/coretests/src/android/provider/SettingsBackupTest.java
+++ b/core/tests/coretests/src/android/provider/SettingsBackupTest.java
@@ -35,6 +35,7 @@
 import org.junit.runner.RunWith;
 
 import java.lang.reflect.Field;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -625,7 +626,6 @@
                  Settings.Secure.DIALER_DEFAULT_APPLICATION,
                  Settings.Secure.DISABLED_PRINT_SERVICES,
                  Settings.Secure.DISABLED_SYSTEM_INPUT_METHODS,
-                 Settings.Secure.DISPLAY_DENSITY_FORCED,
                  Settings.Secure.DOCKED_CLOCK_FACE,
                  Settings.Secure.DOZE_PULSE_ON_LONG_PRESS,
                  Settings.Secure.EMERGENCY_ASSISTANCE_APPLICATION,
@@ -742,9 +742,12 @@
 
     @Test
     public void secureSettingsBackedUpOrBlacklisted() {
+        HashSet<String> keys = new HashSet<String>();
+        Collections.addAll(keys, Settings.Secure.SETTINGS_TO_BACKUP);
+        Collections.addAll(keys, Settings.Secure.DEVICE_SPECIFIC_SETTINGS_TO_BACKUP);
         checkSettingsBackedUpOrBlacklisted(
                 getCandidateSettings(Settings.Secure.class),
-                newHashSet(Settings.Secure.SETTINGS_TO_BACKUP),
+                keys,
             BACKUP_BLACKLISTED_SECURE_SETTINGS);
     }
 
@@ -758,9 +761,9 @@
                 is(empty()));
 
         assertThat(
-            "blacklisted settings backed up",
-            intersect(settingsToBackup, blacklist),
-            is(empty()));
+                "blacklisted settings backed up",
+                intersect(settingsToBackup, blacklist),
+                is(empty()));
     }
 
     private static Set<String> getCandidateSettings(Class<? extends Settings.NameValueTable> clazz) {
diff --git a/packages/SettingsProvider/Android.bp b/packages/SettingsProvider/Android.bp
index 1c97fc3..e54b847 100644
--- a/packages/SettingsProvider/Android.bp
+++ b/packages/SettingsProvider/Android.bp
@@ -9,7 +9,10 @@
         "telephony-common",
         "ims-common",
     ],
-    static_libs: ["junit"],
+    static_libs: [
+        "junit",
+        "SettingsLib",
+    ],
     platform_apis: true,
     certificate: "platform",
     privileged: true,
@@ -21,11 +24,18 @@
     // because this test is not an instrumentation test. (because the target runs in the system process.)
     srcs: [
         "test/**/*.java",
+        "src/com/android/providers/settings/SettingsBackupAgent.java",
         "src/com/android/providers/settings/SettingsState.java",
         "src/com/android/providers/settings/SettingsHelper.java",
     ],
-    static_libs: ["androidx.test.rules"],
-    libs: ["android.test.base"],
+    static_libs: [
+        "androidx.test.rules",
+        "SettingsLib",
+    ],
+    libs: [
+        "android.test.base",
+        "android.test.mock",
+    ],
     resource_dirs: ["res"],
     aaptflags: [
         "--auto-add-overlay",
diff --git a/packages/SettingsProvider/src/com/android/providers/settings/SettingsBackupAgent.java b/packages/SettingsProvider/src/com/android/providers/settings/SettingsBackupAgent.java
index 7d56868..2286f4c 100644
--- a/packages/SettingsProvider/src/com/android/providers/settings/SettingsBackupAgent.java
+++ b/packages/SettingsProvider/src/com/android/providers/settings/SettingsBackupAgent.java
@@ -39,9 +39,13 @@
 import android.util.ArraySet;
 import android.util.BackupUtils;
 import android.util.Log;
+import android.util.Slog;
+import android.view.Display;
 
+import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.util.ArrayUtils;
 import com.android.internal.widget.LockPatternUtils;
+import com.android.settingslib.display.DisplayDensityUtils;
 
 import java.io.BufferedOutputStream;
 import java.io.ByteArrayInputStream;
@@ -52,11 +56,14 @@
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.OutputStream;
 import java.time.DateTimeException;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.zip.CRC32;
 
 /**
@@ -78,10 +85,11 @@
     private static final String KEY_SOFTAP_CONFIG = "softap_config";
     private static final String KEY_NETWORK_POLICIES = "network_policies";
     private static final String KEY_WIFI_NEW_CONFIG = "wifi_new_config";
+    private static final String KEY_DEVICE_SPECIFIC_CONFIG = "device_specific_config";
 
     // Versioning of the state file.  Increment this version
     // number any time the set of state items is altered.
-    private static final int STATE_VERSION = 7;
+    private static final int STATE_VERSION = 8;
 
     // Versioning of the Network Policies backup payload.
     private static final int NETWORK_POLICIES_BACKUP_VERSION = 1;
@@ -99,8 +107,9 @@
     private static final int STATE_SOFTAP_CONFIG    = 7;
     private static final int STATE_NETWORK_POLICIES = 8;
     private static final int STATE_WIFI_NEW_CONFIG  = 9;
+    private static final int STATE_DEVICE_CONFIG    = 10;
 
-    private static final int STATE_SIZE             = 10; // The current number of state items
+    private static final int STATE_SIZE             = 11; // The current number of state items
 
     // Number of entries in the checksum array at various version numbers
     private static final int STATE_SIZES[] = {
@@ -111,17 +120,19 @@
             7,              // version 4 added STATE_LOCK_SETTINGS
             8,              // version 5 added STATE_SOFTAP_CONFIG
             9,              // version 6 added STATE_NETWORK_POLICIES
-            STATE_SIZE      // version 7 added STATE_WIFI_NEW_CONFIG
+            10,             // version 7 added STATE_WIFI_NEW_CONFIG
+            STATE_SIZE      // version 8 added STATE_DEVICE_CONFIG
     };
 
-    // Versioning of the 'full backup' format
-    // Increment this version any time a new item is added
-    private static final int FULL_BACKUP_VERSION = 6;
     private static final int FULL_BACKUP_ADDED_GLOBAL = 2;  // added the "global" entry
     private static final int FULL_BACKUP_ADDED_LOCK_SETTINGS = 3; // added the "lock_settings" entry
     private static final int FULL_BACKUP_ADDED_SOFTAP_CONF = 4; //added the "softap_config" entry
     private static final int FULL_BACKUP_ADDED_NETWORK_POLICIES = 5; //added "network_policies"
     private static final int FULL_BACKUP_ADDED_WIFI_NEW = 6; // added "wifi_new_config" entry
+    private static final int FULL_BACKUP_ADDED_DEVICE_SPECIFIC = 7; // added "device specific" entry
+    // Versioning of the 'full backup' format
+    // Increment this version any time a new item is added
+    private static final int FULL_BACKUP_VERSION = FULL_BACKUP_ADDED_DEVICE_SPECIFIC;
 
     private static final int INTEGER_BYTE_COUNT = Integer.SIZE / Byte.SIZE;
 
@@ -129,11 +140,17 @@
 
     private static final String TAG = "SettingsBackupAgent";
 
-    private static final String[] PROJECTION = {
+    @VisibleForTesting
+    static final String[] PROJECTION = {
             Settings.NameValueTable.NAME,
             Settings.NameValueTable.VALUE
     };
 
+    // Versioning of the 'device specific' section of a backup
+    // Increment this any time the format is changed or data added.
+    @VisibleForTesting
+    static final int DEVICE_SPECIFIC_VERSION = 1;
+
     // the key to store the WIFI data under, should be sorted as last, so restore happens last.
     // use very late unicode character to quasi-guarantee last sort position.
     private static final String KEY_WIFI_SUPPLICANT = "\uffedWIFI";
@@ -161,7 +178,8 @@
                 KEY_GLOBAL,
             }));
 
-    private SettingsHelper mSettingsHelper;
+    @VisibleForTesting
+    SettingsHelper mSettingsHelper;
 
     private WifiManager mWifiManager;
 
@@ -190,6 +208,7 @@
         byte[] softApConfigData = getSoftAPConfiguration();
         byte[] netPoliciesData = getNetworkPolicies();
         byte[] wifiFullConfigData = getNewWifiConfigData();
+        byte[] deviceSpecificInformation = getDeviceSpecificConfiguration();
 
         long[] stateChecksums = readOldChecksums(oldState);
 
@@ -215,6 +234,9 @@
         stateChecksums[STATE_WIFI_NEW_CONFIG] =
                 writeIfChanged(stateChecksums[STATE_WIFI_NEW_CONFIG], KEY_WIFI_NEW_CONFIG,
                         wifiFullConfigData, data);
+        stateChecksums[STATE_DEVICE_CONFIG] =
+                writeIfChanged(stateChecksums[STATE_DEVICE_CONFIG], KEY_DEVICE_SPECIFIC_CONFIG,
+                        deviceSpecificInformation, data);
 
         writeNewChecksums(stateChecksums, newState);
     }
@@ -313,6 +335,12 @@
                     restoreNewWifiConfigData(restoredWifiNewConfigData);
                     break;
 
+                case KEY_DEVICE_SPECIFIC_CONFIG:
+                    byte[] restoredDeviceSpecificConfig = new byte[size];
+                    data.readEntityData(restoredDeviceSpecificConfig, 0, size);
+                    restoreDeviceSpecificConfig(restoredDeviceSpecificConfig);
+                    break;
+
                 default :
                     data.skipEntityData();
 
@@ -591,6 +619,11 @@
 
     private void restoreSettings(byte[] settings, int bytes, Uri contentUri,
             HashSet<String> movedToGlobal, Set<String> movedToSecure) {
+        restoreSettings(settings, 0, bytes, contentUri, movedToGlobal, movedToSecure);
+    }
+
+    private void restoreSettings(byte[] settings, int pos, int bytes, Uri contentUri,
+                HashSet<String> movedToGlobal, Set<String> movedToSecure) {
         if (DEBUG) {
             Log.i(TAG, "restoreSettings: " + contentUri);
         }
@@ -601,7 +634,8 @@
         Map<String, Validator> validators = null;
         if (contentUri.equals(Settings.Secure.CONTENT_URI)) {
             whitelist = ArrayUtils.concatElements(String.class, Settings.Secure.SETTINGS_TO_BACKUP,
-                    Settings.Secure.LEGACY_RESTORE_SETTINGS);
+                    Settings.Secure.LEGACY_RESTORE_SETTINGS,
+                    Settings.Secure.DEVICE_SPECIFIC_SETTINGS_TO_BACKUP);
             validators = Settings.Secure.VALIDATORS;
         } else if (contentUri.equals(Settings.System.CONTENT_URI)) {
             whitelist = ArrayUtils.concatElements(String.class, Settings.System.SETTINGS_TO_BACKUP,
@@ -616,7 +650,6 @@
         }
 
         // Restore only the white list data.
-        int pos = 0;
         final ArrayMap<String, String> cachedEntries = new ArrayMap<>();
         ContentValues contentValues = new ContentValues(2);
         SettingsHelper settingsHelper = mSettingsHelper;
@@ -940,6 +973,150 @@
         }
     }
 
+    @VisibleForTesting
+    byte[] getDeviceSpecificConfiguration() throws IOException {
+        try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
+            writeHeader(os);
+            os.write(getDeviceSpecificSettings());
+            return os.toByteArray();
+        }
+    }
+
+    @VisibleForTesting
+    void writeHeader(OutputStream os) throws IOException {
+        os.write(toByteArray(DEVICE_SPECIFIC_VERSION));
+        os.write(toByteArray(Build.MANUFACTURER));
+        os.write(toByteArray(Build.PRODUCT));
+    }
+
+    private byte[] getDeviceSpecificSettings() {
+        try (Cursor cursor =
+                     getContentResolver()
+                             .query(Settings.Secure.CONTENT_URI, PROJECTION, null, null, null)) {
+            return extractRelevantValues(
+                    cursor, Settings.Secure.DEVICE_SPECIFIC_SETTINGS_TO_BACKUP);
+        }
+    }
+
+    /**
+     * Restore the device specific settings.
+     *
+     * @param data The byte array holding a backed up version of another devices settings.
+     * @return true if the restore succeeded, false if it was stopped.
+     */
+    @VisibleForTesting
+    boolean restoreDeviceSpecificConfig(byte[] data) {
+        // We're using an AtomicInteger to wrap the position int and allow called methods to
+        // modify it.
+        AtomicInteger pos = new AtomicInteger(0);
+        if (!isSourceAcceptable(data, pos)) {
+            return false;
+        }
+
+        Integer originalDensity = getPreviousDensity();
+
+        int dataStart = pos.get();
+        restoreSettings(
+                data, dataStart, data.length, Settings.Secure.CONTENT_URI, null, null);
+
+        updateWindowManagerIfNeeded(originalDensity);
+
+        return true;
+    }
+
+    private void updateWindowManagerIfNeeded(Integer previousDensity) {
+        int newDensity;
+        try {
+            newDensity = getForcedDensity();
+        } catch (Settings.SettingNotFoundException e) {
+            // If there's not density setting we can't perform a change.
+            return;
+        }
+
+        if (previousDensity == null || previousDensity != newDensity) {
+            // From nothing to something is a change.
+            DisplayDensityUtils.setForcedDisplayDensity(Display.DEFAULT_DISPLAY, newDensity);
+        }
+    }
+
+    private Integer getPreviousDensity() {
+        try {
+            return getForcedDensity();
+        } catch (Settings.SettingNotFoundException e) {
+            return null;
+        }
+    }
+
+    private int getForcedDensity() throws Settings.SettingNotFoundException {
+        return Settings.Secure.getInt(getContentResolver(), Settings.Secure.DISPLAY_DENSITY_FORCED);
+    }
+
+    @VisibleForTesting
+    boolean isSourceAcceptable(byte[] data, AtomicInteger pos) {
+        int version = readInt(data, pos);
+        if (version > DEVICE_SPECIFIC_VERSION) {
+            Slog.w(TAG, "Unable to restore device specific information; Backup is too new");
+            return false;
+        }
+
+        String sourceManufacturer = readString(data, pos);
+        if (!Objects.equals(Build.MANUFACTURER, sourceManufacturer)) {
+            Log.w(
+                    TAG,
+                    "Unable to restore device specific information; Manufacturer mismatch "
+                            + "(\'"
+                            + Build.MANUFACTURER
+                            + "\' and \'"
+                            + sourceManufacturer
+                            + "\')");
+            return false;
+        }
+
+        String sourceProduct = readString(data, pos);
+        if (!Objects.equals(Build.PRODUCT, sourceProduct)) {
+            Log.w(
+                    TAG,
+                    "Unable to restore device specific information; Product mismatch (\'"
+                            + Build.PRODUCT
+                            + "\' and \'"
+                            + sourceProduct
+                            + "\')");
+            return false;
+        }
+
+        return true;
+    }
+
+    @VisibleForTesting
+    static byte[] toByteArray(String value) {
+        if (value == null) {
+            return toByteArray(NULL_SIZE);
+        }
+
+        byte[] stringBytes = value.getBytes();
+        byte[] sizeAndString = new byte[stringBytes.length + INTEGER_BYTE_COUNT];
+        writeInt(sizeAndString, 0, stringBytes.length);
+        writeBytes(sizeAndString, INTEGER_BYTE_COUNT, stringBytes);
+        return sizeAndString;
+    }
+
+    @VisibleForTesting
+    static byte[] toByteArray(int value) {
+        byte[] result = new byte[INTEGER_BYTE_COUNT];
+        writeInt(result, 0, value);
+        return result;
+    }
+
+    private String readString(byte[] data, AtomicInteger pos) {
+        int byteCount = readInt(data, pos);
+        if (byteCount == NULL_SIZE) {
+            return null;
+        }
+
+        int stringStart = pos.getAndAdd(byteCount);
+        return new String(data, stringStart, byteCount);
+    }
+
     /**
      * Write an int in BigEndian into the byte array.
      * @param out byte array
@@ -947,7 +1124,7 @@
      * @param value integer to write
      * @return the index after adding the size of an int (4) in bytes.
      */
-    private int writeInt(byte[] out, int pos, int value) {
+    private static int writeInt(byte[] out, int pos, int value) {
         out[pos + 0] = (byte) ((value >> 24) & 0xFF);
         out[pos + 1] = (byte) ((value >> 16) & 0xFF);
         out[pos + 2] = (byte) ((value >>  8) & 0xFF);
@@ -955,11 +1132,15 @@
         return pos + INTEGER_BYTE_COUNT;
     }
 
-    private int writeBytes(byte[] out, int pos, byte[] value) {
+    private static int writeBytes(byte[] out, int pos, byte[] value) {
         System.arraycopy(value, 0, out, pos, value.length);
         return pos + value.length;
     }
 
+    private int readInt(byte[] in, AtomicInteger pos) {
+        return readInt(in, pos.getAndAdd(INTEGER_BYTE_COUNT));
+    }
+
     private int readInt(byte[] in, int pos) {
         int result = ((in[pos] & 0xFF) << 24)
                 | ((in[pos + 1] & 0xFF) << 16)
diff --git a/packages/SettingsProvider/test/src/com/android/providers/settings/SettingsBackupAgentTest.java b/packages/SettingsProvider/test/src/com/android/providers/settings/SettingsBackupAgentTest.java
new file mode 100644
index 0000000..cf8e1a5
--- /dev/null
+++ b/packages/SettingsProvider/test/src/com/android/providers/settings/SettingsBackupAgentTest.java
@@ -0,0 +1,272 @@
+/*
+ * 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.providers.settings;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+import static org.junit.Assert.assertArrayEquals;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.Settings;
+import android.test.mock.MockContentProvider;
+import android.test.mock.MockContentResolver;
+
+import androidx.test.runner.AndroidJUnit4;
+
+import com.android.internal.annotations.VisibleForTesting;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/** Tests for the SettingsHelperTest */
+@RunWith(AndroidJUnit4.class)
+public class SettingsBackupAgentTest extends BaseSettingsProviderTest {
+
+    private static final String TEST_DISPLAY_DENSITY_FORCED = "123";
+    private static final Map<String, String> TEST_VALUES = new HashMap<>();
+
+    static {
+        TEST_VALUES.put(Settings.Secure.DISPLAY_DENSITY_FORCED, TEST_DISPLAY_DENSITY_FORCED);
+    }
+
+    private TestFriendlySettingsBackupAgent mAgentUnderTest;
+    private Context mContext;
+
+    @Before
+    public void setUp() {
+        mContext = new ContextWithMockContentResolver(getContext());
+
+        mAgentUnderTest = new TestFriendlySettingsBackupAgent();
+        mAgentUnderTest.attach(mContext);
+    }
+
+    @Test
+    public void testRoundTripDeviceSpecificSettings() throws IOException {
+        TestSettingsHelper helper = new TestSettingsHelper(mContext);
+        mAgentUnderTest.mSettingsHelper = helper;
+
+        byte[] settingsBackup = mAgentUnderTest.getDeviceSpecificConfiguration();
+
+        assertEquals("Not all values backed up.", TEST_VALUES.keySet(), helper.mReadEntries);
+
+        mAgentUnderTest.restoreDeviceSpecificConfig(settingsBackup);
+
+        assertEquals("Not all values were restored.", TEST_VALUES, helper.mWrittenValues);
+    }
+
+    @Test
+    public void testGeneratedHeaderMatchesCurrentDevice() throws IOException {
+        mAgentUnderTest.mSettingsHelper = new TestSettingsHelper(mContext);
+
+        byte[] header = generateUncorruptedHeader();
+
+        AtomicInteger pos = new AtomicInteger(0);
+        assertTrue(
+                "Generated header is not correct for device.",
+                mAgentUnderTest.isSourceAcceptable(header, pos));
+    }
+
+    @Test
+    public void testTestHeaderGeneratorIsAccurate() throws IOException {
+        byte[] classGeneratedHeader = generateUncorruptedHeader();
+        byte[] testGeneratedHeader = generateCorruptedHeader(false, false, false);
+
+        assertArrayEquals(
+                "Difference in header generation", classGeneratedHeader, testGeneratedHeader);
+    }
+
+    @Test
+    public void testNewerHeaderVersionFailsMatch() throws IOException {
+        byte[] header = generateCorruptedHeader(true, false, false);
+
+        AtomicInteger pos = new AtomicInteger(0);
+        assertFalse(
+                "Newer header does not fail match",
+                mAgentUnderTest.isSourceAcceptable(header, pos));
+    }
+
+    @Test
+    public void testWrongManufacturerFailsMatch() throws IOException {
+        byte[] header = generateCorruptedHeader(false, true, false);
+
+        AtomicInteger pos = new AtomicInteger(0);
+        assertFalse(
+                "Wrong manufacturer does not fail match",
+                mAgentUnderTest.isSourceAcceptable(header, pos));
+    }
+
+    @Test
+    public void testWrongProductFailsMatch() throws IOException {
+        byte[] header = generateCorruptedHeader(false, false, true);
+
+        AtomicInteger pos = new AtomicInteger(0);
+        assertFalse(
+                "Wrong product does not fail match",
+                mAgentUnderTest.isSourceAcceptable(header, pos));
+    }
+
+    @Test
+    public void checkAcceptTestFailingBlockRestore() {
+        mAgentUnderTest.setForcedDeviceInfoRestoreAcceptability(false);
+        byte[] data = new byte[0];
+
+        assertFalse(
+                "Blocking isSourceAcceptable did not stop restore",
+                mAgentUnderTest.restoreDeviceSpecificConfig(data));
+    }
+
+    private byte[] generateUncorruptedHeader() throws IOException {
+        try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
+            mAgentUnderTest.writeHeader(os);
+            return os.toByteArray();
+        }
+    }
+
+    private byte[] generateCorruptedHeader(
+            boolean corruptVersion, boolean corruptManufacturer, boolean corruptProduct)
+            throws IOException {
+        try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
+            int version = SettingsBackupAgent.DEVICE_SPECIFIC_VERSION;
+            if (corruptVersion) {
+                version++;
+            }
+            os.write(SettingsBackupAgent.toByteArray(version));
+
+            String manufacturer = Build.MANUFACTURER;
+            if (corruptManufacturer) {
+                manufacturer = manufacturer == null ? "X" : manufacturer + "X";
+            }
+            os.write(SettingsBackupAgent.toByteArray(manufacturer));
+
+            String product = Build.PRODUCT;
+            if (corruptProduct) {
+                product = product == null ? "X" : product + "X";
+            }
+            os.write(SettingsBackupAgent.toByteArray(product));
+
+            return os.toByteArray();
+        }
+    }
+
+    private static class TestFriendlySettingsBackupAgent extends SettingsBackupAgent {
+        private Boolean mForcedDeviceInfoRestoreAcceptability = null;
+
+        void setForcedDeviceInfoRestoreAcceptability(boolean value) {
+            mForcedDeviceInfoRestoreAcceptability = value;
+        }
+
+        @VisibleForTesting
+        boolean isSourceAcceptable(byte[] data, AtomicInteger pos) {
+            return mForcedDeviceInfoRestoreAcceptability == null
+                    ? super.isSourceAcceptable(data, pos)
+                    : mForcedDeviceInfoRestoreAcceptability;
+        }
+    }
+
+    /** The TestSettingsHelper tracks which values have been backed up and/or restored. */
+    private static class TestSettingsHelper extends SettingsHelper {
+        private Set<String> mReadEntries;
+        private Map<String, String> mWrittenValues;
+
+        TestSettingsHelper(Context context) {
+            super(context);
+            mReadEntries = new HashSet<>();
+            mWrittenValues = new HashMap<>();
+        }
+
+        @Override
+        public String onBackupValue(String key, String value) {
+            mReadEntries.add(key);
+            String readValue = TEST_VALUES.get(key);
+            assert readValue != null;
+            return readValue;
+        }
+
+        @Override
+        public void restoreValue(
+                Context context,
+                ContentResolver cr,
+                ContentValues contentValues,
+                Uri destination,
+                String name,
+                String value,
+                int restoredFromSdkInt) {
+            mWrittenValues.put(name, value);
+        }
+    }
+
+    /**
+     * ContextWrapper which allows us to return a MockContentResolver to code which uses it to
+     * access settings. This allows us to override the ContentProvider for the Settings URIs to
+     * return known values.
+     */
+    private static class ContextWithMockContentResolver extends ContextWrapper {
+        private MockContentResolver mContentResolver;
+
+        ContextWithMockContentResolver(Context targetContext) {
+            super(targetContext);
+
+            mContentResolver = new MockContentResolver();
+            mContentResolver.addProvider(
+                    Settings.AUTHORITY, new DeviceSpecificInfoMockContentProvider());
+        }
+
+        @Override
+        public ContentResolver getContentResolver() {
+            return mContentResolver;
+        }
+    }
+
+    /** ContentProvider which returns a set of known test values. */
+    private static class DeviceSpecificInfoMockContentProvider extends MockContentProvider {
+        private static final Object[][] RESULT_ROWS = {
+            {Settings.Secure.DISPLAY_DENSITY_FORCED, TEST_DISPLAY_DENSITY_FORCED},
+        };
+
+        @Override
+        public Cursor query(
+                Uri uri,
+                String[] projection,
+                String selection,
+                String[] selectionArgs,
+                String sortOrder) {
+            MatrixCursor result = new MatrixCursor(SettingsBackupAgent.PROJECTION);
+            for (Object[] resultRow : RESULT_ROWS) {
+                result.addRow(resultRow);
+            }
+            return result;
+        }
+    }
+}