Merge dom node and node unit types.

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 19 matching lines @@
 cursors.Unit = {
   /** A single character within accessible name or value. */
   CHARACTER: 'character',
 
   /** A range of characters (given by attributes on automation nodes). */
   WORD: 'word',
 
   /** A leaf node. */
   NODE: 'node',
 
-  /** A leaf DOM-node. */
-  DOM_NODE: 'dom_node',
-
-  /** Formed by a set of leaf nodes that are inline. */
+  /**
+   * A node or in line textbox that immediately precedes or follows a visual
+   *     line break.
+   */
   LINE: 'line'
 };
 
 /**
  * Represents the ways in which cursors can move given a cursor unit.
  * @enum {string}
  */
 cursors.Movement = {
   /** Move to the beginning or end of the current unit. */
   BOUND: 'bound',
@@ skipping 157 matching lines @@
    * @return {!cursors.Cursor} The moved cursor.
    */
   move: function(unit, movement, dir) {
     var originalNode = this.node;
     if (!originalNode)
       return this;
 
     var newNode = originalNode;
     var newIndex = this.index_;
 
-    if ((unit != Unit.NODE || unit != Unit.DOM_NODE) &&
-        newIndex === cursors.NODE_INDEX)
+    if (unit != Unit.NODE && newIndex === cursors.NODE_INDEX)
       newIndex = 0;
 
     switch (unit) {
       case Unit.CHARACTER:
         // 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) {
@@ skipping 67 matching lines @@
                     }
                   }
                 }
               }
             } else {
               // TODO(dtseng): Figure out what to do in this case.
             }
         }
         break;
       case Unit.NODE:
-      case Unit.DOM_NODE:
         switch (movement) {
           case Movement.BOUND:
             newIndex = dir == Dir.FORWARD ? this.getText().length - 1 : 0;
             break;
           case Movement.DIRECTIONAL:
-            var pred = unit == Unit.NODE ?
-                AutomationPredicate.leaf : AutomationPredicate.object;
             newNode = AutomationUtil.findNextNode(
-                newNode, dir, pred) || originalNode;
+                newNode, dir, AutomationPredicate.object) || originalNode;
             newIndex = cursors.NODE_INDEX;
             break;
         }
         break;
       case Unit.LINE:
         newIndex = 0;
         switch (movement) {
           case Movement.BOUND:
             newNode = AutomationUtil.findNodeUntil(newNode, dir,
                 AutomationPredicate.linebreak, true);
@@ skipping 50 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.DOM_NODE ?
+      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.
@@ skipping 149 matching lines @@
         if (newStart.node !== newEnd.node)
           newEnd = new cursors.Cursor(newStart.node, newStart.index + 1);
         break;
       case Unit.WORD:
       case Unit.LINE:
         newStart = newStart.move(unit, Movement.DIRECTIONAL, dir);
         newStart = newStart.move(unit, Movement.BOUND, Dir.BACKWARD);
         newEnd = newStart.move(unit, Movement.BOUND, Dir.FORWARD);
         break;
       case Unit.NODE:
-      case Unit.DOM_NODE:
         newStart = newStart.move(unit, Movement.DIRECTIONAL, dir);
         newEnd = newStart;
         break;
       default:
         throw Error('Invalid unit: ' + unit);
     }
     return new cursors.Range(newStart, newEnd);
   },
 
   /**
@@ skipping 48 matching lines @@
   /**
    * Returns whether this range has valid start and end cursors.
    * @return {boolean}
    */
   isValid: function() {
     return this.start.isValid() && this.end.isValid();
   }
 };
 
 });  // goog.scope