Added auto-scan, made some small changes to how prefs are stored, refactored.

chrome/browser/resources/chromeos/switch_access/prefs.js

 // Copyright 2017 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.
 
 /**
  * Class to manage user preferences.
  *
  * @constructor
  */
 let SwitchAccessPrefs = function() {
   /**
    * User preferences, initially set to the default preference values.
    *
    * @private
    */
   this.prefs_ = Object.assign({}, this.DEFAULT_PREFS);
+
   this.loadPrefs_();
   chrome.storage.onChanged.addListener(this.handleStorageChange_.bind(this));
 };
 
 SwitchAccessPrefs.prototype = {
   /**
    * Asynchronously load the current preferences from chrome.storage.sync and
-   * store them in this.prefs_.
+   * store them in this.prefs_, if this.prefs_ is not already set to that value.
+   * If this.prefs_ changes, fire a prefsUpdate event.
    *
    * @private
    */
   loadPrefs_: function() {
     let defaultKeys = Object.keys(this.DEFAULT_PREFS);
     chrome.storage.sync.get(defaultKeys, function(loadedPrefs) {
-      let loadedKeys = Object.keys(loadedPrefs);
-      if (loadedKeys.length > 0) {
-        for (let key of loadedKeys) {
+      let updatedPrefs = {};
+      for (let key of Object.keys(loadedPrefs)) {
+        if (this.prefs_[key] !== loadedPrefs[key]) {
           this.prefs_[key] = loadedPrefs[key];
+          updatedPrefs[key] = loadedPrefs[key];
         }
-        let event = new CustomEvent('prefsUpdate', {'detail': loadedPrefs});
+      }
+      if (Object.keys(updatedPrefs).length > 0) {
+        let event = new CustomEvent('prefsUpdate', {'detail': updatedPrefs});
         document.dispatchEvent(event);
       }
     }.bind(this));
   },
 
   /**
-   * Store any changes to chrome.storage.sync in this.prefs_.
+   * Store any changes from chrome.storage.sync to this.prefs_, if this.prefs_
+   * is not already set to that value. If this.prefs_ changes, fire a
+   * prefsUpdate event.
    *
-   * @param {!Object} changes
+   * @param {!Object} storageChanges
    * @param {string} areaName
    * @private
    */
-  handleStorageChange_: function(changes, areaName) {
-    for (let key of Object.keys(changes)) {
-      // If pref change happened on same device, prefs will already be updated,
-      // so this will have no effect.
-      this.prefs_[key] = changes[key].newValue;
-      changes[key] = changes[key].newValue;
+  handleStorageChange_: function(storageChanges, areaName) {
+    let updatedPrefs = {};
+    for (let key of Object.keys(storageChanges)) {
+      if (this.prefs_[key] !== storageChanges[key].newValue) {
+        this.prefs_[key] = storageChanges[key].newValue;
+        updatedPrefs[key] = storageChanges[key].newValue;
+      }
     }
-
-    let event = new CustomEvent('prefsUpdate', {'detail': changes});
-    document.dispatchEvent(event);
+    if (Object.keys(updatedPrefs).length > 0) {
+      let event = new CustomEvent('prefsUpdate', {'detail': updatedPrefs});

[dmazzoni, 2017/03/29 05:52:20]

Now that you have a nice SwitchAccessInterface class, it might be more
consistent to call this.switchAccess_.updatedPrefs() to be consistent
with the rest of the code rather than firing an event here

[elichtenberg, 2017/03/29 19:15:11]

Currently, the options page(s) also listen(s) to 'prefsUpdate' events, which
occur on the background document, so in order to not use events here, our
switchAccess object would need to have access to all of the options pages. We
could have each options page register itself on the background document when it
is created, but not sure I like that solution, especially since the options page
would have to be unregistered once it is closed. So not changing for now.

+      document.dispatchEvent(event);
+    }
   },
 
   /**
-   * Set the value of the preference |key| to |value|.
+   * Set the value of the preference |key| to |value| in chrome.storage.sync.
+   * this.prefs_ is not set until handleStorageChange_.
    *
    * @param {string} key
    * @param {boolean|string|number} value
    */
   setPref: function(key, value) {
     let pref = {};
     pref[key] = value;
     chrome.storage.sync.set(pref);
-    this.prefs_[key] = value;
   },
 
   /**
-   * Get all user preferences.
+   * Get the value of the preference |key|.
+   *
+   * @param {string} key
+   * @return {boolean|string|number}
    */
-  getPrefs: function() {
-    return Object.assign({}, this.prefs_);
+  getPref: function(key) {
+    return this.prefs_[key];
   },
 
   /**
    * The default value of all preferences. All preferences should be primitives
    * to prevent changes to default values.
    *
    * @const
    */
   DEFAULT_PREFS: {
     'enableAutoScan': false,
-    'autoScanTime': .75
+    'autoScanTime': .8
   }
 };