Lazy init prefs in MD Settings

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 69 matching lines @@
 
   Polymer({
     is: 'cr-settings-prefs',
 
     properties: {
       /**
        * Object containing all preferences, for use by Polymer controls.
        */
       prefs: {
         type: Object,
-        value: function() { return {}; },
         notify: true,
       },
 
       /**
        * Map of pref keys to PrefWrapper objects representing the state of the
        * Chrome pref store.
        * @type {Object<PrefWrapper>}
        * @private
        */
       prefWrappers_: {
@@ skipping 81 matching lines @@
 
       // Get the current pref value from chrome.settingsPrivate to ensure the
       // UI stays up to date.
       chrome.settingsPrivate.getPref(key, function(pref) {
         this.updatePrefs_([pref]);
       }.bind(this));
     },
 
     /**
      * Updates the prefs model with the given prefs.
-     * @param {!Array<!chrome.settingsPrivate.PrefObject>} prefs
+     * @param {!Array<!chrome.settingsPrivate.PrefObject>} newPrefs
      * @private
      */
-    updatePrefs_: function(prefs) {
-      prefs.forEach(function(newPrefObj) {
+    updatePrefs_: function(newPrefs) {
+      // Use the existing prefs object or create it.
+      var prefs = this.prefs || {};
+      newPrefs.forEach(function(newPrefObj) {
         // Use the PrefObject from settingsPrivate to create a PrefWrapper in
         // prefWrappers_ at the pref's key.
         this.prefWrappers_[newPrefObj.key] =
             this.createPrefWrapper_(newPrefObj);
 
-        // Set or update the pref in |prefs|. This triggers observers in the UI,
-        // which update controls associated with the pref.
-        this.setPref_(newPrefObj);
+        // Add the pref to |prefs|.
+        cr.exportPath(newPrefObj.key, newPrefObj, prefs);
+        // If this.prefs already exists, notify listeners of the change.
+        if (prefs == this.prefs)
+          this.notifyPath('prefs.' + newPrefObj.key, newPrefObj);
       }, this);
+      if (!this.prefs)
+        this.prefs = prefs;
     },
 
     /**
      * Given a 'property-changed' path, returns the key of the preference the
      * path refers to. E.g., if the path of the changed property is
      * 'prefs.search.suggest_enabled.value', the key of the pref that changed is
      * 'search.suggest_enabled'.
      * @param {string} path
      * @return {string}
      * @private
      */
     getPrefKeyFromPath_: function(path) {
       // Skip the first token, which refers to the member variable (this.prefs).
       var parts = path.split('.');
       assert(parts.shift() == 'prefs');
 
       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.
-     * @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);
-      }
-    },
-
-    /**
      * 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);
     },
   });
 })();