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

chrome/browser/resources/chromeos/chromevox/common/editable_text.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.
 
 goog.provide('cvox.ChromeVoxEditableContentEditable');
 goog.provide('cvox.ChromeVoxEditableElement');
 goog.provide('cvox.ChromeVoxEditableHTMLInput');
 goog.provide('cvox.ChromeVoxEditableTextArea');
 goog.provide('cvox.TextHandlerInterface');
 
@@ skipping 42 matching lines @@
  * and EditableTextArea, but that might not apply to a non-DOM text box.
  * @param {Element} node A DOM node which allows text input.
  * @param {string} value The string value of the editable text control.
  * @param {number} start The 0-based start cursor/selection index.
  * @param {number} end The 0-based end cursor/selection index.
  * @param {boolean} isPassword Whether the text control if a password field.
  * @param {cvox.TtsInterface} tts A TTS object.
  * @extends {cvox.ChromeVoxEditableTextBase}
  * @constructor
  */
-cvox.ChromeVoxEditableElement = function(node, value, start, end, isPassword,
-    tts) {
+cvox.ChromeVoxEditableElement = function(
+    node, value, start, end, isPassword, tts) {
   goog.base(this, value, start, end, isPassword, tts);
 
   /**
    * An optional handler for braille output.
    * @type {cvox.BrailleTextHandler|undefined}
    * @private
    */
   this.brailleHandler_ = cvox.ChromeVox.braille ?
-      new cvox.BrailleTextHandler(cvox.ChromeVox.braille) : undefined;
+      new cvox.BrailleTextHandler(cvox.ChromeVox.braille) :
+      undefined;
 
   /**
    * The DOM node which allows text input.
    * @type {Element}
    * @protected
    */
   this.node = node;
 
   /**
    * True if the description was just spoken.
    * @type {boolean}
    * @private
    */
   this.justSpokeDescription_ = false;
 };
-goog.inherits(cvox.ChromeVoxEditableElement,
-    cvox.ChromeVoxEditableTextBase);
+goog.inherits(cvox.ChromeVoxEditableElement, cvox.ChromeVoxEditableTextBase);
 
 
 /** @override */
 cvox.ChromeVoxEditableElement.prototype.changed = function(evt) {
   // Ignore changes to the cursor and selection if they happen immediately
   // after the description was just spoken. This avoid double-speaking when,
   // for example, a text field is focused and then a moment later the
   // contents are selected. If the value changes, though, this change will
   // not be ignored.
   if (this.justSpokeDescription_ && this.value == evt.value) {
@@ skipping 73 matching lines @@
       index = re.lastIndex;
     }
   }
   node.selectionStart = node.selectionEnd = index;
   cvox.ChromeVoxEventWatcher.handleTextChanged(true);
   return true;
 };
 
 
 /** @override */
