Add an options page to Select-to-Speak and allow setting voice name, rate

chrome/browser/resources/chromeos/select_to_speak/select_to_speak.js

 // Copyright 2016 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.
 
 var AutomationEvent = chrome.automation.AutomationEvent;
 var AutomationNode = chrome.automation.AutomationNode;
 var EventType = chrome.automation.EventType;
 var RoleType = chrome.automation.RoleType;
 
 /**
@@ skipping 50 matching lines @@
   chrome.automation.getDesktop(function(desktop) {
     desktop.addEventListener(
         EventType.MOUSE_PRESSED, this.onMousePressed_.bind(this), true);
     desktop.addEventListener(
         EventType.MOUSE_DRAGGED, this.onMouseDragged_.bind(this), true);
     desktop.addEventListener(
         EventType.MOUSE_RELEASED, this.onMouseReleased_.bind(this), true);
     desktop.addEventListener(
         EventType.MOUSE_CANCELED, this.onMouseCanceled_.bind(this), true);
   }.bind(this));
+
+  /** @private { ?string } */
+  this.voiceName_ = null;
+
+  /** @private { number } */
+  this.speechRate_ = 1.0;
+
+  this.initPreferences_();
 };
 
 SelectToSpeak.prototype = {
   /**
    * Called when the mouse is pressed and the user is in a mode where
    * select-to-speak is capturing mouse events (for example holding down
    * Search).
    *
    * @param {!AutomationEvent} evt
    */
@@ skipping 101 matching lines @@
 
   /**
    * Enqueue speech commands for all of the given nodes.
    * @param {Array<AutomationNode>} nodes The nodes to speak.
    */
   startSpeechQueue_: function(nodes) {
     chrome.tts.stop();
     for (var i = 0; i < nodes.length; i++) {
       var node = nodes[i];
       var isLast = (i == nodes.length - 1);
-      chrome.tts.speak(node.name || '', {
+
+      var options = {
         lang: 'en-US',
+        rate: this.rate_,
         'enqueue': true,
         onEvent: (function(node, isLast, event) {
           if (event.type == 'start') {
             chrome.accessibilityPrivate.setFocusRing([node.location]);
           } else if (event.type == 'interrupted' ||
                      event.type == 'cancelled') {
             chrome.accessibilityPrivate.setFocusRing([]);
           } else if (event.type == 'end') {
             if (isLast) {
               chrome.accessibilityPrivate.setFocusRing([]);
             }
           }
         }).bind(this, node, isLast)
+      };
+      if (this.voiceName_) {
+        options['voiceName'] = this.voiceName_;
+      }
+      chrome.tts.speak(node.name || '', options);
+    }
+  },
+
+  /**
+   * Loads preferences from chrome.storage, sets default values if
+   * necessary, and registers a listener to update prefs when they
+   * change.
+   */
+  initPreferences_: function() {
+    var updatePrefs = (function() {
+      chrome.storage.sync.get(['voice', 'rate'], (function(prefs) {
+        if (prefs['voice']) {

[David Tseng, 2017/03/29 22:24:46]

Just a warning, a voice synced in this way might be invalid on this machine. For
example, if I use a Chromebook with ARC, and select that voice. Logging into
another Chromebook without that voice will sync 'android' for the voice, but
nothing on this machine will speak.

[dmazzoni, 2017/03/30 20:19:17]

Good catch.

I made this more robust by tracking the prefs voice,
the best voice for the locale, and the installed 
voices, all separately. Now it takes all of that
into account each time it sends a speech command.

I tested it manually by setting the pref to an
extension voice, then uninstalling the extension and
verifying that it falls back on the best voice for
the locale.

+          this.voiceName_ = prefs['voice'];
+        }
+        if (prefs['rate']) {
+          this.rate_ = parseFloat(prefs['rate']);
+        } else {
+          chrome.storage.sync.set({'rate': this.rate_});
+        }
+      }).bind(this));
+    }).bind(this);
+
+    updatePrefs();
+    chrome.storage.onChanged.addListener(updatePrefs);
+
+    this.updateDefaultVoice_();
+    window.speechSynthesis.onvoiceschanged =
+        this.updateDefaultVoice_.bind(this);
+  },
+
+  /**
+   * Get the list of TTS voices, and set the default voice if not already set.
+   */
+  updateDefaultVoice_: function() {
+    var uiLocale = chrome.i18n.getMessage('@@ui_locale');
+    uiLocale = uiLocale.replace('_', '-').toLowerCase();
+
+    chrome.tts.getVoices(function(voices) {
+      if (voices.length == 0)
+        return;
+
+      voices.sort(function(a, b) {
+        function score(voice) {
+          var lang = voice.lang.toLowerCase();
+          var s = 0;
+          if (lang == uiLocale)
+            s += 2;
+          if (lang.substr(0, 2) == uiLocale.substr(0, 2))
+            s += 1;
+          return s;
+        }
+        return score(b) - score(a);
       });
-    }
+
+      chrome.storage.sync.get(['voice'], (function(prefs) {
+        if (!prefs['voice']) {
+          chrome.storage.sync.set({'voice': voices[0].voiceName});
+        }
+      }).bind(this));
+    });
   }
 };
 
 new SelectToSpeak();