Run clang-format on .js files in c/b/r/chromeos/chromevox

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 97 matching lines @@
  *                 earconId: (string|undefined),
  *                 inherits: (string|undefined),
  *                 outputContextFirst: (boolean|undefined)}>}
  * msgId: the message id of the role.
  * earconId: an optional earcon to play when encountering the role.
  * inherits: inherits rules from this role.
  * outputContextFirst: where to place the context output.
  * @private
  */
 Output.ROLE_INFO_ = {
-  alert: {
-    msgId: 'role_alert'
-  },
-  alertDialog: {
-    msgId: 'role_alertdialog',
-    outputContextFirst: true
-  },
-  article: {
-    msgId: 'role_article',
-    inherits: 'abstractContainer'
-  },
-  application: {
-    msgId: 'role_application',
-    inherits: 'abstractContainer'
-  },
-  banner: {
-    msgId: 'role_banner',
-    inherits: 'abstractContainer'
-  },
-  button: {
-    msgId: 'role_button',
-    earconId: 'BUTTON'
-  },
-  buttonDropDown: {
-    msgId: 'role_button',
-    earconId: 'BUTTON'
-  },
-  checkBox: {
-    msgId: 'role_checkbox'
-  },
-  columnHeader: {
-    msgId: 'role_columnheader',
-    inherits: 'cell'
-  },
-  comboBox: {
-    msgId: 'role_combobox',
-    earconId: 'LISTBOX'
-  },
-  complementary: {
-    msgId: 'role_complementary',
-    inherits: 'abstractContainer'
-  },
-  contentInfo: {
-    msgId: 'role_contentinfo',
-    inherits: 'abstractContainer'
-  },
-  date: {
-    msgId: 'input_type_date',
-    inherits: 'abstractContainer'
-  },
-  definition: {
-    msgId: 'role_definition',
-    inherits: 'abstractContainer'
-  },
-  dialog: {
-    msgId: 'role_dialog',
-    outputContextFirst: true
-  },
-  directory: {
-    msgId: 'role_directory',
-    inherits: 'abstractContainer'
-  },
-  document: {
-    msgId: 'role_document',
-    inherits: 'abstractContainer'
-  },
-  form: {
-    msgId: 'role_form',
-    inherits: 'abstractContainer'
-  },
-  grid: {
-    msgId: 'role_grid'
-  },
-  group: {
-    msgId: 'role_group',
-    inherits: 'abstractContainer'
-  },
+  alert: {msgId: 'role_alert'},
+  alertDialog: {msgId: 'role_alertdialog', outputContextFirst: true},
+  article: {msgId: 'role_article', inherits: 'abstractContainer'},
+  application: {msgId: 'role_application', inherits: 'abstractContainer'},
+  banner: {msgId: 'role_banner', inherits: 'abstractContainer'},
+  button: {msgId: 'role_button', earconId: 'BUTTON'},
+  buttonDropDown: {msgId: 'role_button', earconId: 'BUTTON'},
+  checkBox: {msgId: 'role_checkbox'},
+  columnHeader: {msgId: 'role_columnheader', inherits: 'cell'},
+  comboBox: {msgId: 'role_combobox', earconId: 'LISTBOX'},
+  complementary: {msgId: 'role_complementary', inherits: 'abstractContainer'},
+  contentInfo: {msgId: 'role_contentinfo', inherits: 'abstractContainer'},
+  date: {msgId: 'input_type_date', inherits: 'abstractContainer'},
+  definition: {msgId: 'role_definition', inherits: 'abstractContainer'},
+  dialog: {msgId: 'role_dialog', outputContextFirst: true},
+  directory: {msgId: 'role_directory', inherits: 'abstractContainer'},
+  document: {msgId: 'role_document', inherits: 'abstractContainer'},
+  form: {msgId: 'role_form', inherits: 'abstractContainer'},
+  grid: {msgId: 'role_grid'},
+  group: {msgId: 'role_group', inherits: 'abstractContainer'},
   heading: {
     msgId: 'role_heading',
   },
   image: {
     msgId: 'role_img',
   },
-  inputTime: {
-    msgId: 'input_type_time',
-    inherits: 'abstractContainer'
-  },
-  link: {
-    msgId: 'role_link',
-    earconId: 'LINK'
-  },
-  listBox: {
-    msgId: 'role_listbox',
-    earconId: 'LISTBOX'
-  },
-  listBoxOption: {
-    msgId: 'role_listitem',
-    earconId: 'LIST_ITEM'
-  },
-  listItem: {
-    msgId: 'role_listitem',
-    earconId: 'LIST_ITEM'
-  },
+  inputTime: {msgId: 'input_type_time', inherits: 'abstractContainer'},
+  link: {msgId: 'role_link', earconId: 'LINK'},
+  listBox: {msgId: 'role_listbox', earconId: 'LISTBOX'},
+  listBoxOption: {msgId: 'role_listitem', earconId: 'LIST_ITEM'},
+  listItem: {msgId: 'role_listitem', earconId: 'LIST_ITEM'},
   log: {
     msgId: 'role_log',
   },
-  main: {
-    msgId: 'role_main',
-    inherits: 'abstractContainer'
-  },
+  main: {msgId: 'role_main', inherits: 'abstractContainer'},
   marquee: {
     msgId: 'role_marquee',
   },
-  math: {
-    msgId: 'role_math',
-    inherits: 'abstractContainer'
-  },
-  menu: {
-    msgId: 'role_menu',
-    outputContextFirst: true
-  },
+  math: {msgId: 'role_math', inherits: 'abstractContainer'},
+  menu: {msgId: 'role_menu', outputContextFirst: true},
   menuBar: {
     msgId: 'role_menubar',
   },
-  menuItem: {
-    msgId: 'role_menuitem'
-  },
-  menuItemCheckBox: {
-    msgId: 'role_menuitemcheckbox'
-  },
-  menuItemRadio: {
-    msgId: 'role_menuitemradio'
-  },
-  menuListOption: {
-    msgId: 'role_menuitem'
-  },
-  menuListPopup: {
-    msgId: 'role_menu'
-  },
-  meter: {
-    msgId: 'role_meter',
-    inherits: 'abstractRange'
-  },
-  navigation: {
-    msgId: 'role_navigation',
-    inherits: 'abstractContainer'
-  },
-  note: {
-    msgId: 'role_note',
-    inherits: 'abstractContainer'
-  },
-  progressIndicator: {
-    msgId: 'role_progress_indicator',
-    inherits: 'abstractRange'
-  },
-  popUpButton: {
-    msgId: 'role_button',
-    earconId: 'POP_UP_BUTTON'
-  },
-  radioButton: {
-    msgId: 'role_radio'
-  },
+  menuItem: {msgId: 'role_menuitem'},
+  menuItemCheckBox: {msgId: 'role_menuitemcheckbox'},
+  menuItemRadio: {msgId: 'role_menuitemradio'},
+  menuListOption: {msgId: 'role_menuitem'},
+  menuListPopup: {msgId: 'role_menu'},
+  meter: {msgId: 'role_meter', inherits: 'abstractRange'},
+  navigation: {msgId: 'role_navigation', inherits: 'abstractContainer'},
+  note: {msgId: 'role_note', inherits: 'abstractContainer'},
+  progressIndicator:
+      {msgId: 'role_progress_indicator', inherits: 'abstractRange'},
+  popUpButton: {msgId: 'role_button', earconId: 'POP_UP_BUTTON'},
+  radioButton: {msgId: 'role_radio'},
   radioGroup: {
     msgId: 'role_radiogroup',
   },
-  rootWebArea: {
-    outputContextFirst: true
-  },
-  row: {
-    msgId: 'role_row',
-    inherits: 'abstractContainer'
-  },
-  rowHeader: {
-    msgId: 'role_rowheader',
-    inherits: 'cell'
-  },
-  scrollBar: {
-    msgId: 'role_scrollbar',
-    inherits: 'abstractRange'
-  },
-  search: {
-    msgId: 'role_search',
-    inherits: 'abstractContainer'
-  },
-  separator: {
-    msgId: 'role_separator',
-    inherits: 'abstractContainer'
-  },
-  slider: {
-    msgId: 'role_slider',
-    inherits: 'abstractRange',
-    earconId: 'SLIDER'
-  },
+  rootWebArea: {outputContextFirst: true},
+  row: {msgId: 'role_row', inherits: 'abstractContainer'},
+  rowHeader: {msgId: 'role_rowheader', inherits: 'cell'},
+  scrollBar: {msgId: 'role_scrollbar', inherits: 'abstractRange'},
+  search: {msgId: 'role_search', inherits: 'abstractContainer'},
+  separator: {msgId: 'role_separator', inherits: 'abstractContainer'},
+  slider: {msgId: 'role_slider', inherits: 'abstractRange', earconId: 'SLIDER'},
   spinButton: {
     msgId: 'role_spinbutton',
     inherits: 'abstractRange',
     earconId: 'LISTBOX'
   },
-  status: {
-    msgId: 'role_status'
-  },
-  tab: {
-    msgId: 'role_tab'
-  },
-  tabList: {
-    msgId: 'role_tablist'
-  },
-  tabPanel: {
-    msgId: 'role_tabpanel'
-  },
-  textBox: {
-    msgId: 'input_type_text',
-    earconId: 'EDITABLE_TEXT'
-  },
-  textField: {
-    msgId: 'input_type_text',
-    earconId: 'EDITABLE_TEXT'
-  },
-  time: {
-    msgId: 'tag_time',
-    inherits: 'abstractContainer'
-  },
-  timer: {
-    msgId: 'role_timer'
-  },
-  toolbar: {
-    msgId: 'role_toolbar'
-  },
-  toggleButton: {
-    msgId: 'role_button',
-    inherits: 'checkBox'
-  },
-  tree: {
-    msgId: 'role_tree'
-  },
-  treeItem: {
-    msgId: 'role_treeitem'
-  }
+  status: {msgId: 'role_status'},
+  tab: {msgId: 'role_tab'},
+  tabList: {msgId: 'role_tablist'},
+  tabPanel: {msgId: 'role_tabpanel'},
+  textBox: {msgId: 'input_type_text', earconId: 'EDITABLE_TEXT'},
+  textField: {msgId: 'input_type_text', earconId: 'EDITABLE_TEXT'},
+  time: {msgId: 'tag_time', inherits: 'abstractContainer'},
+  timer: {msgId: 'role_timer'},
+  toolbar: {msgId: 'role_toolbar'},
+  toggleButton: {msgId: 'role_button', inherits: 'checkBox'},
+  tree: {msgId: 'role_tree'},
+  treeItem: {msgId: 'role_treeitem'}
 };
 
 /**
  * Metadata about supported automation states.
  * @const {!Object<string, {on: {msgId: string, earconId: string},
  *                          off: {msgId: string, earconId: string},
  *                          isRoleSpecific: (boolean|undefined)}>}
  *     on: info used to describe a state that is set to true.
  *     off: info used to describe a state that is set to undefined.
  *     isRoleSpecific: info used for specific roles.
@@ skipping 47 matching lines @@
   'false': 'aria_pressed_false',
   'mixed': 'aria_pressed_mixed'
 };
 
 /**
  * Rules specifying format of AutomationNodes for output.
  * @type {!Object<Object<Object<string>>>}
  */
 Output.RULES = {
   navigate: {
-    'default': {
-      speak: '$name $value $state $role $description',
-      braille: ''
-    },
+    'default': {speak: '$name $value $state $role $description', braille: ''},
     abstractContainer: {
       enter: '$nameFromNode $role $state $description',
       leave: '@exited_container($role)'
     },
     abstractRange: {
-      speak:
-          '$if($valueForRange, $valueForRange, $value) ' +
+      speak: '$if($valueForRange, $valueForRange, $value) ' +
           '$if($minValueForRange, @aria_value_min($minValueForRange)) ' +
           '$if($maxValueForRange, @aria_value_max($maxValueForRange)) ' +
           '$name $role $description $state'
     },
     alert: {
       enter: '$name $role $state',
       speak: '$earcon(ALERT_NONMODAL) $role $nameOrTextContent $state'
     },
     alertDialog: {
       enter: '$earcon(ALERT_MODAL) $name $state',
       speak: '$earcon(ALERT_MODAL) $name $nameOrTextContent $state $role'
     },
     cell: {
       enter: '@cell_summary($if($ariaCellRowIndex, $ariaCellRowIndex, ' +
-      '$tableCellRowIndex), ' +
-      '$if($ariaCellColumnIndex, $ariaCellColumnIndex, ' +
-      '$tableCellColumnIndex)) $node(tableColumnHeader)',
+          '$tableCellRowIndex), ' +
+          '$if($ariaCellColumnIndex, $ariaCellColumnIndex, ' +
+          '$tableCellColumnIndex)) $node(tableColumnHeader)',
       speak: '$name @cell_summary($if($ariaCellRowIndex, $ariaCellRowIndex, ' +
-      '$tableCellRowIndex), ' +
-      '$if($ariaCellColumnIndex, $ariaCellColumnIndex, ' +
-      '$tableCellColumnIndex)) $node(tableColumnHeader) $state'
+          '$tableCellRowIndex), ' +
+          '$if($ariaCellColumnIndex, $ariaCellColumnIndex, ' +
+          '$tableCellColumnIndex)) $node(tableColumnHeader) $state'
     },
     checkBox: {
       speak: '$if($checked, $earcon(CHECK_ON), $earcon(CHECK_OFF)) ' +
-             '$name $role $checked $description $state'
+          '$name $role $checked $description $state'
     },
-    client: {
-      speak: '$name'
-    },
-    date: {
-      enter: '$nameFromNode $role $description'
-    },
-    dialog: {
-      enter: '$nameFromNode $role $description'
-    },
-    genericContainer: {
-      enter: '$nameFromNode',
-      speak: '$nameOrTextContent $description'
-    },
-    embeddedObject: {
-      speak: '$name'
-    },
-    grid: {
-      enter: '$nameFromNode $role $description'
-    },
+    client: {speak: '$name'},
+    date: {enter: '$nameFromNode $role $description'},
+    dialog: {enter: '$nameFromNode $role $description'},
+    genericContainer:
+        {enter: '$nameFromNode', speak: '$nameOrTextContent $description'},
+    embeddedObject: {speak: '$name'},
+    grid: {enter: '$nameFromNode $role $description'},
     group: {
       enter: '$nameFromNode $state $description',
       speak: '$nameOrDescendants $value $state $description',
       leave: ''
     },
     heading: {
       enter: '!relativePitch(hierarchicalLevel) ' +
           '$nameFromNode= ' +
           '$if($hierarchicalLevel, @tag_h+$hierarchicalLevel, $role) $state',
       speak: '!relativePitch(hierarchicalLevel) ' +
           '$nameOrDescendants= ' +
           '$if($hierarchicalLevel, @tag_h+$hierarchicalLevel, $role) $state'
     },
     image: {
       speak: '$if($name, $name, $urlFilename) ' +
           '$value $state $role $description',
     },
-    inlineTextBox: {
-      speak: '$name='
-    },
-    inputTime: {
-      enter: '$nameFromNode $role $description'
-    },
+    inlineTextBox: {speak: '$name='},
+    inputTime: {enter: '$nameFromNode $role $description'},
     link: {
       enter: '$nameFromNode= $role $state',
       speak: '$name $value $state ' +
           '$if($inPageLinkTarget, @internal_link, $role) $description',
     },
     list: {
       enter: '$role @@list_with_items($countChildren(listItem))',
       speak: '$descendants $role @@list_with_items($countChildren(listItem))'
     },
     listBox: {
@@ skipping 26 matching lines @@
     menuItemRadio: {
       speak: '$if($checked, $earcon(CHECK_ON), $earcon(CHECK_OFF)) ' +
           '$if($checked, @describe_radio_selected($name), ' +
           '@describe_radio_unselected($name)) $description ' +
           '@describe_index($indexInParent, $parentChildCount) '
     },
     menuListOption: {
       speak: '$name @role_menuitem ' +
           '@describe_index($indexInParent, $parentChildCount) $description'
     },
-    paragraph: {
-      speak: '$descendants'
-    },
+    paragraph: {speak: '$descendants'},
     popUpButton: {
       speak: '$value $name $role @aria_has_popup ' +
           '$state $description'
     },
     radioButton: {
       speak: '$if($checked, $earcon(CHECK_ON), $earcon(CHECK_OFF)) ' +
           '$if($checked, @describe_radio_selected($name), ' +
           '@describe_radio_unselected($name)) $description'
     },
-    radioGroup: {
-      enter: '$name $role $description'
-    },
-    rootWebArea: {
-      enter: '$name',
-      speak: '$if($name, $name, $docUrl)'
-    },
-    region: {
-      speak: '$nameOrTextContent'
-    },
-    row: {
-      enter: '$node(tableRowHeader)'
-    },
-    rowHeader: {
-      speak: '$nameOrTextContent $state'
-    },
-    staticText: {
-      speak: '$name='
-    },
+    radioGroup: {enter: '$name $role $description'},
+    rootWebArea: {enter: '$name', speak: '$if($name, $name, $docUrl)'},
+    region: {speak: '$nameOrTextContent'},
+    row: {enter: '$node(tableRowHeader)'},
+    rowHeader: {speak: '$nameOrTextContent $state'},
+    staticText: {speak: '$name='},
     switch: {
       speak: '$if($checked, $earcon(CHECK_ON), $earcon(CHECK_OFF)) ' +
           '$if($checked, @describe_switch_on($name), ' +
           '@describe_switch_off($name)) $description $state'
     },
     tab: {
       speak: '@describe_tab($name) $state $description ' +
           '$if($setSize, @describe_index($posInSet, $setSize))',
     },
     table: {
       enter: '@table_summary($name, ' +
           '$if($ariaRowCount, $ariaRowCount, $tableRowCount), ' +
           '$if($ariaColumnCount, $ariaColumnCount, $tableColumnCount)) ' +
           '$node(tableHeader)'
     },
-    tableHeaderContainer: {
-      speak: '$nameOrTextContent $state $description'
-    },
+    tableHeaderContainer: {speak: '$nameOrTextContent $state $description'},
     textField: {
       speak: '$name $value $if($multiline, @tag_textarea, $if(' +
           '$inputType, $inputType, $role)) $description $state',
       braille: ''
     },
-        timer: {
-      speak: '$nameFromNode $descendants $value $state $description'
-    },
+    timer: {speak: '$nameFromNode $descendants $value $state $description'},
     toggleButton: {
       speak: '$if($checked, $earcon(CHECK_ON), $earcon(CHECK_OFF)) ' +
           '$name $role $pressed $description $state'
     },
-    toolbar: {
-      enter: '$name $role $description'
-    },
-    tree: {
-      enter: '$name $role @@list_with_items($countChildren(treeItem))'
-    },
+    toolbar: {enter: '$name $role $description'},
+    tree: {enter: '$name $role @@list_with_items($countChildren(treeItem))'},
     treeItem: {
       enter: '$role $expanded $collapsed ' +
           '@describe_index($indexInParent, $parentChildCount) ' +
           '@describe_depth($hierarchicalLevel)',
       speak: '$name ' +
           '$role $state ' +
           '@describe_index($indexInParent, $parentChildCount) ' +
           '@describe_depth($hierarchicalLevel)'
     },
     window: {
       enter: '@describe_window($name)',
       speak: '@describe_window($name) $earcon(OBJECT_OPEN)'
     }
   },
-  menuStart: {
-    'default': {
-      speak: '@chrome_menu_opened($name)  $earcon(OBJECT_OPEN)'
-    }
-  },
-  menuEnd: {
-    'default': {
-      speak: '@chrome_menu_closed $earcon(OBJECT_CLOSE)'
-    }
-  },
+  menuStart:
+      {'default': {speak: '@chrome_menu_opened($name)  $earcon(OBJECT_OPEN)'}},
+  menuEnd: {'default': {speak: '@chrome_menu_closed $earcon(OBJECT_CLOSE)'}},
   menuListValueChanged: {
     'default': {
       speak: '$value $name ' +
           '$find({"state": {"selected": true, "invisible": false}}, ' +
-              '@describe_index($indexInParent, $parentChildCount)) '
+          '@describe_index($indexInParent, $parentChildCount)) '
     }
   },
   alert: {
     default: {
       speak: '$earcon(ALERT_NONMODAL) @role_alert ' +
           '$nameOrTextContent $description'
     }
   }
 };
 
 /**
  * Used to annotate utterances with speech properties.
  * @constructor
  */
 Output.SpeechProperties = function() {};
 
 /**
  * Custom actions performed while rendering an output string.
  * @constructor
  */
-Output.Action = function() {
-};
+Output.Action = function() {};
 
 Output.Action.prototype = {
-  run: function() {
-  }
+  run: function() {}
 };
 
 /**
  * Action to play an earcon.
  * @param {string} earconId
  * @param {chrome.automation.Rect=} opt_location
  * @constructor
  * @extends {Output.Action}
  */
 Output.EarconAction = function(earconId, opt_location) {
@@ skipping 57 matching lines @@
  * queueing mode.
  * @type {cvox.QueueMode|undefined}
  * @private
  */
 Output.forceModeForNextSpeechUtterance_;
 
 /**
  * Calling this will make the next speech utterance use |mode| even if it would
  * normally queue or do a category flush. This differs from the |withQueueMode|
  * instance method as it can apply to future output.
-   * @param {cvox.QueueMode} mode
+ * @param {cvox.QueueMode} mode
  */
 Output.forceModeForNextSpeechUtterance = function(mode) {
   Output.forceModeForNextSpeechUtterance_ = mode;
 };
 
 /**
  * For a given automation property, return true if the value
  * represents something 'truthy', e.g.: for checked:
  * 'true'|'mixed' -> true
  * 'false'|undefined -> false
  */
 Output.isTruthy = function(node, attrib) {
-  switch(attrib) {
+  switch (attrib) {
     case 'checked':
       return node.checked && node.checked !== 'false';
     default:
       return node[attrib] !== undefined || node.state[attrib];
   }
 };
 
 Output.prototype = {
   /**
    * @return {boolean} True if there's any speech that will be output.
@@ skipping 12 matching lines @@
    * @param {cursors.Range} prevRange
    * @param {EventType|Output.EventType} type
    * @return {!Output}
    */
   withSpeech: function(range, prevRange, type) {
     this.formatOptions_ = {speech: true, braille: false, auralStyle: false};
     this.render_(range, prevRange, type, this.speechBuffer_);
     return this;
   },
 
-    /**
+  /**
    * Specify ranges for aurally styled speech.
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @param {EventType|Output.EventType} type
    * @return {!Output}
    */
   withRichSpeech: function(range, prevRange, type) {
     this.formatOptions_ = {speech: true, braille: false, auralStyle: true};
     this.render_(range, prevRange, type, this.speechBuffer_);
     return this;
@@ skipping 31 matching lines @@
    * @param {cursors.Range} prevRange
    * @param {EventType|Output.EventType} type
    * @return {!Output}
    */
   withSpeechAndBraille: function(range, prevRange, type) {
     this.withSpeech(range, prevRange, type);
     this.withBraille(range, prevRange, type);
     return this;
   },
 
-    /**
+  /**
    * Specify the same ranges for aurally styled speech and braille.
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @param {EventType|Output.EventType} type
    * @return {!Output}
    */
   withRichSpeechAndBraille: function(range, prevRange, type) {
     this.withRichSpeech(range, prevRange, type);
     this.withBraille(range, prevRange, type);
     return this;
@@ skipping 42 matching lines @@
 
   /**
    * Apply a format string directly to the output buffer. This lets you
    * output a message directly to the buffer using the format syntax.
    * @param {string} formatStr
    * @param {!AutomationNode=} opt_node An optional node to apply the
    *     formatting to.
    * @return {!Output} |this| for chaining
    */
   format: function(formatStr, opt_node) {
-    return this
-        .formatForSpeech(formatStr, opt_node)
+    return this.formatForSpeech(formatStr, opt_node)
         .formatForBraille(formatStr, opt_node);
   },
 
   /**
    * Apply a format string directly to the speech output buffer. This lets you
    * output a message directly to the buffer using the format syntax.
    * @param {string} formatStr
    * @param {!AutomationNode=} opt_node An optional node to apply the
    *     formatting to.
    * @return {!Output} |this| for chaining
@@ skipping 45 matching lines @@
     if (Output.forceModeForNextSpeechUtterance_ !== undefined)
       queueMode = Output.forceModeForNextSpeechUtterance_;
     else if (this.queueMode_ !== undefined)
       queueMode = this.queueMode_;
 
     if (this.speechBuffer_.length > 0)
       Output.forceModeForNextSpeechUtterance_ = undefined;
 
     for (var i = 0; i < this.speechBuffer_.length; i++) {
       var buff = this.speechBuffer_[i];
-      var speechProps = /** @type {Object} */(
-          buff.getSpanInstanceOf(Output.SpeechProperties)) || {};
+      var speechProps = /** @type {Object} */ (
+                            buff.getSpanInstanceOf(Output.SpeechProperties)) ||
+          {};
 
       speechProps.category = this.speechCategory_;
 
       (function() {
         var scopedBuff = buff;
         speechProps['startCallback'] = function() {
           var actions = scopedBuff.getSpansInstanceOf(Output.Action);
           if (actions) {
             actions.forEach(function(a) {
               a.run();
             });
           }
         };
       }());
 
       if (i == this.speechBuffer_.length - 1)
         speechProps['endCallback'] = this.speechEndCallback_;
 
-      cvox.ChromeVox.tts.speak(
-          buff.toString(), queueMode, speechProps);
+      cvox.ChromeVox.tts.speak(buff.toString(), queueMode, speechProps);
       queueMode = cvox.QueueMode.QUEUE;
     }
 
     // Braille.
     if (this.brailleBuffer_.length) {
       var buff = this.mergeBraille_(this.brailleBuffer_);
-      var selSpan =
-          buff.getSpanInstanceOf(Output.SelectionSpan);
+      var selSpan = buff.getSpanInstanceOf(Output.SelectionSpan);
       var startIndex = -1, endIndex = -1;
       if (selSpan) {
         var valueStart = buff.getSpanStart(selSpan);
         var valueEnd = buff.getSpanEnd(selSpan);
         startIndex = valueStart + selSpan.startIndex;
         endIndex = valueStart + selSpan.endIndex;
         buff.setSpan(new cvox.ValueSpan(0), valueStart, valueEnd);
         buff.setSpan(new cvox.ValueSelectionSpan(), startIndex, endIndex);
       }
 
-      var output = new cvox.NavBraille({
-        text: buff,
-        startIndex: startIndex,
-        endIndex: endIndex
-      });
+      var output = new cvox.NavBraille(
+          {text: buff, startIndex: startIndex, endIndex: endIndex});
 
       cvox.ChromeVox.braille.write(output);
     }
 
     // Display.
     if (this.speechCategory_ != cvox.TtsCategory.LIVE)
       chrome.accessibilityPrivate.setFocusRing(this.locations_);
   },
 
   /**
@@ skipping 82 matching lines @@
       // All possible tokens based on prefix.
       if (prefix == '$') {
         if (token == 'value') {
           var text = node.value || '';
           if (!node.state[StateType.EDITABLE] && node.name == text)
             return;
 
           var selectedText = '';
           if (node.textSelStart !== undefined) {
             options.annotation.push(new Output.SelectionSpan(
-                node.textSelStart || 0,
-                node.textSelEnd || 0));
+                node.textSelStart || 0, node.textSelEnd || 0));
 
-            selectedText =
-                node.value.substring(node.textSelStart || 0,
-                                     node.textSelEnd || 0);
+            selectedText = node.value.substring(
+                node.textSelStart || 0, node.textSelEnd || 0);
           }
           options.annotation.push(token);
           if (selectedText && !this.formatOptions_.braille) {
             this.append_(buff, selectedText, options);
             this.append_(buff, Msgs.getMsg('selected'));
           } else {
             this.append_(buff, text, options);
           }
         } else if (token == 'name') {
           options.annotation.push(token);
@@ skipping 10 matching lines @@
         } else if (token == 'urlFilename') {
           options.annotation.push('name');
           var url = node.url || '';
           var filename = '';
           if (url.substring(0, 4) != 'data') {
             filename =
                 url.substring(url.lastIndexOf('/') + 1, url.lastIndexOf('.'));
 
             // Hack to not speak the filename if it's ridiculously long.
             if (filename.length >= 30)
-            filename = filename.substring(0, 16) + '...';
+              filename = filename.substring(0, 16) + '...';
           }
           this.append_(buff, filename, options);
         } else if (token == 'nameFromNode') {
           if (node.nameFrom == chrome.automation.NameFromType.CONTENTS)
             return;
 
           options.annotation.push('name');
           this.append_(buff, node.name || '', options);
         } else if (token == 'nameOrDescendants') {
           options.annotation.push(token);
@@ skipping 14 matching lines @@
               if (node.role == child.role)
                 count++;
               if (node === child)
                 break;
             }
             this.append_(buff, String(count));
           }
         } else if (token == 'parentChildCount') {
           if (node.parent) {
             options.annotation.push(token);
-            var count = node.parent.children.filter(function(child) {
-              return node.role == child.role;
-            }).length;
+            var count = node.parent.children
+                            .filter(function(child) {
+                              return node.role == child.role;
+                            })
+                            .length;
             this.append_(buff, String(count));
           }
         } else if (token == 'checked') {
           var msg = Output.CHECKED_STATE_MAP[node.checked];
           if (msg) {
             this.format_(node, '@' + msg, buff);
           }
         } else if (token == 'pressed') {
           var msg = Output.PRESSED_STATE_MAP[node.checked];
           if (msg) {
             this.format_(node, '@' + msg, buff);
           }
         } else if (token == 'state') {
           if (node.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);
+                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 {chrome.automation.FindParams}*/(
+                /** @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.
@@ skipping 39 matching lines @@
           this.append_(buff, msg || '', options);
         } else if (token == 'inputType') {
           if (!node.inputType)
             return;
           options.annotation.push(token);
           var msgId = Output.INPUT_TYPE_MESSAGE_IDS_[node.inputType] ||
               'input_type_text';
           if (this.formatOptions_.braille)
             msgId = msgId + '_brl';
           this.append_(buff, Msgs.getMsg(msgId), options);
-        } else if (token == 'tableCellRowIndex' ||
-            token == 'tableCellColumnIndex') {
+        } else if (
+            token == 'tableCellRowIndex' || token == 'tableCellColumnIndex') {
           var value = node[token];
           if (value == undefined)
             return;
           value = String(value + 1);
           options.annotation.push(token);
           this.append_(buff, value, options);
         } else if (token == 'node') {
           if (!tree.firstChild || !node[tree.firstChild.value])
             return;
           var related = node[tree.firstChild.value];
           this.node_(related, related, Output.EventType.NAVIGATE, buff);
         } else if (token == 'nameOrTextContent') {
           if (node.name) {
             this.format_(node, '$name', buff);
           } else {
-            var walker = new AutomationTreeWalker(node,
-                Dir.FORWARD,
-                {visit: AutomationPredicate.leafOrStaticText,
-                 leaf: AutomationPredicate.leafOrStaticText});
+            var walker = new AutomationTreeWalker(node, Dir.FORWARD, {
+              visit: AutomationPredicate.leafOrStaticText,
+              leaf: AutomationPredicate.leafOrStaticText
+            });
             var outputStrings = [];
             while (walker.next().node &&
-                walker.phase == AutomationTreeWalkerPhase.DESCENDANT) {
+                   walker.phase == AutomationTreeWalkerPhase.DESCENDANT) {
               if (walker.node.name)
                 outputStrings.push(walker.node.name);
             }
             var joinedOutput = outputStrings.join(' ');
             this.append_(buff, joinedOutput, options);
           }
         } else if (node[token] !== undefined) {
           options.annotation.push(token);
           var value = node[token];
           if (typeof value == 'number')
             value = String(value);
           this.append_(buff, value, options);
         } else if (Output.STATE_INFO_[token]) {
           options.annotation.push('state');
           var stateInfo = Output.STATE_INFO_[token];
           var resolvedInfo = {};
           resolvedInfo = node.state[token] ? stateInfo.on : stateInfo.off;
           if (!resolvedInfo)
             return;
           if (this.formatOptions_.speech && resolvedInfo.earconId) {
             options.annotation.push(
                 new Output.EarconAction(resolvedInfo.earconId),
-                                        node.location || undefined);
+                node.location || undefined);
           }
-          var msgId =
-              this.formatOptions_.braille ? resolvedInfo.msgId + '_brl' :
+          var msgId = this.formatOptions_.braille ?
+              resolvedInfo.msgId + '_brl' :
               resolvedInfo.msgId;
           var msg = Msgs.getMsg(msgId);
           this.append_(buff, msg, options);
         } else if (tree.firstChild) {
           // Custom functions.
           if (token == 'if') {
             var cond = tree.firstChild;
             var attrib = cond.value.slice(1);
             if (Output.isTruthy(node, attrib))
               this.format_(node, cond.nextSibling, buff);
             else
               this.format_(node, cond.nextSibling.nextSibling, buff);
           } else if (token == 'earcon') {
             // Ignore unless we're generating speech output.
             if (!this.formatOptions_.speech)
               return;
 
-            options.annotation.push(
-                new Output.EarconAction(tree.firstChild.value,
-                                        node.location || undefined));
+            options.annotation.push(new Output.EarconAction(
+                tree.firstChild.value, node.location || undefined));
             this.append_(buff, '', options);
           } else if (token == 'countChildren') {
             var role = tree.firstChild.value;
-            var count = node.children.filter(function(e) {
-              return e.role == role;
-            }).length;
+            var count = node.children
+                            .filter(function(e) {
+                              return e.role == role;
+                            })
+                            .length;
             this.append_(buff, String(count));
           }
         }
       } else if (prefix == '@') {
         if (this.formatOptions_.auralStyle) {
           speechProps = new Output.SpeechProperties();
           speechProps['relativePitch'] = -0.2;
         }
         var isPluralized = (token[0] == '@');
         if (isPluralized)
@@ skipping 21 matching lines @@
             if (!msgBuff.length)
               msgBuff = [''];
             msgArgs = msgArgs.concat(msgBuff);
             curArg = curArg.nextSibling;
           }
         }
         var msg = Msgs.getMsg(msgId, msgArgs);
         try {
           if (this.formatOptions_.braille)
             msg = Msgs.getMsg(msgId + '_brl', msgArgs) || msg;
-        } catch(e) {}
+        } catch (e) {
+        }
 
         if (!msg) {
           console.error('Could not get message ' + msgId);
           return;
         }
 
         if (isPluralized) {
           var arg = tree.firstChild;
           if (!arg || arg.nextSibling) {
             console.error('Pluralized messages take exactly one argument');
@@ skipping 65 matching lines @@
         this.ancestry_(node, prevNode, type, buff);
       this.node_(node, prevNode, type, buff);
       if (!this.outputContextFirst_)
         this.ancestry_(node, prevNode, type, buff);
       if (node.location)
         this.locations_.push(node.location);
       return buff;
     }.bind(this);
 
     var unit = range.isInlineText() ? cursors.Unit.TEXT : cursors.Unit.NODE;
-    while (cursor.node &&
-        range.end.node &&
-        AutomationUtil.getDirection(cursor.node, range.end.node) ==
-        Dir.FORWARD) {
+    while (cursor.node && range.end.node &&
+           AutomationUtil.getDirection(cursor.node, range.end.node) ==
+               Dir.FORWARD) {
       var node = cursor.node;
       rangeBuff.push.apply(rangeBuff, formatNodeAndAncestors(node, prevNode));
       prevNode = node;
-      cursor = cursor.move(unit,
-                           cursors.Movement.DIRECTIONAL,
-                           Dir.FORWARD);
+      cursor = cursor.move(unit, cursors.Movement.DIRECTIONAL, Dir.FORWARD);
 
       // Reached a boundary.
       if (cursor.node == prevNode)
         break;
     }
   },
 
   /**
    * @param {!AutomationNode} node
    * @param {!AutomationNode} prevNode
@@ skipping 14 matching lines @@
           contextFirst = [];
           rest = [];
         }
         if ((Output.ROLE_INFO_[node.role] || {}).outputContextFirst)
           contextFirst.push(node);
         else
           rest.push(node);
       }
       return rest.concat(contextFirst.reverse());
     }
-    var prevUniqueAncestors = byContextFirst(AutomationUtil.getUniqueAncestors(
-        node, prevNode));
-    var uniqueAncestors = byContextFirst(AutomationUtil.getUniqueAncestors(
-        prevNode, node));
+    var prevUniqueAncestors =
+        byContextFirst(AutomationUtil.getUniqueAncestors(node, prevNode));
+    var uniqueAncestors =
+        byContextFirst(AutomationUtil.getUniqueAncestors(prevNode, node));
 
     // First, look up the event type's format block.
     // Navigate is the default event.
     var eventBlock = Output.RULES[type] || Output.RULES['navigate'];
 
     var getMergedRoleBlock = function(role) {
       var parentRole = (Output.ROLE_INFO_[role] || {}).inherits;
       var roleBlock = eventBlock[role] || eventBlock['default'];
       var parentRoleBlock = parentRole ? eventBlock[parentRole] : {};
       var mergedRoleBlock = {};
       for (var key in parentRoleBlock)
         mergedRoleBlock[key] = parentRoleBlock[key];
       for (var key in roleBlock)
         mergedRoleBlock[key] = roleBlock[key];
       return mergedRoleBlock;
     };
 
     // Hash the roles we've entered.
     var enteredRoleSet = {};
     for (var j = uniqueAncestors.length - 1, hashNode;
-         (hashNode = uniqueAncestors[j]);
-         j--)
+         (hashNode = uniqueAncestors[j]); j--)
       enteredRoleSet[hashNode.role] = true;
 
-    for (var i = 0, formatPrevNode;
-         (formatPrevNode = prevUniqueAncestors[i]);
+    for (var i = 0, formatPrevNode; (formatPrevNode = prevUniqueAncestors[i]);
          i++) {
       // This prevents very repetitive announcements.
       if (enteredRoleSet[formatPrevNode.role] ||
           node.role == formatPrevNode.role ||
           localStorage['useVerboseMode'] == 'false')
         continue;
 
       var roleBlock = getMergedRoleBlock(formatPrevNode.role);
       if (roleBlock.leave && localStorage['useVerboseMode'] == 'true')
         this.format_(formatPrevNode, roleBlock.leave, buff, prevNode);
     }
 
     // Customize for braille node annotations.
     var originalBuff = buff;
     var enterRole = {};
     for (var j = uniqueAncestors.length - 1, formatNode;
-         (formatNode = uniqueAncestors[j]);
-         j--) {
+         (formatNode = uniqueAncestors[j]); j--) {
       var roleBlock = getMergedRoleBlock(formatNode.role);
       if (roleBlock.enter) {
         if (enterRole[formatNode.role])
           continue;
 
         if (this.formatOptions_.braille)
           buff = [];
 
         enterRole[formatNode.role] = true;
         this.format_(formatNode, roleBlock.enter, buff, prevNode);
@@ skipping 18 matching lines @@
     var originalBuff = buff;
 
     if (this.formatOptions_.braille)
       buff = [];
 
     // Navigate is the default event.
     var eventBlock = Output.RULES[type] || Output.RULES['navigate'];
     var roleBlock = eventBlock[node.role] || {};
     var parentRole = (Output.ROLE_INFO_[node.role] || {}).inherits;
     var parentRoleBlock = eventBlock[parentRole || ''] || {};
-    var speakFormat = roleBlock.speak ||
-        parentRoleBlock.speak ||
-        eventBlock['default'].speak;
+    var speakFormat =
+        roleBlock.speak || parentRoleBlock.speak || eventBlock['default'].speak;
 
     this.format_(node, speakFormat, buff, prevNode);
 
     // Restore braille and add an annotation for this node.
     if (this.formatOptions_.braille) {
       var nodeSpan = this.mergeBraille_(buff);
       nodeSpan.setSpan(new Output.NodeSpan(node), 0, nodeSpan.length);
       originalBuff.push(nodeSpan);
     }
   },
@@ skipping 15 matching lines @@
       return;
 
     var options = {annotation: ['name'], isUnique: true};
     var rangeStart = range.start.index;
     var rangeEnd = range.end.index;
     if (this.formatOptions_.braille) {
       options.annotation.push(new Output.NodeSpan(node));
       var selStart = node.textSelStart;
       var selEnd = node.textSelEnd;
 
-      if (selStart !== undefined &&
-          selEnd >= rangeStart && selStart <= rangeEnd) {
+      if (selStart !== undefined && selEnd >= rangeStart &&
+          selStart <= rangeEnd) {
         // Editable text selection.
 
         // |rangeStart| and |rangeEnd| are indices set by the caller and are
         // assumed to be inside of the range. In braille, we only ever expect to
         // get ranges surrounding a line as anything smaller doesn't make sense.
 
         // |selStart| and |selEnd| reflect the editable selection. The relative
         // selStart and relative selEnd for the current line are then just the
         // difference between |selStart|, |selEnd| with |rangeStart|.
         // See editing_test.js for examples.
@@ skipping 21 matching lines @@
     } else {
       // This is output for speech or editable braille.
       text = range.start.getText().substring(rangeStart, rangeEnd);
     }
 
     this.append_(buff, text, options);
 
     if (!this.outputContextFirst_)
       this.ancestry_(node, prevNode, type, buff);
 
-    var loc =
-        range.start.node.boundsForRange(rangeStart, rangeEnd);
+    var loc = range.start.node.boundsForRange(rangeStart, rangeEnd);
     if (loc)
       this.locations_.push(loc);
   },
 
   /**
    * Appends output to the |buff|.
    * @param {!Array<Spannable>} buff
    * @param {string|!Spannable} value
    * @param {{isUnique: (boolean|undefined),
    *      annotation: !Array<*>}=} opt_options
    */
   append_: function(buff, value, opt_options) {
     opt_options = opt_options || {isUnique: false, annotation: []};
 
     // Reject empty values without meaningful annotations.
-    if ((!value || value.length == 0) && opt_options.annotation.every(
-        function(a) {
+    if ((!value || value.length == 0) &&
+        opt_options.annotation.every(function(a) {
           return !(a instanceof Output.Action) &&
               !(a instanceof Output.SelectionSpan);
 
         }))
       return;
 
     var spannableToAdd = new Spannable(value);
     opt_options.annotation.forEach(function(a) {
       spannableToAdd.setSpan(a, 0, spannableToAdd.length);
     });
 
     // |isUnique| specifies an annotation that cannot be duplicated.
     if (opt_options.isUnique) {
-      var annotationSansNodes = opt_options.annotation.filter(
-          function(annotation) {
+      var annotationSansNodes =
+          opt_options.annotation.filter(function(annotation) {
             return !(annotation instanceof Output.NodeSpan);
           });
 
       var alreadyAnnotated = buff.some(function(s) {
         return annotationSansNodes.some(function(annotation) {
           if (!s.hasSpan(annotation))
             return false;
           var start = s.getSpanStart(annotation);
           var end = s.getSpanEnd(annotation);
           var substr = s.substring(start, end);
@@ skipping 70 matching lines @@
       // showing the braille cursor.
       if (cur.length == 0 && hasSelection) {
         result.append(cur);
         result.append(Output.SPACE);
         separator = '';
         return result;
       }
 
       // Keep track of if there's an inline node associated with
       // |cur|.
-      var hasInlineNode = cur.getSpansInstanceOf(Output.NodeSpan)
-          .some(function(s) {
+      var hasInlineNode =
+          cur.getSpansInstanceOf(Output.NodeSpan).some(function(s) {
             if (!s.node)
               return false;
             return s.node.display == 'inline' ||
                 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
       // node's name. In all other cases, use the surrounding whitespace to
       // ensure we only have one separator between the node text.
       if (result.length == 0 ||
           (hasInlineNode && prevHasInlineNode && isName && prevIsName))
         separator = '';
-      else if (result.toString()[result.length - 1] == Output.SPACE ||
+      else if (
+          result.toString()[result.length - 1] == Output.SPACE ||
           cur.toString()[0] == Output.SPACE)
         separator = '';
       else
         separator = Output.SPACE;
 
       prevHasInlineNode = hasInlineNode;
       prevIsName = isName;
       result.append(separator);
       result.append(cur);
       return result;
@@ skipping 14 matching lines @@
       var earconFinder = node;
       var ancestors;
       if (opt_prevNode)
         ancestors = AutomationUtil.getUniqueAncestors(opt_prevNode, node);
       else
         ancestors = AutomationUtil.getAncestors(node);
 
       while (earconFinder = ancestors.pop()) {
         var info = Output.ROLE_INFO_[earconFinder.role];
         if (info && info.earconId) {
-          return new Output.EarconAction(info.earconId,
-                                         node.location || undefined);
+          return new Output.EarconAction(
+              info.earconId, node.location || undefined);
           break;
         }
         earconFinder = earconFinder.parent;
       }
     }
     return null;
   },
 
   /**
    * Gets a human friendly string with the contents of output.
@@ skipping 25 matching lines @@
   /**
    * Gets the output buffer for braille.
    * @return {!Spannable}
    */
   get brailleOutputForTest() {
     return this.mergeBraille_(this.brailleBuffer_);
   }
 };
 
 });  // goog.scope