Add Polymer tests for cr-settings-prefs

chrome/browser/resources/settings/prefs/prefs.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
  * 'cr-settings-prefs' models Chrome settings and preferences, listening for
  * changes to Chrome prefs whitelisted in chrome.settingsPrivate.
  * When changing prefs in this element's 'prefs' property via the UI, this
  * element tries to set those preferences in Chrome. Whether or not the calls to
@@ skipping 89 matching lines @@
       prefWrappers_: {
         type: Object,
         value: function() { return {}; },
       },
     },
 
     observers: [
       'prefsChanged_(prefs.*)',
     ],
 
+    settingsApi_: chrome.settingsPrivate,
+
     /** @override */
     created: function() {
+      // Set window.mockApi to pass a custom settings API, i.e. for tests.
+      // TODO(michaelpg): don't use a global.
+      if (window.mockApi)
+        this.settingsApi_ = window.mockApi;
       CrSettingsPrefs.isInitialized = false;
 
-      chrome.settingsPrivate.onPrefsChanged.addListener(
+      this.settingsApi_.onPrefsChanged.addListener(
           this.onSettingsPrivatePrefsChanged_.bind(this));
-      chrome.settingsPrivate.getAllPrefs(
+      this.settingsApi_.getAllPrefs(
           this.onSettingsPrivatePrefsFetched_.bind(this));
     },
 
     /**
      * Polymer callback for changes to this.prefs.
      * @param {!{path: string, value: *}} change
      * @private
      */
     prefsChanged_: function(change) {
       if (!CrSettingsPrefs.isInitialized)
         return;
 
       var key = this.getPrefKeyFromPath_(change.path);
+      if (!key)

[stevenjb, 2015/09/11 21:03:47]

Should this normally happen? If not, maybe log an error?

[michaelpg, 2015/09/13 03:01:05]

I can't recall why or when this may happen. It's probably obsolete and doesn't
seem to get happen anymore, so I removed it.

+        return;
+
       var prefWrapper = this.prefWrappers_[key];
       if (!prefWrapper)
         return;
 
       var prefObj = /** @type {chrome.settingsPrivate.PrefObject} */(
           this.get(key, this.prefs));
 
       // If settingsPrivate already has this value, do nothing. (Otherwise,
       // a change event from settingsPrivate could make us call
       // settingsPrivate.setPref and potentially trigger an IPC loop.)
       if (prefWrapper.equals(this.createPrefWrapper_(prefObj)))
         return;
 
-      chrome.settingsPrivate.setPref(
+      this.settingsApi_.setPref(
           key,
           prefObj.value,
           /* pageId */ '',
           /* callback */ this.setPrefCallback_.bind(this, key));
     },
 
     /**
      * Called when prefs in the underlying Chrome pref store are changed.
      * @param {!Array<!chrome.settingsPrivate.PrefObject>} prefs
      *     The prefs that changed.
@@ skipping 21 matching lines @@
      * @param {string} key The key used in the call to setPref.
      * @param {boolean} success True if setting the pref succeeded.
      * @private
      */
     setPrefCallback_: function(key, success) {
       if (success)
         return;
 
       // Get the current pref value from chrome.settingsPrivate to ensure the
       // UI stays up to date.
-      chrome.settingsPrivate.getPref(key, function(pref) {
+      this.settingsApi_.getPref(key, function(pref) {
         this.updatePrefs_([pref]);
       }.bind(this));
     },
 
     /**
      * Updates the prefs model with the given prefs.
      * @param {!Array<!chrome.settingsPrivate.PrefObject>} prefs
      * @private
      */
     updatePrefs_: function(prefs) {
@@ skipping 26 matching lines @@
       for (let i = 1; i <= parts.length; i++) {
         let key = parts.slice(0, i).join('.');
         // The prefWrappers_ keys match the pref keys.
         if (this.prefWrappers_[key] != undefined)
           return key;
       }
       return '';
     },
 
     /**
-     * Sets or updates the pref denoted by newPrefObj.key in the publicy exposed
-     * |prefs| property.
+     * Sets or updates the pref denoted by newPrefObj.key in the publicly
+     * exposed |prefs| property.
      * @param {chrome.settingsPrivate.PrefObject} newPrefObj The pref object to
      *     update the pref with.
      * @private
      */
     setPref_: function(newPrefObj) {
-      // Check if the pref exists already in the Polymer |prefs| object.
-      if (this.get(newPrefObj.key, this.prefs)) {
-        // Update just the value, notifying listeners of the change.
-        this.set('prefs.' + newPrefObj.key + '.value', newPrefObj.value);
-      } else {
-        // Add the pref to |prefs|. cr.exportPath doesn't use Polymer.Base.set,
-        // which is OK because the nested property update events aren't useful.
-        cr.exportPath(newPrefObj.key, newPrefObj, this.prefs);
-        // Notify listeners of the change at the preference key.
-        this.notifyPath('prefs.' + newPrefObj.key, newPrefObj);
-      }
+      // Add the pref to |prefs|. cr.exportPath doesn't use Polymer.Base.set,
+      // which is OK because the nested property update events aren't useful.
+      cr.exportPath(newPrefObj.key, newPrefObj, this.prefs);
+      // Notify listeners of the change at the preference key.
+      this.notifyPath('prefs.' + newPrefObj.key, newPrefObj);
     },
 
     /**
      * Creates a PrefWrapper object from a chrome.settingsPrivate pref.
      * @param {!chrome.settingsPrivate.PrefObject} prefObj
      *     PrefObject received from chrome.settingsPrivate.
      * @return {PrefWrapper} An object containing a copy of the PrefObject's
      *     value.
      * @private
      */
     createPrefWrapper_: function(prefObj) {
       return prefObj.type == chrome.settingsPrivate.PrefType.LIST ?
           new ListPrefWrapper(prefObj) : new PrefWrapper(prefObj);
     },
   });
 })();