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

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');
@@ skipping 56 matching lines @@
 /**
  * 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);
 
   chrome.automation.getDesktop(function(desktop) {
-    var useRichText = editing.useRichText &&
-        node.state.richlyEditable;
+    var useRichText = editing.useRichText && node.state.richlyEditable;
 
     /** @private {!AutomationEditableText} */
-    this.editableText_ = useRichText ?
-        new AutomationRichEditableText(node) : new AutomationEditableText(node);
+    this.editableText_ = useRichText ? new AutomationRichEditableText(node) :
+                                       new AutomationEditableText(node);
   }.bind(this));
 }
 
 TextFieldTextEditHandler.prototype = {
   __proto__: editing.TextEditHandler.prototype,
 
   /** @override */
   onEvent: function(evt) {
     if (evt.type !== EventType.TEXT_CHANGED &&
         evt.type !== EventType.TEXT_SELECTION_CHANGED &&
-        evt.type !== EventType.VALUE_CHANGED &&
-        evt.type !== EventType.FOCUS)
+        evt.type !== EventType.VALUE_CHANGED && evt.type !== EventType.FOCUS)
       return;
-    if (!evt.target.state.focused ||
-        !evt.target.state.editable ||
+    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 || '',
-      Math.min(start, end),
-      Math.max(start, end),
-      node.state[StateType.PROTECTED] /**password*/,
-      cvox.ChromeVox.tts);
+      this, node.value || '', Math.min(start, end), Math.max(start, end),
+      node.state[StateType.PROTECTED] /**password*/, cvox.ChromeVox.tts);
   /** @override */
   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 || '';
 
     if (this.value != newValue)
       this.lineBreaks_ = [];
 
     var textChangeEvent = new cvox.TextChangeEvent(
-        newValue,
-        this.node_.textSelStart || 0,
-        this.node_.textSelEnd || 0,
+        newValue, 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 76 matching lines @@
 AutomationRichEditableText.prototype = {
   __proto__: AutomationEditableText.prototype,
 
   /** @override */
   onUpdate: function() {
     var root = this.node_.root;
     if (!root.anchorObject || !root.focusObject)
       return;
 
     var cur = new editing.EditableLine(
-        root.anchorObject, root.anchorOffset || 0,
-        root.focusObject, root.focusOffset || 0);
+        root.anchorObject, root.anchorOffset || 0, root.focusObject,
+        root.focusOffset || 0);
     var prev = this.line_;
     this.line_ = cur;
 
     if (prev.equals(cur)) {
       // Collapsed cursor.
       this.changed(new cvox.TextChangeEvent(
-          cur.text || '',
-          cur.startOffset || 0,
-          cur.endOffset || 0,
-          true));
+          cur.text || '', cur.startOffset || 0, cur.endOffset || 0, true));
       this.brailleCurrentRichLine_();
 
       // Finally, queue up any text markers/styles at bounds.
       var container = cur.startContainer_;
       if (!container)
         return;
 
       if (container.markerTypes) {
         // Only consider markers that start or end at the selection bounds.
         var markerStartIndex = -1, markerEndIndex = -1;
@@ skipping 51 matching lines @@
     var msgs = [];
     if (markerType & 1)
       msgs.push(opt_end ? 'misspelling_end' : 'misspelling_start');
     if (markerType & 2)
       msgs.push(opt_end ? 'grammar_end' : 'grammar_start');
     if (markerType & 4)
       msgs.push(opt_end ? 'text_match_end' : 'text_match_start');
 
     if (msgs.length) {
       msgs.forEach(function(msg) {
-        cvox.ChromeVox.tts.speak(Msgs.getMsg(msg),
-                                 cvox.QueueMode.QUEUE,
-                                 cvox.AbstractTts.PERSONALITY_ANNOTATION);
+        cvox.ChromeVox.tts.speak(
+            Msgs.getMsg(msg), cvox.QueueMode.QUEUE,
+            cvox.AbstractTts.PERSONALITY_ANNOTATION);
       });
     }
   },
 
   /**
    * @param {!AutomationNode} style
    * @param {boolean=} opt_end
    * @private
    */
   speakTextStyle_: function(style, opt_end) {
     var msgs = [];
     if (style.bold)
       msgs.push(opt_end ? 'bold_end' : 'bold_start');
     if (style.italic)
       msgs.push(opt_end ? 'italic_end' : 'italic_start');
     if (style.underline)
       msgs.push(opt_end ? 'underline_end' : 'underline_start');
     if (style.lineThrough)
       msgs.push(opt_end ? 'line_through_end' : 'line_through_start');
 
     if (msgs.length) {
       msgs.forEach(function(msg) {
-        cvox.ChromeVox.tts.speak(Msgs.getMsg(msg),
-                                 cvox.QueueMode.QUEUE,
-                                 cvox.AbstractTts.PERSONALITY_ANNOTATION);
+        cvox.ChromeVox.tts.speak(
+            Msgs.getMsg(msg), cvox.QueueMode.QUEUE,
+            cvox.AbstractTts.PERSONALITY_ANNOTATION);
       });
     }
   },
 
   /** @private */
   brailleCurrentRichLine_: function() {
     var cur = this.line_;
     var value = cur.value_;
     value.setSpan(new cvox.ValueSpan(0), 0, cur.value_.length);
     value.setSpan(
         new cvox.ValueSelectionSpan(), cur.startOffset, cur.endOffset);
     cvox.ChromeVox.braille.write(new cvox.NavBraille(
-        {text: value,
-         startIndex: cur.startOffset,
-         endIndex: cur.endOffset}));
+        {text: value, startIndex: cur.startOffset, endIndex: cur.endOffset}));
   },
 
   /** @override */
   describeSelectionChanged: function(evt) {
     // Ignore end of text announcements.
     if ((this.start + 1) == evt.start && evt.start == this.value.length)
       return;
 
     cvox.ChromeVoxEditableTextBase.prototype.describeSelectionChanged.call(
         this, evt);
@@ skipping 69 matching lines @@
 
 /**
  * @private {ChromeVoxStateObserver}
  */
 editing.observer_ = new editing.EditingChromeVoxStateObserver();
 
 /**
  * An EditableLine encapsulates all data concerning a line in the automation
  * tree necessary to provide output.
  * @constructor
-  */
+ */
 editing.EditableLine = function(startNode, startIndex, endNode, endIndex) {
   /** @private {!Cursor} */
   this.start_ = new Cursor(startNode, startIndex);
   this.start_ = this.start_.deepEquivalent || this.start_;
 
   /** @private {!Cursor} */
   this.end_ = new Cursor(endNode, endIndex);
   this.end_ = this.end_.deepEquivalent || this.end_;
   /** @private {number} */
   this.localContainerStartOffset_ = startIndex;
@@ skipping 119 matching lines @@
         currentLen -= textCountAfterLineEnd;
 
       len += currentLen;
 
       try {
         this.value_.setSpan(new Output.NodeSpan(parent, offset), prevLen, len);
 
         // Also, annotate this span if it is associated with line containre.
         if (parent == this.startContainer_)
           this.value_.setSpan(parent, prevLen, len);
-      } catch (e) {}
+      } catch (e) {
+      }
     }
   },
 
   /**
    * Gets the selection offset based on the text content of this line.
    * @return {number}
    */
   get startOffset() {
     return this.value_.getSpanStart(this.start_) + this.start_.index;
   },
@@ skipping 54 matching lines @@
    * Returns true if |otherLine| surrounds the same line as |this|. Note that
    * the contents of the line might be different.
    * @return {boolean}
    */
   equals: function(otherLine) {
     // Equality is intentionally loose here as any of the state nodes can be
     // invalidated at any time. We rely upon the start/anchor of the line
     // staying the same.
     return otherLine.lineStartContainer_ == this.lineStartContainer_ &&
         otherLine.localLineStartContainerOffset_ ==
-            this.localLineStartContainerOffset_;
+        this.localLineStartContainerOffset_;
   }
 };
 
 });