Re-land: Update json_schema_compiler to handle the Automation extension API

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 20 matching lines @@
 goog.require('cvox.ChromeVoxEditableTextBase');
 goog.require('cvox.ClassicEarcons');
 goog.require('cvox.ExtensionBridge');
 goog.require('cvox.NavBraille');
 
 goog.scope(function() {
 var AutomationNode = chrome.automation.AutomationNode;
 var Dir = constants.Dir;
 var EventType = chrome.automation.EventType;
 var RoleType = chrome.automation.RoleType;
+var StateType = chrome.automation.StateType;
 
 /**
  * ChromeVox2 background page.
  * @constructor
  * @extends {ChromeVoxState}
  */
 Background = function() {
   ChromeVoxState.call(this);
 
   /**
@@ skipping 194 matching lines @@
     if (!target)
       return useNext ? ChromeVoxMode.FORCE_NEXT : ChromeVoxMode.CLASSIC;
 
     // Closure complains, but clearly, |target| is not null.
     var topLevelRoot =
         AutomationUtil.getTopLevelRoot(/** @type {!AutomationNode} */(target));
     if (!topLevelRoot)
       return useNext ? ChromeVoxMode.FORCE_NEXT :
           ChromeVoxMode.CLASSIC_COMPAT;
 
-    var nextSite = this.isWhitelistedForNext_(topLevelRoot.docUrl);
-    var nextCompat = this.nextCompatRegExp_.test(topLevelRoot.docUrl) &&
+    var docUrl = topLevelRoot.docUrl || '';
+    var nextSite = this.isWhitelistedForNext_(docUrl);
+    var nextCompat = this.nextCompatRegExp_.test(docUrl) &&
         this.chromeChannel_ != 'dev';
     var classicCompat =
-        this.isWhitelistedForClassicCompat_(topLevelRoot.docUrl);
+        this.isWhitelistedForClassicCompat_(docUrl);
     if (nextCompat && useNext)
       return ChromeVoxMode.NEXT_COMPAT;
     else if (classicCompat && !useNext)
       return ChromeVoxMode.CLASSIC_COMPAT;
     else if (nextSite)
       return ChromeVoxMode.NEXT;
     else if (!useNext)
       return ChromeVoxMode.CLASSIC;
     else
       return ChromeVoxMode.FORCE_NEXT;
@@ skipping 134 matching lines @@
     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)
+      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;
     }
@@ skipping 62 matching lines @@
         if (this.pageSel_)
           this.pageSel_.select();
       }
     } else {
       // Ensure we don't select the editable when we first encounter it.
       var lca = null;
       if (range.start.node && prevRange.start.node) {
         lca = AutomationUtil.getLeastCommonAncestor(prevRange.start.node,
                                                     range.start.node);
       }
-      if (!lca || lca.state.editable || !range.start.node.state.editable)
+      if (!lca || lca.state[StateType.EDITABLE] ||
+          !range.start.node.state[StateType.EDITABLE])
         range.select();
     }
 
     o.withRichSpeechAndBraille(
         selectedRange || range, prevRange, Output.EventType.NAVIGATE)
             .withQueueMode(cvox.QueueMode.FLUSH);
 
     if (msg)
       o.format(msg);
 
@@ skipping 73 matching lines @@
   },
 
   /**
    * 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
    * @return {boolean}
    */
   isWhitelistedForClassicCompat_: function(url) {
-    return this.isBlacklistedForClassic_(url) || (this.getCurrentRange() &&
+    return (this.isBlacklistedForClassic_(url) || (this.getCurrentRange() &&
         !this.getCurrentRange().isWebRange() &&
-        this.getCurrentRange().start.node.state.focused);
+        this.getCurrentRange().start.node.state[StateType.FOCUSED])) || false;
   },
 
   /**
    * @param {string} url
    * @return {boolean}
    * @private
    */
   isBlacklistedForClassic_: function(url) {
     if (this.classicBlacklistRegExp_.test(url))
       return true;
@@ skipping 56 matching lines @@
       } else if (span instanceof Output.NodeSpan) {
         if (!actionNodeSpan ||
             text.getSpanLength(span) <= text.getSpanLength(actionNodeSpan)) {
           actionNodeSpan = span;
         }
       }
     });
     if (!actionNodeSpan)
       return;
     var actionNode = actionNodeSpan.node;
