Home | History | Annotate | Download | only in accessibility 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <execinfo.h>
      6 
      7 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
      8 
      9 #include <map>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/strings/string16.h"
     13 #include "base/strings/sys_string_conversions.h"
     14 #include "base/strings/utf_string_conversions.h"
     15 #include "content/app/strings/grit/content_strings.h"
     16 #include "content/browser/accessibility/browser_accessibility_manager.h"
     17 #include "content/browser/accessibility/browser_accessibility_manager_mac.h"
     18 #include "content/public/common/content_client.h"
     19 #import "ui/accessibility/platform/ax_platform_node_mac.h"
     20 
     21 // See http://openradar.appspot.com/9896491. This SPI has been tested on 10.5,
     22 // 10.6, and 10.7. It allows accessibility clients to observe events posted on
     23 // this object.
     24 extern "C" void NSAccessibilityUnregisterUniqueIdForUIElement(id element);
     25 
     26 using ui::AXNodeData;
     27 using content::BrowserAccessibility;
     28 using content::BrowserAccessibilityManager;
     29 using content::BrowserAccessibilityManagerMac;
     30 using content::ContentClient;
     31 typedef ui::AXStringAttribute StringAttribute;
     32 
     33 namespace {
     34 
     35 // Returns an autoreleased copy of the AXNodeData's attribute.
     36 NSString* NSStringForStringAttribute(
     37     BrowserAccessibility* browserAccessibility,
     38     StringAttribute attribute) {
     39   return base::SysUTF8ToNSString(
     40       browserAccessibility->GetStringAttribute(attribute));
     41 }
     42 
     43 // GetState checks the bitmask used in AXNodeData to check
     44 // if the given state was set on the accessibility object.
     45 bool GetState(BrowserAccessibility* accessibility, ui::AXState state) {
     46   return ((accessibility->GetState() >> state) & 1);
     47 }
     48 
     49 // A mapping from an accessibility attribute to its method name.
     50 NSDictionary* attributeToMethodNameMap = nil;
     51 
     52 } // namespace
     53 
     54 @implementation BrowserAccessibilityCocoa
     55 
     56 + (void)initialize {
     57   const struct {
     58     NSString* attribute;
     59     NSString* methodName;
     60   } attributeToMethodNameContainer[] = {
     61     { NSAccessibilityChildrenAttribute, @"children" },
     62     { NSAccessibilityColumnsAttribute, @"columns" },
     63     { NSAccessibilityColumnHeaderUIElementsAttribute, @"columnHeaders" },
     64     { NSAccessibilityColumnIndexRangeAttribute, @"columnIndexRange" },
     65     { NSAccessibilityContentsAttribute, @"contents" },
     66     { NSAccessibilityDescriptionAttribute, @"description" },
     67     { NSAccessibilityDisclosingAttribute, @"disclosing" },
     68     { NSAccessibilityDisclosedByRowAttribute, @"disclosedByRow" },
     69     { NSAccessibilityDisclosureLevelAttribute, @"disclosureLevel" },
     70     { NSAccessibilityDisclosedRowsAttribute, @"disclosedRows" },
     71     { NSAccessibilityEnabledAttribute, @"enabled" },
     72     { NSAccessibilityFocusedAttribute, @"focused" },
     73     { NSAccessibilityHeaderAttribute, @"header" },
     74     { NSAccessibilityHelpAttribute, @"help" },
     75     { NSAccessibilityIndexAttribute, @"index" },
     76     { NSAccessibilityLinkedUIElementsAttribute, @"linkedUIElements" },
     77     { NSAccessibilityMaxValueAttribute, @"maxValue" },
     78     { NSAccessibilityMinValueAttribute, @"minValue" },
     79     { NSAccessibilityNumberOfCharactersAttribute, @"numberOfCharacters" },
     80     { NSAccessibilityOrientationAttribute, @"orientation" },
     81     { NSAccessibilityParentAttribute, @"parent" },
     82     { NSAccessibilityPositionAttribute, @"position" },
     83     { NSAccessibilityRoleAttribute, @"role" },
     84     { NSAccessibilityRoleDescriptionAttribute, @"roleDescription" },
     85     { NSAccessibilityRowHeaderUIElementsAttribute, @"rowHeaders" },
     86     { NSAccessibilityRowIndexRangeAttribute, @"rowIndexRange" },
     87     { NSAccessibilityRowsAttribute, @"rows" },
     88     // TODO(aboxhall): expose NSAccessibilityServesAsTitleForUIElementsAttribute
     89     { NSAccessibilitySelectedChildrenAttribute, @"selectedChildren" },
     90     { NSAccessibilitySizeAttribute, @"size" },
     91     { NSAccessibilitySubroleAttribute, @"subrole" },
     92     { NSAccessibilityTabsAttribute, @"tabs" },
     93     { NSAccessibilityTitleAttribute, @"title" },
     94     { NSAccessibilityTitleUIElementAttribute, @"titleUIElement" },
     95     { NSAccessibilityTopLevelUIElementAttribute, @"window" },
     96     { NSAccessibilityURLAttribute, @"url" },
     97     { NSAccessibilityValueAttribute, @"value" },
     98     { NSAccessibilityValueDescriptionAttribute, @"valueDescription" },
     99     { NSAccessibilityVisibleCharacterRangeAttribute, @"visibleCharacterRange" },
    100     { NSAccessibilityVisibleCellsAttribute, @"visibleCells" },
    101     { NSAccessibilityVisibleChildrenAttribute, @"visibleChildren" },
    102     { NSAccessibilityVisibleColumnsAttribute, @"visibleColumns" },
    103     { NSAccessibilityVisibleRowsAttribute, @"visibleRows" },
    104     { NSAccessibilityWindowAttribute, @"window" },
    105     { @"AXAccessKey", @"accessKey" },
    106     { @"AXARIAAtomic", @"ariaAtomic" },
    107     { @"AXARIABusy", @"ariaBusy" },
    108     { @"AXARIALive", @"ariaLive" },
    109     { @"AXARIARelevant", @"ariaRelevant" },
    110     { @"AXInvalid", @"invalid" },
    111     { @"AXLoaded", @"loaded" },
    112     { @"AXLoadingProgress", @"loadingProgress" },
    113     { @"AXRequired", @"required" },
    114     { @"AXVisited", @"visited" },
    115   };
    116 
    117   NSMutableDictionary* dict = [[NSMutableDictionary alloc] init];
    118   const size_t numAttributes = sizeof(attributeToMethodNameContainer) /
    119                                sizeof(attributeToMethodNameContainer[0]);
    120   for (size_t i = 0; i < numAttributes; ++i) {
    121     [dict setObject:attributeToMethodNameContainer[i].methodName
    122              forKey:attributeToMethodNameContainer[i].attribute];
    123   }
    124   attributeToMethodNameMap = dict;
    125   dict = nil;
    126 }
    127 
    128 - (id)initWithObject:(BrowserAccessibility*)accessibility {
    129   if ((self = [super init]))
    130     browserAccessibility_ = accessibility;
    131   return self;
    132 }
    133 
    134 - (void)detach {
    135   if (browserAccessibility_) {
    136     NSAccessibilityUnregisterUniqueIdForUIElement(self);
    137     browserAccessibility_ = NULL;
    138   }
    139 }
    140 
    141 - (NSString*)accessKey {
    142   return NSStringForStringAttribute(
    143       browserAccessibility_, ui::AX_ATTR_ACCESS_KEY);
    144 }
    145 
    146 - (NSNumber*)ariaAtomic {
    147   bool boolValue = browserAccessibility_->GetBoolAttribute(
    148       ui::AX_ATTR_LIVE_ATOMIC);
    149   return [NSNumber numberWithBool:boolValue];
    150 }
    151 
    152 - (NSNumber*)ariaBusy {
    153   bool boolValue = browserAccessibility_->GetBoolAttribute(
    154       ui::AX_ATTR_LIVE_BUSY);
    155   return [NSNumber numberWithBool:boolValue];
    156 }
    157 
    158 - (NSString*)ariaLive {
    159   return NSStringForStringAttribute(
    160       browserAccessibility_, ui::AX_ATTR_LIVE_STATUS);
    161 }
    162 
    163 - (NSString*)ariaRelevant {
    164   return NSStringForStringAttribute(
    165       browserAccessibility_, ui::AX_ATTR_LIVE_RELEVANT);
    166 }
    167 
    168 // Returns an array of BrowserAccessibilityCocoa objects, representing the
    169 // accessibility children of this object.
    170 - (NSArray*)children {
    171   if (!children_) {
    172     uint32 childCount = browserAccessibility_->PlatformChildCount();
    173     children_.reset([[NSMutableArray alloc] initWithCapacity:childCount]);
    174     for (uint32 index = 0; index < childCount; ++index) {
    175       BrowserAccessibilityCocoa* child =
    176           browserAccessibility_->PlatformGetChild(index)->
    177               ToBrowserAccessibilityCocoa();
    178       if ([child isIgnored])
    179         [children_ addObjectsFromArray:[child children]];
    180       else
    181         [children_ addObject:child];
    182     }
    183 
    184     // Also, add indirect children (if any).
    185     const std::vector<int32>& indirectChildIds =
    186         browserAccessibility_->GetIntListAttribute(
    187             ui::AX_ATTR_INDIRECT_CHILD_IDS);
    188     for (uint32 i = 0; i < indirectChildIds.size(); ++i) {
    189       int32 child_id = indirectChildIds[i];
    190       BrowserAccessibility* child =
    191           browserAccessibility_->manager()->GetFromID(child_id);
    192 
    193       // This only became necessary as a result of crbug.com/93095. It should be
    194       // a DCHECK in the future.
    195       if (child) {
    196         BrowserAccessibilityCocoa* child_cocoa =
    197             child->ToBrowserAccessibilityCocoa();
    198         [children_ addObject:child_cocoa];
    199       }
    200     }
    201   }
    202   return children_;
    203 }
    204 
    205 - (void)childrenChanged {
    206   if (![self isIgnored]) {
    207     children_.reset();
    208   } else {
    209     [browserAccessibility_->GetParent()->ToBrowserAccessibilityCocoa()
    210        childrenChanged];
    211   }
    212 }
    213 
    214 - (NSArray*)columnHeaders {
    215   if ([self internalRole] != ui::AX_ROLE_TABLE &&
    216       [self internalRole] != ui::AX_ROLE_GRID) {
    217     return nil;
    218   }
    219 
    220   NSMutableArray* ret = [[[NSMutableArray alloc] init] autorelease];
    221   const std::vector<int32>& uniqueCellIds =
    222       browserAccessibility_->GetIntListAttribute(
    223           ui::AX_ATTR_UNIQUE_CELL_IDS);
    224   for (size_t i = 0; i < uniqueCellIds.size(); ++i) {
    225     int id = uniqueCellIds[i];
    226     BrowserAccessibility* cell =
    227         browserAccessibility_->manager()->GetFromID(id);
    228     if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER)
    229       [ret addObject:cell->ToBrowserAccessibilityCocoa()];
    230   }
    231   return ret;
    232 }
    233 
    234 - (NSValue*)columnIndexRange {
    235   if ([self internalRole] != ui::AX_ROLE_CELL)
    236     return nil;
    237 
    238   int column = -1;
    239   int colspan = -1;
    240   browserAccessibility_->GetIntAttribute(
    241       ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column);
    242   browserAccessibility_->GetIntAttribute(
    243       ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan);
    244   if (column >= 0 && colspan >= 1)
    245     return [NSValue valueWithRange:NSMakeRange(column, colspan)];
    246   return nil;
    247 }
    248 
    249 - (NSArray*)columns {
    250   NSMutableArray* ret = [[[NSMutableArray alloc] init] autorelease];
    251   for (BrowserAccessibilityCocoa* child in [self children]) {
    252     if ([[child role] isEqualToString:NSAccessibilityColumnRole])
    253       [ret addObject:child];
    254   }
    255   return ret;
    256 }
    257 
    258 - (NSString*)description {
    259   std::string description;
    260   if (browserAccessibility_->GetStringAttribute(
    261           ui::AX_ATTR_DESCRIPTION, &description)) {
    262     return base::SysUTF8ToNSString(description);
    263   }
    264 
    265   // If the role is anything other than an image, or if there's
    266   // a title or title UI element, just return an empty string.
    267   if (![[self role] isEqualToString:NSAccessibilityImageRole])
    268     return @"";
    269   if (browserAccessibility_->HasStringAttribute(
    270           ui::AX_ATTR_NAME)) {
    271     return @"";
    272   }
    273   if ([self titleUIElement])
    274     return @"";
    275 
    276   // The remaining case is an image where there's no other title.
    277   // Return the base part of the filename as the description.
    278   std::string url;
    279   if (browserAccessibility_->GetStringAttribute(
    280           ui::AX_ATTR_URL, &url)) {
    281     // Given a url like http://foo.com/bar/baz.png, just return the
    282     // base name, e.g., "baz.png".
    283     size_t leftIndex = url.rfind('/');
    284     std::string basename =
    285         leftIndex != std::string::npos ? url.substr(leftIndex) : url;
    286     return base::SysUTF8ToNSString(basename);
    287   }
    288 
    289   return @"";
    290 }
    291 
    292 - (NSNumber*)disclosing {
    293   if ([self internalRole] == ui::AX_ROLE_TREE_ITEM) {
    294     return [NSNumber numberWithBool:
    295         GetState(browserAccessibility_, ui::AX_STATE_EXPANDED)];
    296   } else {
    297     return nil;
    298   }
    299 }
    300 
    301 - (id)disclosedByRow {
    302   // The row that contains this row.
    303   // It should be the same as the first parent that is a treeitem.
    304   return nil;
    305 }
    306 
    307 - (NSNumber*)disclosureLevel {
    308   ui::AXRole role = [self internalRole];
    309   if (role == ui::AX_ROLE_ROW ||
    310       role == ui::AX_ROLE_TREE_ITEM) {
    311     int level = browserAccessibility_->GetIntAttribute(
    312         ui::AX_ATTR_HIERARCHICAL_LEVEL);
    313     // Mac disclosureLevel is 0-based, but web levels are 1-based.
    314     if (level > 0)
    315       level--;
    316     return [NSNumber numberWithInt:level];
    317   } else {
    318     return nil;
    319   }
    320 }
    321 
    322 - (id)disclosedRows {
    323   // The rows that are considered inside this row.
    324   return nil;
    325 }
    326 
    327 - (NSNumber*)enabled {
    328   return [NSNumber numberWithBool:
    329       GetState(browserAccessibility_, ui::AX_STATE_ENABLED)];
    330 }
    331 
    332 - (NSNumber*)focused {
    333   BrowserAccessibilityManager* manager = browserAccessibility_->manager();
    334   NSNumber* ret = [NSNumber numberWithBool:
    335       manager->GetFocus(NULL) == browserAccessibility_];
    336   return ret;
    337 }
    338 
    339 - (id)header {
    340   int headerElementId = -1;
    341   if ([self internalRole] == ui::AX_ROLE_TABLE ||
    342       [self internalRole] == ui::AX_ROLE_GRID) {
    343     browserAccessibility_->GetIntAttribute(
    344         ui::AX_ATTR_TABLE_HEADER_ID, &headerElementId);
    345   } else if ([self internalRole] == ui::AX_ROLE_COLUMN) {
    346     browserAccessibility_->GetIntAttribute(
    347         ui::AX_ATTR_TABLE_COLUMN_HEADER_ID, &headerElementId);
    348   } else if ([self internalRole] == ui::AX_ROLE_ROW) {
    349     browserAccessibility_->GetIntAttribute(
    350         ui::AX_ATTR_TABLE_ROW_HEADER_ID, &headerElementId);
    351   }
    352 
    353   if (headerElementId > 0) {
    354     BrowserAccessibility* headerObject =
    355         browserAccessibility_->manager()->GetFromID(headerElementId);
    356     if (headerObject)
    357       return headerObject->ToBrowserAccessibilityCocoa();
    358   }
    359   return nil;
    360 }
    361 
    362 - (NSString*)help {
    363   return NSStringForStringAttribute(
    364       browserAccessibility_, ui::AX_ATTR_HELP);
    365 }
    366 
    367 - (NSNumber*)index {
    368   if ([self internalRole] == ui::AX_ROLE_COLUMN) {
    369     int columnIndex = browserAccessibility_->GetIntAttribute(
    370           ui::AX_ATTR_TABLE_COLUMN_INDEX);
    371     return [NSNumber numberWithInt:columnIndex];
    372   } else if ([self internalRole] == ui::AX_ROLE_ROW) {
    373     int rowIndex = browserAccessibility_->GetIntAttribute(
    374         ui::AX_ATTR_TABLE_ROW_INDEX);
    375     return [NSNumber numberWithInt:rowIndex];
    376   }
    377 
    378   return nil;
    379 }
    380 
    381 // Returns whether or not this node should be ignored in the
    382 // accessibility tree.
    383 - (BOOL)isIgnored {
    384   return [[self role] isEqualToString:NSAccessibilityUnknownRole];
    385 }
    386 
    387 - (NSString*)invalid {
    388   base::string16 invalidUTF;
    389   if (!browserAccessibility_->GetHtmlAttribute("aria-invalid", &invalidUTF))
    390     return NULL;
    391   NSString* invalid = base::SysUTF16ToNSString(invalidUTF);
    392   if ([invalid isEqualToString:@"false"] ||
    393       [invalid isEqualToString:@""]) {
    394     return @"false";
    395   }
    396   return invalid;
    397 }
    398 
    399 - (void)addLinkedUIElementsFromAttribute:(ui::AXIntListAttribute)attribute
    400                                    addTo:(NSMutableArray*)outArray {
    401   const std::vector<int32>& attributeValues =
    402       browserAccessibility_->GetIntListAttribute(attribute);
    403   for (size_t i = 0; i < attributeValues.size(); ++i) {
    404     BrowserAccessibility* element =
    405         browserAccessibility_->manager()->GetFromID(attributeValues[i]);
    406     if (element)
    407       [outArray addObject:element->ToBrowserAccessibilityCocoa()];
    408   }
    409 }
    410 
    411 - (NSArray*)linkedUIElements {
    412   NSMutableArray* ret = [[[NSMutableArray alloc] init] autorelease];
    413   [self addLinkedUIElementsFromAttribute:ui::AX_ATTR_OWNS_IDS addTo:ret];
    414   [self addLinkedUIElementsFromAttribute:ui::AX_ATTR_CONTROLS_IDS addTo:ret];
    415   [self addLinkedUIElementsFromAttribute:ui::AX_ATTR_FLOWTO_IDS addTo:ret];
    416   if ([ret count] == 0)
    417     return nil;
    418   return ret;
    419 }
    420 
    421 - (NSNumber*)loaded {
    422   return [NSNumber numberWithBool:YES];
    423 }
    424 
    425 - (NSNumber*)loadingProgress {
    426   float floatValue = browserAccessibility_->GetFloatAttribute(
    427       ui::AX_ATTR_DOC_LOADING_PROGRESS);
    428   return [NSNumber numberWithFloat:floatValue];
    429 }
    430 
    431 - (NSNumber*)maxValue {
    432   float floatValue = browserAccessibility_->GetFloatAttribute(
    433       ui::AX_ATTR_MAX_VALUE_FOR_RANGE);
    434   return [NSNumber numberWithFloat:floatValue];
    435 }
    436 
    437 - (NSNumber*)minValue {
    438   float floatValue = browserAccessibility_->GetFloatAttribute(
    439       ui::AX_ATTR_MIN_VALUE_FOR_RANGE);
    440   return [NSNumber numberWithFloat:floatValue];
    441 }
    442 
    443 - (NSString*)orientation {
    444   // We present a spin button as a vertical slider, with a role description
    445   // of "spin button".
    446   if ([self internalRole] == ui::AX_ROLE_SPIN_BUTTON)
    447     return NSAccessibilityVerticalOrientationValue;
    448 
    449   if ([self internalRole] == ui::AX_ROLE_LIST ||
    450       [self internalRole] == ui::AX_ROLE_LIST_BOX) {
    451     return NSAccessibilityVerticalOrientationValue;
    452   }
    453 
    454   if (GetState(browserAccessibility_, ui::AX_STATE_VERTICAL))
    455     return NSAccessibilityVerticalOrientationValue;
    456   else
    457     return NSAccessibilityHorizontalOrientationValue;
    458 }
    459 
    460 - (NSNumber*)numberOfCharacters {
    461   return [NSNumber numberWithInt:browserAccessibility_->value().length()];
    462 }
    463 
    464 // The origin of this accessibility object in the page's document.
    465 // This is relative to webkit's top-left origin, not Cocoa's
    466 // bottom-left origin.
    467 - (NSPoint)origin {
    468   gfx::Rect bounds = browserAccessibility_->GetLocalBoundsRect();
    469   return NSMakePoint(bounds.x(), bounds.y());
    470 }
    471 
    472 - (id)parent {
    473   // A nil parent means we're the root.
    474   if (browserAccessibility_->GetParent()) {
    475     return NSAccessibilityUnignoredAncestor(
    476         browserAccessibility_->GetParent()->ToBrowserAccessibilityCocoa());
    477   } else {
    478     // Hook back up to RenderWidgetHostViewCocoa.
    479     BrowserAccessibilityManagerMac* manager =
    480         static_cast<BrowserAccessibilityManagerMac*>(
    481             browserAccessibility_->manager());
    482     return manager->parent_view();
    483   }
    484 }
    485 
    486 - (NSValue*)position {
    487   NSPoint origin = [self origin];
    488   NSSize size = [[self size] sizeValue];
    489   NSPoint pointInScreen = [self pointInScreen:origin size:size];
    490   return [NSValue valueWithPoint:pointInScreen];
    491 }
    492 
    493 - (NSNumber*)required {
    494   return [NSNumber numberWithBool:
    495       GetState(browserAccessibility_, ui::AX_STATE_REQUIRED)];
    496 }
    497 
    498 // Returns an enum indicating the role from browserAccessibility_.
    499 - (ui::AXRole)internalRole {
    500   return static_cast<ui::AXRole>(browserAccessibility_->GetRole());
    501 }
    502 
    503 - (content::BrowserAccessibilityDelegate*)delegate {
    504   return browserAccessibility_->manager() ?
    505       browserAccessibility_->manager()->delegate() :
    506       nil;
    507 }
    508 
    509 - (NSPoint)pointInScreen:(NSPoint)origin
    510                     size:(NSSize)size {
    511   if (!browserAccessibility_)
    512     return NSZeroPoint;
    513 
    514   gfx::Rect bounds(origin.x, origin.y, size.width, size.height);
    515   gfx::Point point = [self delegate]->AccessibilityOriginInScreen(bounds);
    516   return NSMakePoint(point.x(), point.y());
    517 }
    518 
    519 // Returns a string indicating the NSAccessibility role of this object.
    520 - (NSString*)role {
    521   ui::AXRole role = [self internalRole];
    522   if (role == ui::AX_ROLE_CANVAS &&
    523       browserAccessibility_->GetBoolAttribute(
    524           ui::AX_ATTR_CANVAS_HAS_FALLBACK)) {
    525     return NSAccessibilityGroupRole;
    526   }
    527   if (role == ui::AX_ROLE_BUTTON || role == ui::AX_ROLE_TOGGLE_BUTTON) {
    528     bool isAriaPressedDefined;
    529     bool isMixed;
    530     browserAccessibility_->GetAriaTristate("aria-pressed",
    531                                            &isAriaPressedDefined,
    532                                            &isMixed);
    533     if (isAriaPressedDefined)
    534       return NSAccessibilityCheckBoxRole;
    535     else
    536       return NSAccessibilityButtonRole;
    537   }
    538   return [AXPlatformNodeCocoa nativeRoleFromAXRole:role];
    539 }
    540 
    541 // Returns a string indicating the role description of this object.
    542 - (NSString*)roleDescription {
    543   NSString* role = [self role];
    544 
    545   ContentClient* content_client = content::GetContentClient();
    546 
    547   // The following descriptions are specific to webkit.
    548   if ([role isEqualToString:@"AXWebArea"]) {
    549     return base::SysUTF16ToNSString(content_client->GetLocalizedString(
    550         IDS_AX_ROLE_WEB_AREA));
    551   }
    552 
    553   if ([role isEqualToString:@"NSAccessibilityLinkRole"]) {
    554     return base::SysUTF16ToNSString(content_client->GetLocalizedString(
    555         IDS_AX_ROLE_LINK));
    556   }
    557 
    558   if ([role isEqualToString:@"AXHeading"]) {
    559     return base::SysUTF16ToNSString(content_client->GetLocalizedString(
    560         IDS_AX_ROLE_HEADING));
    561   }
    562 
    563   if ([role isEqualToString:NSAccessibilityGroupRole] ||
    564       [role isEqualToString:NSAccessibilityRadioButtonRole]) {
    565     std::string role;
    566     if (browserAccessibility_->GetHtmlAttribute("role", &role)) {
    567       ui::AXRole internalRole = [self internalRole];
    568       if ((internalRole != ui::AX_ROLE_GROUP &&
    569            internalRole != ui::AX_ROLE_LIST_ITEM) ||
    570           internalRole == ui::AX_ROLE_TAB) {
    571         // TODO(dtseng): This is not localized; see crbug/84814.
    572         return base::SysUTF8ToNSString(role);
    573       }
    574     }
    575   }
    576 
    577   switch([self internalRole]) {
    578   case ui::AX_ROLE_FOOTER:
    579     return base::SysUTF16ToNSString(content_client->GetLocalizedString(
    580         IDS_AX_ROLE_FOOTER));
    581   case ui::AX_ROLE_SPIN_BUTTON:
    582     // This control is similar to what VoiceOver calls a "stepper".
    583     return base::SysUTF16ToNSString(content_client->GetLocalizedString(
    584         IDS_AX_ROLE_STEPPER));
    585   case ui::AX_ROLE_TOGGLE_BUTTON:
    586     return base::SysUTF16ToNSString(content_client->GetLocalizedString(
    587         IDS_AX_ROLE_TOGGLE_BUTTON));
    588   default:
    589     break;
    590   }
    591 
    592   return NSAccessibilityRoleDescription(role, nil);
    593 }
    594 
    595 - (NSArray*)rowHeaders {
    596   if ([self internalRole] != ui::AX_ROLE_TABLE &&
    597       [self internalRole] != ui::AX_ROLE_GRID) {
    598     return nil;
    599   }
    600 
    601   NSMutableArray* ret = [[[NSMutableArray alloc] init] autorelease];
    602   const std::vector<int32>& uniqueCellIds =
    603       browserAccessibility_->GetIntListAttribute(
    604           ui::AX_ATTR_UNIQUE_CELL_IDS);
    605   for (size_t i = 0; i < uniqueCellIds.size(); ++i) {
    606     int id = uniqueCellIds[i];
    607     BrowserAccessibility* cell =
    608         browserAccessibility_->manager()->GetFromID(id);
    609     if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER)
    610       [ret addObject:cell->ToBrowserAccessibilityCocoa()];
    611   }
    612   return ret;
    613 }
    614 
    615 - (NSValue*)rowIndexRange {
    616   if ([self internalRole] != ui::AX_ROLE_CELL)
    617     return nil;
    618 
    619   int row = -1;
    620   int rowspan = -1;
    621   browserAccessibility_->GetIntAttribute(
    622       ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row);
    623   browserAccessibility_->GetIntAttribute(
    624       ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan);
    625   if (row >= 0 && rowspan >= 1)
    626     return [NSValue valueWithRange:NSMakeRange(row, rowspan)];
    627   return nil;
    628 }
    629 
    630 - (NSArray*)rows {
    631   NSMutableArray* ret = [[[NSMutableArray alloc] init] autorelease];
    632 
    633   if ([self internalRole] == ui::AX_ROLE_TABLE||
    634       [self internalRole] == ui::AX_ROLE_GRID) {
    635     for (BrowserAccessibilityCocoa* child in [self children]) {
    636       if ([[child role] isEqualToString:NSAccessibilityRowRole])
    637         [ret addObject:child];
    638     }
    639   } else if ([self internalRole] == ui::AX_ROLE_COLUMN) {
    640     const std::vector<int32>& indirectChildIds =
    641         browserAccessibility_->GetIntListAttribute(
    642             ui::AX_ATTR_INDIRECT_CHILD_IDS);
    643     for (uint32 i = 0; i < indirectChildIds.size(); ++i) {
    644       int id = indirectChildIds[i];
    645       BrowserAccessibility* rowElement =
    646           browserAccessibility_->manager()->GetFromID(id);
    647       if (rowElement)
    648         [ret addObject:rowElement->ToBrowserAccessibilityCocoa()];
    649     }
    650   }
    651 
    652   return ret;
    653 }
    654 
    655 - (NSArray*)selectedChildren {
    656   NSMutableArray* ret = [[[NSMutableArray alloc] init] autorelease];
    657 
    658   BrowserAccessibilityManager* manager = browserAccessibility_->manager();
    659   BrowserAccessibility* focusedChild =
    660       manager->GetFocus(browserAccessibility_);
    661   if (focusedChild && focusedChild != browserAccessibility_) {
    662     // First try the focused child.
    663     [ret addObject:focusedChild->ToBrowserAccessibilityCocoa()];
    664   } else {
    665     // Next try the active descendant.
    666     int activeDescendantId;
    667     if (browserAccessibility_->GetIntAttribute(
    668             ui::AX_ATTR_ACTIVEDESCENDANT_ID, &activeDescendantId)) {
    669       BrowserAccessibility* activeDescendant =
    670           manager->GetFromID(activeDescendantId);
    671       if (activeDescendant)
    672         [ret addObject:activeDescendant->ToBrowserAccessibilityCocoa()];
    673     } else {
    674       // Otherwise return any children with the "selected" state, which
    675       // may come from aria-selected.
    676       uint32 childCount = browserAccessibility_->PlatformChildCount();
    677       for (uint32 index = 0; index < childCount; ++index) {
    678         BrowserAccessibility* child =
    679             browserAccessibility_->PlatformGetChild(index);
    680         if (child->HasState(ui::AX_STATE_SELECTED))
    681           [ret addObject:child->ToBrowserAccessibilityCocoa()];
    682       }
    683     }
    684   }
    685 
    686   return ret;
    687 }
    688 
    689 // Returns the size of this object.
    690 - (NSValue*)size {
    691   gfx::Rect bounds = browserAccessibility_->GetLocalBoundsRect();
    692   return  [NSValue valueWithSize:NSMakeSize(bounds.width(), bounds.height())];
    693 }
    694 
    695 // Returns a subrole based upon the role.
    696 - (NSString*) subrole {
    697   ui::AXRole browserAccessibilityRole = [self internalRole];
    698   if (browserAccessibilityRole == ui::AX_ROLE_TEXT_FIELD &&
    699       GetState(browserAccessibility_, ui::AX_STATE_PROTECTED)) {
    700     return @"AXSecureTextField";
    701   }
    702 
    703   NSString* htmlTag = NSStringForStringAttribute(
    704       browserAccessibility_, ui::AX_ATTR_HTML_TAG);
    705 
    706   if (browserAccessibilityRole == ui::AX_ROLE_LIST) {
    707     if ([htmlTag isEqualToString:@"dl"]) {
    708       return @"AXDescriptionList";
    709     } else {
    710       return @"AXContentList";
    711     }
    712   }
    713 
    714   return [AXPlatformNodeCocoa nativeSubroleFromAXRole:browserAccessibilityRole];
    715 }
    716 
    717 // Returns all tabs in this subtree.
    718 - (NSArray*)tabs {
    719   NSMutableArray* tabSubtree = [[[NSMutableArray alloc] init] autorelease];
    720 
    721   if ([self internalRole] == ui::AX_ROLE_TAB)
    722     [tabSubtree addObject:self];
    723 
    724   for (uint i=0; i < [[self children] count]; ++i) {
    725     NSArray* tabChildren = [[[self children] objectAtIndex:i] tabs];
    726     if ([tabChildren count] > 0)
    727       [tabSubtree addObjectsFromArray:tabChildren];
    728   }
    729 
    730   return tabSubtree;
    731 }
    732 
    733 - (NSString*)title {
    734   return NSStringForStringAttribute(
    735       browserAccessibility_, ui::AX_ATTR_NAME);
    736 }
    737 
    738 - (id)titleUIElement {
    739   int titleElementId;
    740   if (browserAccessibility_->GetIntAttribute(
    741           ui::AX_ATTR_TITLE_UI_ELEMENT, &titleElementId)) {
    742     BrowserAccessibility* titleElement =
    743         browserAccessibility_->manager()->GetFromID(titleElementId);
    744     if (titleElement)
    745       return titleElement->ToBrowserAccessibilityCocoa();
    746   }
    747   std::vector<int32> labelledby_ids =
    748       browserAccessibility_->GetIntListAttribute(ui::AX_ATTR_LABELLEDBY_IDS);
    749   if (labelledby_ids.size() == 1) {
    750     BrowserAccessibility* titleElement =
    751         browserAccessibility_->manager()->GetFromID(labelledby_ids[0]);
    752     if (titleElement)
    753       return titleElement->ToBrowserAccessibilityCocoa();
    754   }
    755 
    756   return nil;
    757 }
    758 
    759 - (NSURL*)url {
    760   StringAttribute urlAttribute =
    761       [[self role] isEqualToString:@"AXWebArea"] ?
    762           ui::AX_ATTR_DOC_URL :
    763           ui::AX_ATTR_URL;
    764 
    765   std::string urlStr = browserAccessibility_->GetStringAttribute(urlAttribute);
    766   if (urlStr.empty())
    767     return nil;
    768 
    769   return [NSURL URLWithString:(base::SysUTF8ToNSString(urlStr))];
    770 }
    771 
    772 - (id)value {
    773   // WebCore uses an attachmentView to get the below behavior.
    774   // We do not have any native views backing this object, so need
    775   // to approximate Cocoa ax behavior best as we can.
    776   NSString* role = [self role];
    777   if ([role isEqualToString:@"AXHeading"]) {
    778     int level = 0;
    779     if (browserAccessibility_->GetIntAttribute(
    780             ui::AX_ATTR_HIERARCHICAL_LEVEL, &level)) {
    781       return [NSNumber numberWithInt:level];
    782     }
    783   } else if ([role isEqualToString:NSAccessibilityButtonRole]) {
    784     // AXValue does not make sense for pure buttons.
    785     return @"";
    786   } else if ([self internalRole] == ui::AX_ROLE_TOGGLE_BUTTON) {
    787     int value = 0;
    788     bool isAriaPressedDefined;
    789     bool isMixed;
    790     value = browserAccessibility_->GetAriaTristate(
    791         "aria-pressed", &isAriaPressedDefined, &isMixed) ? 1 : 0;
    792 
    793     if (isMixed)
    794       value = 2;
    795 
    796     return [NSNumber numberWithInt:value];
    797 
    798   } else if ([role isEqualToString:NSAccessibilityCheckBoxRole] ||
    799              [role isEqualToString:NSAccessibilityRadioButtonRole]) {
    800     int value = 0;
    801     value = GetState(
    802         browserAccessibility_, ui::AX_STATE_CHECKED) ? 1 : 0;
    803     value = GetState(
    804         browserAccessibility_, ui::AX_STATE_SELECTED) ?
    805             1 :
    806             value;
    807 
    808     if (browserAccessibility_->GetBoolAttribute(
    809         ui::AX_ATTR_BUTTON_MIXED)) {
    810       value = 2;
    811     }
    812     return [NSNumber numberWithInt:value];
    813   } else if ([role isEqualToString:NSAccessibilityProgressIndicatorRole] ||
    814              [role isEqualToString:NSAccessibilitySliderRole] ||
    815              [role isEqualToString:NSAccessibilityScrollBarRole]) {
    816     float floatValue;
    817     if (browserAccessibility_->GetFloatAttribute(
    818             ui::AX_ATTR_VALUE_FOR_RANGE, &floatValue)) {
    819       return [NSNumber numberWithFloat:floatValue];
    820     }
    821   } else if ([role isEqualToString:NSAccessibilityColorWellRole]) {
    822     int r = browserAccessibility_->GetIntAttribute(
    823         ui::AX_ATTR_COLOR_VALUE_RED);
    824     int g = browserAccessibility_->GetIntAttribute(
    825         ui::AX_ATTR_COLOR_VALUE_GREEN);
    826     int b = browserAccessibility_->GetIntAttribute(
    827         ui::AX_ATTR_COLOR_VALUE_BLUE);
    828     // This string matches the one returned by a native Mac color well.
    829     return [NSString stringWithFormat:@"rgb %7.5f %7.5f %7.5f 1",
    830                 r / 255., g / 255., b / 255.];
    831   }
    832 
    833   return NSStringForStringAttribute(
    834       browserAccessibility_, ui::AX_ATTR_VALUE);
    835 }
    836 
    837 - (NSString*)valueDescription {
    838   return NSStringForStringAttribute(
    839       browserAccessibility_, ui::AX_ATTR_VALUE);
    840 }
    841 
    842 - (NSValue*)visibleCharacterRange {
    843   return [NSValue valueWithRange:
    844       NSMakeRange(0, browserAccessibility_->value().length())];
    845 }
    846 
    847 - (NSArray*)visibleCells {
    848   NSMutableArray* ret = [[[NSMutableArray alloc] init] autorelease];
    849   const std::vector<int32>& uniqueCellIds =
    850       browserAccessibility_->GetIntListAttribute(
    851           ui::AX_ATTR_UNIQUE_CELL_IDS);
    852   for (size_t i = 0; i < uniqueCellIds.size(); ++i) {
    853     int id = uniqueCellIds[i];
    854     BrowserAccessibility* cell =
    855         browserAccessibility_->manager()->GetFromID(id);
    856     if (cell)
    857       [ret addObject:cell->ToBrowserAccessibilityCocoa()];
    858   }
    859   return ret;
    860 }
    861 
    862 - (NSArray*)visibleChildren {
    863   NSMutableArray* ret = [[[NSMutableArray alloc] init] autorelease];
    864   uint32 childCount = browserAccessibility_->PlatformChildCount();
    865   for (uint32 index = 0; index < childCount; ++index) {
    866     BrowserAccessibilityCocoa* child =
    867         browserAccessibility_->PlatformGetChild(index)->
    868             ToBrowserAccessibilityCocoa();
    869     [ret addObject:child];
    870   }
    871   return ret;
    872 }
    873 
    874 - (NSArray*)visibleColumns {
    875   return [self columns];
    876 }
    877 
    878 - (NSArray*)visibleRows {
    879   return [self rows];
    880 }
    881 
    882 - (NSNumber*)visited {
    883   return [NSNumber numberWithBool:
    884       GetState(browserAccessibility_, ui::AX_STATE_VISITED)];
    885 }
    886 
    887 - (id)window {
    888   if (!browserAccessibility_)
    889     return nil;
    890 
    891   BrowserAccessibilityManagerMac* manager =
    892       static_cast<BrowserAccessibilityManagerMac*>(
    893           browserAccessibility_->manager());
    894   return [manager->parent_view() window];
    895 }
    896 
    897 - (NSString*)methodNameForAttribute:(NSString*)attribute {
    898   return [attributeToMethodNameMap objectForKey:attribute];
    899 }
    900 
    901 - (void)swapChildren:(base::scoped_nsobject<NSMutableArray>*)other {
    902   children_.swap(*other);
    903 }
    904 
    905 // Returns the accessibility value for the given attribute.  If the value isn't
    906 // supported this will return nil.
    907 - (id)accessibilityAttributeValue:(NSString*)attribute {
    908   if (!browserAccessibility_)
    909     return nil;
    910 
    911   SEL selector =
    912       NSSelectorFromString([self methodNameForAttribute:attribute]);
    913   if (selector)
    914     return [self performSelector:selector];
    915 
    916   // TODO(dtseng): refactor remaining attributes.
    917   int selStart, selEnd;
    918   if (browserAccessibility_->GetIntAttribute(
    919           ui::AX_ATTR_TEXT_SEL_START, &selStart) &&
    920       browserAccessibility_->
    921           GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, &selEnd)) {
    922     if (selStart > selEnd)
    923       std::swap(selStart, selEnd);
    924     int selLength = selEnd - selStart;
    925     if ([attribute isEqualToString:
    926         NSAccessibilityInsertionPointLineNumberAttribute]) {
    927       const std::vector<int32>& line_breaks =
    928           browserAccessibility_->GetIntListAttribute(
    929               ui::AX_ATTR_LINE_BREAKS);
    930       for (int i = 0; i < static_cast<int>(line_breaks.size()); ++i) {
    931         if (line_breaks[i] > selStart)
    932           return [NSNumber numberWithInt:i];
    933       }
    934       return [NSNumber numberWithInt:static_cast<int>(line_breaks.size())];
    935     }
    936     if ([attribute isEqualToString:NSAccessibilitySelectedTextAttribute]) {
    937       std::string value = browserAccessibility_->GetStringAttribute(
    938           ui::AX_ATTR_VALUE);
    939       return base::SysUTF8ToNSString(value.substr(selStart, selLength));
    940     }
    941     if ([attribute isEqualToString:NSAccessibilitySelectedTextRangeAttribute]) {
    942       return [NSValue valueWithRange:NSMakeRange(selStart, selLength)];
    943     }
    944   }
    945   return nil;
    946 }
    947 
    948 // Returns the accessibility value for the given attribute and parameter. If the
    949 // value isn't supported this will return nil.
    950 - (id)accessibilityAttributeValue:(NSString*)attribute
    951                      forParameter:(id)parameter {
    952   if (!browserAccessibility_)
    953     return nil;
    954 
    955   const std::vector<int32>& line_breaks =
    956       browserAccessibility_->GetIntListAttribute(
    957           ui::AX_ATTR_LINE_BREAKS);
    958   int len = static_cast<int>(browserAccessibility_->value().size());
    959 
    960   if ([attribute isEqualToString:
    961       NSAccessibilityStringForRangeParameterizedAttribute]) {
    962     NSRange range = [(NSValue*)parameter rangeValue];
    963     std::string value = browserAccessibility_->GetStringAttribute(
    964         ui::AX_ATTR_VALUE);
    965     return base::SysUTF8ToNSString(value.substr(range.location, range.length));
    966   }
    967 
    968   if ([attribute isEqualToString:
    969       NSAccessibilityLineForIndexParameterizedAttribute]) {
    970     int index = [(NSNumber*)parameter intValue];
    971     for (int i = 0; i < static_cast<int>(line_breaks.size()); ++i) {
    972       if (line_breaks[i] > index)
    973         return [NSNumber numberWithInt:i];
    974     }
    975     return [NSNumber numberWithInt:static_cast<int>(line_breaks.size())];
    976   }
    977 
    978   if ([attribute isEqualToString:
    979       NSAccessibilityRangeForLineParameterizedAttribute]) {
    980     int line_index = [(NSNumber*)parameter intValue];
    981     int line_count = static_cast<int>(line_breaks.size()) + 1;
    982     if (line_index < 0 || line_index >= line_count)
    983       return nil;
    984     int start = line_index > 0 ? line_breaks[line_index - 1] : 0;
    985     int end = line_index < line_count - 1 ? line_breaks[line_index] : len;
    986     return [NSValue valueWithRange:
    987         NSMakeRange(start, end - start)];
    988   }
    989 
    990   if ([attribute isEqualToString:
    991       NSAccessibilityCellForColumnAndRowParameterizedAttribute]) {
    992     if ([self internalRole] != ui::AX_ROLE_TABLE &&
    993         [self internalRole] != ui::AX_ROLE_GRID) {
    994       return nil;
    995     }
    996     if (![parameter isKindOfClass:[NSArray self]])
    997       return nil;
    998     NSArray* array = parameter;
    999     int column = [[array objectAtIndex:0] intValue];
   1000     int row = [[array objectAtIndex:1] intValue];
   1001     int num_columns = browserAccessibility_->GetIntAttribute(
   1002         ui::AX_ATTR_TABLE_COLUMN_COUNT);
   1003     int num_rows = browserAccessibility_->GetIntAttribute(
   1004         ui::AX_ATTR_TABLE_ROW_COUNT);
   1005     if (column < 0 || column >= num_columns ||
   1006         row < 0 || row >= num_rows) {
   1007       return nil;
   1008     }
   1009     for (size_t i = 0;
   1010          i < browserAccessibility_->PlatformChildCount();
   1011          ++i) {
   1012       BrowserAccessibility* child = browserAccessibility_->PlatformGetChild(i);
   1013       if (child->GetRole() != ui::AX_ROLE_ROW)
   1014         continue;
   1015       int rowIndex;
   1016       if (!child->GetIntAttribute(
   1017               ui::AX_ATTR_TABLE_ROW_INDEX, &rowIndex)) {
   1018         continue;
   1019       }
   1020       if (rowIndex < row)
   1021         continue;
   1022       if (rowIndex > row)
   1023         break;
   1024       for (size_t j = 0;
   1025            j < child->PlatformChildCount();
   1026            ++j) {
   1027         BrowserAccessibility* cell = child->PlatformGetChild(j);
   1028         if (cell->GetRole() != ui::AX_ROLE_CELL)
   1029           continue;
   1030         int colIndex;
   1031         if (!cell->GetIntAttribute(
   1032                 ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX,
   1033                 &colIndex)) {
   1034           continue;
   1035         }
   1036         if (colIndex == column)
   1037           return cell->ToBrowserAccessibilityCocoa();
   1038         if (colIndex > column)
   1039           break;
   1040       }
   1041     }
   1042     return nil;
   1043   }
   1044 
   1045   if ([attribute isEqualToString:
   1046       NSAccessibilityBoundsForRangeParameterizedAttribute]) {
   1047     if ([self internalRole] != ui::AX_ROLE_STATIC_TEXT)
   1048       return nil;
   1049     NSRange range = [(NSValue*)parameter rangeValue];
   1050     gfx::Rect rect = browserAccessibility_->GetGlobalBoundsForRange(
   1051         range.location, range.length);
   1052     NSPoint origin = NSMakePoint(rect.x(), rect.y());
   1053     NSSize size = NSMakeSize(rect.width(), rect.height());
   1054     NSPoint pointInScreen = [self pointInScreen:origin size:size];
   1055     NSRect nsrect = NSMakeRect(
   1056         pointInScreen.x, pointInScreen.y, rect.width(), rect.height());
   1057     return [NSValue valueWithRect:nsrect];
   1058   }
   1059 
   1060   // TODO(dtseng): support the following attributes.
   1061   if ([attribute isEqualTo:
   1062           NSAccessibilityRangeForPositionParameterizedAttribute] ||
   1063       [attribute isEqualTo:
   1064           NSAccessibilityRangeForIndexParameterizedAttribute] ||
   1065       [attribute isEqualTo:NSAccessibilityRTFForRangeParameterizedAttribute] ||
   1066       [attribute isEqualTo:
   1067           NSAccessibilityStyleRangeForIndexParameterizedAttribute]) {
   1068     return nil;
   1069   }
   1070   return nil;
   1071 }
   1072 
   1073 // Returns an array of parameterized attributes names that this object will
   1074 // respond to.
   1075 - (NSArray*)accessibilityParameterizedAttributeNames {
   1076   if (!browserAccessibility_)
   1077     return nil;
   1078 
   1079   if ([[self role] isEqualToString:NSAccessibilityTableRole] ||
   1080       [[self role] isEqualToString:NSAccessibilityGridRole]) {
   1081     return [NSArray arrayWithObjects:
   1082         NSAccessibilityCellForColumnAndRowParameterizedAttribute,
   1083         nil];
   1084   }
   1085   if ([[self role] isEqualToString:NSAccessibilityTextFieldRole] ||
   1086       [[self role] isEqualToString:NSAccessibilityTextAreaRole]) {
   1087     return [NSArray arrayWithObjects:
   1088         NSAccessibilityLineForIndexParameterizedAttribute,
   1089         NSAccessibilityRangeForLineParameterizedAttribute,
   1090         NSAccessibilityStringForRangeParameterizedAttribute,
   1091         NSAccessibilityRangeForPositionParameterizedAttribute,
   1092         NSAccessibilityRangeForIndexParameterizedAttribute,
   1093         NSAccessibilityBoundsForRangeParameterizedAttribute,
   1094         NSAccessibilityRTFForRangeParameterizedAttribute,
   1095         NSAccessibilityAttributedStringForRangeParameterizedAttribute,
   1096         NSAccessibilityStyleRangeForIndexParameterizedAttribute,
   1097         nil];
   1098   }
   1099   if ([self internalRole] == ui::AX_ROLE_STATIC_TEXT) {
   1100     return [NSArray arrayWithObjects:
   1101         NSAccessibilityBoundsForRangeParameterizedAttribute,
   1102         nil];
   1103   }
   1104   return nil;
   1105 }
   1106 
   1107 // Returns an array of action names that this object will respond to.
   1108 - (NSArray*)accessibilityActionNames {
   1109   if (!browserAccessibility_)
   1110     return nil;
   1111 
   1112   NSMutableArray* ret =
   1113       [NSMutableArray arrayWithObject:NSAccessibilityShowMenuAction];
   1114   NSString* role = [self role];
   1115   // TODO(dtseng): this should only get set when there's a default action.
   1116   if (![role isEqualToString:NSAccessibilityStaticTextRole] &&
   1117       ![role isEqualToString:NSAccessibilityTextAreaRole] &&
   1118       ![role isEqualToString:NSAccessibilityTextFieldRole]) {
   1119     [ret addObject:NSAccessibilityPressAction];
   1120   }
   1121 
   1122   return ret;
   1123 }
   1124 
   1125 // Returns a sub-array of values for the given attribute value, starting at
   1126 // index, with up to maxCount items.  If the given index is out of bounds,
   1127 // or there are no values for the given attribute, it will return nil.
   1128 // This method is used for querying subsets of values, without having to
   1129 // return a large set of data, such as elements with a large number of
   1130 // children.
   1131 - (NSArray*)accessibilityArrayAttributeValues:(NSString*)attribute
   1132                                         index:(NSUInteger)index
   1133                                      maxCount:(NSUInteger)maxCount {
   1134   if (!browserAccessibility_)
   1135     return nil;
   1136 
   1137   NSArray* fullArray = [self accessibilityAttributeValue:attribute];
   1138   if (!fullArray)
   1139     return nil;
   1140   NSUInteger arrayCount = [fullArray count];
   1141   if (index >= arrayCount)
   1142     return nil;
   1143   NSRange subRange;
   1144   if ((index + maxCount) > arrayCount) {
   1145     subRange = NSMakeRange(index, arrayCount - index);
   1146   } else {
   1147     subRange = NSMakeRange(index, maxCount);
   1148   }
   1149   return [fullArray subarrayWithRange:subRange];
   1150 }
   1151 
   1152 // Returns the count of the specified accessibility array attribute.
   1153 - (NSUInteger)accessibilityArrayAttributeCount:(NSString*)attribute {
   1154   if (!browserAccessibility_)
   1155     return 0;
   1156 
   1157   NSArray* fullArray = [self accessibilityAttributeValue:attribute];
   1158   return [fullArray count];
   1159 }
   1160 
   1161 // Returns the list of accessibility attributes that this object supports.
   1162 - (NSArray*)accessibilityAttributeNames {
   1163   if (!browserAccessibility_)
   1164     return nil;
   1165 
   1166   // General attributes.
   1167   NSMutableArray* ret = [NSMutableArray arrayWithObjects:
   1168       NSAccessibilityChildrenAttribute,
   1169       NSAccessibilityDescriptionAttribute,
   1170       NSAccessibilityEnabledAttribute,
   1171       NSAccessibilityFocusedAttribute,
   1172       NSAccessibilityHelpAttribute,
   1173       NSAccessibilityLinkedUIElementsAttribute,
   1174       NSAccessibilityParentAttribute,
   1175       NSAccessibilityPositionAttribute,
   1176       NSAccessibilityRoleAttribute,
   1177       NSAccessibilityRoleDescriptionAttribute,
   1178       NSAccessibilitySizeAttribute,
   1179       NSAccessibilitySubroleAttribute,
   1180       NSAccessibilityTitleAttribute,
   1181       NSAccessibilityTopLevelUIElementAttribute,
   1182       NSAccessibilityValueAttribute,
   1183       NSAccessibilityWindowAttribute,
   1184       @"AXAccessKey",
   1185       @"AXInvalid",
   1186       @"AXRequired",
   1187       @"AXVisited",
   1188       nil];
   1189 
   1190   // Specific role attributes.
   1191   NSString* role = [self role];
   1192   NSString* subrole = [self subrole];
   1193   if ([role isEqualToString:NSAccessibilityTableRole] ||
   1194       [role isEqualToString:NSAccessibilityGridRole]) {
   1195     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1196         NSAccessibilityColumnsAttribute,
   1197         NSAccessibilityVisibleColumnsAttribute,
   1198         NSAccessibilityRowsAttribute,
   1199         NSAccessibilityVisibleRowsAttribute,
   1200         NSAccessibilityVisibleCellsAttribute,
   1201         NSAccessibilityHeaderAttribute,
   1202         NSAccessibilityColumnHeaderUIElementsAttribute,
   1203         NSAccessibilityRowHeaderUIElementsAttribute,
   1204         nil]];
   1205   } else if ([role isEqualToString:NSAccessibilityColumnRole]) {
   1206     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1207         NSAccessibilityIndexAttribute,
   1208         NSAccessibilityHeaderAttribute,
   1209         NSAccessibilityRowsAttribute,
   1210         NSAccessibilityVisibleRowsAttribute,
   1211         nil]];
   1212   } else if ([role isEqualToString:NSAccessibilityCellRole]) {
   1213     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1214         NSAccessibilityColumnIndexRangeAttribute,
   1215         NSAccessibilityRowIndexRangeAttribute,
   1216         nil]];
   1217   } else if ([role isEqualToString:@"AXWebArea"]) {
   1218     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1219         @"AXLoaded",
   1220         @"AXLoadingProgress",
   1221         nil]];
   1222   } else if ([role isEqualToString:NSAccessibilityTextFieldRole] ||
   1223              [role isEqualToString:NSAccessibilityTextAreaRole]) {
   1224     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1225         NSAccessibilityInsertionPointLineNumberAttribute,
   1226         NSAccessibilityNumberOfCharactersAttribute,
   1227         NSAccessibilitySelectedTextAttribute,
   1228         NSAccessibilitySelectedTextRangeAttribute,
   1229         NSAccessibilityVisibleCharacterRangeAttribute,
   1230         nil]];
   1231   } else if ([role isEqualToString:NSAccessibilityTabGroupRole]) {
   1232     [ret addObject:NSAccessibilityTabsAttribute];
   1233   } else if ([role isEqualToString:NSAccessibilityProgressIndicatorRole] ||
   1234              [role isEqualToString:NSAccessibilitySliderRole] ||
   1235              [role isEqualToString:NSAccessibilityScrollBarRole]) {
   1236     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1237         NSAccessibilityMaxValueAttribute,
   1238         NSAccessibilityMinValueAttribute,
   1239         NSAccessibilityOrientationAttribute,
   1240         NSAccessibilityValueDescriptionAttribute,
   1241         nil]];
   1242   } else if ([subrole isEqualToString:NSAccessibilityOutlineRowSubrole]) {
   1243     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1244         NSAccessibilityDisclosingAttribute,
   1245         NSAccessibilityDisclosedByRowAttribute,
   1246         NSAccessibilityDisclosureLevelAttribute,
   1247         NSAccessibilityDisclosedRowsAttribute,
   1248         nil]];
   1249   } else if ([role isEqualToString:NSAccessibilityRowRole]) {
   1250     if (browserAccessibility_->GetParent()) {
   1251       base::string16 parentRole;
   1252       browserAccessibility_->GetParent()->GetHtmlAttribute(
   1253           "role", &parentRole);
   1254       const base::string16 treegridRole(base::ASCIIToUTF16("treegrid"));
   1255       if (parentRole == treegridRole) {
   1256         [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1257             NSAccessibilityDisclosingAttribute,
   1258             NSAccessibilityDisclosedByRowAttribute,
   1259             NSAccessibilityDisclosureLevelAttribute,
   1260             NSAccessibilityDisclosedRowsAttribute,
   1261             nil]];
   1262       } else {
   1263         [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1264             NSAccessibilityIndexAttribute,
   1265             nil]];
   1266       }
   1267     }
   1268   } else if ([role isEqualToString:NSAccessibilityListRole]) {
   1269     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1270         NSAccessibilityOrientationAttribute,
   1271         NSAccessibilitySelectedChildrenAttribute,
   1272         NSAccessibilityVisibleChildrenAttribute,
   1273         nil]];
   1274   }
   1275 
   1276   // Add the url attribute only if it has a valid url.
   1277   if ([self url] != nil) {
   1278     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1279         NSAccessibilityURLAttribute,
   1280         nil]];
   1281   }
   1282 
   1283   // Live regions.
   1284   if (browserAccessibility_->HasStringAttribute(
   1285           ui::AX_ATTR_LIVE_STATUS)) {
   1286     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1287         @"AXARIALive",
   1288         @"AXARIARelevant",
   1289         nil]];
   1290   }
   1291   if (browserAccessibility_->HasStringAttribute(
   1292           ui::AX_ATTR_CONTAINER_LIVE_STATUS)) {
   1293     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1294         @"AXARIAAtomic",
   1295         @"AXARIABusy",
   1296         nil]];
   1297   }
   1298 
   1299   // Title UI Element.
   1300   if (browserAccessibility_->HasIntAttribute(ui::AX_ATTR_TITLE_UI_ELEMENT) ||
   1301       (browserAccessibility_->HasIntListAttribute(ui::AX_ATTR_LABELLEDBY_IDS) &&
   1302        browserAccessibility_->GetIntListAttribute(ui::AX_ATTR_LABELLEDBY_IDS)
   1303                             .size() == 1)) {
   1304     [ret addObjectsFromArray:[NSArray arrayWithObjects:
   1305          NSAccessibilityTitleUIElementAttribute,
   1306          nil]];
   1307   }
   1308   // TODO(aboxhall): expose NSAccessibilityServesAsTitleForUIElementsAttribute
   1309   // for elements which are referred to by labelledby or are labels
   1310 
   1311   return ret;
   1312 }
   1313 
   1314 // Returns the index of the child in this objects array of children.
   1315 - (NSUInteger)accessibilityGetIndexOf:(id)child {
   1316   if (!browserAccessibility_)
   1317     return 0;
   1318 
   1319   NSUInteger index = 0;
   1320   for (BrowserAccessibilityCocoa* childToCheck in [self children]) {
   1321     if ([child isEqual:childToCheck])
   1322       return index;
   1323     ++index;
   1324   }
   1325   return NSNotFound;
   1326 }
   1327 
   1328 // Returns whether or not the specified attribute can be set by the
   1329 // accessibility API via |accessibilitySetValue:forAttribute:|.
   1330 - (BOOL)accessibilityIsAttributeSettable:(NSString*)attribute {
   1331   if (!browserAccessibility_)
   1332     return NO;
   1333 
   1334   if ([attribute isEqualToString:NSAccessibilityFocusedAttribute])
   1335     return GetState(browserAccessibility_,
   1336         ui::AX_STATE_FOCUSABLE);
   1337   if ([attribute isEqualToString:NSAccessibilityValueAttribute]) {
   1338     return browserAccessibility_->GetBoolAttribute(
   1339         ui::AX_ATTR_CAN_SET_VALUE);
   1340   }
   1341   if ([attribute isEqualToString:NSAccessibilitySelectedTextRangeAttribute] &&
   1342       ([[self role] isEqualToString:NSAccessibilityTextFieldRole] ||
   1343        [[self role] isEqualToString:NSAccessibilityTextAreaRole]))
   1344     return YES;
   1345 
   1346   return NO;
   1347 }
   1348 
   1349 // Returns whether or not this object should be ignored in the accessibilty
   1350 // tree.
   1351 - (BOOL)accessibilityIsIgnored {
   1352   if (!browserAccessibility_)
   1353     return true;
   1354 
   1355   return [self isIgnored];
   1356 }
   1357 
   1358 // Performs the given accessibilty action on the webkit accessibility object
   1359 // that backs this object.
   1360 - (void)accessibilityPerformAction:(NSString*)action {
   1361   if (!browserAccessibility_)
   1362     return;
   1363 
   1364   // TODO(dmazzoni): Support more actions.
   1365   if ([action isEqualToString:NSAccessibilityPressAction]) {
   1366     [self delegate]->AccessibilityDoDefaultAction(
   1367         browserAccessibility_->GetId());
   1368   } else if ([action isEqualToString:NSAccessibilityShowMenuAction]) {
   1369     NSPoint objOrigin = [self origin];
   1370     NSSize size = [[self size] sizeValue];
   1371     gfx::Point origin = [self delegate]->AccessibilityOriginInScreen(
   1372         gfx::Rect(objOrigin.x, objOrigin.y, size.width, size.height));
   1373     origin.Offset(size.width / 2, size.height / 2);
   1374     [self delegate]->AccessibilityShowMenu(origin);
   1375   }
   1376 }
   1377 
   1378 // Returns the description of the given action.
   1379 - (NSString*)accessibilityActionDescription:(NSString*)action {
   1380   if (!browserAccessibility_)
   1381     return nil;
   1382 
   1383   return NSAccessibilityActionDescription(action);
   1384 }
   1385 
   1386 // Sets an override value for a specific accessibility attribute.
   1387 // This class does not support this.
   1388 - (BOOL)accessibilitySetOverrideValue:(id)value
   1389                          forAttribute:(NSString*)attribute {
   1390   return NO;
   1391 }
   1392 
   1393 // Sets the value for an accessibility attribute via the accessibility API.
   1394 - (void)accessibilitySetValue:(id)value forAttribute:(NSString*)attribute {
   1395   if (!browserAccessibility_)
   1396     return;
   1397 
   1398   if ([attribute isEqualToString:NSAccessibilityFocusedAttribute]) {
   1399     BrowserAccessibilityManager* manager = browserAccessibility_->manager();
   1400     NSNumber* focusedNumber = value;
   1401     BOOL focused = [focusedNumber intValue];
   1402     if (focused)
   1403       manager->SetFocus(browserAccessibility_, true);
   1404   }
   1405   if ([attribute isEqualToString:NSAccessibilitySelectedTextRangeAttribute]) {
   1406     NSRange range = [(NSValue*)value rangeValue];
   1407     [self delegate]->AccessibilitySetTextSelection(
   1408         browserAccessibility_->GetId(),
   1409         range.location, range.location + range.length);
   1410   }
   1411 }
   1412 
   1413 // Returns the deepest accessibility child that should not be ignored.
   1414 // It is assumed that the hit test has been narrowed down to this object
   1415 // or one of its children, so this will never return nil unless this
   1416 // object is invalid.
   1417 - (id)accessibilityHitTest:(NSPoint)point {
   1418   if (!browserAccessibility_)
   1419     return nil;
   1420 
   1421   BrowserAccessibilityCocoa* hit = self;
   1422   for (BrowserAccessibilityCocoa* child in [self children]) {
   1423     if (!child->browserAccessibility_)
   1424       continue;
   1425     NSPoint origin = [child origin];
   1426     NSSize size = [[child size] sizeValue];
   1427     NSRect rect;
   1428     rect.origin = origin;
   1429     rect.size = size;
   1430     if (NSPointInRect(point, rect)) {
   1431       hit = child;
   1432       id childResult = [child accessibilityHitTest:point];
   1433       if (![childResult accessibilityIsIgnored]) {
   1434         hit = childResult;
   1435         break;
   1436       }
   1437     }
   1438   }
   1439   return NSAccessibilityUnignoredAncestor(hit);
   1440 }
   1441 
   1442 - (BOOL)isEqual:(id)object {
   1443   if (![object isKindOfClass:[BrowserAccessibilityCocoa class]])
   1444     return NO;
   1445   return ([self hash] == [object hash]);
   1446 }
   1447 
   1448 - (NSUInteger)hash {
   1449   // Potentially called during dealloc.
   1450   if (!browserAccessibility_)
   1451     return [super hash];
   1452   return browserAccessibility_->GetId();
   1453 }
   1454 
   1455 - (BOOL)accessibilityShouldUseUniqueId {
   1456   return YES;
   1457 }
   1458 
   1459 @end
   1460 
   1461