[MD Settings] Stop prefs singleton firing change events at initialization

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
  * 'settings-prefs' exposes a singleton model of Chrome settings and
  * preferences, which listens to changes to Chrome prefs whitelisted in
  * chrome.settingsPrivate. When changing prefs in this element's 'prefs'
  * property via the UI, the singleton model tries to set those preferences in
@@ skipping 190 matching lines @@
     },
 
     /**
      * Forwards changes to this.prefs to settings-prefs-singleton.
      * @private
      */
     prefsChanged_: function(info) {
       // Ignore changes that came from singleton_ so we don't re-process
       // changes made in other instances of this element.
       if (!this.ignoreChanges_)
-        this.singleton_.fire('prefs-changed', info, {bubbles: false});
+        this.singleton_.fire('shared-prefs-changed', info, {bubbles: false});
     },
 
     /**
      * Sets ignoreChanged_ before calling the function to suppress change
      * events that are manually handled.
      * @param {!function()} fn
      * @private
      */
     runWhileIgnoringChanges_: function(fn) {
       assert(!this.ignoreChanges_,
@@ skipping 50 matching lines @@
        * pref store as of the last update from the API.
        * @type {Object<*>}
        * @private
        */
       lastPrefValues_: {
         type: Object,
         value: function() { return {}; },
       },
     },
 
-    // Listen for the manually fired prefs-changed event.
+    // Listen for the manually fired shared-prefs-changed event, fired when
+    // a shared-prefs instance is changed by another element.
     listeners: {
-      'prefs-changed': 'prefsChanged_',
+      'shared-prefs-changed': 'sharedPrefsChanged_',
     },
 
     /** @type {SettingsPrivate} */
     settingsApi_: /** @type {SettingsPrivate} */(chrome.settingsPrivate),
 
     /**
      * @param {SettingsPrivate=} opt_settingsApi SettingsPrivate implementation
      *     to use (chrome.settingsPrivate by default).
      */
     initialize: function(opt_settingsApi) {
       // Only initialize once (or after resetForTesting() is called).
       if (this.initialized_)
         return;
       this.initialized_ = true;
 
       if (opt_settingsApi)
         this.settingsApi_ = opt_settingsApi;
 
       /** @private {function(!Array<!chrome.settingsPrivate.PrefObject>)} */
       this.boundPrefsChanged_ = this.onSettingsPrivatePrefsChanged_.bind(this);
       this.settingsApi_.onPrefsChanged.addListener(this.boundPrefsChanged_);
       this.settingsApi_.getAllPrefs(
           this.onSettingsPrivatePrefsFetched_.bind(this));
     },
 
     /**
-     * Polymer callback for changes to this.prefs.
+     * Polymer callback for changes to prefs.* from a shared-prefs element.
      * @param {!CustomEvent} e
      * @param {!{path: string}} change
      * @private
      */
-    prefsChanged_: function(e, change) {
+    sharedPrefsChanged_: function(e, change) {
       if (!CrSettingsPrefs.isInitialized)
         return;
 
       var key = this.getPrefKeyFromPath_(change.path);
       var prefStoreValue = this.lastPrefValues_[key];
 
       var prefObj = /** @type {chrome.settingsPrivate.PrefObject} */(
           this.get(key, this.prefs));
 
-      // If settingsPrivate already has this value, do nothing. (Otherwise,
+      // If settingsPrivate already has this value, ignore it. (Otherwise,
       // a change event from settingsPrivate could make us call
       // settingsPrivate.setPref and potentially trigger an IPC loop.)
-      if (deepEqual(prefStoreValue, prefObj.value))
-        return;
+      if (!deepEqual(prefStoreValue, prefObj.value)) {
+        this.settingsApi_.setPref(
+            key,
+            prefObj.value,
+            /* pageId */ '',
+            /* callback */ this.setPrefCallback_.bind(this, key));
+      }
 
-      this.settingsApi_.setPref(
-          key,
-          prefObj.value,
-          /* pageId */ '',
-          /* callback */ this.setPrefCallback_.bind(this, key));
+      // Package the event as a prefs-changed event for other elements.
+      this.fire('prefs-changed', change);
     },
 
     /**
      * Called when prefs in the underlying Chrome pref store are changed.
      * @param {!Array<!chrome.settingsPrivate.PrefObject>} prefs
      *     The prefs that changed.
      * @private
      */
     onSettingsPrivatePrefsChanged_: function(prefs) {
       if (CrSettingsPrefs.isInitialized)
@@ skipping 84 matching lines @@
       this.prefs = undefined;
       this.lastPrefValues_ = {};
       this.initialized_ = false;
       // Remove the listener added in initialize().
       this.settingsApi_.onPrefsChanged.removeListener(this.boundPrefsChanged_);
       this.settingsApi_ =
           /** @type {SettingsPrivate} */(chrome.settingsPrivate);
     },
   });
 })();