Update json_schema_compiler to handle the Automation extension API

chrome/browser/resources/chromeos/chromevox/cvox2/background/cursors.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 Classes related to cursors that point to and select parts of
  * the automation tree.
  */
 
 goog.provide('cursors.Cursor');
@@ skipping 103 matching lines @@
    * Use this for loose equality between cursors where specific character-based
    * indicies do not matter such as when processing node-targeted events.
    * @param {!cursors.Cursor} rhs
    * @return {boolean}
    */
   contentEquals: function(rhs) {
     // First, normalize the two nodes so they both point to the first non-text
     // node.
     var lNode = this.node;
     var rNode = rhs.node;
-    while (lNode && (lNode.role == RoleType.inlineTextBox ||
-        lNode.role == RoleType.staticText))
+    while (lNode && (lNode.role == RoleType.INLINE_TEXT_BOX ||
+        lNode.role == RoleType.STATIC_TEXT))
       lNode = lNode.parent;
-    while (rNode && (rNode.role == RoleType.inlineTextBox ||
-        rNode.role == RoleType.staticText))
+    while (rNode && (rNode.role == RoleType.INLINE_TEXT_BOX ||
+        rNode.role == RoleType.STATIC_TEXT))
       rNode = rNode.parent;
 
     // Ignore indicies for now.
 
     return lNode === rNode && lNode != undefined;
   },
 
   /**
    * Returns the node. If the node is invalid since the last time it
    * was accessed, moves the cursor to the nearest valid ancestor first.
@@ skipping 30 matching lines @@
     if (!adjustedNode)
       return null;
 
     // Make no adjustments if we're within editable content.
     if (adjustedNode.state.editable)
       return adjustedNode;
 
     // Selections over line break nodes are broken.
     var parent = adjustedNode.parent;
     var grandparent = parent && parent.parent;
-    if (parent.role == RoleType.lineBreak) {
+    if (parent.role == RoleType.LINE_BREAK) {
       adjustedNode = grandparent;
-    } else if (grandparent.role == RoleType.lineBreak) {
+    } else if (grandparent.role == RoleType.LINE_BREAK) {
       adjustedNode = grandparent.parent;
     } else if (this.index_ == cursors.NODE_INDEX ||
-        adjustedNode.role == RoleType.inlineTextBox ||
-        chrome.automation.NameFromType[adjustedNode.nameFrom] != 'contents') {
+        adjustedNode.role == RoleType.INLINE_TEXT_BOX ||
+        adjustedNode.nameFrom != chrome.automation.NameFromType.CONTENTS) {
       // A node offset or unselectable character offset.
       adjustedNode = parent;
     } else {
       // A character offset into content.
       adjustedNode =
-          adjustedNode.find({role: RoleType.staticText}) || adjustedNode;
+          adjustedNode.find({role: RoleType.STATIC_TEXT}) || adjustedNode;
     }
 
-    return adjustedNode;
+    return adjustedNode || null;
   },
 
   /**
    * An index appropriate for making selections.  If this cursor has a
    * cursors.NODE_INDEX index, the selection index is a node offset e.g. the
    * index in parent. If not, the index is a character offset.
    * @return {number}
    * @private
    */
   get selectionIndex_() {
     var adjustedIndex = this.index_;
 
     if (!this.node)
       return -1;
 
     if (this.node.state.editable) {
       return this.index_ == cursors.NODE_INDEX ? 0 : this.index_;
-    } else if (this.node.role == RoleType.inlineTextBox &&
+    } else if (this.node.role == RoleType.INLINE_TEXT_BOX &&
     // Selections under a line break are broken.
-        this.node.parent && this.node.parent.role != RoleType.lineBreak) {
+        this.node.parent && this.node.parent.role != RoleType.LINE_BREAK) {
       if (adjustedIndex == cursors.NODE_INDEX)
         adjustedIndex = 0;
 
       var sibling = this.node.previousSibling;
       while (sibling) {
         adjustedIndex += sibling.name.length;
         sibling = sibling.previousSibling;
       }
     } else if (this.index_ == cursors.NODE_INDEX ||
-        chrome.automation.NameFromType[this.node.nameFrom] != 'contents') {
+        this.node.nameFrom != chrome.automation.NameFromType.CONTENTS) {
       // A node offset or unselectable character offset.
 
       // The selected node could have been adjusted upwards in the tree.
       var childOfSelection = this.node;
       do {
-        adjustedIndex = childOfSelection.indexInParent;
+        adjustedIndex = childOfSelection.indexInParent || 0;
         childOfSelection = childOfSelection.parent;
       } while (childOfSelection && childOfSelection != this.selectionNode_);
     }
     // A character offset into content is the remaining case. It requires no
     // adjustment.
 
     return adjustedIndex;
   },
 
   /**
@@ skipping 38 matching lines @@
             newIndex =
                 dir == Dir.FORWARD ? 0 :
                 StringUtil.previousCodePointOffset(newText, newText.length);
             newIndex = Math.max(newIndex, 0);
           } else {
             newIndex = this.index_;
           }
         }
         break;
       case Unit.WORD:
-        if (newNode.role != RoleType.inlineTextBox) {
+        if (newNode.role != RoleType.INLINE_TEXT_BOX) {
           newNode = AutomationUtil.findNextNode(newNode,
               Dir.FORWARD,
               AutomationPredicate.inlineTextBox,
               {skipInitialSubtree: false}) || newNode;
         }
         switch (movement) {
           case Movement.BOUND:
-            if (newNode.role == RoleType.inlineTextBox) {
+            if (newNode.role == RoleType.INLINE_TEXT_BOX) {
               var start, end;
               for (var i = 0; i < newNode.wordStarts.length; i++) {
                 if (newIndex >= newNode.wordStarts[i] &&
                     newIndex <= newNode.wordEnds[i]) {
                   start = newNode.wordStarts[i];
                   end = newNode.wordEnds[i];
                   break;
                 }
               }
               if (goog.isDef(start) && goog.isDef(end))
                 newIndex = dir == Dir.FORWARD ? end : start;
             } else {
               // TODO(dtseng): Figure out what to do in this case.
             }
             break;
           case Movement.DIRECTIONAL:
-            if (newNode.role == RoleType.inlineTextBox) {
+            if (newNode.role == RoleType.INLINE_TEXT_BOX) {
               var start, end;
               for (var i = 0; i < newNode.wordStarts.length; i++) {
                 if (newIndex >= newNode.wordStarts[i] &&
                     newIndex <= newNode.wordEnds[i]) {
                   var nextIndex = dir == Dir.FORWARD ? i + 1 : i - 1;
                   start = newNode.wordStarts[nextIndex];
                   end = newNode.wordEnds[nextIndex];
                   break;
                 }
               }
               if (goog.isDef(start)) {
                 newIndex = start;
               } else {
                 // The backward case is special at the beginning of nodes.
                 if (dir == Dir.BACKWARD && newIndex != 0) {
                   newIndex = 0;
                 } else {
                   newNode = AutomationUtil.findNextNode(newNode, dir,
                       AutomationPredicate.leaf);
                   if (newNode) {
                     newIndex = 0;
                     if (dir == Dir.BACKWARD &&
-                        newNode.role == RoleType.inlineTextBox) {
+                        newNode.role == RoleType.INLINE_TEXT_BOX) {
                       var starts = newNode.wordStarts;
                       newIndex = starts[starts.length - 1] || 0;
                     } else {
                       // TODO(dtseng): Figure out what to do for general nodes.
                     }
                   }
                 }
               }
             } else {
               // TODO(dtseng): Figure out what to do in this case.
@@ skipping 250 matching lines @@
 
   /**
    * Returns true if this range covers inline text (i.e. each end points to an
    * inlineTextBox).
    * @return {boolean?}
    */
   isInlineText: function() {
     return this.start.node &&
         this.end.node &&
         this.start.node.role == this.end.node.role &&
-        this.start.node.role == RoleType.inlineTextBox;
+        this.start.node.role == RoleType.INLINE_TEXT_BOX;
   },
 
   /**
    * Makes a Range which has been moved from this range by the given unit and
    * direction.
    * @param {Unit} unit
    * @param {Dir} dir
    * @return {cursors.Range}
    */
   move: function(unit, dir) {
@@ skipping 31 matching lines @@
    */
   select: function() {
     var startNode = this.start.selectionNode_;
     var endNode = this.end.selectionNode_;
 
     if (!startNode || !endNode)
       return;
 
     // Only allow selections within the same web tree.
     if (startNode.root &&
-        startNode.root.role == RoleType.rootWebArea &&
+        startNode.root.role == RoleType.ROOT_WEB_AREA &&
         startNode.root == endNode.root) {
       // We want to adjust to select the entire node for node offsets;
       // otherwise, use the plain character offset.
       var startIndex = this.start.selectionIndex_;
       var endIndex = this.end.index_ == cursors.NODE_INDEX ?
           this.end.selectionIndex_ + 1 : this.end.selectionIndex_;
 
       chrome.automation.setDocumentSelection(
           { anchorObject: startNode,
             anchorOffset: startIndex,
             focusObject: endNode,
             focusOffset: endIndex }
       );
     }
   },
 
   /**
    * Returns true if this range has either cursor end on web content.
    * @return {boolean}
   */
   isWebRange: function() {
     return this.isValid() &&
-        (this.start.node.root.role != RoleType.desktop ||
-        this.end.node.root.role != RoleType.desktop);
+        (this.start.node.root.role != RoleType.DESKTOP ||
+        this.end.node.root.role != RoleType.DESKTOP);
   },
 
   /**
    * Returns whether this range has valid start and end cursors.
    * @return {boolean}
    */
   isValid: function() {
     return this.start.isValid() && this.end.isValid();
   }
 };
 
 });  // goog.scope