Add FakeChromeEvent

chrome/test/data/webui/settings/fake_settings_private.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 Fake implementation of chrome.settingsPrivate for testing. */
 cr.define('settings', function() {
   /**
    * Creates a deep copy of the object.
    * @param {!Object} obj
    * @return {!Object}
    */
   function deepCopy(obj) {
     return JSON.parse(JSON.stringify(obj));
   }
 
   /**
    * Fake of chrome.settingsPrivate API. Use by setting
    * CrSettingsPrefs.deferInitialization to true, then passing a
    * FakeSettingsPrivate to SettingsPrefs.initializeForTesting.
    * @constructor
    * @param {Array<!settings.FakeSettingsPrivate.Pref>=} opt_initialPrefs
    * @implements {SettingsPrivate}
    */
   function FakeSettingsPrivate(opt_initialPrefs) {
     this.prefs = {};
 
-    // Hack alert: bind this instance's onPrefsChanged members to this.
-    this.onPrefsChanged = {
-      addListener: this.onPrefsChanged.addListener.bind(this),
-      removeListener: this.onPrefsChanged.removeListener.bind(this),
-    };
-
     if (!opt_initialPrefs)
       return;
     for (var pref of opt_initialPrefs)
       this.addPref_(pref.type, pref.key, pref.value);
   }
 
   FakeSettingsPrivate.prototype = {
     // chrome.settingsPrivate overrides.
-    onPrefsChanged: {
-      addListener: function(listener) {
-        this.listener_ = listener;
-      },
-
-      removeListener: function(listener) {
-        this.listener_ = null;
-      },
-    },
+    onPrefsChanged: new FakeChromeEvent(),
 
     getAllPrefs: function(callback) {
       // Send a copy of prefs to keep our internal state private.
       var prefs = [];
       for (var key in this.prefs)

[dpapad, 2015/12/16 21:18:07]

Drive by: That is fine, but as FYI you could also use Array#map as follows.

var prefs = Object.keys(this.prefs).map(function(key) {
  return deepCopy(this.prefs[key];
}.bind(this));

[stevenjb, 2015/12/16 22:20:57]

Question: Is there an advantage to using map() here instead? To me this just
seems like a slightly more convoluted way of doing exactly the same thing. Also,
I threw together a quick fiddle and unless I messed something up it appears to
be almost 10x slower: https://jsfiddle.net/stevenjb_chromium/s5sj6swn/

         prefs.push(deepCopy(this.prefs[key]));
 
       // Run the callback asynchronously to test that the prefs aren't actually
       // used before they become available.
       setTimeout(callback.bind(null, prefs));
     },
 
     setPref: function(key, value, pageId, callback) {
       var pref = this.prefs[key];
       assertNotEquals(undefined, pref);
@@ skipping 32 matching lines @@
     /** 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.
+     * Notifies the listeners 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(deepCopy(pref));
       }
-      this.listener_(prefs);
+      this.onPrefsChanged.callListeners(prefs);
     },
 
     // Private methods for use by the fake API.
 
     /**
      * @param {!chrome.settingsPrivate.PrefType} type
      * @param {string} key
      * @param {*} value
      */
     addPref_: function(type, key, value) {
       this.prefs[key] = {
         type: type,
         key: key,
         value: value,
       };
     },
   };
 
   return {FakeSettingsPrivate: FakeSettingsPrivate};
 });
 
 /**
  * @type {Array<{key: string,
  *               type: chrome.settingsPrivate.PrefType,
  *               values: !Array<*>}>}
  */
 settings.FakeSettingsPrivate.Pref;