Use new earcons in ChromeVox Next.

chrome/browser/resources/chromeos/chromevox/testing/mock_feedback.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 This file contains the |MockFeedback| class which is a
- * combined mock class for speech and braille feedback.  A test that uses
- * this class may add expectations for speech utterances and braille display
- * content to be output.  The |install| method sets appropriate mock classes
- * as the |cvox.ChromeVox.tts| and |cvox.ChromeVox.braille| objects,
- * respectively.  Output sent to those objects will then be collected in
- * an internal queue.
+ * @fileoverview This file contains the |MockFeedback| class which is
+ * a combined mock class for speech, braille, and earcon feedback.  A
+ * test that uses this class may add expectations for speech
+ * utterances, braille display content to be output, and earcons
+ * played (by name).  The |install| method sets appropriate mock
+ * classes as the |cvox.ChromeVox.tts|, |cvox.ChromeVox.braille| and
+ * |cvox.ChromeVox.earcons| objects, respectively.  Output sent to
+ * those objects will then be collected in an internal queue.
  *
- * Expectations can be added using the |expectSpeech| and |expectBraille|
- * methods.  These methods take either strings or regular expressions to match
- * against.  Strings must match a full utterance (or display content) exactly,
- * while a regular expression must match a substring (use anchor operators if
+ * Expectations can be added using the |expectSpeech|,
+ * |expectBraille|, and |expectEarcon| methods.  These methods take
+ * either strings or regular expressions to match against.  Strings
+ * must match a full utterance (or display content) exactly, while a
+ * regular expression must match a substring (use anchor operators if
  * needed).
  *
  * Function calls may be inserted in the stream of expectations using the
  * |call| method.  Such callbacks are called after all preceding expectations
  * have been met, and before any further expectations are matched.  Callbacks
  * are called in the order they were added to the mock.
  *
- * The |replay| method starts processing any pending utterances and braille
- * display content and will try to match expectations as new feedback enters
- * the queue asynchronously.  When all expectations have been met and callbacks
- * called, the finish callback, if any was provided to the constructor, is
- * called.
+ * The |replay| method starts processing any pending utterances,
+ * braille display content, and earcons and will try to match
+ * expectations as new feedback enters the queue asynchronously.  When
+ * all expectations have been met and callbacks called, the finish
+ * callback, if any was provided to the constructor, is called.
  *
  * This mock class is lean, meaning that feedback that doesn't match
  * any expectations is silently ignored.
  *
  * NOTE: for asynchronous tests, the processing will never finish if there
  * are unmet expectations.  To help debugging in such situations, the mock
  * will output its pending state if there are pending expectations and no
  * output is received within a few seconds.
  *
  * See mock_feedback_test.js for example usage of this class.
@@ skipping 35 matching lines @@
    * @private
    */
   this.pendingUtterances_ = [];
   /**
    * Pending braille output.
    * @type {Array<{text: string, callback: (function|undefined)}>}
    * @private
    */
   this.pendingBraille_ = [];
   /**
+   * Pending earcons.
+   * @type {Array<{text: string, callback: (function|undefined)}>}
+   * @private
+   */
+  this.pendingEarcons_ = [];
+  /**
    * Handle for the timeout set for debug logging.
    * @type {number}
    * @private
    */
   this.logTimeoutId_ = 0;
   /**
    * @type {cvox.NavBraille}
    * @private
    */
   this.lastMatchedBraille_ = null;
@@ skipping 16 matching lines @@
 
     cvox.ChromeVox.tts = new MockTts();
 
     var MockBraille = function() {};
     MockBraille.prototype = {
       __proto__: cvox.BrailleInterface.prototype,
       write: this.addBraille_.bind(this)
     };
 
     cvox.ChromeVox.braille = new MockBraille();
+
+    var MockEarcons = function() {};
+    MockEarcons.prototype = {
+      __proto__: cvox.AbstractEarcons.prototype,
+      playEarcon: this.addEarcon_.bind(this)
+    };
+
+    // cvox.ChromeVox.earcons is a getter that switches between Classic and
+    // Next; replace it with MockEarcons.
+    delete cvox.ChromeVox.earcons;
+    cvox.ChromeVox.earcons = new MockEarcons();
   },
 
   /**
    * Adds an expectation for one or more spoken utterances.
    * @param {...(string|RegExp)} var_args One or more utterance to add as
    *     expectations.
    * @return {MockFeedback} |this| for chaining
    */
   expectSpeech: function() {
     assertFalse(this.replaying_);
@@ skipping 59 matching lines @@
         return !!match;
       }.bind(this),
       toString: function() {
         return 'Braille \'' + text + '\' ' + JSON.stringify(props);
       }
     });
     return this;
   },
 
   /**
+   * Adds an expectation for a played earcon.
+   * @param {string} earconName The name of the earcon.
+   * @return {MockFeedback} |this| for chaining
+   */
+  expectEarcon: function(earconName, opt_props) {
+    assertFalse(this.replaying_);
+    this.pendingActions_.push({
+      perform: function() {
+        var match = MockFeedback.matchAndConsume_(
+            earconName, {}, this.pendingEarcons_);
+        return !!match;
+      }.bind(this),
+      toString: function() {
+        return 'Earcon \'' + earconName + '\'';
+      }
+    });
+    return this;
+  },
+
+  /**
    * Arranges for a callback to be invoked when all expectations that were
    * added before this call have been met.  Callbacks are called in the
    * order they are added.
    * @param {Function} callback
    * @return {MockFeedback} |this| for chaining
    */
   call: function(callback) {
     assertFalse(this.replaying_);
     this.pendingActions_.push({
       perform: function() {
@@ skipping 53 matching lines @@
          callback: callback});
     this.process_();
   },
 
   /** @private */
   addBraille_: function(navBraille) {
     this.pendingBraille_.push(navBraille);
     this.process_();
   },
 
+  /** @private */
+  addEarcon_: function(earconName) {
+    this.pendingEarcons_.push({text: earconName});
+    this.process_();
+  },
+
   /*** @private */
   process_: function() {
     if (!this.replaying_ || this.inProcess_)
       return;
     try {
       this.inProcess_ = true;
       while (this.pendingActions_.length > 0) {
         var action = this.pendingActions_[0];
         if (action.perform()) {
           this.pendingActions_.shift();
@@ skipping 34 matching lines @@
               var ret = '\'' + i.text + '\'';
               if ('startIndex' in i)
                 ret += ' startIndex=' + i.startIndex;
               if ('endIndex' in i)
                 ret += ' endIndex=' + i.endIndex;
               return ret;
             }).join('\n  ') + '\n  ');
     }
     logPending('speech utterances', this.pendingUtterances_);
     logPending('braille', this.pendingBraille_);
+    logPending('earcons', this.pendingEarcons_);
     this.logTimeoutId_ = 0;
   },
 };
 
 /**
  * @param {string} text
  * @param {Object} props
  * @param {Array<{text: (string|RegExp), callback: (function|undefined)}>}
  *     pending
  * @return {Object}
  * @private
  */
 MockFeedback.matchAndConsume_ = function(text, props, pending) {
   for (var i = 0, candidate; candidate = pending[i]; ++i) {
-    var candidateText = candidate.text.toString();
+    var candidateText = candidate.text;
+    if (typeof(candidateText) != 'string')
+      candidateText = candidateText.toString();
+
     if (text === candidateText ||
         (text instanceof RegExp && text.test(candidateText))) {
       var matched = true;
       for (prop in props) {
         if (candidate[prop] !== props[prop]) {
           matched = false;
           break;
         }
       }
       if (matched)
         break;
     }
   }
   if (candidate) {
     var consumed = pending.splice(0, i + 1);
     consumed.forEach(function(item) {
       if (item.callback)
         item.callback();
     });
   }
   return candidate;
 };