Update json_schema_compiler to handle the Automation extension API

chrome/browser/resources/chromeos/chromevox/cvox2/background/automation_predicate.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 ChromeVox predicates for the automation extension API.
  */
 
 goog.provide('AutomationPredicate');
 goog.provide('AutomationPredicate.Binary');
 goog.provide('AutomationPredicate.Unary');
 
 goog.require('constants');
 
 goog.scope(function() {
 var AutomationNode = chrome.automation.AutomationNode;
 var Dir = constants.Dir;
 var Role = chrome.automation.RoleType;
+var State = chrome.automation.StateType;
 
 /**
  * @constructor
  */
 AutomationPredicate = function() {};
 
 /**
  * @typedef {function(!AutomationNode) : boolean}
  */
 AutomationPredicate.Unary;
@@ skipping 22 matching lines @@
   var anyRole = params.anyRole || [];
   var anyPredicate = params.anyPredicate || [];
   return function(node) {
     return anyRole.some(function(role) { return role == node.role; }) ||
         anyPredicate.some(function(p) { return p(node); });
   };
 };
 
 /** @type {AutomationPredicate.Unary} */
 AutomationPredicate.checkBox =
-    AutomationPredicate.roles([Role.checkBox, Role.switch]);
+    AutomationPredicate.roles([Role.CHECK_BOX, Role.SWITCH]);
 /** @type {AutomationPredicate.Unary} */
 AutomationPredicate.comboBox = AutomationPredicate.roles(
-    [Role.comboBox, Role.popUpButton, Role.menuListPopup]);
+    [Role.COMBO_BOX, Role.POP_UP_BUTTON, Role.MENU_LIST_POPUP]);
 /** @type {AutomationPredicate.Unary} */
-AutomationPredicate.heading = AutomationPredicate.roles([Role.heading]);
+AutomationPredicate.heading = AutomationPredicate.roles([Role.HEADING]);
 /** @type {AutomationPredicate.Unary} */
 AutomationPredicate.inlineTextBox =
-    AutomationPredicate.roles([Role.inlineTextBox]);
+    AutomationPredicate.roles([Role.INLINE_TEXT_BOX]);
 /** @type {AutomationPredicate.Unary} */
-AutomationPredicate.link = AutomationPredicate.roles([Role.link]);
+AutomationPredicate.link = AutomationPredicate.roles([Role.LINK]);
 /** @type {AutomationPredicate.Unary} */
-AutomationPredicate.row = AutomationPredicate.roles([Role.row]);
+AutomationPredicate.row = AutomationPredicate.roles([Role.ROW]);
 /** @type {AutomationPredicate.Unary} */
