Complete live region support in ChromeVox Next.

chrome/browser/resources/chromeos/chromevox/cvox2/background/desktop_automation_handler.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 Handles automation from a desktop automation node.
  */
 
 goog.provide('DesktopAutomationHandler');
 
-goog.require('Background');
 goog.require('BaseAutomationHandler');
+goog.require('ChromeVoxState');
 
 goog.scope(function() {
 var AutomationEvent = chrome.automation.AutomationEvent;
 var AutomationNode = chrome.automation.AutomationNode;
 var Dir = AutomationUtil.Dir;
 var RoleType = chrome.automation.RoleType;
 
 /**
  * @param {!AutomationNode} node
  * @constructor
@@ skipping 31 matching lines @@
   /**
    * Provides all feedback once ChromeVox's focus changes.
    * @param {Object} evt
    */
   onEventDefault: function(evt) {
     var node = evt.target;
 
     if (!node)
       return;
 
-    var prevRange = global.backgroundObj.currentRange;
+    var prevRange = ChromeVoxState.instance.currentRange;
 
-    global.backgroundObj.currentRange = cursors.Range.fromNode(node);
+    ChromeVoxState.instance.setCurrentRange(cursors.Range.fromNode(node));
 
     // Check to see if we've crossed roots. Continue if we've crossed roots or
     // are not within web content.
     if (node.root.role == RoleType.desktop ||
         !prevRange ||
         prevRange.start.node.root != node.root)
-      global.backgroundObj.refreshMode(node.root.docUrl || '');
+      ChromeVoxState.instance.refreshMode(node.root.docUrl || '');
 
     // Don't process nodes inside of web content if ChromeVox Next is inactive.
     if (node.root.role != RoleType.desktop &&
-        global.backgroundObj.mode === ChromeVoxMode.CLASSIC) {
+        ChromeVoxState.instance.mode === ChromeVoxMode.CLASSIC) {
       if (cvox.ChromeVox.isChromeOS)
         chrome.accessibilityPrivate.setFocusRing([]);
       return;
     }
 
     // Don't output if focused node hasn't changed.
     if (prevRange &&
         evt.type == 'focus' &&
-        global.backgroundObj.currentRange.equals(prevRange))
+        ChromeVoxState.instance.currentRange.equals(prevRange))
       return;
 
     new Output().withSpeechAndBraille(
-            global.backgroundObj.currentRange, prevRange, evt.type)
+            ChromeVoxState.instance.currentRange, prevRange, evt.type)
         .go();
   },
 
   /**
    * Makes an announcement without changing focus.
    * @param {Object} evt
    */
   onAlert: function(evt) {
     var node = evt.target;
     if (!node)
       return;
 
     // Don't process nodes inside of web content if ChromeVox Next is inactive.
     if (node.root.role != RoleType.desktop &&
-        global.backgroundObj.mode === ChromeVoxMode.CLASSIC) {
+        ChromeVoxState.instance.mode === ChromeVoxMode.CLASSIC) {
       return;
     }
 
     var range = cursors.Range.fromNode(node);
 
     new Output().withSpeechAndBraille(range, null, evt.type).go();
   },
 
   /**
    * Provides all feedback once a focus event fires.
    * @param {Object} evt
    */
   onFocus: function(evt) {
     // Invalidate any previous editable text handler state.
     this.editableTextHandler_ = null;
 
     var node = evt.target;
 
     // Discard focus events on embeddedObject nodes.
     if (node.role == RoleType.embeddedObject)
       return;
 
     // It almost never makes sense to place focus directly on a rootWebArea.
     if (node.role == RoleType.rootWebArea) {
       // Discard focus events for root web areas when focus was previously
       // placed on a descendant.
-      var currentRange = global.backgroundObj.currentRange;
+      var currentRange = ChromeVoxState.instance.currentRange;
       if (currentRange && currentRange.start.node.root == node)
         return;
 
       // Discard focused root nodes without focused state set.
       if (!node.state.focused)
         return;
 
       // Try to find a focusable descendant.
       node = node.find({state: {focused: true}}) || node;
     }
 
     if (this.isEditable_(evt.target))
       this.createEditableTextHandlerIfNeeded_(evt.target);
 
     this.onEventDefault({target: node, type: 'focus'});
   },
 
   /**
    * Provides all feedback once a load complete event fires.
    * @param {Object} evt
    */
   onLoadComplete: function(evt) {
-    global.backgroundObj.refreshMode(evt.target.docUrl);
+    ChromeVoxState.instance.refreshMode(evt.target.docUrl);
 
     // Don't process nodes inside of web content if ChromeVox Next is inactive.
     if (evt.target.root.role != RoleType.desktop &&
-        global.backgroundObj.mode === ChromeVoxMode.CLASSIC)
+        ChromeVoxState.instance.mode === ChromeVoxMode.CLASSIC)
       return;
 
     // If initial focus was already placed on this page (e.g. if a user starts
     // tabbing before load complete), then don't move ChromeVox's position on
     // the page.
