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

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 70 matching lines @@
     // Re-interpret this case as the beginning of the next node.
     var nextNode = AutomationUtil.findNextNode(
         node, Dir.FORWARD, AutomationPredicate.leafOrStaticText);
 
     // The exception is when a user types at the end of a line. In that case,
     // staying on the current node is appropriate.
     if (node && node.nextOnLine && nextNode) {
       node = nextNode;
       index = 0;
     }
-  } else if (node.role == RoleType.GENERIC_CONTAINER &&
-      node.state.richlyEditable &&
-      (node.firstChild && (node.firstChild.role == RoleType.LINE_BREAK ||
-          node.firstChild.role == RoleType.STATIC_TEXT))) {
+  } else if (
+      node.role == RoleType.GENERIC_CONTAINER && node.state.richlyEditable &&
+      (node.firstChild &&
+       (node.firstChild.role == RoleType.LINE_BREAK ||
+        node.firstChild.role == RoleType.STATIC_TEXT))) {
     // Re-interpret this case as pointing to the text under the div.
-    node = node.find({ role: RoleType.INLINE_TEXT_BOX }) || node;
+    node = node.find({role: RoleType.INLINE_TEXT_BOX}) || node;
   }
 
   /** @type {number} @private */
   this.index_ = index;
   /** @type {Array<AutomationNode>} @private */
   this.ancestry_ = [];
   var nodeWalker = node;
   while (nodeWalker) {
     this.ancestry_.push(nodeWalker);
     nodeWalker = nodeWalker.parent;
@@ skipping 12 matching lines @@
 };
 
 cursors.Cursor.prototype = {
   /**
    * Returns true if |rhs| is equal to this cursor.
    * Use this for strict equality between cursors.
    * @param {!cursors.Cursor} rhs
    * @return {boolean}
    */
   equals: function(rhs) {
-    return this.node === rhs.node &&
-        this.index === rhs.index;
+    return this.node === rhs.node && this.index === rhs.index;
   },
 
   /**
    * Returns true if |rhs| is equal to this cursor.
    * 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.INLINE_TEXT_BOX ||
-        lNode.role == RoleType.STATIC_TEXT))
+    while (lNode &&
+           (lNode.role == RoleType.INLINE_TEXT_BOX ||
+            lNode.role == RoleType.STATIC_TEXT))
       lNode = lNode.parent;
-    while (rNode && (rNode.role == RoleType.INLINE_TEXT_BOX ||
-        rNode.role == RoleType.STATIC_TEXT))
+    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;
   },
 
   /**
    * Compares this cursor with |rhs|.
    * @param {cursors.Cursor} rhs
@@ skipping 49 matching lines @@
     if (adjustedNode.state.editable)
       return adjustedNode;
 
     // Selections over line break nodes are broken.
     var parent = adjustedNode.parent;
     var grandparent = parent && parent.parent;
     if (parent && parent.role == RoleType.LINE_BREAK) {
       adjustedNode = grandparent;
     } else if (grandparent && grandparent.role == RoleType.LINE_BREAK) {
       adjustedNode = grandparent.parent;
-    } else if (this.index_ == cursors.NODE_INDEX ||
+    } else if (
+        this.index_ == cursors.NODE_INDEX ||
         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.STATIC_TEXT}) || 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.INLINE_TEXT_BOX &&
-    // Selections under a line break are broken.
+    } else if (
+        this.node.role == RoleType.INLINE_TEXT_BOX &&
+        // Selections under a line break are broken.
         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 ||
+    } else if (
+        this.index_ == cursors.NODE_INDEX ||
         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 || 0;
         childOfSelection = childOfSelection.parent;
       } while (childOfSelection && childOfSelection != this.selectionNode_);
     }
@@ skipping 35 matching lines @@
         // BOUND and DIRECTIONAL are the same for characters.
         var text = this.getText();
         newIndex = dir == Dir.FORWARD ?
             StringUtil.nextCodePointOffset(text, newIndex) :
             StringUtil.previousCodePointOffset(text, newIndex);
         if (newIndex < 0 || newIndex >= text.length) {
           newNode = AutomationUtil.findNextNode(
               newNode, dir, AutomationPredicate.leafWithText);
           if (newNode) {
             var newText = AutomationUtil.getText(newNode);
-            newIndex =
-                dir == Dir.FORWARD ? 0 :
+            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.INLINE_TEXT_BOX) {
-          newNode = AutomationUtil.findNextNode(newNode,
-              Dir.FORWARD,
-              AutomationPredicate.inlineTextBox,
-              {skipInitialSubtree: false}) || newNode;
+          newNode = AutomationUtil.findNextNode(
+                        newNode, Dir.FORWARD, AutomationPredicate.inlineTextBox,
+                        {skipInitialSubtree: false}) ||
+              newNode;
         }
         switch (movement) {
           case Movement.BOUND:
             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];
@@ skipping 18 matching lines @@
                   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);
+                  newNode = AutomationUtil.findNextNode(
+                      newNode, dir, AutomationPredicate.leaf);
                   if (newNode) {
                     newIndex = 0;
                     if (dir == Dir.BACKWARD &&
                         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.
             }
         }
         break;
       case Unit.TEXT:
       case Unit.NODE:
         switch (movement) {
           case Movement.BOUND:
             newIndex = dir == Dir.FORWARD ? this.getText().length - 1 : 0;
             break;
           case Movement.DIRECTIONAL:
-            var pred = unit == Unit.TEXT ?
-                AutomationPredicate.leaf : AutomationPredicate.object;
-            newNode = AutomationUtil.findNextNode(newNode, dir, pred) ||
-                originalNode;
+            var pred = unit == Unit.TEXT ? AutomationPredicate.leaf :
+                                           AutomationPredicate.object;
+            newNode =
+                AutomationUtil.findNextNode(newNode, dir, pred) || originalNode;
             newIndex = cursors.NODE_INDEX;
             break;
         }
         break;
       case Unit.LINE:
         var deepEquivalent = this.deepEquivalent;
         newNode = deepEquivalent.node || newNode;
         newIndex = deepEquivalent.index || 0;
 
         switch (movement) {
           case Movement.BOUND:
-            newNode = AutomationUtil.findNodeUntil(newNode, dir,
-                AutomationPredicate.linebreak, true);
+            newNode = AutomationUtil.findNodeUntil(
+                newNode, dir, AutomationPredicate.linebreak, true);
             newNode = newNode || originalNode;
             newIndex =
                 dir == Dir.FORWARD ? AutomationUtil.getText(newNode).length : 0;
             break;
           case Movement.DIRECTIONAL:
             newNode = AutomationUtil.findNodeUntil(
                 newNode, dir, AutomationPredicate.linebreak);
             break;
-          }
-      break;
+        }
+        break;
       default:
         throw Error('Unrecognized unit: ' + unit);
     }
     newNode = newNode || originalNode;
     newIndex = goog.isDef(newIndex) ? newIndex : this.index_;
     return new cursors.Cursor(newNode, newIndex);
   },
 
   /**
    * Returns the deepest equivalent cursor.
@@ skipping 12 matching lines @@
           if (length <= newIndex && newIndex < (length + target.name.length))
             break;
           length += target.name.length;
           target = target.nextSibling;
         }
         if (target) {
           newNode = target;
           newIndex = newIndex - length;
         }
         break;
-      } else if (newNode.role != RoleType.INLINE_TEXT_BOX &&
+      } else if (
+          newNode.role != RoleType.INLINE_TEXT_BOX &&
           newNode.children[newIndex]) {
         // Valid node offset.
         newNode = newNode.children[newIndex];
         newIndex = 0;
       } else {
         // Invalid offset.
         break;
       }
     }
 
@@ skipping 35 matching lines @@
 cursors.WrappingCursor.prototype = {
   __proto__: cursors.Cursor.prototype,
 
   /** @override */
   move: function(unit, movement, dir) {
     var result = this;
     if (!result.node)
       return this;
 
     // Regular movement.
-    if (!AutomationPredicate.root(this.node) ||
-        dir == Dir.FORWARD ||
+    if (!AutomationPredicate.root(this.node) || dir == Dir.FORWARD ||
         movement == Movement.BOUND)
       result = cursors.Cursor.prototype.move.call(this, unit, movement, dir);
 
     // Moving to the bounds of a unit never wraps.
     if (movement == Movement.BOUND)
       return new cursors.WrappingCursor(result.node, result.index);
 
     // There are two cases for wrapping:
     // 1. moving forwards from the last element.
     // 2. moving backwards from the first element.
     // Both result in |move| returning the same cursor.
     // For 1, simply place the new cursor on the document node.
     // For 2, place range on the root (if not already there). If at root,
     // try to descend to the first leaf-like object.
     if (movement == Movement.DIRECTIONAL && result.equals(this)) {
-      var pred = unit == Unit.NODE ?
-          AutomationPredicate.object : AutomationPredicate.leaf;
+      var pred = unit == Unit.NODE ? AutomationPredicate.object :
+                                     AutomationPredicate.leaf;
       var endpoint = this.node;
       if (!endpoint)
         return this;
 
       // Case 1: forwards (find the root-like node).
       while (!AutomationPredicate.root(endpoint) && endpoint.parent)
         endpoint = endpoint.parent;
 
       // Always play a wrap earcon when moving forward.
       var playEarcon = dir == Dir.FORWARD;
 
       // Case 2: backward (sync downwards to a leaf), if already on the root.
       if (dir == Dir.BACKWARD && endpoint == this.node) {
         playEarcon = true;
-        endpoint = AutomationUtil.findNodePre(endpoint,
-            dir,
-            function(n) {
-              return pred(n) && !AutomationPredicate.shouldIgnoreNode(n);
-            }) || endpoint;
+        endpoint = AutomationUtil.findNodePre(endpoint, dir, function(n) {
+          return pred(n) && !AutomationPredicate.shouldIgnoreNode(n);
+        }) || endpoint;
       }
 
       if (playEarcon)
         cvox.ChromeVox.earcons.playEarcon(cvox.Earcon.WRAP);
 
       return new cursors.WrappingCursor(endpoint, cursors.NODE_INDEX);
     }
     return new cursors.WrappingCursor(result.node, result.index);
   }
 };
@@ skipping 16 matching lines @@
 /**
  * Convenience method to construct a Range surrounding one node.
  * @param {!AutomationNode} node
  * @return {!cursors.Range}
  */
 cursors.Range.fromNode = function(node) {
   var cursor = cursors.WrappingCursor.fromNode(node);
   return new cursors.Range(cursor, cursor);
 };
 
- /**
+/**
  * Given |rangeA| and |rangeB| in order, determine which |Dir|
  * relates them.
  * @param {!cursors.Range} rangeA
  * @param {!cursors.Range} rangeB
  * @return {Dir}
  */
 cursors.Range.getDirection = function(rangeA, rangeB) {
   if (!rangeA || !rangeB)
     return Dir.FORWARD;
 
-  if (!rangeA.start.node || !rangeA.end.node ||
-      !rangeB.start.node || !rangeB.end.node)
+  if (!rangeA.start.node || !rangeA.end.node || !rangeB.start.node ||
+      !rangeB.end.node)
     return Dir.FORWARD;
 
   // They are the same range.
   if (rangeA.start.node === rangeB.start.node &&
       rangeB.end.node === rangeA.end.node)
     return Dir.FORWARD;
 
   var testDirA =
-      AutomationUtil.getDirection(
-          rangeA.start.node, rangeB.end.node);
+      AutomationUtil.getDirection(rangeA.start.node, rangeB.end.node);
   var testDirB =
-      AutomationUtil.getDirection(
-          rangeB.start.node, rangeA.end.node);
+      AutomationUtil.getDirection(rangeB.start.node, rangeA.end.node);
 
   // The two ranges are either partly overlapping or non overlapping.
   if (testDirA == Dir.FORWARD && testDirB == Dir.BACKWARD)
     return Dir.FORWARD;
   else if (testDirA == Dir.BACKWARD && testDirB == Dir.FORWARD)
     return Dir.BACKWARD;
   else
     return testDirA;
 };
 
 cursors.Range.prototype = {
   /**
    * Returns true if |rhs| is equal to this range.
    * Use this for strict equality between ranges.
    * @param {!cursors.Range} rhs
    * @return {boolean}
    */
   equals: function(rhs) {
-    return this.start_.equals(rhs.start) &&
-        this.end_.equals(rhs.end);
+    return this.start_.equals(rhs.start) && this.end_.equals(rhs.end);
   },
 
   /**
    * Returns true if |rhs| is equal to this range.
    * Use this for loose equality between ranges.
    * @param {!cursors.Range} rhs
    * @return {boolean}
    */
   contentEquals: function(rhs) {
     return this.start_.contentEquals(rhs.start) &&
@@ skipping 22 matching lines @@
    */
   get end() {
     return this.end_;
   },
 
   /**
    * Returns true if this range covers a single node's text content or less.
    * @return {boolean}
    */
   isSubNode: function() {
-    return this.start.node === this.end.node &&
-        this.start.index > -1 &&
+    return this.start.node === this.end.node && this.start.index > -1 &&
         this.end.index > -1;
   },
 
   /**
    * 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 &&
+    return this.start.node && this.end.node &&
         this.start.node.role == this.end.node.role &&
         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}
@@ skipping 32 matching lines @@
    * Select the text contained within this range.
    */
   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.ROOT_WEB_AREA &&
+    if (startNode.root && 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_;
+          this.end.selectionIndex_ + 1 :
+          this.end.selectionIndex_;
 
-      chrome.automation.setDocumentSelection(
-          { anchorObject: startNode,
-            anchorOffset: startIndex,
-            focusObject: endNode,
-            focusOffset: endIndex }
-      );
+      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.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