-    if (actionNode.role === RoleType.inlineTextBox)
+    if (actionNode.role === RoleType.INLINE_TEXT_BOX)
       actionNode = actionNode.parent;
     actionNode.doDefault();
     if (selectionSpan) {
       var start = text.getSpanStart(selectionSpan);
       var targetPosition = position - start;
       actionNode.setSelection(targetPosition, targetPosition);
     }
   },
 
   /**
@@ skipping 99 matching lines @@
   setFocusToRange_: function(range, prevRange) {
     var start = range.start.node;
     var end = range.end.node;
 
     // First, see if we've crossed a root. Remove once webview handles focus
     // correctly.
     if (prevRange && prevRange.start.node && start) {
       var entered = AutomationUtil.getUniqueAncestors(
           prevRange.start.node, start);
       var embeddedObject = entered.find(function(f) {
-        return f.role == RoleType.embeddedObject; });
-      if (embeddedObject && !embeddedObject.state.focused)
+        return f.role == RoleType.EMBEDDED_OBJECT; });
+      if (embeddedObject && !embeddedObject.state[StateType.FOCUSED])
         embeddedObject.focus();
     }
 
-    if (start.state.focused || end.state.focused)
+    if (start.state[StateType.FOCUSED] || end.state[StateType.FOCUSED])
       return;
 
     var isFocusableLinkOrControl = function(node) {
-      return node.state.focusable &&
+      return node.state[StateType.FOCUSABLE] &&
           AutomationPredicate.linkOrControl(node);
     };
 
     // Next, try to focus the start or end node.
     if (!AutomationPredicate.structuralContainer(start) &&
-        start.state.focusable) {
-      if (!start.state.focused)
+        start.state[StateType.FOCUSABLE]) {
+      if (!start.state[StateType.FOCUSED])
         start.focus();
       return;
     } else if (!AutomationPredicate.structuralContainer(end) &&
-        end.state.focusable) {
-      if (!end.state.focused)
+        end.state[StateType.FOCUSABLE]) {
+      if (!end.state[StateType.FOCUSED])
         end.focus();
       return;
     }
 
     // If a common ancestor of |start| and |end| is a link, focus that.
     var ancestor = AutomationUtil.getLeastCommonAncestor(start, end);
     while (ancestor && ancestor.root == start.root) {
       if (isFocusableLinkOrControl(ancestor)) {
-        if (!ancestor.state.focused)
+        if (!ancestor.state[StateType.FOCUSED])
           ancestor.focus();
         return;
       }
       ancestor = ancestor.parent;
     }
 
     // If nothing is focusable, set the sequential focus navigation starting
     // point, which ensures that the next time you press Tab, you'll reach
     // the next or previous focusable node from |start|.
-    if (!start.state.offscreen)
+    if (!start.state[StateType.OFFSCREEN])
       start.setSequentialFocusNavigationStartingPoint();
   }
 };
 
 /**
  * Converts a list of globs, as used in the extension manifest, to a regular
  * expression that matches if and only if any of the globs in the list matches.
  * @param {!Array<string>} globs
  * @return {!RegExp}
  * @private
  */
 Background.globsToRegExp_ = function(globs) {
   return new RegExp('^(' + globs.map(function(glob) {
     return glob.replace(/[.+^$(){}|[\]\\]/g, '\\$&')
         .replace(/\*/g, '.*')
         .replace(/\?/g, '.');
   }).join('|') + ')$');
 };
 
 new Background();
 
 });  // goog.scope