-cvox.ChromeVoxEditableElement.prototype.moveCursorToNextParagraph =
-    function() {
+cvox.ChromeVoxEditableElement.prototype.moveCursorToNextParagraph = function() {
   var node = this.node;
   var length = node.value.length;
-  var index = node.selectionEnd >= length ? length :
+  var index = node.selectionEnd >= length ?
+      length :
       node.value.indexOf('\n', node.selectionEnd);
   if (index < 0) {
     index = length;
   }
   node.selectionStart = node.selectionEnd = index + 1;
   cvox.ChromeVoxEventWatcher.handleTextChanged(true);
   return true;
 };
 
 
 /** @override */
 cvox.ChromeVoxEditableElement.prototype.moveCursorToPreviousParagraph =
     function() {
   var node = this.node;
-  var index = node.selectionStart <= 0 ? 0 :
+  var index = node.selectionStart <= 0 ?
+      0 :
       node.value.lastIndexOf('\n', node.selectionStart - 2) + 1;
   if (index < 0) {
     index = 0;
   }
   node.selectionStart = node.selectionEnd = index;
   cvox.ChromeVoxEventWatcher.handleTextChanged(true);
   return true;
 };
 
 /**
  * Shows the current line on the braille display.
  * @private
  */
 cvox.ChromeVoxEditableElement.prototype.brailleCurrentLine_ = function() {
   if (this.brailleHandler_) {
     var lineIndex = this.getLineIndex(this.start);
     var line = this.getLine(lineIndex);
     // Collapsable whitespace inside the contenteditable is represented
     // as non-breaking spaces.  This confuses braille input (which relies on
     // the text being added to be the same as the text in the input field).
     // Since the non-breaking spaces are just an artifact of how
     // contenteditable is implemented, normalize to normal spaces instead.
     if (this instanceof cvox.ChromeVoxEditableContentEditable) {
       line = line.replace(/\u00A0/g, ' ');
     }
     var lineStart = this.getLineStart(lineIndex);
     var start = this.start - lineStart;
     var end = Math.min(this.end - lineStart, line.length);
-    this.brailleHandler_.changed(line, start, end, this.multiline, this.node,
-                                 lineStart);
+    this.brailleHandler_.changed(
+        line, start, end, this.multiline, this.node, lineStart);
   }
 };
 
 /******************************************/
 
 
 /**
  * A subclass of ChromeVoxEditableElement for an HTMLInputElement.
  * @param {HTMLInputElement} node The HTMLInputElement node.
  * @param {cvox.TtsInterface} tts A TTS object.
  * @extends {cvox.ChromeVoxEditableElement}
  * @implements {cvox.TextHandlerInterface}
  * @constructor
  */
 cvox.ChromeVoxEditableHTMLInput = function(node, tts) {
   this.node = node;
   this.setup();
-  goog.base(this,
-            node,
-            node.value,
-            node.selectionStart,
-            node.selectionEnd,
-            node.type === 'password',
-            tts);
+  goog.base(
+      this, node, node.value, node.selectionStart, node.selectionEnd,
+      node.type === 'password', tts);
 };
-goog.inherits(cvox.ChromeVoxEditableHTMLInput,
-    cvox.ChromeVoxEditableElement);
+goog.inherits(cvox.ChromeVoxEditableHTMLInput, cvox.ChromeVoxEditableElement);
 
 
 /**
  * Performs setup for this input node.
  * This accounts for exception-throwing behavior introduced by crbug.com/324360.
  * @override
  */
 cvox.ChromeVoxEditableHTMLInput.prototype.setup = function() {
   if (!this.node) {
     return;
@@ skipping 18 matching lines @@
 
 
 /**
  * Update the state of the text and selection and describe any changes as
  * appropriate.
  *
  * @param {boolean} triggeredByUser True if this was triggered by a user action.
  */
 cvox.ChromeVoxEditableHTMLInput.prototype.update = function(triggeredByUser) {
   var newValue = this.node.value;
-  var textChangeEvent = new cvox.TextChangeEvent(newValue,
-                                                 this.node.selectionStart,
-                                                 this.node.selectionEnd,
-                                                 triggeredByUser);
+  var textChangeEvent = new cvox.TextChangeEvent(
+      newValue, this.node.selectionStart, this.node.selectionEnd,
+      triggeredByUser);
   this.changed(textChangeEvent);
 };
 
 
 /******************************************/
 
 
 /**
  * A subclass of ChromeVoxEditableElement for an HTMLTextAreaElement.
  * @param {HTMLTextAreaElement} node The HTMLTextAreaElement node.
  * @param {cvox.TtsInterface} tts A TTS object.
  * @extends {cvox.ChromeVoxEditableElement}
  * @implements {cvox.TextHandlerInterface}
  * @constructor
  */
 cvox.ChromeVoxEditableTextArea = function(node, tts) {
-  goog.base(this, node, node.value, node.selectionStart, node.selectionEnd,
+  goog.base(
+      this, node, node.value, node.selectionStart, node.selectionEnd,
       false /* isPassword */, tts);
   this.multiline = true;
 
   /**
    * True if the shadow is up to date with the current value of this text area.
    * @type {boolean}
    * @private
    */
   this.shadowIsCurrent_ = false;
 };
-goog.inherits(cvox.ChromeVoxEditableTextArea,
-    cvox.ChromeVoxEditableElement);
+goog.inherits(cvox.ChromeVoxEditableTextArea, cvox.ChromeVoxEditableElement);
 
 
 /**
  * An offscreen div used to compute the line numbers. A single div is
  * shared by all instances of the class.
  * @type {!cvox.EditableTextAreaShadow|undefined}
  * @private
  */
 cvox.ChromeVoxEditableTextArea.shadow_;
 
 
 /**
  * Update the state of the text and selection and describe any changes as
  * appropriate.
  *
  * @param {boolean} triggeredByUser True if this was triggered by a user action.
  */
 cvox.ChromeVoxEditableTextArea.prototype.update = function(triggeredByUser) {
   if (this.node.value != this.value) {
     this.shadowIsCurrent_ = false;
   }
-  var textChangeEvent = new cvox.TextChangeEvent(this.node.value,
-      this.node.selectionStart, this.node.selectionEnd, triggeredByUser);
+  var textChangeEvent = new cvox.TextChangeEvent(
+      this.node.value, this.node.selectionStart, this.node.selectionEnd,
+      triggeredByUser);
   this.changed(textChangeEvent);
 };
 
 
 /**
  * Get the line number corresponding to a particular index.
  * @param {number} index The 0-based character index.
  * @return {number} The 0-based line number corresponding to that character.
  */
 cvox.ChromeVoxEditableTextArea.prototype.getLineIndex = function(index) {
@@ skipping 44 matching lines @@
   var node = this.node;
   var length = node.value.length;
   if (node.selectionEnd >= length) {
     return false;
   }
   var shadow = this.getShadow();
   var lineIndex = shadow.getLineIndex(node.selectionEnd);
   var lineStart = shadow.getLineStart(lineIndex);
   var offset = node.selectionEnd - lineStart;
   var lastLine = (length == 0) ? 0 : shadow.getLineIndex(length - 1);
-  var newCursorPosition = (lineIndex >= lastLine) ? length :
-      Math.min(shadow.getLineStart(lineIndex + 1) + offset,
+  var newCursorPosition = (lineIndex >= lastLine) ?
+      length :
+      Math.min(
+          shadow.getLineStart(lineIndex + 1) + offset,
           shadow.getLineEnd(lineIndex + 1));
   node.selectionStart = node.selectionEnd = newCursorPosition;
   cvox.ChromeVoxEventWatcher.handleTextChanged(true);
   return true;
 };
 
 
 /** @override */
 cvox.ChromeVoxEditableTextArea.prototype.moveCursorToPreviousLine = function() {
   var node = this.node;
   if (node.selectionStart <= 0) {
     return false;
   }
   var shadow = this.getShadow();
   var lineIndex = shadow.getLineIndex(node.selectionStart);
   var lineStart = shadow.getLineStart(lineIndex);
   var offset = node.selectionStart - lineStart;
-  var newCursorPosition = (lineIndex <= 0) ? 0 :
-      Math.min(shadow.getLineStart(lineIndex - 1) + offset,
+  var newCursorPosition = (lineIndex <= 0) ?
+      0 :
+      Math.min(
+          shadow.getLineStart(lineIndex - 1) + offset,
           shadow.getLineEnd(lineIndex - 1));
   node.selectionStart = node.selectionEnd = newCursorPosition;
   cvox.ChromeVoxEventWatcher.handleTextChanged(true);
   return true;
 };
 
 
 /******************************************/
 
 
@@ skipping 19 matching lines @@
    * @private
    */
   this.extractorIsCurrent_ = false;
 
   var extractor = this.getExtractor();
   this.value = extractor.getText();
   this.start = extractor.getStartIndex();
   this.end = extractor.getEndIndex();
   this.multiline = true;
 };
-goog.inherits(cvox.ChromeVoxEditableContentEditable,
-    cvox.ChromeVoxEditableElement);
+goog.inherits(
+    cvox.ChromeVoxEditableContentEditable, cvox.ChromeVoxEditableElement);
 
 /**
  * A helper used to compute the line numbers. A single object is
  * shared by all instances of the class.
  * @type {!cvox.ContentEditableExtractor|undefined}
  * @private
  */
 cvox.ChromeVoxEditableContentEditable.extractor_;
 
 
 /**
  * Update the state of the text and selection and describe any changes as
  * appropriate.
  *
  * @param {boolean} triggeredByUser True if this was triggered by a user action.
  */
-cvox.ChromeVoxEditableContentEditable.prototype.update =
-    function(triggeredByUser) {
+cvox.ChromeVoxEditableContentEditable.prototype.update = function(
+    triggeredByUser) {
   this.extractorIsCurrent_ = false;
   var textChangeEvent = new cvox.TextChangeEvent(
-      this.getExtractor().getText(),
-      this.getExtractor().getStartIndex(),
-      this.getExtractor().getEndIndex(),
-      triggeredByUser);
+      this.getExtractor().getText(), this.getExtractor().getStartIndex(),
+      this.getExtractor().getEndIndex(), triggeredByUser);
   this.changed(textChangeEvent);
 };
 
 
 /**
  * Get the line number corresponding to a particular index.
  * @param {number} index The 0-based character index.
  * @return {number} The 0-based line number corresponding to that character.
  */
 cvox.ChromeVoxEditableContentEditable.prototype.getLineIndex = function(index) {
@@ skipping 33 matching lines @@
   }
   if (!this.extractorIsCurrent_) {
     extractor.update(this.node);
     this.extractorIsCurrent_ = true;
   }
   return extractor;
 };
 
 
 /** @override */
-cvox.ChromeVoxEditableContentEditable.prototype.changed =
-    function(evt) {
+cvox.ChromeVoxEditableContentEditable.prototype.changed = function(evt) {
   if (!evt.triggeredByUser) {
     return;
   }
   // Take over here if we can't describe a change; assume it's a blank line.
   if (!this.shouldDescribeChange(evt)) {
     this.speak(Msgs.getMsg('text_box_blank'), true);
     if (this.brailleHandler_) {
-      this.brailleHandler_.changed('' /*line*/, 0 /*start*/, 0 /*end*/,
-                                   true /*multiline*/, null /*element*/,
-                                   evt.start /*lineStart*/);
+      this.brailleHandler_.changed(
+          '' /*line*/, 0 /*start*/, 0 /*end*/, true /*multiline*/,
+          null /*element*/, evt.start /*lineStart*/);
     }
   } else {
     goog.base(this, 'changed', evt);
   }
 };
 
 
 /** @override */
 cvox.ChromeVoxEditableContentEditable.prototype.moveCursorToNextCharacter =
     function() {
@@ skipping 25 matching lines @@
     function() {
   window.getSelection().modify('move', 'backward', 'paragraph');
   cvox.ChromeVoxEventWatcher.handleTextChanged(true);
   return true;
 };
 
 
 /**
  * @override
  */
-cvox.ChromeVoxEditableContentEditable.prototype.shouldDescribeChange =
-    function(evt) {
+cvox.ChromeVoxEditableContentEditable.prototype.shouldDescribeChange = function(
+    evt) {
   var sel = window.getSelection();
   var cursor = new cvox.Cursor(sel.baseNode, sel.baseOffset, '');
 
   // This is a very specific work around because of our buggy content editable
   // support. Blank new lines are not captured in the line indexing data
   // structures.
   // Scenario: given a piece of text like:
   //
   // Some Title
   //
   // Description
   // Footer
   //
   // The new lines after Title are not traversed to by TraverseUtil. A root fix
   // would make changes there. However, considering the fickle nature of that
   // code, we specifically detect for new lines here.
-  if (Math.abs(this.start - evt.start) != 1 &&
-      this.start == this.end &&
-      evt.start == evt.end &&
-      sel.baseNode == sel.extentNode &&
+  if (Math.abs(this.start - evt.start) != 1 && this.start == this.end &&
+      evt.start == evt.end && sel.baseNode == sel.extentNode &&
       sel.baseOffset == sel.extentOffset &&
       sel.baseNode.nodeType == Node.ELEMENT_NODE &&
       sel.baseNode.querySelector('BR') &&
       cvox.TraverseUtil.forwardsChar(cursor, [], [])) {
     // This case detects if the range selection surrounds a new line,
     // but there is still content after the new line (like the example
     // above after "Title"). In these cases, we "pretend" we're the
     // last character so we speak "blank".
     return false;
   }
 
   // Otherwise, we should never speak "blank" no matter what (even if
   // we're at the end of a content editable).
   return true;
 };