Update json_schema_compiler to handle the Automation extension API

chrome/browser/resources/chromeos/chromevox/cvox2/background/editing.js

 // Copyright 2015 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 Processes events related to editing text and emits the
  * appropriate spoken and braille feedback.
  */
 
 goog.provide('editing.TextEditHandler');
 
 goog.require('AutomationTreeWalker');
 goog.require('AutomationUtil');
 goog.require('Output');
 goog.require('Output.EventType');
 goog.require('cursors.Cursor');
 goog.require('cursors.Range');
 goog.require('cvox.ChromeVoxEditableTextBase');
 
 goog.scope(function() {
 var AutomationEvent = chrome.automation.AutomationEvent;
 var AutomationNode = chrome.automation.AutomationNode;
 var Cursor = cursors.Cursor;
 var Dir = AutomationUtil.Dir;
 var EventType = chrome.automation.EventType;
 var Range = cursors.Range;
 var RoleType = chrome.automation.RoleType;
+var StateType = chrome.automation.StateType;
 var Movement = cursors.Movement;
 var Unit = cursors.Unit;
 
 /**
  * A handler for automation events in a focused text field or editable root
  * such as a |contenteditable| subtree.
  * @constructor
  * @param {!AutomationNode} node
  */
 editing.TextEditHandler = function(node) {
   /** @const {!AutomationNode} @private */
   this.node_ = node;
 };
 
 editing.TextEditHandler.prototype = {
   /** @return {!AutomationNode} */
   get node() {
     return this.node_;
   },
 
   /**
    * Receives the following kinds of events when the node provided to the
    * constructor is focuse: |focus|, |textChanged|, |textSelectionChanged| and
    * |valueChanged|.
    * An implementation of this method should emit the appropritate braille and
    * spoken feedback for the event.
-   * @param {!AutomationEvent} evt
+   * @param {!(AutomationEvent|CustomAutomationEvent)} evt
    */
   onEvent: goog.abstractMethod,
 };
 
 /**
  * A |TextEditHandler| suitable for text fields.
  * @constructor
  * @param {!AutomationNode} node A node with the role of |textField|
  * @extends {editing.TextEditHandler}
  */
 function TextFieldTextEditHandler(node) {
   editing.TextEditHandler.call(this, node);
   /** @type {AutomationEditableText} @private */
   this.editableText_ = new AutomationEditableText(node);
 }
 
 TextFieldTextEditHandler.prototype = {
   __proto__: editing.TextEditHandler.prototype,
 
   /** @override */
   onEvent: function(evt) {
-    if (evt.type !== EventType.textChanged &&
-        evt.type !== EventType.textSelectionChanged &&
-        evt.type !== EventType.valueChanged &&
-        evt.type !== EventType.focus)
+    if (evt.type !== EventType.TEXT_CHANGED &&
+        evt.type !== EventType.TEXT_SELECTION_CHANGED &&
+        evt.type !== EventType.VALUE_CHANGED &&
+        evt.type !== EventType.FOCUS)
       return;
     if (!evt.target.state.focused ||
         !evt.target.state.editable ||
         evt.target != this.node_)
       return;
 
     this.editableText_.onUpdate();
   },
 };
 
 /**
  * A |ChromeVoxEditableTextBase| that implements text editing feedback
  * for automation tree text fields.
  * @constructor
  * @param {!AutomationNode} node
  * @extends {cvox.ChromeVoxEditableTextBase}
  */
 function AutomationEditableText(node) {
   if (!node.state.editable)
     throw Error('Node must have editable state set to true.');
   var start = node.textSelStart;
   var end = node.textSelEnd;
   cvox.ChromeVoxEditableTextBase.call(
       this,
-      node.value,
+      node.value || '',
       Math.min(start, end),
       Math.max(start, end),
-      node.state.protected /**password*/,
+      node.state[StateType.PROTECTED] /**password*/,
       cvox.ChromeVox.tts);
   /** @override */
-  this.multiline = node.state.multiline || false;
+  this.multiline = node.state[StateType.MULTILINE] || false;
   /** @type {!AutomationNode} @private */
   this.node_ = node;
   /** @type {Array<number>} @private */
   this.lineBreaks_ = [];
 }
 
 AutomationEditableText.prototype = {
   __proto__: cvox.ChromeVoxEditableTextBase.prototype,
 
   /**
    * Called when the text field has been updated.
    */
   onUpdate: function() {
-    var newValue = this.node_.value;
+    var newValue = this.node_.value || '';
 
     if (this.value != newValue)
       this.lineBreaks_ = [];
 
     var textChangeEvent = new cvox.TextChangeEvent(
         newValue,
-        this.node_.textSelStart,
-        this.node_.textSelEnd,
+        this.node_.textSelStart || 0,
+        this.node_.textSelEnd || 0,
         true /* triggered by user */);
     this.changed(textChangeEvent);
     this.outputBraille_();
   },
 
   /** @override */
   getLineIndex: function(charIndex) {
     if (!this.multiline)
       return 0;
     var breaks = this.node_.lineBreaks || [];
@@ skipping 57 matching lines @@
 /**
  * @param {!AutomationNode} node The root editable node, i.e. the root of a
  *     contenteditable subtree or a text field.
  * @return {editing.TextEditHandler}
  */
 editing.TextEditHandler.createForNode = function(node) {
   var rootFocusedEditable = null;
   var testNode = node;
 
   do {
-    if (testNode.state.focused && testNode.state.editable)
+    if (testNode.state[StateType.FOCUSED] && testNode.state[StateType.EDITABLE])
       rootFocusedEditable = testNode;
     testNode = testNode.parent;
   } while (testNode);
 
   if (rootFocusedEditable)
     return new TextFieldTextEditHandler(rootFocusedEditable);
 
   return null;
 };
 
 });