-AutomationPredicate.table = AutomationPredicate.roles([Role.grid, Role.table]);
+AutomationPredicate.table = AutomationPredicate.roles([Role.GRID, Role.TABLE]);
 
 /**
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.button = function(node) {
   return /button/i.test(node.role);
 };
 
 /**
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.editText = function(node) {
   return node.state.editable &&
       node.parent &&
       !node.parent.state.editable;
 };
 
 /** @type {AutomationPredicate.Unary} */
 AutomationPredicate.formField = AutomationPredicate.match({
   anyPredicate: [
     AutomationPredicate.button,
     AutomationPredicate.comboBox,
     AutomationPredicate.editText
   ],
   anyRole: [
-    Role.checkBox,
-    Role.colorWell,
-    Role.listBox,
-    Role.slider,
-    Role.switch,
-    Role.tab,
-    Role.tree
+    Role.CHECK_BOX,
+    Role.COLOR_WELL,
+    Role.LIST_BOX,
+    Role.SLIDER,
+    Role.SWITCH,
+    Role.TAB,
+    Role.TREE
   ]
 });
 
 /** @type {AutomationPredicate.Unary} */
 AutomationPredicate.control = AutomationPredicate.match({
   anyPredicate: [
     AutomationPredicate.formField,
   ],
   anyRole: [
-    Role.disclosureTriangle,
-    Role.menuItem,
-    Role.menuItemCheckBox,
-    Role.menuItemRadio,
-    Role.menuListOption,
-    Role.scrollBar
+    Role.DISCLOSURE_TRIANGLE,
+    Role.MENU_ITEM,
+    Role.MENU_ITEM_CHECK_BOX,
+    Role.MENU_ITEM_RADIO,
+    Role.MENU_LIST_OPTION,
+    Role.SCROLL_BAR
   ]
 });
 
 /**
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.image = function(node) {
-  return node.role == Role.image && !!(node.name || node.url);
+  return node.role == Role.IMAGE && !!(node.name || node.url);
 };
 
 /** @type {AutomationPredicate.Unary} */
 AutomationPredicate.linkOrControl = AutomationPredicate.match({
   anyPredicate: [
     AutomationPredicate.control
   ],
   anyRole: [
-    Role.link
+    Role.LINK
   ]
 });
 
 /** @type {AutomationPredicate.Unary} */
 AutomationPredicate.landmark = AutomationPredicate.roles([
-    Role.application,
-    Role.banner,
-    Role.complementary,
-    Role.contentInfo,
-    Role.form,
-    Role.main,
-    Role.navigation,
-    Role.region,
-    Role.search]);
+    Role.APPLICATION,
+    Role.BANNER,
+    Role.COMPLEMENTARY,
+    Role.CONTENT_INFO,
+    Role.FORM,
+    Role.MAIN,
+    Role.NAVIGATION,
+    Role.REGION,
+    Role.SEARCH]);
 
 /**
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.visitedLink = function(node) {
   return node.state.visited;
 };
 
 /**
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.focused = function(node) {
   return node.state.focused;
 };
 
 /**
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.leaf = function(node) {
   return !node.firstChild ||
-      node.role == Role.button ||
-      node.role == Role.buttonDropDown ||
-      node.role == Role.popUpButton ||
-      node.role == Role.slider ||
-      node.role == Role.textField ||
-      node.state.invisible ||
+      node.role == Role.BUTTON ||
+      node.role == Role.BUTTON_DROP_DOWN ||
+      node.role == Role.POP_UP_BUTTON ||
+      node.role == Role.SLIDER ||
+      node.role == Role.TEXT_FIELD ||
+      node.state[State.INVISIBLE] ||
       node.children.every(function(n) {
-        return n.state.invisible;
+        return n.state[State.INVISIBLE];
       });
 };
 
 /**
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.leafWithText = function(node) {
   return AutomationPredicate.leaf(node) &&
       !!(node.name || node.value);
 };
 
 /**
  * Matches against leaves or static text nodes. Useful when restricting
  * traversal to non-inline textboxes while still allowing them if navigation
  * already entered into an inline textbox.
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.leafOrStaticText = function(node) {
   return AutomationPredicate.leaf(node) ||
-      node.role == Role.staticText;
+      node.role == Role.STATIC_TEXT;
 };
 
 /**
  * Matches against nodes visited during object navigation. An object as
  * defined below, are all nodes that are focusable or static text. When used in
  * tree walking, it should visit all nodes that tab traversal would as well as
  * non-focusable static text.
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.object = function(node) {
   // Editable nodes are within a text-like field and don't make sense when
   // performing object navigation. Users should use line, word, or character
   // navigation. Only navigate to the top level node.
   if (node.parent && node.parent.state.editable)
     return false;
 
   // Descend into large nodes.
   if (node.name && node.name.length > constants.OBJECT_MAX_CHARCOUNT)
     return false;
 
   return node.state.focusable ||
       (AutomationPredicate.leafOrStaticText(node) &&
        (/\S+/.test(node.name) ||
-        (node.role != Role.lineBreak &&
-         node.role != Role.staticText &&
-         node.role != Role.inlineTextBox)));
+        (node.role != Role.LINE_BREAK &&
+         node.role != Role.STATIC_TEXT &&
+         node.role != Role.INLINE_TEXT_BOX)));
 };
 
 /**
  * Matches against nodes visited during group navigation. An object as
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.group = AutomationPredicate.match({
   anyRole: [
-    Role.heading,
-    Role.list,
-    Role.paragraph
+    Role.HEADING,
+    Role.LIST,
+    Role.PARAGRAPH
   ],
   anyPredicate: [
     AutomationPredicate.editText,
     AutomationPredicate.formField,
     AutomationPredicate.object,
     AutomationPredicate.table
   ]
 });
 
 /**
@@ skipping 11 matching lines @@
 
 /**
  * Matches against a node that contains other interesting nodes.
  * These nodes should always have their subtrees scanned when navigating.
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.container = function(node) {
   return AutomationPredicate.match({
     anyRole: [
-      Role.div,
-      Role.document,
-      Role.group,
-      Role.listItem,
-      Role.toolbar,
-      Role.window],
+      Role.DIV,
+      Role.DOCUMENT,
+      Role.GROUP,
+      Role.LIST_ITEM,
+      Role.TOOLBAR,
+      Role.WINDOW],
     anyPredicate: [
       AutomationPredicate.landmark,
       AutomationPredicate.structuralContainer,
       function(node) {
         // For example, crosh.
-        return (node.role == Role.textField && node.state.readOnly);
+        return (node.role == Role.TEXT_FIELD && node.state.readOnly);
       },
       function(node) {
         return (node.state.editable &&
             node.parent &&
             !node.parent.state.editable);
       }]
   })(node);
 };
 
 /**
  * Matches against nodes that contain interesting nodes, but should never be
  * visited.
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.structuralContainer = AutomationPredicate.roles([
-    Role.alertDialog,
-    Role.dialog,
-    Role.rootWebArea,
-    Role.webView,
-    Role.window,
-    Role.embeddedObject,
-    Role.iframe,
-    Role.iframePresentational]);
+    Role.ALERT_DIALOG,
+    Role.DIALOG,
+    Role.ROOT_WEB_AREA,
+    Role.WEB_VIEW,
+    Role.WINDOW,
+    Role.EMBEDDED_OBJECT,
+    Role.IFRAME,
+    Role.IFRAME_PRESENTATIONAL]);
 
 /**
  * Returns whether the given node should not be crossed when performing
  * traversals up the ancestry chain.
  * @param {AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.root = function(node) {
   switch (node.role) {
-    case Role.dialog:
-    case Role.window:
+    case Role.DIALOG:
+    case Role.WINDOW:
       return true;
-    case Role.toolbar:
-      return node.root.role == Role.desktop;
-    case Role.rootWebArea:
-      return !node.parent || node.parent.root.role == Role.desktop;
+    case Role.TOOLBAR:
+      return node.root.role == Role.DESKTOP;
+    case Role.ROOT_WEB_AREA:
+      return !node.parent || node.parent.root.role == Role.DESKTOP;
     default:
       return false;
   }
 };
 
 /**
  * Nodes that should be ignored while traversing the automation tree. For
  * example, apply this predicate when moving to the next object.
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.shouldIgnoreNode = function(node) {
   // Ignore invisible nodes.
   if (node.state.invisible ||
       (node.location.height == 0 && node.location.width == 0))
     return true;
 
   // Ignore structural containres.
   if (AutomationPredicate.structuralContainer(node))
     return true;
 
   // Ignore list markers since we already announce listitem role.
-  if (node.role == Role.listMarker)
+  if (node.role == Role.LIST_MARKER)
     return true;
 
   // Don't ignore nodes with names or name-like attribute.
   if (node.name || node.value || node.description || node.url)
     return false;
 
   // Ignore some roles.
   return AutomationPredicate.leaf(node) &&
-      (AutomationPredicate.roles([Role.client,
-                                  Role.column,
-                                  Role.div,
-                                  Role.group,
-                                  Role.image,
-                                  Role.staticText,
-                                  Role.svgRoot,
-                                  Role.tableHeaderContainer,
-                                  Role.unknown
+      (AutomationPredicate.roles([Role.CLIENT,
+                                  Role.COLUMN,
+                                  Role.DIV,
+                                  Role.GROUP,
+                                  Role.IMAGE,
+                                  Role.STATIC_TEXT,
+                                  Role.SVG_ROOT,
+                                  Role.TABLE_HEADER_CONTAINER,
+                                  Role.UNKNOWN
                                  ])(node));
 };
 
 /**
  * Returns if the node has a meaningful checked state.
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.checkable = AutomationPredicate.roles([
-  Role.checkBox,
-  Role.radioButton,
-  Role.menuItemCheckBox,
-  Role.menuItemRadio,
-  Role.treeItem]);
+  Role.CHECK_BOX,
+  Role.RADIO_BUTTON,
+  Role.MENU_ITEM_CHECK_BOX,
+  Role.MENU_ITEM_RADIO,
+  Role.TREE_ITEM]);
 
 // Table related predicates.
 /**
  * Returns if the node has a cell like role.
  * @param {!AutomationNode} node
  * @return {boolean}
  */
 AutomationPredicate.cellLike = AutomationPredicate.roles([
-  Role.cell,
-  Role.rowHeader,
-  Role.columnHeader]);
+  Role.CELL,
+  Role.ROW_HEADER,
+  Role.COLUMN_HEADER]);
 
 /**
  * Returns a predicate that will match against the directed next cell taking
  * into account the current ancestor cell's position in the table.
  * @param {AutomationNode} start
  * @param {{dir: (Dir|undefined),
 *           row: (boolean|undefined),
  *          col: (boolean|undefined)}} opts
  * |dir|, specifies direction for |row or/and |col| movement by one cell.
  *     |dir| defaults to forward.
@@ skipping 59 matching lines @@
 };
 
 /**
  * Returns a predicate that will match against a heading with a specific
  * hierarchical level.
  * @param {number} level 1-6
  * @return {AutomationPredicate.Unary}
  */
 AutomationPredicate.makeHeadingPredicate = function(level) {
   return function(node) {
-    return node.role == Role.heading && node.hierarchicalLevel == level;
+    return node.role == Role.HEADING && node.hierarchicalLevel == level;
   };
 };
 
 });  // goog.scope