-    if (global.backgroundObj.currentRange &&
-        global.backgroundObj.currentRange.start.node.role !=
+    if (ChromeVoxState.instance.currentRange &&
+        ChromeVoxState.instance.currentRange.start.node.role !=
             RoleType.rootWebArea &&
-        global.backgroundObj.currentRange.start.node.root.docUrl ==
+        ChromeVoxState.instance.currentRange.start.node.root.docUrl ==
             evt.target.docUrl)
       return;
 
     var root = evt.target;
     var webView = root;
     while (webView && webView.role != RoleType.webView)
       webView = webView.parent;
 
     if (!webView || !webView.state.focused)
       return;
 
     var node = AutomationUtil.findNodePost(root,
         Dir.FORWARD,
         AutomationPredicate.leaf);
 
     if (node)
-      global.backgroundObj.currentRange = cursors.Range.fromNode(node);
+      ChromeVoxState.instance.setCurrentRange(cursors.Range.fromNode(node));
 
-    if (global.backgroundObj.currentRange)
+    if (ChromeVoxState.instance.currentRange)
       new Output().withSpeechAndBraille(
-              global.backgroundObj.currentRange, null, evt.type)
+              ChromeVoxState.instance.currentRange, null, evt.type)
           .go();
   },
 
   /**
    * Provides all feedback once a text selection change event fires.
    * @param {Object} evt
    */
   onTextOrTextSelectionChanged: function(evt) {
     if (!this.isEditable_(evt.target))
       return;
 
     // Don't process nodes inside of web content if ChromeVox Next is inactive.
     if (evt.target.root.role != RoleType.desktop &&
-        global.backgroundObj.mode === ChromeVoxMode.CLASSIC)
+        ChromeVoxState.instance.mode === ChromeVoxMode.CLASSIC)
       return;
 
     if (!evt.target.state.focused)
       return;
 
-    if (!global.backgroundObj.currentRange) {
+    if (!ChromeVoxState.instance.currentRange) {
       this.onEventDefault(evt);
-      global.backgroundObj.currentRange = cursors.Range.fromNode(evt.target);
+      ChromeVoxState.instance.setCurrentRange(
+          cursors.Range.fromNode(evt.target));
     }
 
     this.createEditableTextHandlerIfNeeded_(evt.target);
 
     var textChangeEvent = new cvox.TextChangeEvent(
         evt.target.value,
         evt.target.textSelStart,
         evt.target.textSelEnd,
         true);  // triggered by user
 
     this.editableTextHandler_.changed(textChangeEvent);
 
     new Output().withBraille(
-            global.backgroundObj.currentRange, null, evt.type)
+            ChromeVoxState.instance.currentRange, null, evt.type)
         .go();
   },
 
   /**
    * Provides all feedback once a value changed event fires.
    * @param {Object} evt
    */
   onValueChanged: function(evt) {
     // Don't process nodes inside of web content if ChromeVox Next is inactive.
     if (evt.target.root.role != RoleType.desktop &&
-        global.backgroundObj.mode === ChromeVoxMode.CLASSIC)
+        ChromeVoxState.instance.mode === ChromeVoxMode.CLASSIC)
       return;
 
     if (!evt.target.state.focused)
       return;
 
     // Value change events fire on web editables when typing. Suppress them.
-    if (!global.backgroundObj.currentRange || !this.isEditable_(evt.target)) {
+    if (!ChromeVoxState.instance.currentRange ||
+        !this.isEditable_(evt.target)) {
       this.onEventDefault(evt);
-      global.backgroundObj.currentRange = cursors.Range.fromNode(evt.target);
+      ChromeVoxState.instance.setCurrentRange(
+          cursors.Range.fromNode(evt.target));
     }
   },
 
   /**
    * Handle updating the active indicator when the document scrolls.
    * @override
    */
   onScrollPositionChanged: function(evt) {
-    var currentRange = global.backgroundObj.currentRange;
+    var currentRange = ChromeVoxState.instance.currentRange;
     if (currentRange)
       new Output().withLocation(currentRange, null, evt.type).go();
   },
 
   /**
    * Create an editable text handler for the given node if needed.
    * @param {Object} node
    */
   createEditableTextHandlerIfNeeded_: function(node) {
     if (!this.editableTextHandler_ ||
-        node != global.backgroundObj.currentRange.start.node) {
+        node != ChromeVoxState.instance.currentRange.start.node) {
       var start = node.textSelStart;
       var end = node.textSelEnd;
       if (start > end) {
         var tempOffset = end;
         end = start;
         start = tempOffset;
       }
 
       this.editableTextHandler_ =
           new cvox.ChromeVoxEditableTextBase(
@@ skipping 26 matching lines @@
   if (cvox.ChromeVox.isMac)
     return;
   chrome.automation.getDesktop(function(desktop) {
     global.desktopAutomationHandler = new DesktopAutomationHandler(desktop);
   });
 };
 
 DesktopAutomationHandler.init_();
 
 });  // goog.scope