Include relationship ARIA objects in serialized accessibility tree

content/browser/accessibility/accessibility_tree_formatter_mac.mm

 // Copyright (c) 2012 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.
 
 #include "content/browser/accessibility/accessibility_tree_formatter.h"
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
@@ skipping 65 matching lines @@
   return rangeDict.Pass();
 }
 
 // Returns true if |value| is an NSValue containing a NSRange.
 bool IsRangeValue(id value) {
   if (![value isKindOfClass:[NSValue class]])
     return false;
   return 0 == strcmp([value objCType], @encode(NSRange));
 }
 
+scoped_ptr<base::Value> PopulateObject(id value);
+
+scoped_ptr<base::ListValue> PopulateArray(NSArray* array) {
+  scoped_ptr<base::ListValue> list(new base::ListValue);
+  for (NSUInteger i = 0; i < [array count]; i++)
+    list->Append(PopulateObject([array objectAtIndex:i]).release());
+  return list.Pass();
+}
+
+scoped_ptr<base::StringValue> StringForBrowserAccessibility(
+    BrowserAccessibilityCocoa* obj) {
+  NSString* description = [obj role];
+  id value = [obj value];
+  id roleDescription = [obj roleDescription];
+  if (value != nil && ![value isEqualToString:@""]) {
+    description = [NSString stringWithFormat:@"%@ %@", description, value];
+  } else if ([description isEqualToString:NSAccessibilityGroupRole] &&
+           roleDescription != nil &&
+           ![roleDescription isEqualToString:@""]) {
+    description = [NSString stringWithFormat:@"%@ %@",
+                            description, roleDescription];
+  }
+  return scoped_ptr<base::StringValue>(
+      new base::StringValue(SysNSStringToUTF16(description))).Pass();
+}
+
+scoped_ptr<base::Value> PopulateObject(id value) {
+  if ([value isKindOfClass:[NSArray class]])
+    return scoped_ptr<base::Value>(PopulateArray((NSArray*) value));
+  if (IsRangeValue(value))
+    return scoped_ptr<base::Value>(PopulateRange([value rangeValue]));
+  if ([value isKindOfClass:[BrowserAccessibilityCocoa class]]) {
+    std::string str;
+    StringForBrowserAccessibility(value)->GetAsString(&str);
+    return scoped_ptr<base::Value>(StringForBrowserAccessibility(
+        (BrowserAccessibilityCocoa*) value));
+  }
+
+  return scoped_ptr<base::Value>(
+      new base::StringValue(
+          SysNSStringToUTF16([NSString stringWithFormat:@"%@", value]))).Pass();
+}
+
 NSArray* BuildAllAttributesArray() {
   NSArray* array = [NSArray arrayWithObjects:
       NSAccessibilityRoleDescriptionAttribute,
       NSAccessibilityTitleAttribute,
       NSAccessibilityValueAttribute,
       NSAccessibilityMinValueAttribute,
       NSAccessibilityMaxValueAttribute,
       NSAccessibilityValueDescriptionAttribute,
       NSAccessibilityDescriptionAttribute,
       NSAccessibilityHelpAttribute,
       @"AXInvalid",
       NSAccessibilityDisclosingAttribute,
       NSAccessibilityDisclosureLevelAttribute,
       @"AXAccessKey",
       @"AXARIAAtomic",
       @"AXARIABusy",
       @"AXARIALive",
       @"AXARIARelevant",
       NSAccessibilityColumnIndexRangeAttribute,
       NSAccessibilityEnabledAttribute,
       NSAccessibilityFocusedAttribute,
       NSAccessibilityIndexAttribute,
       @"AXLoaded",
       @"AXLoadingProcess",
       NSAccessibilityNumberOfCharactersAttribute,
       NSAccessibilityOrientationAttribute,
       @"AXRequired",
       NSAccessibilityRowIndexRangeAttribute,
+      NSAccessibilityTitleUIElementAttribute,
       NSAccessibilityURLAttribute,
       NSAccessibilityVisibleCharacterRangeAttribute,
       @"AXVisited",
+      @"AXLinkedUIElements",
       nil];
   return [array retain];
 }
 
 }  // namespace
 
 void AccessibilityTreeFormatter::Initialize() {
 }
 
 
 void AccessibilityTreeFormatter::AddProperties(const BrowserAccessibility& node,
                                                base::DictionaryValue* dict) {
   BrowserAccessibilityCocoa* cocoa_node =
       const_cast<BrowserAccessibility*>(&node)->ToBrowserAccessibilityCocoa();
   NSArray* supportedAttributes = [cocoa_node accessibilityAttributeNames];
 
   string role = SysNSStringToUTF8(
       [cocoa_node accessibilityAttributeValue:NSAccessibilityRoleAttribute]);
   dict->SetString(SysNSStringToUTF8(NSAccessibilityRoleAttribute), role);
 
   NSString* subrole =
       [cocoa_node accessibilityAttributeValue:NSAccessibilitySubroleAttribute];
   if (subrole != nil) {
     dict->SetString(SysNSStringToUTF8(NSAccessibilitySubroleAttribute),
                     SysNSStringToUTF8(subrole));
   }
 
   CR_DEFINE_STATIC_LOCAL(NSArray*, all_attributes, (BuildAllAttributesArray()));
   for (NSString* requestedAttribute in all_attributes) {
-    if (![supportedAttributes containsObject:requestedAttribute]) {
+    if (![supportedAttributes containsObject:requestedAttribute])
       continue;
-    }
     id value = [cocoa_node accessibilityAttributeValue:requestedAttribute];
-    if (IsRangeValue(value)) {
+    if (value != nil) {
       dict->Set(
           SysNSStringToUTF8(requestedAttribute),
-          PopulateRange([value rangeValue]).release());
-    } else if (value != nil) {
-      dict->SetString(
-          SysNSStringToUTF8(requestedAttribute),
-          SysNSStringToUTF16([NSString stringWithFormat:@"%@", value]));
+          PopulateObject(value).release());
     }
   }
   dict->Set(kPositionDictAttr, PopulatePosition(node).release());
   dict->Set(kSizeDictAttr, PopulateSize(cocoa_node).release());
 }
 
 base::string16 AccessibilityTreeFormatter::ToString(
     const base::DictionaryValue& dict,
     const base::string16& indent) {
   base::string16 line;
   NSArray* defaultAttributes =
       [NSArray arrayWithObjects:NSAccessibilityTitleAttribute,
                                 NSAccessibilityValueAttribute,
                                 nil];
   string s_value;
   dict.GetString(SysNSStringToUTF8(NSAccessibilityRoleAttribute), &s_value);
   WriteAttribute(true, base::UTF8ToUTF16(s_value), &line);
 
   string subroleAttribute = SysNSStringToUTF8(NSAccessibilitySubroleAttribute);
   if (dict.GetString(subroleAttribute, &s_value)) {
     WriteAttribute(false,
                    StringPrintf("%s=%s",
                                 subroleAttribute.c_str(), s_value.c_str()),
                    &line);
   }
 
   CR_DEFINE_STATIC_LOCAL(NSArray*, all_attributes, (BuildAllAttributesArray()));
   for (NSString* requestedAttribute in all_attributes) {
     string requestedAttributeUTF8 = SysNSStringToUTF8(requestedAttribute);
-    const base::DictionaryValue* d_value;
-    if (dict.GetDictionary(requestedAttributeUTF8, &d_value)) {
+    if (dict.GetString(requestedAttributeUTF8, &s_value)) {
+      WriteAttribute([defaultAttributes containsObject:requestedAttribute],
+                     StringPrintf("%s='%s'",
+                                  requestedAttributeUTF8.c_str(),
+                                  s_value.c_str()),
+                     &line);
+      continue;
+    }
+    const base::Value* value;
+    if (dict.Get(requestedAttributeUTF8, &value)) {
       std::string json_value;
-      base::JSONWriter::Write(d_value, &json_value);
+      base::JSONWriter::Write(value, &json_value);
       WriteAttribute(
           [defaultAttributes containsObject:requestedAttribute],
           StringPrintf("%s=%s",
                        requestedAttributeUTF8.c_str(),
                        json_value.c_str()),
           &line);
     }
-    if (!dict.GetString(requestedAttributeUTF8, &s_value))
-      continue;
-    WriteAttribute([defaultAttributes containsObject:requestedAttribute],
-                   StringPrintf("%s='%s'",
-                                requestedAttributeUTF8.c_str(),
-                                s_value.c_str()),
-                   &line);
   }
   const base::DictionaryValue* d_value = NULL;
   if (dict.GetDictionary(kPositionDictAttr, &d_value)) {
     WriteAttribute(false,
                    FormatCoordinates(kPositionDictAttr,
                                      kXCoordDictAttr, kYCoordDictAttr,
                                      *d_value),
                    &line);
   }
   if (dict.GetDictionary(kSizeDictAttr, &d_value)) {
@@ skipping 27 matching lines @@
 const string AccessibilityTreeFormatter::GetAllowString() {
   return "@MAC-ALLOW:";
 }
 
 // static
 const string AccessibilityTreeFormatter::GetDenyString() {
   return "@MAC-DENY:";
 }
 
 }  // namespace content