Update json_schema_compiler to handle the Automation extension API

chrome/browser/resources/chromeos/chromevox/cvox2/background/output.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 Provides output services for ChromeVox.
  */
 
 goog.provide('Output');
 goog.provide('Output.EventType');
@@ skipping 12 matching lines @@
 goog.require('cvox.TtsCategory');
 goog.require('cvox.ValueSelectionSpan');
 goog.require('cvox.ValueSpan');
 goog.require('goog.i18n.MessageFormat');
 
 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;
 
 /**
  * An Output object formats a cursors.Range into speech, braille, or both
  * representations. This is typically a |Spannable|.
  *
  * The translation from Range to these output representations rely upon format
  * rules which specify how to convert AutomationNode objects into annotated
  * strings.
  * The format of these rules is as follows.
  *
@@ skipping 935 matching lines @@
     if (prevRange && !prevRange.isValid())
       prevRange = null;
 
     // Scan unique ancestors to get the value of |outputContextFirst|.
     var parent = range.start.node;
     var prevParent = prevRange ? prevRange.start.node : parent;
     if (!parent || !prevParent)
       return;
     var uniqueAncestors = AutomationUtil.getUniqueAncestors(prevParent, parent);
     for (var i = 0; parent = uniqueAncestors[i]; i++) {
-      if (parent.role == RoleType.window)
+      if (parent.role == RoleType.WINDOW)
         break;
       if (Output.ROLE_INFO_[parent.role] &&
           Output.ROLE_INFO_[parent.role].outputContextFirst) {
         this.outputContextFirst_ = true;
         break;
       }
     }
 
     if (range.isSubNode())
       this.subNode_(range, prevRange, type, buff);
@@ skipping 46 matching lines @@
         token = token.substring(0, token.length - 1);
 
       // Process token based on prefix.
       var prefix = token[0];
       token = token.slice(1);
 
       // All possible tokens based on prefix.
       if (prefix == '$') {
         if (token == 'value') {
           var text = node.value;
-          if (!node.state.editable && node.name == text)
+          if (!node.state[StateType.EDITABLE] && node.name == text)
             return;
 
           var selectedText = '';
           if (text !== undefined) {
             if (node.textSelStart !== undefined) {
               options.annotation.push(new Output.SelectionSpan(
                   node.textSelStart,
                   node.textSelEnd));
 
               selectedText =
@@ skipping 71 matching lines @@
             case 'mixed':
               msg = 'aria_checked_mixed';
               break;
             case 'true':
               msg = 'aria_checked_true';
               break;
             case 'false':
               msg = 'aria_checked_false';
               break;
             default:
-            msg =
-                node.state.checked ? 'aria_checked_true' : 'aria_checked_false';
+              msg = node.state[StateType.CHECKED] ?
+                  'aria_checked_true' : 'aria_checked_false';
           }
           this.format_(node, '@' + msg, buff);
         } else if (token == 'state') {
           Object.getOwnPropertyNames(node.state).forEach(function(s) {
             var stateInfo = Output.STATE_INFO_[s];
             if (stateInfo && !stateInfo.isRoleSpecific && stateInfo.on)
               this.format_(node, '@' + stateInfo.on.msgId, buff);
           }.bind(this));
         } else if (token == 'find') {
           // Find takes two arguments: JSON query string and format string.
           if (tree.firstChild) {
             var jsonQuery = tree.firstChild.value;
             node = node.find(
-                /** @type {Object}*/(JSON.parse(jsonQuery)));
+                /** @type {chrome.automation.FindParams}*/(
+                    JSON.parse(jsonQuery)));
             var formatString = tree.firstChild.nextSibling;
             if (node)
               this.format_(node, formatString, buff);
           }
         } else if (token == 'descendants') {
           if (!node || AutomationPredicate.leafOrStaticText(node))
             return;
 
           // Construct a range to the leftmost and rightmost leaves.
           var leftmost = AutomationUtil.findNodePre(
@@ skipping 270 matching lines @@
    */
   ancestry_: function(node, prevNode, type, buff) {
     // Expects |ancestors| to be ordered from root down to leaf. Outputs in
     // reverse; place context first nodes at the end.
     function byContextFirst(ancestors) {
       var contextFirst = [];
       var rest = [];
       for (i = 0; i < ancestors.length - 1; i++) {
         var node = ancestors[i];
         // Discard ancestors of deepest window.
-        if (node.role == RoleType.window) {
+        if (node.role == RoleType.WINDOW) {
           contextFirst = [];
           rest = [];
         }
         if ((Output.ROLE_INFO_[node.role] || {}).outputContextFirst)
           contextFirst.push(node);
         else
           rest.push(node);
       }
       return rest.concat(contextFirst.reverse());
     }
@@ skipping 143 matching lines @@
       }
     }
 
     if (this.outputContextFirst_)
       this.ancestry_(node, prevNode, type, buff);
     var earcon = this.findEarcon_(node, prevNode);
     if (earcon)
       options.annotation.push(earcon);
     var text = '';
 
-    if (this.formatOptions_.braille && !node.state.editable) {
+    if (this.formatOptions_.braille && !node.state[StateType.EDITABLE]) {
       // In braille, we almost always want to show the entire contents and
       // simply place the cursor under the SelectionSpan we set above.
       text = range.start.getText();
     } else {
       // This is output for speech or editable braille.
       text = range.start.getText().substring(rangeStart, rangeEnd);
     }
 
     this.append_(buff, text, options);
 
@@ skipping 122 matching lines @@
         return result;
       }
 
       // Keep track of if there's an inline node associated with
       // |cur|.
       var hasInlineNode = cur.getSpansInstanceOf(Output.NodeSpan)
           .some(function(s) {
             if (!s.node)
               return false;
             return s.node.display == 'inline' ||
-                s.node.role == RoleType.inlineTextBox;
+                s.node.role == RoleType.INLINE_TEXT_BOX;
           });
 
       var isName = cur.hasSpan('name');
 
       // Now, decide whether we should include separators between the previous
       // span and |cur|.
       // Never separate chunks without something already there at this point.
 
       // The only case where we know for certain that a separator is not needed
       // is when the previous and current values are in-lined and part of the
@@ skipping 76 matching lines @@
   /**
    * Gets the output buffer for braille.
    * @return {!Spannable}
    */
   get brailleOutputForTest() {
     return this.mergeBraille_(this.brailleBuffer_);
   }
 };
 
 });  // goog.scope