Complete live region support in ChromeVox Next.

chrome/browser/resources/chromeos/chromevox/cvox2/background/background.js

 // Copyright 2014 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 The entry point for all ChromeVox2 related code for the
  * background page.
  */
 
 goog.provide('Background');
-goog.provide('ChromeVoxMode');
 goog.provide('global');
 
 goog.require('AutomationPredicate');
 goog.require('AutomationUtil');
+goog.require('ChromeVoxState');
+goog.require('LiveRegions');
 goog.require('NextEarcons');
 goog.require('Output');
 goog.require('Output.EventType');
 goog.require('cursors.Cursor');
 goog.require('cvox.BrailleKeyCommand');
 goog.require('cvox.ChromeVoxEditableTextBase');
 goog.require('cvox.ChromeVoxKbHandler');
 goog.require('cvox.ClassicEarcons');
 goog.require('cvox.ExtensionBridge');
 goog.require('cvox.NavBraille');
 
 goog.scope(function() {
 var AutomationNode = chrome.automation.AutomationNode;
 var Dir = AutomationUtil.Dir;
 var EventType = chrome.automation.EventType;
 var RoleType = chrome.automation.RoleType;
 
 /**
- * All possible modes ChromeVox can run.
- * @enum {string}
- */
-ChromeVoxMode = {
-  CLASSIC: 'classic',
-  COMPAT: 'compat',
-  NEXT: 'next',
-  FORCE_NEXT: 'force_next'
-};
-
-/**
  * ChromeVox2 background page.
  * @constructor
+ * @extends {ChromeVoxState}
  */
 Background = function() {
+  ChromeVoxState.call(this);
+
   /**
    * A list of site substring patterns to use with ChromeVox next. Keep these
    * strings relatively specific.
    * @type {!Array<string>}
    * @private
    */
   this.whitelist_ = ['chromevox_next_test'];
 
   /**
    * Regular expression for blacklisting classic.
@@ skipping 61 matching lines @@
   });
 
   cvox.ExtensionBridge.addMessageListener(this.onMessage_);
 
   document.addEventListener('keydown', this.onKeyDown.bind(this), true);
   cvox.ChromeVoxKbHandler.commandHandler = this.onGotCommand.bind(this);
 
   // Classic keymap.
   cvox.ChromeVoxKbHandler.handlerKeyMap = cvox.KeyMap.fromDefaults();
 
-  chrome.automation.addTreeChangeObserver(this.onTreeChange);
+  // Live region handler.
+  this.liveRegions_ = new LiveRegions(this);
 };
 
+/**
+ * Live region events received in fewer than this many milliseconds will
+ * queue, otherwise they'll be output with a category flush.
+ * @type {number}
+ * @const
+ */

[David Tseng, 2015/11/23 23:23:57]

Move this as well?

[dmazzoni, 2015/11/30 22:00:47]

Done.

+Background.LIVE_REGION_QUEUE_TIME_MS = 500;

[Peter Lundblad, 2015/11/24 11:04:30]

Move to LiveRegionHandler?

[dmazzoni, 2015/11/30 22:00:46]

Done.

+
 Background.prototype = {
-  /** Forces ChromeVox Next to be active for all tabs. */
-  forceChromeVoxNextActive: function() {
-    this.setChromeVoxMode(ChromeVoxMode.FORCE_NEXT);
-  },
+  __proto__: ChromeVoxState.prototype,
 
-  /** @type {ChromeVoxMode} */
-  get mode() {
+  /**
+   * @override
+   */
+  getMode: function() {
     return this.mode_;
   },
 
-  /** @type {cursors.Range} */
-  get currentRange() {
+  /**
+   * @override
+   */
+  setMode: function(mode, opt_injectClassic) {
+    // Switching key maps potentially affects the key codes that involve
+    // sequencing. Without resetting this list, potentially stale key codes
+    // remain. The key codes themselves get pushed in
+    // cvox.KeySequence.deserialize which gets called by cvox.KeyMap.
+    cvox.ChromeVox.sequenceSwitchKeyCodes = [];
+    if (mode === ChromeVoxMode.CLASSIC || mode === ChromeVoxMode.COMPAT)
+      cvox.ChromeVoxKbHandler.handlerKeyMap = cvox.KeyMap.fromDefaults();
+    else
+      cvox.ChromeVoxKbHandler.handlerKeyMap = cvox.KeyMap.fromNext();
+
+    if (mode == ChromeVoxMode.CLASSIC) {
+      if (chrome.commands &&
+          chrome.commands.onCommand.hasListener(this.onGotCommand))
+        chrome.commands.onCommand.removeListener(this.onGotCommand);
+    } else {
+      if (chrome.commands &&
+          !chrome.commands.onCommand.hasListener(this.onGotCommand))
+        chrome.commands.onCommand.addListener(this.onGotCommand);
+    }
+
+    chrome.tabs.query({active: true}, function(tabs) {
+      if (mode === ChromeVoxMode.CLASSIC) {
+        // Generally, we don't want to inject classic content scripts as it is
+        // done by the extension system at document load. The exception is when
+        // we toggle classic on manually as part of a user command.
+        if (opt_injectClassic)
+          cvox.ChromeVox.injectChromeVoxIntoTabs(tabs);
+      } else {
+        // When in compat mode, if the focus is within the desktop tree proper,
+        // then do not disable content scripts.
+        if (this.currentRange_ &&
+            this.currentRange_.start.node.root.role == RoleType.desktop)
+          return;
+
+        this.disableClassicChromeVox_();
+      }
+    }.bind(this));
+
+    this.mode_ = mode;
+  },
+
+  /**
+   * @override
+   */
+  getCurrentRange: function() {
     return this.currentRange_;
   },
 
-  set currentRange(value) {
-    if (!value)
+  /**
+   * @override
+   */
+  setCurrentRange: function(newRange) {
+    if (!newRange)
       return;
 
-    this.currentRange_ = value;
+    this.currentRange_ = newRange;
 
     if (this.currentRange_)
       this.currentRange_.start.node.makeVisible();
   },
 
+  /** Forces ChromeVox Next to be active for all tabs. */
+  forceChromeVoxNextActive: function() {
+    this.setMode(ChromeVoxMode.FORCE_NEXT);
+  },
+
   /**
    * Handles ChromeVox Next commands.
    * @param {string} command
    * @param {boolean=} opt_bypassModeCheck Always tries to execute the command
    *    regardless of mode.
    * @return {boolean} True if the command should propagate.
    */
   onGotCommand: function(command, opt_bypassModeCheck) {
     if (!this.currentRange_)
       return true;
@@ skipping 155 matching lines @@
         global.isReadingContinuously = true;
         var continueReading = function(prevRange) {
           if (!global.isReadingContinuously || !this.currentRange_)
             return;
 
           new Output().withSpeechAndBraille(
                   this.currentRange_, prevRange, Output.EventType.NAVIGATE)
               .onSpeechEnd(function() { continueReading(prevRange); })
               .go();
           prevRange = this.currentRange_;
-          this.currentRange =
-              this.currentRange.move(cursors.Unit.NODE, Dir.FORWARD);
+          this.setCurrentRange(
+              this.currentRange_.move(cursors.Unit.NODE, Dir.FORWARD));
 
           if (!this.currentRange_ || this.currentRange_.equals(prevRange))
             global.isReadingContinuously = false;
         }.bind(this);
 
         continueReading(null);
         return false;
       case 'showContextMenu':
         if (this.currentRange_) {
           var actionNode = this.currentRange_.start.node;
@@ skipping 19 matching lines @@
         break;
       case 'toggleChromeVoxVersion':
         var newMode;
         if (this.mode_ == ChromeVoxMode.FORCE_NEXT) {
           var inViews =
               this.currentRange_.start.node.root.role == RoleType.desktop;
           newMode = inViews ? ChromeVoxMode.COMPAT : ChromeVoxMode.CLASSIC;
         } else {
           newMode = ChromeVoxMode.FORCE_NEXT;
         }
-        this.setChromeVoxMode(newMode, true);
+        this.setMode(newMode, true);
 
         var isClassic =
             newMode == ChromeVoxMode.CLASSIC || newMode == ChromeVoxMode.COMPAT;
 
         // Leaving unlocalized as 'next' isn't an official name.
         cvox.ChromeVox.tts.speak(isClassic ?
             'classic' : 'next', cvox.QueueMode.FLUSH, {doNotInterrupt: true});
         break;
       default:
         return true;
@@ skipping 15 matching lines @@
     }
 
     if (current) {
       // TODO(dtseng): Figure out what it means to focus a range.
       var actionNode = current.start.node;
       if (actionNode.role == RoleType.inlineTextBox)
         actionNode = actionNode.parent;
       actionNode.focus();
 
       var prevRange = this.currentRange_;
-      this.currentRange = current;
+      this.setCurrentRange(current);
 
       new Output().withSpeechAndBraille(
               this.currentRange_, prevRange, Output.EventType.NAVIGATE)
           .go();
     }
 
     return false;
   },
 
   /**
    * Handles key down events.
    * @param {Event} evt The key down event to process.
    * @return {boolean} True if the default action should be performed.
    */
   onKeyDown: function(evt) {
     if (this.mode_ != ChromeVoxMode.CLASSIC &&
         !cvox.ChromeVoxKbHandler.basicKeyDownActionsListener(evt)) {
       evt.preventDefault();
       evt.stopPropagation();
     }
+
+    Output.flushNextSpeechUtterance();
   },
 
   /**
    * Open the options page in a new tab.
    */
   showOptionsPage: function() {
     var optionsPage = {url: 'chromevox/background/options.html'};
     chrome.tabs.create(optionsPage);
   },
 
@@ skipping 46 matching lines @@
     var mode = this.mode_;
     if (mode != ChromeVoxMode.FORCE_NEXT) {
       if (this.isWhitelistedForNext_(url))
         mode = ChromeVoxMode.NEXT;
       else if (this.isBlacklistedForClassic_(url))
         mode = ChromeVoxMode.COMPAT;
       else
         mode = ChromeVoxMode.CLASSIC;
     }
 
-    this.setChromeVoxMode(mode);
+    this.setMode(mode);
   },
 
   /**
-   * Called when the automation tree is changed.
-   * @param {chrome.automation.TreeChange} treeChange
-   */
-  onTreeChange: function(treeChange) {
-    if (this.mode_ === ChromeVoxMode.CLASSIC || !cvox.ChromeVox.isActive)
-      return;
-
-    var node = treeChange.target;
-    if (!node.containerLiveStatus)
-      return;
-
-    if (node.containerLiveRelevant.indexOf('additions') >= 0 &&
-        treeChange.type == 'nodeCreated')
-      this.outputLiveRegionChange_(node, null);
-    if (node.containerLiveRelevant.indexOf('text') >= 0 &&
-        treeChange.type == 'nodeChanged')
-      this.outputLiveRegionChange_(node, null);
-    if (node.containerLiveRelevant.indexOf('removals') >= 0 &&
-        treeChange.type == 'nodeRemoved')
-      this.outputLiveRegionChange_(node, '@live_regions_removed');
-  },
-
-  /**
-   * Given a node that needs to be spoken as part of a live region
-   * change and an additional optional format string, output the
-   * live region description.
-   * @param {!chrome.automation.AutomationNode} node The changed node.
-   * @param {?string} opt_prependFormatStr If set, a format string for
-   *     cvox2.Output to prepend to the output.
-   * @private
-   */
-  outputLiveRegionChange_: function(node, opt_prependFormatStr) {
-    var range = cursors.Range.fromNode(node);
-    var output = new Output();
-    if (opt_prependFormatStr) {
-      output.format(opt_prependFormatStr);
-    }
-    output.withSpeech(range, null, Output.EventType.NAVIGATE);
-    output.withSpeechCategory(cvox.TtsCategory.LIVE);
-    output.go();
-  },
-
-  /**
    * Returns true if the url should have Classic running.
    * @return {boolean}
    * @private
    */
   shouldEnableClassicForUrl_: function(url) {
     return this.mode_ != ChromeVoxMode.FORCE_NEXT &&
         !this.isBlacklistedForClassic_(url) &&
         !this.isWhitelistedForNext_(url);
   },
 
@@ skipping 21 matching lines @@
    * Disables classic ChromeVox in current web content.
    */
   disableClassicChromeVox_: function() {
     cvox.ExtensionBridge.send({
         message: 'SYSTEM_COMMAND',
         command: 'killChromeVox'
     });
   },
 
   /**
-   * Sets the current ChromeVox mode.
-   * @param {ChromeVoxMode} mode
-   * @param {boolean=} opt_injectClassic Injects ChromeVox classic into tabs;
-   *                                     defaults to false.
-   */
-  setChromeVoxMode: function(mode, opt_injectClassic) {
-    // Switching key maps potentially affects the key codes that involve
-    // sequencing. Without resetting this list, potentially stale key codes
-    // remain. The key codes themselves get pushed in
-    // cvox.KeySequence.deserialize which gets called by cvox.KeyMap.
-    cvox.ChromeVox.sequenceSwitchKeyCodes = [];
-    if (mode === ChromeVoxMode.CLASSIC || mode === ChromeVoxMode.COMPAT)
-      cvox.ChromeVoxKbHandler.handlerKeyMap = cvox.KeyMap.fromDefaults();
-    else
-      cvox.ChromeVoxKbHandler.handlerKeyMap = cvox.KeyMap.fromNext();
-
-    if (mode == ChromeVoxMode.CLASSIC) {
-      if (chrome.commands &&
-          chrome.commands.onCommand.hasListener(this.onGotCommand))
-        chrome.commands.onCommand.removeListener(this.onGotCommand);
-    } else {
-      if (chrome.commands &&
-          !chrome.commands.onCommand.hasListener(this.onGotCommand))
-        chrome.commands.onCommand.addListener(this.onGotCommand);
-    }
-
-    chrome.tabs.query({active: true}, function(tabs) {
-      if (mode === ChromeVoxMode.CLASSIC) {
-        // Generally, we don't want to inject classic content scripts as it is
-        // done by the extension system at document load. The exception is when
-        // we toggle classic on manually as part of a user command.
-        if (opt_injectClassic)
-          cvox.ChromeVox.injectChromeVoxIntoTabs(tabs);
-      } else {
-        // When in compat mode, if the focus is within the desktop tree proper,
-        // then do not disable content scripts.
-        if (this.currentRange_ &&
-            this.currentRange_.start.node.root.role == RoleType.desktop)
-          return;
-
-        this.disableClassicChromeVox_();
-      }
-    }.bind(this));
-
-    this.mode_ = mode;
-  },
-
-  /**
    * @param {!Spannable} text
    * @param {number} position
    * @private
    */
   brailleRoutingCommand_: function(text, position) {
     var actionNodeSpan = null;
     var selectionSpan = null;
     text.getSpans(position).forEach(function(span) {
       if (span instanceof Output.SelectionSpan) {
         selectionSpan = span;
@@ skipping 52 matching lines @@
     return glob.replace(/[.+^$(){}|[\]\\]/g, '\\$&')
         .replace(/\*/g, '.*')
         .replace(/\?/g, '.');
   }).join('|') + ')$');
 };
 
 /** @type {Background} */
 global.backgroundObj = new Background();
 
 });  // goog.scope