Support lists in <cr-settings-pref>

chrome/test/data/webui/settings/prefs_tests.js

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** @fileoverview Suite of tests for cr-settings-prefs. */
 cr.define('cr_settings_prefs', function() {
   /**
+   * Creates a deep copy of the object.
+   * @param {!Object} obj
+   * @return {!Object}
+   */
+  function deepCopy(obj) {
+    return JSON.parse(JSON.stringify(obj));
+  }
+
+  /**
    * Mock of chrome.settingsPrivate API.
    * @constructor
    * @extends {chrome.settingsPrivate}
    */
   function MockSettingsApi() {
     this.prefs = {};
     this.listener_ = null;
 
     // Hack alert: bind this instance's onPrefsChanged members to this.
     this.onPrefsChanged = {
@@ skipping 15 matching lines @@
       removeListener: function(listener) {
         expectNotEquals(null, this.listener_);
         this.listener_ = null;
       },
     },
 
     getAllPrefs: function(callback) {
       // Send a copy of prefs to keep our internal state private.
       var prefs = [];
       for (var key in this.prefs)
-        prefs.push(Object.assign({}, this.prefs[key]));
+        prefs.push(deepCopy(this.prefs[key]));
 
       callback(prefs);
     },
 
     setPref: function(key, value, pageId, callback) {
       var pref = this.prefs[key];
       assertNotEquals(undefined, pref);
       assertEquals(typeof value, typeof pref.value);
       assertEquals(Array.isArray(value), Array.isArray(pref.value));
 
       if (this.failNextSetPref_) {
         callback(false);
         this.failNextSetPref_ = false;
         return;
       }
       assertNotEquals(true, this.disallowSetPref_);
 
-      // TODO(michaelpg): support list and dict prefs.
-      var changed = pref.value != value;
-      pref.value = value;
+      var changed = JSON.stringify(pref.value) != JSON.stringify(value);
+      pref.value = deepCopy(value);
       callback(true);
 
       // Like chrome.settingsPrivate, send a notification when prefs change.
       if (changed)
-        this.sendPrefChanges([{key: key, value: value}]);
+        this.sendPrefChanges([{key: key, value: deepCopy(value)}]);
     },
 
     getPref: function(key, callback) {
       var pref = this.prefs[key];
       assertNotEquals(undefined, pref);
-      callback(Object.assign({}, pref));
+      callback(deepCopy(pref));
     },
 
     // Functions used by tests.
 
     /** Instructs the API to return a failure when setPref is next called. */
     failNextSetPref: function() {
       this.failNextSetPref_ = true;
     },
 
     /** Instructs the API to assert (fail the test) if setPref is called. */
     disallowSetPref: function() {
       this.disallowSetPref_ = true;
     },
 
     allowSetPref: function() {
       this.disallowSetPref_ = false;
     },
 
     /**
      * Notifies the listener of pref changes.
      * @param {!Object<{key: string, value: *}>} changes
      */
     sendPrefChanges: function(changes) {
       var prefs = [];
       for (var change of changes) {
         var pref = this.prefs[change.key];
         assertNotEquals(undefined, pref);
         pref.value = change.value;
-        prefs.push(Object.assign({}, pref));
+        prefs.push(deepCopy(pref));
       }
       this.listener_(prefs);
     },
 
     // Private methods for use by the mock API.
 
     /**
      * @param {!chrome.settingsPrivate.PrefType} type
      * @param {string} key
      * @param {*} value
@@ skipping 100 matching lines @@
             continue;
           }
 
           expectEquals(JSON.stringify(expectedPref),
                        JSON.stringify(actualPref));
         }
       });
 
       test('forwards pref changes to API', function() {
         // Test that cr-settings-prefs uses the setPref API.
-        for (var testCase of prefsTestCases)
-          prefs.set('prefs.' + testCase.key + '.value', testCase.values[1]);
-
+        for (var testCase of prefsTestCases) {
+          prefs.set('prefs.' + testCase.key + '.value',
+                    deepCopy(testCase.values[1]));
+        }
         // Check that setPref has been called for the right values.
         expectMockApiPrefsSet(1);
 
         // Test that when setPref fails, the pref is reverted locally.
         for (var testCase of prefsTestCases) {
           mockApi.failNextSetPref();
-          prefs.set('prefs.' + testCase.key + '.value', testCase.values[2]);
+          prefs.set('prefs.' + testCase.key + '.value',
+                    deepCopy(testCase.values[2]));
         }
 
         expectPrefsSet(1);
 
         // Test that setPref is not called when the pref doesn't change.
         mockApi.disallowSetPref();
-        for (var testCase of prefsTestCases)
-          prefs.set('prefs.' + testCase.key + '.value', testCase.values[1]);
-
+        for (var testCase of prefsTestCases) {
+          prefs.set('prefs.' + testCase.key + '.value',
+                    deepCopy(testCase.values[1]));
+        }
         expectMockApiPrefsSet(1);
         mockApi.allowSetPref();
       });
 
       test('responds to API changes', function() {
         // Changes from the API should not result in those changes being sent
         // back to the API, as this could trigger a race condition.
         mockApi.disallowSetPref();
         var prefChanges = [];
         for (var testCase of prefsTestCases)
@@ skipping 15 matching lines @@
         mockApi.sendPrefChanges(prefChanges);
         expectPrefsSet(2);
       });
     });
   }
 
   return {
     registerTests: registerTests,
   };
 });