Support Compat mode inside of the desktop tree.

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');
@@ skipping 43 matching lines @@
   this.currentRange_ = null;
 
   /**
    * Which variant of ChromeVox is active.
    * @type {ChromeVoxMode}
    * @private
    */
   this.mode_ = ChromeVoxMode.CLASSIC;
 
   /** @type {!ClassicCompatibility} @private */
-  this.compat_ = new ClassicCompatibility(this.mode_ === ChromeVoxMode.COMPAT);
+  this.compat_ = new ClassicCompatibility();
 
   // Manually bind all functions to |this|.
   for (var func in this) {
     if (typeof(this[func]) == 'function')
       this[func] = this[func].bind(this);
   }
 
   /**
    * Maps an automation event to its listener.
    * @type {!Object<EventType, function(Object) : void>}
    */
   this.listeners_ = {
     alert: this.onEventDefault,
     focus: this.onEventDefault,
     hover: this.onEventDefault,
     loadComplete: this.onLoadComplete,
     menuStart: this.onEventDefault,
     menuEnd: this.onEventDefault,
     menuListValueChanged: this.onEventDefault,
     textChanged: this.onTextOrTextSelectionChanged,
     textSelectionChanged: this.onTextOrTextSelectionChanged,
     valueChanged: this.onValueChanged
   };
 
