Add a nameFromNode attrib to link output rule

chrome/browser/resources/chromeos/chromevox/cvox2/background/output.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 Provides output services for ChromeVox.
  */
 
 goog.provide('Output');
 goog.provide('Output.EventType');
@@ skipping 378 matching lines @@
  * Rules specifying format of AutomationNodes for output.
  * @type {!Object<Object<Object<string>>>}
  */
 Output.RULES = {
   navigate: {
     'default': {
       speak: '$name $value $role $description',
       braille: ''
     },
     abstractContainer: {
-      enter: '$name $role $description',
+      enter: '$nameFromNode $role $description',
       leave: '@exited_container($role)'
     },
     alert: {
       speak: '!doNotInterrupt $role $descendants'
     },
     alertDialog: {
-      enter: '$name $role $description $descendants'
+      enter: '$nameFromNode $role $description $descendants'
     },
     cell: {
       enter: '@column_granularity $tableCellColumnIndex'
     },
     checkBox: {
       speak: '$if($checked, $earcon(CHECK_ON), $earcon(CHECK_OFF)) ' +
              '$name $role $checked $description'
     },
     dialog: {
-      enter: '$name $role $description'
+      enter: '$nameFromNode $role $description'
     },
     div: {
-      enter: '$name',
+      enter: '$nameFromNode',
       speak: '$name $description'
     },
     grid: {
-      enter: '$name $role $description'
+      enter: '$nameFromNode $role $description'
     },
     heading: {
       enter: '@tag_h+$hierarchicalLevel',
       speak: '!relativePitch(hierarchicalLevel)' +
           ' $nameOrDescendants= @tag_h+$hierarchicalLevel'
     },
     inlineTextBox: {
       speak: '$name='
     },
     link: {
-      enter: '$name= $if($visited, @visited_link, $role)',
+      enter: '$nameFromNode $if($visited, @visited_link, $role)',
       speak: '$name= $if($visited, @visited_link, $role) $description'
     },
     list: {
       enter: '$role @@list_with_items($countChildren(listItem))'
     },
     listBox: {
-      enter: '$name $role @@list_with_items($countChildren(listBoxOption)) ' +
+      enter: '$nameFromNode' +
+          '$role @@list_with_items($countChildren(listBoxOption)) ' +
           '$description'
     },
     listBoxOption: {
       speak: '$name $role @describe_index($indexInParent, $parentChildCount) ' +
           '$description'
     },
     listItem: {
       enter: '$role'
     },
     menu: {
@@ skipping 464 matching lines @@
     else
       this.range_(range, prevRange, type, buff);
   },
 
   /**
    * Format the node given the format specifier.
    * @param {AutomationNode} node
    * @param {string|!Object} format The output format either specified as an
    * output template string or a parsed output format tree.
    * @param {!Array<Spannable>} buff Buffer to receive rendered output.
+   * @param {!AutomationNode=} opt_prevNode
    * @private
    */
-  format_: function(node, format, buff) {
+  format_: function(node, format, buff, opt_prevNode) {
     var tokens = [];
     var args = null;
 
     // Hacky way to support args.
     if (typeof(format) == 'string') {
       format = format.replace(/([,:])\W/g, '$1');
       tokens = format.split(' ');
     } else {
       tokens = [format];
     }
@@ skipping 38 matching lines @@
             if (node.textSelStart !== undefined) {
               options.annotation.push(new Output.SelectionSpan(
                   node.textSelStart,
                   node.textSelEnd));
             }
           }
           options.annotation.push(token);
           this.append_(buff, text, options);
         } else if (token == 'name') {
           options.annotation.push(token);
-          var earcon = node ? this.findEarcon_(node) : null;
+          var earcon = node ? this.findEarcon_(node, opt_prevNode) : null;
           if (earcon)
             options.annotation.push(earcon);
           this.append_(buff, node.name, options);
+        } else if (token == 'nameFromNode') {
+          if (chrome.automation.NameFromType[node.nameFrom] ==
+              'nameFromContents')
+            return;
+
+          options.annotation.push(token);
+          this.append_(buff, node.name, options);
         } else if (token == 'nameOrDescendants') {
           options.annotation.push(token);
           if (node.name)
             this.append_(buff, node.name, options);
           else
             this.format_(node, '$descendants', buff);
         } else if (token == 'indexInParent') {
           options.annotation.push(token);
           this.append_(buff, String(node.indexInParent + 1));
         } else if (token == 'parentChildCount') {
@@ skipping 296 matching lines @@
     for (var i = 0, formatPrevNode;
          (formatPrevNode = prevUniqueAncestors[i]);
          i++) {
       // This prevents very repetitive announcements.
       if (enteredRoleSet[formatPrevNode.role] ||
           localStorage['useVerboseMode'] == 'false')
         continue;
 
       var roleBlock = getMergedRoleBlock(formatPrevNode.role);
       if (roleBlock.leave && localStorage['useVerboseMode'] == 'true')
-        this.format_(formatPrevNode, roleBlock.leave, buff);
+        this.format_(formatPrevNode, roleBlock.leave, buff, prevNode);
     }
 
     var enterOutputs = [];
     var enterRole = {};
     for (var j = uniqueAncestors.length - 2, formatNode;
          (formatNode = uniqueAncestors[j]);
          j--) {
       var roleBlock = getMergedRoleBlock(formatNode.role);
       if (roleBlock.enter) {
         if (enterRole[formatNode.role])
           continue;
         enterRole[formatNode.role] = true;
-        this.format_(formatNode, roleBlock.enter, buff);
+        this.format_(formatNode, roleBlock.enter, buff, prevNode);
       }
       if (formatNode.role == 'window')
         break;
     }
   },
 
   /**
    * @param {!AutomationNode} node
    * @param {!AutomationNode} prevNode
    * @param {EventType|Output.EventType} type
    * @param {!Array<Spannable>} buff
    * @private
    */
   node_: function(node, prevNode, type, buff) {
     // Navigate is the default event.
     var eventBlock = Output.RULES[type] || Output.RULES['navigate'];
     var roleBlock = eventBlock[node.role] || {};
     var parentRole = (Output.ROLE_INFO_[node.role] || {}).inherits;
     var parentRoleBlock = eventBlock[parentRole || ''] || {};
     var speakFormat = roleBlock.speak ||
         parentRoleBlock.speak ||
         eventBlock['default'].speak;
 
-    this.format_(node, speakFormat, buff);
+    this.format_(node, speakFormat, buff, prevNode);
   },
 
   /**
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @param {EventType|Output.EventType} type
    * @param {!Array<Spannable>} buff
    * @private
    */
   subNode_: function(range, prevRange, type, buff) {
@@ skipping 182 matching lines @@
     return result;
   },
 
   /**
    * Find the earcon for a given node (including ancestry).
    * @param {!AutomationNode} node
    * @param {!AutomationNode=} opt_prevNode
    * @return {Output.Action}
    */
   findEarcon_: function(node, opt_prevNode) {
+    if (node === opt_prevNode)
+      return null;
+
     if (this.formatOptions_.speech) {
       var earconFinder = node;
       var ancestors;
-      if (opt_prevNode) {
-        // Don't include the node itself.
+      if (opt_prevNode)
         ancestors = AutomationUtil.getUniqueAncestors(opt_prevNode, node);
-        ancestors.pop();
-      } else {
+      else
         ancestors = AutomationUtil.getAncestors(node);
-      }
 
       while (earconFinder = ancestors.pop()) {
         var info = Output.ROLE_INFO_[earconFinder.role];
         if (info && info.earconId) {
           return new Output.EarconAction(info.earconId);
           break;
         }
         earconFinder = earconFinder.parent;
       }
     }
     return null;
   }
 };
 
 });  // goog.scope