Convert some ChromeVox functional getters to properties.

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 71 matching lines @@
   return new cursors.Cursor(node, cursors.NODE_INDEX);
 };
 
 cursors.Cursor.prototype = {
   /**
    * Returns true if |rhs| is equal to this cursor.
    * @param {!cursors.Cursor} rhs
    * @return {boolean}
    */
   equals: function(rhs) {
-    return this.node_ === rhs.getNode() &&
+    return this.node_ === rhs.node &&
         this.index_ === rhs.getIndex();
   },
 
   /**
    * @return {!AutomationNode}
    */
-  getNode: function() {
+  get node() {
     return this.node_;
   },
 
   /**
    * @return {number}
    */
   getIndex: function() {
     return this.index_;
   },
 
@@ skipping 167 matching lines @@
  * relates them.
  * @param {!cursors.Range} rangeA
  * @param {!cursors.Range} rangeB
  * @return {Dir}
  */
 cursors.Range.getDirection = function(rangeA, rangeB) {
   if (!rangeA || !rangeB)
     return Dir.FORWARD;
 
   // They are the same range.
-  if (rangeA.getStart().getNode() === rangeB.getStart().getNode() &&
-      rangeB.getEnd().getNode() === rangeA.getEnd().getNode())
+  if (rangeA.start.node === rangeB.start.node &&
+      rangeB.end.node === rangeA.end.node)
     return Dir.FORWARD;
 
   var testDirA =
       AutomationUtil.getDirection(
-          rangeA.getStart().getNode(), rangeB.getEnd().getNode());
+          rangeA.start.node, rangeB.end.node);
   var testDirB =
       AutomationUtil.getDirection(
-          rangeB.getStart().getNode(), rangeA.getEnd().getNode());
+          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.
    * @param {!cursors.Range} rhs
    * @return {boolean}
    */
   equals: function(rhs) {
-    return this.start_.equals(rhs.getStart()) &&
-        this.end_.equals(rhs.getEnd());
+    return this.start_.equals(rhs.start) &&
+        this.end_.equals(rhs.end);
   },
 
   /**
    * Gets a cursor bounding this range.
    * @param {Dir} dir Which endpoint cursor to return; Dir.FORWARD for end,
    * Dir.BACKWARD for start.
    * @param {boolean=} opt_reverse Specify to have Dir.BACKWARD return end,
    * Dir.FORWARD return start.
    * @return {!cursors.Cursor}
    */
   getBound: function(dir, opt_reverse) {
     if (opt_reverse)
       return dir == Dir.BACKWARD ? this.end_ : this.start_;
     return dir == Dir.FORWARD ? this.end_ : this.start_;
   },
 
   /**
    * @return {!cursors.Cursor}
    */
-  getStart: function() {
+  get start() {
     return this.start_;
   },
 
   /**
    * @return {!cursors.Cursor}
    */
-  getEnd: function() {
+  get end() {
     return this.end_;
   },
 
   /**
    * Returns true if this range covers less than a node.
    * @return {boolean}
    */
   isSubNode: function() {
-    return this.getStart().getNode() === this.getEnd().getNode() &&
-        this.getStart().getIndex() > -1 &&
-        this.getEnd().getIndex() > -1;
+    return this.start.node === this.end.node &&
+        this.start.getIndex() > -1 &&
+        this.end.getIndex() > -1;
   },
 
   /**
    * 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}
    */
   move: function(unit, dir) {
     var newStart = this.start_;
     var newEnd = newStart;
     switch (unit) {
       case Unit.CHARACTER:
         newStart = newStart.move(unit, Movement.BOUND, dir);
         newEnd = newStart.move(unit, Movement.BOUND, Dir.FORWARD);
         // Character crossed a node; collapses to the end of the node.
-        if (newStart.getNode() !== newEnd.getNode())
+        if (newStart.node !== newEnd.node)
           newEnd = newStart;
         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:
         newStart = newStart.move(unit, Movement.DIRECTIONAL, dir);
         newEnd = newStart;
         break;
     }
     return new cursors.Range(newStart, newEnd);
   }
 };
 
 });  // goog.scope