-  // Register listeners for ...
-  // Desktop.
   chrome.automation.getDesktop(this.onGotDesktop);
 };
 
 Background.prototype = {
   /** Forces ChromeVox Next to be active for all tabs. */
   forceChromeVoxNextActive: function() {
     this.setChromeVoxMode(ChromeVoxMode.FORCE_NEXT);
   },
 
   /**
@@ skipping 19 matching lines @@
              type: chrome.automation.EventType.loadComplete});
       }
     }
   },
 
   /**
    * Handles chrome.commands.onCommand.
    * @param {string} command
    * @param {boolean=} opt_skipCompat Whether to skip compatibility checks.
    */
-    onGotCommand: function(command, opt_skipCompat) {
+  onGotCommand: function(command, opt_skipCompat) {
     if (!this.currentRange_)
       return;
 
-    if (!opt_skipCompat) {
+    if (!opt_skipCompat && this.mode_ === ChromeVoxMode.COMPAT) {
       if (this.compat_.onGotCommand(command))
         return;
     }
 
-    if (this.mode_ === ChromeVoxMode.CLASSIC)
-      return;
-
     var current = this.currentRange_;
     var dir = Dir.FORWARD;
     var pred = null;
     var predErrorMsg = undefined;
     switch (command) {
       case 'nextCharacter':
         current = current.move(cursors.Unit.CHARACTER, Dir.FORWARD);
         break;
       case 'previousCharacter':
         current = current.move(cursors.Unit.CHARACTER, Dir.BACKWARD);
@@ skipping 169 matching lines @@
         current = cursors.Range.fromNode(node);
       } else {
           cvox.ChromeVox.tts.speak(cvox.ChromeVox.msgs.getMsg(predErrorMsg),
                                   cvox.QueueMode.FLUSH);
         return;
       }
     }
 
     if (current) {
       // TODO(dtseng): Figure out what it means to focus a range.
-      current.getStart().getNode().focus();
+      var actionNode = current.getStart().getNode();
+      if (actionNode.role == chrome.automation.RoleType.inlineTextBox)
+        actionNode = actionNode.parent;
+      actionNode.focus();
 
       var prevRange = this.currentRange_;
       this.currentRange_ = current;
+
       new Output().withSpeechAndBraille(
               this.currentRange_, prevRange, Output.EventType.NAVIGATE)
           .go();
     }
   },
 
   /**
    * Provides all feedback once ChromeVox's focus changes.
    * @param {Object} evt
    */
   onEventDefault: function(evt) {
     var node = evt.target;
 
     if (!node)
       return;
 
     var prevRange = this.currentRange_;
 
     this.currentRange_ = cursors.Range.fromNode(node);
 
-    // Check to see if we've crossed roots. Only care about focused roots.
-    if (!prevRange ||
+    // Check to see if we've crossed roots. Continue if we've crossed roots or
+    // are not within web content.
+    if (node.root.role == 'desktop' ||
+        !prevRange ||
         (prevRange.getStart().getNode().root != node.root &&
-         node.root.focused))
+        node.state.focused))
       this.setupChromeVoxVariants_(node.root.docUrl || '');
 
     // Don't process nodes inside of web content if ChromeVox Next is inactive.
     if (node.root.role != chrome.automation.RoleType.desktop &&
         this.mode_ === ChromeVoxMode.CLASSIC) {
       chrome.accessibilityPrivate.setFocusRing([]);
       return;
     }
 
+    // Don't output if focused node hasn't changed.
+    if (prevRange &&
+        evt.type == 'focus' &&
+        this.currentRange_.equals(prevRange))
+      return;
+
     new Output().withSpeechAndBraille(
             this.currentRange_, prevRange, evt.type)
         .go();
   },
 
   /**
    * Provides all feedback once a load complete event fires.
    * @param {Object} evt
    */
   onLoadComplete: function(evt) {
@@ skipping 127 matching lines @@
     }
     output.withSpeech(range, null, Output.EventType.NAVIGATE);
     output.go();
   },
 
   /**
    * @return {boolean}
    * @private
    */
   isWhitelistedForCompat_: function(url) {
-    return url.indexOf('chrome://md-settings') != -1;
+    return url.indexOf('chrome://md-settings') != -1 || url === '';
   },
 
   /**
    * @private
    * @param {string} url
    * @return {boolean} Whether the given |url| is whitelisted.
    */
   isWhitelistedForNext_: function(url) {
     return this.whitelist_.some(function(item) {
       return url.indexOf(item) != -1;
     }.bind(this));
   },
 
   /**
    * Setup ChromeVox variants.
    * @param {string} url
    * @private
    */
   setupChromeVoxVariants_: function(url) {
-    this.compat_.active = this.isWhitelistedForCompat_(url);
     var mode = this.mode_;
-    if (this.compat_.active)
-      mode = ChromeVoxMode.COMPAT;
-    else if (this.isWhitelistedForNext_(url))
-      mode = ChromeVoxMode.NEXT;
-    else if (mode != ChromeVoxMode.FORCE_NEXT)
-      mode = ChromeVoxMode.CLASSIC;
+    if (mode != ChromeVoxMode.FORCE_NEXT) {
+      if (this.isWhitelistedForCompat_(url))
+        mode = ChromeVoxMode.COMPAT;
+      else if (this.isWhitelistedForNext_(url))
+        mode = ChromeVoxMode.NEXT;
+      else
+        mode = ChromeVoxMode.CLASSIC;
+    }
 
     this.setChromeVoxMode(mode);
   },
 
   /**
    * Disables classic ChromeVox.
    * @param {number} tabId The tab where ChromeVox classic is running in.
    */
   disableClassicChromeVox_: function(tabId) {
     chrome.tabs.executeScript(
@@ skipping 17 matching lines @@
         chrome.commands.onCommand.removeListener(this.onGotCommand);
     }
 
     chrome.tabs.query({active: true}, function(tabs) {
       if (mode === ChromeVoxMode.CLASSIC) {
         // This case should do nothing because Classic gets injected by the
         // extension system via our manifest. Once ChromeVox Next is enabled
         // for tabs, re-enable.
         // 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_.getStart().getNode().root.role == 'desktop')
+          return;
+
         tabs.forEach(function(tab) {
           this.disableClassicChromeVox_(tab.id);
         }.bind(this));
       }
     }.bind(this));
 
-    this.compat_.active = mode === ChromeVoxMode.COMPAT;
     this.mode_ = mode;
   }
 };
 
 /** @type {Background} */
 global.backgroundObj = new Background();
 
 });  // goog.scope