Make ChromeVox Next a setting in options page.

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 52 matching lines @@
    * @private
    */
   this.currentRange_ = null;
 
   /**
    * @type {cursors.Range}
    * @private
    */
   this.savedRange_ = null;
 
-  /**
-   * Which variant of ChromeVox is active.
-   * @type {ChromeVoxMode}
-   * @private
-   */
-  this.mode_ = ChromeVoxMode.COMPAT;
-
   // Manually bind all functions to |this|.
   for (var func in this) {
     if (typeof(this[func]) == 'function')
       this[func] = this[func].bind(this);
   }
 
   /** @type {!cvox.AbstractEarcons} @private */
   this.classicEarcons_ = cvox.ChromeVox.earcons || new cvox.ClassicEarcons();
 
   /** @type {!cvox.AbstractEarcons} @private */
   this.nextEarcons_ = new NextEarcons();
 
   // Turn cvox.ChromeVox.earcons into a getter that returns either the
   // Next earcons or the Classic earcons depending on the current mode.
   Object.defineProperty(cvox.ChromeVox, 'earcons', {
     get: (function() {
-      if (this.mode_ === ChromeVoxMode.FORCE_NEXT ||
-          this.mode_ === ChromeVoxMode.NEXT) {
+      if (this.mode === ChromeVoxMode.FORCE_NEXT ||
+          this.mode === ChromeVoxMode.NEXT) {
         return this.nextEarcons_;
       } else {
         return this.classicEarcons_;
       }
     }).bind(this)
   });
 
   if (cvox.ChromeVox.isChromeOS) {
     Object.defineProperty(cvox.ChromeVox, 'modKeyStr', {
       get: function() {
-        return (this.mode_ == ChromeVoxMode.CLASSIC || this.mode_ ==
+        return (this.mode == ChromeVoxMode.CLASSIC || this.mode ==
             ChromeVoxMode.COMPAT) ?
                 'Search+Shift' : 'Search';
       }.bind(this)
     });
   }
 
   Object.defineProperty(cvox.ChromeVox, 'isActive', {
     get: function() {
       return localStorage['active'] !== 'false';
     },
@@ skipping 13 matching lines @@
 
   // Live region handler.
   this.liveRegions_ = new LiveRegions(this);
 
   /** @type {number} @private */
   this.passThroughKeyUpCount_ = 0;
 
   /** @type {boolean} @private */
   this.inExcursion_ = false;
 
+  /**
+   * Stores the mode as computed the last time a current range was set.
+   */
+  this.mode_ = ChromeVoxMode.COMPAT;

[dmazzoni, 2016/06/21 21:21:02]

Can you use getMode() here?

[David Tseng, 2016/06/21 22:41:32]

No, because we always need to perform the basic setup required of a mode
transition on startup especially if we're in force next or compat mode.

I made this nullable and set it to null.

+
   if (!chrome.accessibilityPrivate.setKeyboardListener)
     chrome.accessibilityPrivate.setKeyboardListener = function() {};
 
   if (cvox.ChromeVox.isChromeOS) {
     chrome.accessibilityPrivate.onAccessibilityGesture.addListener(
         this.onAccessibilityGesture_);
 
+    if (localStorage['useNext'] == 'true')
+      this.forceChromeVoxNextActive();
+    else
+      this.onModeChanged_(ChromeVoxMode.COMPAT, ChromeVoxMode.CLASSIC);

[dmazzoni, 2016/06/21 21:21:02]

It'd be nice if you could just call refreshMode() here and have it compute the
new mode and call onModeChanged automatically based on that - see comment below

[David Tseng, 2016/06/21 22:41:32]

 new mode and call onModeChanged automatically based on that - see comment below

But, that's doing basically the equivalent. You're just hiding the transition
occuring.
this.mode_ initially gets set to ChromeVoxMode.COMPAT, so if you're unlucky,
you'll transition from compat to compat and not add any listeners.

The right way to think about this I think is setting the range which then
determines the mode (transitions if needed). classic -> force next means setting
the range to the focused node. Moving from force next to classic means setting
the current range to null.

+
     Notifications.onStartup();
   }};
 
 /**
  * @const {string}
  */
 Background.ISSUE_URL = 'https://code.google.com/p/chromium/issues/entry?' +
     'labels=Type-Bug,Pri-2,cvox2,OS-Chrome&' +
     'components=UI>accessibility&' +
     'description=';
@@ skipping 30 matching lines @@
   'swipeDown2': 'readFromHere',
 };
 
 Background.prototype = {
   __proto__: ChromeVoxState.prototype,
 
   /**
    * @override
    */
   getMode: function() {
-    return this.mode_;
+    if (localStorage['useNext'] == 'true')
+      return ChromeVoxMode.FORCE_NEXT;
+
+    var target;
+    if (!this.getCurrentRange()) {
+      chrome.automation.getFocus(function(focus) {
+        target = focus;
+      });
+    } else {
+      target = this.getCurrentRange().start.node;
+    }
+
+    if (!target)
+      return ChromeVoxMode.CLASSIC;
+
+    // Closure complains, but clearly, |target| is not null.
+    var root =
+        AutomationUtil.getTopLevelRoot(/** @type {!AutomationNode} */(target));
+    if (!root)
+        return ChromeVoxMode.COMPAT;

[dmazzoni, 2016/06/21 21:21:02]

nit: wrong indent

[David Tseng, 2016/06/21 22:41:32]

Done.

+    if (this.isWhitelistedForCompat_(root.docUrl))
+      return ChromeVoxMode.COMPAT;
+    else if (this.isWhitelistedForNext_(root.docUrl))
+      return ChromeVoxMode.NEXT;
+    else
+      return ChromeVoxMode.CLASSIC;
   },
 
   /**
-   * @override
+   * Handles a mode change.
+   * @param {ChromeVoxMode} newMode
+   * @param {ChromeVoxMode} oldMode
+   * @private
    */
-  setMode: function(mode, opt_injectClassic) {
+  onModeChanged_: function(newMode, oldMode) {
     // 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)
-      window['prefs'].switchToKeyMap('keymap_classic');
-    else
-      window['prefs'].switchToKeyMap('keymap_next');
+    if (window['prefs']) {
+      if (newMode === ChromeVoxMode.CLASSIC || newMode === ChromeVoxMode.COMPAT)
+        window['prefs'].switchToKeyMap('keymap_classic');
+      else
+        window['prefs'].switchToKeyMap('keymap_next');
+    }
 
-    if (mode == ChromeVoxMode.CLASSIC) {
+    if (newMode == ChromeVoxMode.CLASSIC) {
       if (chrome.commands &&
           chrome.commands.onCommand.hasListener(this.onGotCommand))
         chrome.commands.onCommand.removeListener(this.onGotCommand);
       chrome.accessibilityPrivate.setKeyboardListener(false, false);
+
+      if (cvox.ChromeVox.isChromeOS)
+        chrome.accessibilityPrivate.setFocusRing([]);
     } else {
       if (chrome.commands &&
           !chrome.commands.onCommand.hasListener(this.onGotCommand))
         chrome.commands.onCommand.addListener(this.onGotCommand);
         chrome.accessibilityPrivate.setKeyboardListener(
             true, cvox.ChromeVox.isStickyPrefOn);
     }
 
     // note that |this.currentRange_| can *change* because the request is
     // async. Save it to ensure we're looking at the currentRange at this moment
     // in time.
     var cur = this.currentRange_;
     chrome.tabs.query({active: true}, function(tabs) {
-      if (mode === ChromeVoxMode.CLASSIC) {
+      if (newMode === 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)
+        if (oldMode == ChromeVoxMode.FORCE_NEXT)
           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 (cur && !cur.isWebRange())
           return;
 
         this.disableClassicChromeVox_();
       }
     }.bind(this));
 
     // If switching out of a ChromeVox Next mode, make sure we cancel
     // the progress loading sound just in case.
-    if ((this.mode_ === ChromeVoxMode.NEXT ||
-         this.mode_ === ChromeVoxMode.FORCE_NEXT) &&
-        this.mode_ != mode) {
+    if (oldMode === ChromeVoxMode.NEXT ||
+        oldMode === ChromeVoxMode.FORCE_NEXT)
       cvox.ChromeVox.earcons.cancelEarcon(cvox.Earcon.PAGE_START_LOADING);
-    }
 
-    if (mode === ChromeVoxMode.NEXT ||
-        mode === ChromeVoxMode.FORCE_NEXT) {
+    if (newMode === ChromeVoxMode.NEXT ||
+        newMode === ChromeVoxMode.FORCE_NEXT) {
       (new PanelCommand(PanelCommandType.ENABLE_MENUS)).send();
       if (cvox.TabsApiHandler)
         cvox.TabsApiHandler.shouldOutputSpeechAndBraille = false;
     } else {
       (new PanelCommand(PanelCommandType.DISABLE_MENUS)).send();
       if (cvox.TabsApiHandler)
         cvox.TabsApiHandler.shouldOutputSpeechAndBraille = true;
     }
-
-    // If switching to Classic from any automation-API-based mode,
-    // clear the focus ring.
-    if (mode === ChromeVoxMode.CLASSIC && mode != this.mode_) {
-      if (cvox.ChromeVox.isChromeOS)
-        chrome.accessibilityPrivate.setFocusRing([]);
-    }
-
-    // If switching away from Classic to any automation-API-based mode,
-    // update the range based on what's focused.
-    if (this.mode_ === ChromeVoxMode.CLASSIC && mode != this.mode_) {
-      chrome.automation.getFocus((function(focus) {
-        if (focus)
-          this.setCurrentRange(cursors.Range.fromNode(focus));
-      }).bind(this));
-    }
-
-    this.mode_ = mode;
   },
 
   /**
-   * Mode refreshes takes into account both |url| and the current ChromeVox
-   *    range. The latter gets used to decide if the user is or isn't in web
-   *    content. The focused state also needs to be set for this info to be
-   *    reliable.
-   * @override
+   * Toggles between force next and classic/compat modes.
+   * This toggle automatically handles deciding between classic/compat based on
+   * the start of the current range.
+   * @param {boolean=} opt_setValue Directly set to force next (true) or
+   *                                classic/compat (false).
+   * @return {boolean} True to announce current position.
    */
-  refreshMode: function(node) {
-    // Mode changes are based upon the top level web root.
-    var root = node.root;
-    while (root &&
-        root.parent &&
-        root.parent.root &&
-        root.parent.root.role != RoleType.desktop) {
-      root = root.parent.root;
-    }
+  toggleNext: function(opt_setValue) {
+    var useNext;
+    if (opt_setValue !== undefined)
+      useNext = opt_setValue;
+    else
+      useNext = localStorage['useNext'] != 'true';
 
-    var url = '';
-    if (root && root.role == RoleType.rootWebArea)
-      url = root.docUrl;
+    localStorage['useNext'] = useNext;
+    if (useNext)
+      this.forceChromeVoxNextActive();
+    else
+      this.setCurrentRange(null);
 
-    var mode = this.mode_;
-    if (mode != ChromeVoxMode.FORCE_NEXT) {
-      if (this.isWhitelistedForNext_(url)) {
-        mode = ChromeVoxMode.NEXT;
-      } else if (this.isBlacklistedForClassic_(url) || (this.currentRange_ &&
-          !this.currentRange_.isWebRange() &&
-          this.currentRange_.start.node.state.focused)) {
-        mode = ChromeVoxMode.COMPAT;
-      } else {
-        mode = ChromeVoxMode.CLASSIC;
-      }
-    }
+    var announce = Msgs.getMsg(useNext ?
+        'switch_to_next' : 'switch_to_classic');
+    cvox.ChromeVox.tts.speak(
+        announce, cvox.QueueMode.FLUSH, {doNotInterrupt: true});
+    Notifications.onModeChange();
 
-    this.setMode(mode);
+    // If the new mode is Classic, return false now so we don't announce
+    // anything more.
+    return useNext;
   },
 
   /**
    * @override
    */
   getCurrentRange: function() {
     if (this.currentRange_ && this.currentRange_.isValid())
       return this.currentRange_;
     return null;
   },
 
   /**
    * @override
    */
   setCurrentRange: function(newRange) {
-    if (!newRange)
-      return;
-
-    // Is the range invalid?
-    if (newRange.start.node.role === undefined ||
-        newRange.end.node.role === undefined) {
-      // Restore range to the focused location.
-      chrome.automation.getFocus(function(f) {
-        newRange = cursors.Range.fromNode(f);
-      });
-    }
-
-    if (!this.inExcursion_)
+    if (!this.inExcursion_ && newRange)
       this.savedRange_ = new cursors.Range(newRange.start, newRange.end);
 
     this.currentRange_ = newRange;
+    var oldMode = this.mode_;

[dmazzoni, 2016/06/21 21:21:02]

Could these 5 lines be refreshMode()?

Then any call to forceChromeVoxNextActive can be replaced with refreshMode().

[David Tseng, 2016/06/21 22:41:32]

I'd like to limit the number of methods exposed by background especially if
there are no callers.

It's also not clear from this block that force next would go through the right
transitions since this.mode_ might have been set to force next already (e.g. on
startup) since it's getting persisted.

+    var newMode = this.getMode();
+    if (oldMode != newMode) {
+      this.onModeChanged_(newMode, oldMode);
+      this.mode_ = newMode;
+    }
 
     if (this.currentRange_) {
       var start = this.currentRange_.start.node;
       start.makeVisible();
 
       var root = start.root;
-
       if (!root || root.role == RoleType.desktop)
         return;
 
       var position = {};
       var loc = start.location;
       position.x = loc.left + loc.width / 2;
       position.y = loc.top + loc.height / 2;
       var url = root.docUrl;
       url = url.substring(0, url.indexOf('#')) || url;
       cvox.ChromeVox.position[url] = position;
     }
   },
 
   /** Forces ChromeVox Next to be active for all tabs. */
   forceChromeVoxNextActive: function() {

[dmazzoni, 2016/06/21 21:21:02]

This doesn't actually force it active, it assumes that localStorage and mode_
have already been set.

[David Tseng, 2016/06/21 22:41:32]

Yup; removed and in-lined since there are no external callers anyway.

-    this.setMode(ChromeVoxMode.FORCE_NEXT);
+    this.onModeChanged_(ChromeVoxMode.FORCE_NEXT, ChromeVoxMode.CLASSIC);
   },
 
   /**
    * 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) {
     // Check for loss of focus which results in us invalidating our current
     // range. Note this call is synchronis.
     chrome.automation.getFocus(function(focusedNode) {
       if (this.currentRange_ && !this.currentRange_.isValid())
         this.currentRange_ = cursors.Range.fromNode(focusedNode);
       if (!focusedNode)
         this.currentRange_ = null;
     }.bind(this));
 
     if (!this.currentRange_)
       return true;
 
-    if (this.mode_ == ChromeVoxMode.CLASSIC && !opt_bypassModeCheck)
+    if (this.mode == ChromeVoxMode.CLASSIC && !opt_bypassModeCheck)
       return true;
 
     var current = this.currentRange_;
     var dir = Dir.FORWARD;
     var pred = null;
     var predErrorMsg = undefined;
     var speechProps = {};
     switch (command) {
       case 'nextCharacter':
         speechProps['phoneticCharacters'] = true;
@@ skipping 190 matching lines @@
           return false;
 
         cvox.ChromeVox.isActive = !cvox.ChromeVox.isActive;
         if (!cvox.ChromeVox.isActive) {
           var msg = Msgs.getMsg('chromevox_inactive');
           cvox.ChromeVox.tts.speak(msg, cvox.QueueMode.FLUSH);
           return false;
         }
         break;
       case 'toggleChromeVoxVersion':
-        var newMode;
-        if (this.mode_ == ChromeVoxMode.FORCE_NEXT) {
-          var inWeb = current.isWebRange();
-          newMode = inWeb ? ChromeVoxMode.CLASSIC : ChromeVoxMode.COMPAT;
-        } else {
-          newMode = ChromeVoxMode.FORCE_NEXT;
-        }
-        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});
-
-        // If the new mode is Classic, return now so we don't announce
-        // anything more.
-        if (newMode == ChromeVoxMode.CLASSIC)
-          return false;
+      if (!this.toggleNext())
+        return false;
         break;
       case 'toggleStickyMode':
         cvox.ChromeVoxBackground.setPref('sticky',
                                          !cvox.ChromeVox.isStickyPrefOn,
                                          true);
 
         if (cvox.ChromeVox.isStickyPrefOn)
           chrome.accessibilityPrivate.setKeyboardListener(true, true);
         else
           chrome.accessibilityPrivate.setKeyboardListener(true, false);
@@ skipping 140 matching lines @@
         output.go();
         return false;
       case 'readCurrentURL':
         var output = new Output();
         var target = this.currentRange_.start.node.root;
         output.withString(target.docUrl || '').go();
         return false;
       case 'reportIssue':
         var url = Background.ISSUE_URL;
         var description = {};
-        description['Mode'] = this.mode_;
+        description['Mode'] = this.mode;
         description['Version'] = chrome.app.getDetails().version;
         description['Reproduction Steps'] = '%0a1.%0a2.%0a3.';
         for (var key in description)
           url += key + ':%20' + description[key] + '%0a';
         chrome.tabs.create({url: url});
         return false;
       case 'toggleBrailleCaptions':
         cvox.BrailleCaptionsBackground.setActive(
             !cvox.BrailleCaptionsBackground.isEnabled());
         return false;
@@ skipping 100 matching lines @@
   /**
    * 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) {
     evt.stickyMode = cvox.ChromeVox.isStickyModeOn() && cvox.ChromeVox.isActive;
     if (cvox.ChromeVox.passThroughMode)
       return false;
 
-    if (this.mode_ != ChromeVoxMode.CLASSIC &&
+    if (this.mode != ChromeVoxMode.CLASSIC &&
         !cvox.ChromeVoxKbHandler.basicKeyDownActionsListener(evt)) {
       evt.preventDefault();
       evt.stopPropagation();
     }
     Output.flushNextSpeechUtterance();
     return false;
   },
 
   /**
    * Handles key up events.
@@ skipping 22 matching lines @@
     chrome.tabs.create(optionsPage);
   },
 
   /**
    * Handles a braille command.
    * @param {!cvox.BrailleKeyEvent} evt
    * @param {!cvox.NavBraille} content
    * @return {boolean} True if evt was processed.
    */
   onBrailleKeyEvent: function(evt, content) {
-    if (this.mode_ === ChromeVoxMode.CLASSIC)
+    if (this.mode === ChromeVoxMode.CLASSIC)
       return false;
 
     switch (evt.command) {
       case cvox.BrailleKeyCommand.PAN_LEFT:
         this.onGotCommand('previousObject');
         break;
       case cvox.BrailleKeyCommand.PAN_RIGHT:
         this.onGotCommand('nextObject');
         break;
       case cvox.BrailleKeyCommand.LINE_UP:
@@ skipping 19 matching lines @@
     }
     return true;
   },
 
   /**
    * Returns true if the url should have Classic running.
    * @return {boolean}
    * @private
    */
   shouldEnableClassicForUrl_: function(url) {
-    return this.mode_ != ChromeVoxMode.FORCE_NEXT &&
+    return this.mode != ChromeVoxMode.FORCE_NEXT &&
         !this.isBlacklistedForClassic_(url) &&
         !this.isWhitelistedForNext_(url);
   },
 
   /**
+   * Compat mode is on if any of the following are true:
+   * 1. a url is blacklisted for Classic.
+   * 2. the current range is not within web content.
+   * @param {string} url
+   */
+  isWhitelistedForCompat_: function(url) {
+    return this.isBlacklistedForClassic_(url) || (this.getCurrentRange() &&
+        !this.getCurrentRange().isWebRange() &&
+        this.getCurrentRange().start.node.state.focused);
+  },
+
+  /**
    * @param {string} url
    * @return {boolean}
    * @private
    */
   isBlacklistedForClassic_: function(url) {
     return this.classicBlacklistRegExp_.test(url);
   },
 
   /**
    * @param {string} url
@@ skipping 133 matching lines @@
   /**
    * Handles accessibility gestures from the touch screen.
    * @param {string} gesture The gesture to handle, based on the AXGesture enum
    *     defined in ui/accessibility/ax_enums.idl
    * @private
    */
   onAccessibilityGesture_: function(gesture) {
     // If we're in classic mode, some gestures need to be handled by the
     // content script. Other gestures are universal and will be handled in
     // this function.
-    if (this.mode_ == ChromeVoxMode.CLASSIC) {
+    if (this.mode == ChromeVoxMode.CLASSIC) {
       if (this.handleClassicGesture_(gesture))
         return;
     }
 
     var command = Background.GESTURE_NEXT_COMMAND_MAP[gesture];
     if (command)
       this.onGotCommand(command);
   },
 
   /**
@@ skipping 30 matching lines @@
     return glob.replace(/[.+^$(){}|[\]\\]/g, '\\$&')
         .replace(/\*/g, '.*')
         .replace(/\?/g, '.');
   }).join('|') + ')$');
 };
 
 /** @type {Background} */
 global.backgroundObj = new Background();
 
 });  // goog.scope