Modify AccessibilityTreeFormatter to build up an internal representation of the tree in the form of DictionaryValue et al. This may be used at a later stage to create a JSON representation of the tree.

Also modify the Mac platform implementation to use the NSAccessibility attribute names rather than method names.

BUG=

Review URL: https://chromiumcodereview.appspot.com/13479003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@194775 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 443 insertions, 197 deletions

diff --git a/content/browser/accessibility/accessibility_tree_formatter.cc b/content/browser/accessibility/accessibility_tree_formatter.cc
index 3904bc0..84f200a 100644
--- a/content/browser/accessibility/accessibility_tree_formatter.cc
+++ b/content/browser/accessibility/accessibility_tree_formatter.cc
@@ -7,6 +7,7 @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
@@ -18,11 +19,12 @@ namespace content {
 namespace {
 const int kIndentSpaces = 4;
 const char* kSkipString = "@NO_DUMP";
+const char* kChildrenDictAttr = "children";
 }
 
 AccessibilityTreeFormatter::AccessibilityTreeFormatter(
-    BrowserAccessibility* node)
-    : node_(node) {
+    BrowserAccessibility* root)
+    : root_(root) {
   Initialize();
 }
 
@@ -45,33 +47,59 @@ AccessibilityTreeFormatter* AccessibilityTreeFormatter::Create(
 AccessibilityTreeFormatter::~AccessibilityTreeFormatter() {
 }
 
+scoped_ptr<DictionaryValue>
+AccessibilityTreeFormatter::BuildAccessibilityTree() {
+  scoped_ptr<DictionaryValue> dict(new DictionaryValue);
+  RecursiveBuildAccessibilityTree(*root_, dict.get());
+  return dict.Pass();
+}
+
 void AccessibilityTreeFormatter::FormatAccessibilityTree(
     string16* contents) {
-  RecursiveFormatAccessibilityTree(node_, contents, 0);
+  scoped_ptr<DictionaryValue> dict = BuildAccessibilityTree();
+  RecursiveFormatAccessibilityTree(*(dict.get()), contents);
+}
+
+void AccessibilityTreeFormatter::RecursiveBuildAccessibilityTree(
+    const BrowserAccessibility& node, DictionaryValue* dict) {
+  AddProperties(node, dict);
+  ListValue* children = new ListValue;
+  dict->Set(kChildrenDictAttr, children);
+  for (size_t i = 0; i < node.children().size(); ++i) {
+    BrowserAccessibility* child_node = node.children()[i];
+    DictionaryValue* child_dict = new DictionaryValue;
+    children->Append(child_dict);
+    RecursiveBuildAccessibilityTree(*child_node, child_dict);
+  }
 }
 
 void AccessibilityTreeFormatter::RecursiveFormatAccessibilityTree(
-    BrowserAccessibility* node, string16* contents, int indent) {
-  scoped_ptr<char[]> prefix(new char[indent + 1]);
-  for (int i = 0; i < indent; ++i)
-    prefix[i] = ' ';
-  prefix[indent] = '\0';
-
-  string16 line = ToString(node, prefix.get());
+    const DictionaryValue& dict, string16* contents, int depth) {
+  string16 line = ToString(dict, string16(depth * kIndentSpaces, ' '));
   if (line.find(ASCIIToUTF16(kSkipString)) != string16::npos)
     return;
 
   *contents += line;
-  for (size_t i = 0; i < node->children().size(); ++i) {
-    RecursiveFormatAccessibilityTree(node->children()[i], contents,
-                                     indent + kIndentSpaces);
+  const ListValue* children;
+  dict.GetList(kChildrenDictAttr, &children);
+  const DictionaryValue* child_dict;
+  for (size_t i = 0; i < children->GetSize(); i++) {
+    children->GetDictionary(i, &child_dict);
+    RecursiveFormatAccessibilityTree(*child_dict, contents, depth + 1);
   }
 }
 
 #if (!defined(OS_WIN) && !defined(OS_MACOSX))
-string16 AccessibilityTreeFormatter::ToString(BrowserAccessibility* node,
-                                              char* prefix) {
-  return UTF8ToUTF16(prefix) + base::IntToString16(node->renderer_id()) +
+void AccessibilityTreeFormatter::AddProperties(const BrowserAccessibility& node,
+                                               DictionaryValue* dict) {
+  dict->SetInteger("id", node.renderer_id());
+}
+
+string16 AccessibilityTreeFormatter::ToString(const DictionaryValue& node,
+                                              const string16& indent) {
+  int id_value;
+  node.GetInteger("id", &id_value);
+  return indent + base::IntToString16(id_value) +
        ASCIIToUTF16("\n");
 }
 
@@ -127,23 +155,31 @@ bool AccessibilityTreeFormatter::MatchesFilters(
   return allow;
 }
 
-void AccessibilityTreeFormatter::StartLine() {
-  line_.clear();
+string16 AccessibilityTreeFormatter::FormatCoordinates(
+    const char* name, const char* x_name, const char* y_name,
+    const DictionaryValue& value) {
+  int x, y;
+  value.GetInteger(x_name, &x);
+  value.GetInteger(y_name, &y);
+  std::string xy_str(base::StringPrintf("%s=(%d, %d)", name, x, y));
+
+  return UTF8ToUTF16(xy_str);
+}
+
+void AccessibilityTreeFormatter::WriteAttribute(
+    bool include_by_default, const std::string& attr, string16* line) {
+  WriteAttribute(include_by_default, UTF8ToUTF16(attr), line);
 }
 
-void AccessibilityTreeFormatter::Add(
-    bool include_by_default, const string16& attr) {
+void AccessibilityTreeFormatter::WriteAttribute(
+    bool include_by_default, const string16& attr, string16* line) {
   if (attr.empty())
     return;
   if (!MatchesFilters(attr, include_by_default))
     return;
-  if (!line_.empty())
-    line_ += ASCIIToUTF16(" ");
-  line_ += attr;
-}
-
-string16 AccessibilityTreeFormatter::FinishLine() {
-  return line_;
+  if (!line->empty())
+    *line += ASCIIToUTF16(" ");
+  *line += attr;
 }
 
 }  // namespace content
diff --git a/content/browser/accessibility/accessibility_tree_formatter.h b/content/browser/accessibility/accessibility_tree_formatter.h
index ca51a68..17beff7 100644
--- a/content/browser/accessibility/accessibility_tree_formatter.h
+++ b/content/browser/accessibility/accessibility_tree_formatter.h
@@ -10,6 +10,7 @@
 #include "base/files/file_path.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
+#include "base/values.h"
 #include "content/browser/accessibility/browser_accessibility.h"
 #include "content/common/content_export.h"
 
@@ -23,11 +24,33 @@ class RenderViewHost;
 // implemented.
 class CONTENT_EXPORT AccessibilityTreeFormatter {
  public:
-  explicit AccessibilityTreeFormatter(BrowserAccessibility* node);
+  explicit AccessibilityTreeFormatter(BrowserAccessibility* root);
   virtual ~AccessibilityTreeFormatter();
 
   static AccessibilityTreeFormatter* Create(RenderViewHost* rvh);
 
+  // Populates the given DictionaryValue with the accessibility tree.
+  // The dictionary contains a key/value pair for each attribute of the node,
+  // plus a "children" attribute containing a list of all child nodes.
+  // {
+  //   "AXName": "node",  /* actual attributes will vary by platform */
+  //   "position": {  /* some attributes may be dictionaries */
+  //     "x": 0,
+  //     "y": 0
+  //   },
+  //   /* ... more attributes of |node| */
+  //   "children": [ {  /* list of children created recursively */
+  //     "AXName": "child node 1",
+  //     /* ... more attributes */
+  //     "children": [ ]
+  //   }, {
+  //     "AXName": "child name 2",
+  //     /* ... more attributes */
+  //     "children": [ ]
+  //   } ]
+  // }
+  scoped_ptr<DictionaryValue> BuildAccessibilityTree();
+
   // Dumps a BrowserAccessibility tree into a string.
   void FormatAccessibilityTree(string16* contents);
 
@@ -76,25 +99,45 @@ class CONTENT_EXPORT AccessibilityTreeFormatter {
   static const std::string GetDenyString();
 
  protected:
-  void RecursiveFormatAccessibilityTree(BrowserAccessibility* node,
+  void RecursiveFormatAccessibilityTree(const BrowserAccessibility& node,
                                         string16* contents,
                                         int indent);
+  void RecursiveBuildAccessibilityTree(const BrowserAccessibility& node,
+                                       DictionaryValue* tree_node);
+  void RecursiveFormatAccessibilityTree(const DictionaryValue& tree_node,
+                                        string16* contents,
+                                        int depth = 0);
+
+  // Overridden by each platform to add the required attributes for each node
+  // into the given dict.
+  void AddProperties(const BrowserAccessibility& node, DictionaryValue* dict);
+
+  string16 FormatCoordinates(const char* name,
+                             const char* x_name,
+                             const char* y_name,
+                             const DictionaryValue& value);
 
   // Returns a platform specific representation of a BrowserAccessibility.
   // Should be zero or more complete lines, each with |prefix| prepended
   // (to indent each line).
-  string16 ToString(BrowserAccessibility* node, char* prefix);
+  string16 ToString(const DictionaryValue& node, const string16& indent);
 
   void Initialize();
 
   bool MatchesFilters(const string16& text, bool default_result) const;
-  void StartLine();
-  void Add(bool include_by_default, const string16& attr);
-  string16 FinishLine();
 
-  BrowserAccessibility* node_;
+  // Writes the given attribute string out to |line| if it matches the filters.
+  void WriteAttribute(bool include_by_default,
+                      const string16& attr,
+                      string16* line);
+  void WriteAttribute(bool include_by_default,
+                      const std::string& attr,
+                      string16* line);
+
+  BrowserAccessibility* root_;
+
+  // Filters used when formatting the accessibility tree as text.
   std::vector<Filter> filters_;
-  string16 line_;
 
   DISALLOW_COPY_AND_ASSIGN(AccessibilityTreeFormatter);
 };
diff --git a/content/browser/accessibility/accessibility_tree_formatter_mac.mm b/content/browser/accessibility/accessibility_tree_formatter_mac.mm
index f5f1964..310bfeb 100644
--- a/content/browser/accessibility/accessibility_tree_formatter_mac.mm
+++ b/content/browser/accessibility/accessibility_tree_formatter_mac.mm
@@ -7,129 +7,173 @@
 #import <Cocoa/Cocoa.h>
 
 #include "base/files/file_path.h"
+#include "base/stringprintf.h"
+#include "base/strings/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_cocoa.h"
 #include "content/browser/accessibility/browser_accessibility_mac.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 
+using base::StringPrintf;
+using base::SysNSStringToUTF8;
+using base::SysNSStringToUTF16;
+using std::string;
+
 namespace content {
 
 namespace {
 
-string16 Format(const char *prefix,
-                id value,
-                const char *suffix) {
-  if (value == nil)
-    return UTF8ToUTF16("");
-  NSString* format_str =
-      [NSString stringWithFormat:@"%s%%@%s", prefix, suffix];
-  NSString* tmp = [NSString stringWithFormat:format_str, value];
-  return UTF8ToUTF16([tmp cStringUsingEncoding:NSUTF8StringEncoding]);
-}
-
-string16 FormatPosition(BrowserAccessibility* node) {
+NSArray* ALL_ATTRIBUTES = [NSArray arrayWithObjects:
+    NSAccessibilityRoleDescriptionAttribute,
+    NSAccessibilityTitleAttribute,
+    NSAccessibilityValueAttribute,
+    NSAccessibilityMinValueAttribute,
+    NSAccessibilityMaxValueAttribute,
+    NSAccessibilityValueDescriptionAttribute,
+    NSAccessibilityDescriptionAttribute,
+    NSAccessibilityHelpAttribute,
+    @"AXInvalid",
+    NSAccessibilityDisclosingAttribute,
+    NSAccessibilityDisclosureLevelAttribute,
+    @"AXAccessKey",
+    @"AXARIAAtomic",
+    @"AXARIABusy",
+    @"AXARIALive",
+    @"AXARIARelevant",
+    NSAccessibilityEnabledAttribute,
+    NSAccessibilityFocusedAttribute,
+    @"AXLoaded",
+    @"AXLoadingProcess",
+    NSAccessibilityNumberOfCharactersAttribute,
+    NSAccessibilityOrientationAttribute,
+    @"AXRequired",
+    NSAccessibilityURLAttribute,
+    NSAccessibilityVisibleCharacterRangeAttribute,
+    @"AXVisited",
+    nil];
+
+const char* kPositionDictAttr = "position";
+const char* kXCoordDictAttr = "x";
+const char* kYCoordDictAttr = "y";
+const char* kSizeDictAttr = "size";
+const char* kWidthDictAttr = "width";
+const char* kHeightDictAttr = "height";
+
+scoped_ptr<DictionaryValue> PopulatePosition(const BrowserAccessibility& node) {
+  scoped_ptr<DictionaryValue> position(new DictionaryValue);
   // The NSAccessibility position of an object is in global coordinates and
   // based on the lower-left corner of the object. To make this easier and less
   // confusing, convert it to local window coordinates using the top-left
   // corner when dumping the position.
-  BrowserAccessibility* root = node->manager()->GetRoot();
+  BrowserAccessibility* root = node.manager()->GetRoot();
   BrowserAccessibilityCocoa* cocoa_root = root->ToBrowserAccessibilityCocoa();
   NSPoint root_position = [[cocoa_root position] pointValue];
   NSSize root_size = [[cocoa_root size] sizeValue];
   int root_top = -static_cast<int>(root_position.y + root_size.height);
   int root_left = static_cast<int>(root_position.x);
 
-  BrowserAccessibilityCocoa* cocoa_node = node->ToBrowserAccessibilityCocoa();
+  BrowserAccessibilityCocoa* cocoa_node =
+      const_cast<BrowserAccessibility*>(&node)->ToBrowserAccessibilityCocoa();
   NSPoint node_position = [[cocoa_node position] pointValue];
   NSSize node_size = [[cocoa_node size] sizeValue];
 
-  NSString* position_str =
-      [NSString stringWithFormat:@"position=(%d, %d)",
-                static_cast<int>(node_position.x - root_left),
-                static_cast<int>(
-                    -node_position.y - node_size.height - root_top)];
-  return UTF8ToUTF16([position_str cStringUsingEncoding:NSUTF8StringEncoding]);
+  position->SetInteger(kXCoordDictAttr,
+                       static_cast<int>(node_position.x - root_left));
+  position->SetInteger(kYCoordDictAttr,
+      static_cast<int>(-node_position.y - node_size.height - root_top));
+  return position.Pass();
 }
 
-string16 FormatSize(BrowserAccessibility* node) {
-  BrowserAccessibilityCocoa* cocoa_node = node->ToBrowserAccessibilityCocoa();
+scoped_ptr<DictionaryValue>
+PopulateSize(const BrowserAccessibilityCocoa* cocoa_node) {
+  scoped_ptr<DictionaryValue> size(new DictionaryValue);
   NSSize node_size = [[cocoa_node size] sizeValue];
-  NSString* size_str =
-      [NSString stringWithFormat:@"size=(%d, %d)",
-                static_cast<int>(node_size.width),
-                static_cast<int>(node_size.height)];
-  return UTF8ToUTF16([size_str cStringUsingEncoding:NSUTF8StringEncoding]);
+  size->SetInteger(kHeightDictAttr, static_cast<int>(node_size.height));
+  size->SetInteger(kWidthDictAttr, static_cast<int>(node_size.width));
+  return size.Pass();
 }
 
 }  // namespace
 
 void AccessibilityTreeFormatter::Initialize() {}
 
-string16 AccessibilityTreeFormatter::ToString(BrowserAccessibility* node,
-                                               char* prefix) {
-  StartLine();
-  NSArray* requestedAttributes = [NSArray arrayWithObjects:
-      NSAccessibilityRoleDescriptionAttribute,
-      NSAccessibilityTitleAttribute,
-      NSAccessibilityValueAttribute,
-      NSAccessibilityMinValueAttribute,
-      NSAccessibilityMaxValueAttribute,
-      NSAccessibilityValueDescriptionAttribute,
-      NSAccessibilityDescriptionAttribute,
-      NSAccessibilityHelpAttribute,
-      @"AXInvalid",
-      NSAccessibilityDisclosingAttribute,
-      NSAccessibilityDisclosureLevelAttribute,
-      @"AXAccessKey",
-      @"AXARIAAtomic",
-      @"AXARIABusy",
-      @"AXARIALive",
-      @"AXARIARelevant",
-      NSAccessibilityEnabledAttribute,
-      NSAccessibilityFocusedAttribute,
-      @"AXLoaded",
-      @"AXLoadingProcess",
-      NSAccessibilityNumberOfCharactersAttribute,
-      NSAccessibilityOrientationAttribute,
-      @"AXRequired",
-      NSAccessibilityURLAttribute,
-      NSAccessibilityVisibleCharacterRangeAttribute,
-      @"AXVisited",
-      nil];
-
-  NSArray* defaultAttributes = [NSArray arrayWithObjects:
-      NSAccessibilityTitleAttribute,
-      NSAccessibilityValueAttribute,
-      nil];
-
-  BrowserAccessibilityCocoa* cocoa_node = node->ToBrowserAccessibilityCocoa();
+void AccessibilityTreeFormatter::AddProperties(const BrowserAccessibility& node,
+                                               DictionaryValue* dict) {
+  BrowserAccessibilityCocoa* cocoa_node =
+      const_cast<BrowserAccessibility*>(&node)->ToBrowserAccessibilityCocoa();
   NSArray* supportedAttributes = [cocoa_node accessibilityAttributeNames];
 
-  Add(true,
-      Format("", [cocoa_node accessibilityAttributeValue:
-                      NSAccessibilityRoleAttribute],
-             ""));
-  Add(false,
-      Format("subrole=", [cocoa_node accessibilityAttributeValue:
-                              NSAccessibilitySubroleAttribute],
-             ""));
-  for (NSString* requestedAttribute in requestedAttributes) {
+  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));
+  }
+
+  for (NSString* requestedAttribute in ALL_ATTRIBUTES) {
     if (![supportedAttributes containsObject:requestedAttribute]) {
       continue;
     }
-    NSString* methodName =
-        [cocoa_node methodNameForAttribute:requestedAttribute];
-    Add([defaultAttributes containsObject:requestedAttribute],
-        Format([[NSString stringWithFormat:@"%@='", methodName]
-                   cStringUsingEncoding:NSUTF8StringEncoding],
-               [cocoa_node accessibilityAttributeValue:
-                    requestedAttribute],
-               "'"));
+    id value = [cocoa_node accessibilityAttributeValue:requestedAttribute];
+    if (value != nil) {
+      dict->SetString(
+          SysNSStringToUTF8(requestedAttribute),
+          SysNSStringToUTF16([NSString stringWithFormat:@"%@", value]));
+    }
+  }
+  dict->Set(kPositionDictAttr, PopulatePosition(node).release());
+  dict->Set(kSizeDictAttr, PopulateSize(cocoa_node).release());
+}
+
+string16 AccessibilityTreeFormatter::ToString(const DictionaryValue& dict,
+                                              const string16& indent) {
+  string16 line;
+  NSArray* defaultAttributes =
+      [NSArray arrayWithObjects:NSAccessibilityTitleAttribute,
+                                NSAccessibilityValueAttribute,
+                                nil];
+  string s_value;
+  dict.GetString(SysNSStringToUTF8(NSAccessibilityRoleAttribute), &s_value);
+  WriteAttribute(true, 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);
+  }
+
+  for (NSString* requestedAttribute in ALL_ATTRIBUTES) {
+    string requestedAttributeUTF8 = SysNSStringToUTF8(requestedAttribute);
+    if (!dict.GetString(requestedAttributeUTF8, &s_value))
+      continue;
+    WriteAttribute([defaultAttributes containsObject:requestedAttribute],
+                   StringPrintf("%s='%s'",
+                                requestedAttributeUTF8.c_str(),
+                                s_value.c_str()),
+                   &line);
+  }
+  const 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)) {
+    WriteAttribute(false,
+                   FormatCoordinates(kSizeDictAttr,
+                                     kWidthDictAttr, kHeightDictAttr, *d_value),
+                   &line);
   }
-  Add(false, FormatPosition(node));
-  Add(false, FormatSize(node));
 
-  return ASCIIToUTF16(prefix) + FinishLine() + ASCIIToUTF16("\n");
+  return indent + line + ASCIIToUTF16("\n");
 }
 
 // static
@@ -145,17 +189,17 @@ AccessibilityTreeFormatter::GetExpectedFileSuffix() {
 }
 
 // static
-const std::string AccessibilityTreeFormatter::GetAllowEmptyString() {
+const string AccessibilityTreeFormatter::GetAllowEmptyString() {
   return "@MAC-ALLOW-EMPTY:";
 }
 
 // static
-const std::string AccessibilityTreeFormatter::GetAllowString() {
+const string AccessibilityTreeFormatter::GetAllowString() {
   return "@MAC-ALLOW:";
 }
 
 // static
-const std::string AccessibilityTreeFormatter::GetDenyString() {
+const string AccessibilityTreeFormatter::GetDenyString() {
   return "@MAC-DENY:";
 }
 
diff --git a/content/browser/accessibility/accessibility_tree_formatter_win.cc b/content/browser/accessibility/accessibility_tree_formatter_win.cc
index f5be49e..90bef99 100644
--- a/content/browser/accessibility/accessibility_tree_formatter_win.cc
+++ b/content/browser/accessibility/accessibility_tree_formatter_win.cc
@@ -19,52 +19,63 @@
 #include "third_party/iaccessible2/ia2_api_all.h"
 #include "ui/base/win/atl_module.h"
 
+using base::StringPrintf;
+
 namespace content {
 
+const char* ALL_ATTRIBUTES[] = {
+    "name",
+    "value",
+    "states",
+    "attributes",
+    "role_name",
+    "currentValue",
+    "minimumValue",
+    "maximumValue",
+    "description",
+    "default_action",
+    "keyboard_shortcut",
+    "location",
+    "size",
+    "index_in_parent",
+    "n_relations",
+    "group_level",
+    "similar_items_in_group",
+    "position_in_group",
+    "table_rows",
+    "table_columns",
+    "row_index",
+    "column_index",
+    "n_characters",
+    "caret_offset",
+    "n_selections",
+    "selection_start",
+    "selection_end"
+};
+
 void AccessibilityTreeFormatter::Initialize() {
   ui::win::CreateATLModuleIfNeeded();
 }
 
-string16 AccessibilityTreeFormatter::ToString(
-    BrowserAccessibility* node, char* prefix) {
-  BrowserAccessibilityWin* acc_obj = node->ToBrowserAccessibilityWin();
+void AccessibilityTreeFormatter::AddProperties(
+    const BrowserAccessibility& node, DictionaryValue* dict) {
+  BrowserAccessibilityWin* acc_obj =
+      const_cast<BrowserAccessibility*>(&node)->ToBrowserAccessibilityWin();
 
-  // Get the computed name.
   VARIANT variant_self;
   variant_self.vt = VT_I4;
   variant_self.lVal = CHILDID_SELF;
+
+  dict->SetString("role", IAccessible2RoleToString(acc_obj->ia2_role()));
+
   CComBSTR msaa_variant;
   HRESULT hresult = acc_obj->get_accName(variant_self, &msaa_variant);
-  string16 name;
-  if (S_OK == hresult)
-    name = msaa_variant.m_str;
-
+  if (hresult == S_OK)
+    dict->SetString("name", msaa_variant.m_str);
   hresult = acc_obj->get_accValue(variant_self, &msaa_variant);
-  string16 value;
-  if (S_OK == hresult)
-    value = msaa_variant.m_str;
-
-  hresult = acc_obj->get_accDescription(variant_self, &msaa_variant);
-  string16 description;
-  if (S_OK == hresult)
-    description = msaa_variant.m_str;
-
-  hresult = acc_obj->get_accHelp(variant_self, &msaa_variant);
-  string16 help;
-  if (S_OK == hresult)
-    help = msaa_variant.m_str;
-
-  hresult = acc_obj->get_accDefaultAction(variant_self, &msaa_variant);
-  string16 default_action;
-  if (S_OK == hresult)
-    default_action = msaa_variant.m_str;
+  if (hresult == S_OK)
+    dict->SetString("value", msaa_variant.m_str);
 
-  hresult = acc_obj->get_accKeyboardShortcut(variant_self, &msaa_variant);
-  string16 keyboard_shortcut;
-  if (S_OK == hresult)
-    keyboard_shortcut = msaa_variant.m_str;
-
-  // Get state strings.
   std::vector<string16> state_strings;
   int32 ia_state = acc_obj->ia_state();
 
@@ -75,95 +86,207 @@ string16 AccessibilityTreeFormatter::ToString(
 
   IAccessibleStateToStringVector(ia_state, &state_strings);
   IAccessible2StateToStringVector(acc_obj->ia2_state(), &state_strings);
-
-  // Get the attributes.
-  const std::vector<string16>& ia2_attributes = acc_obj->ia2_attributes();
-
-  // Build the line.
-  StartLine();
-  Add(true, IAccessible2RoleToString(acc_obj->ia2_role()));
-  Add(true, L"name='" + name + L"'");
-  Add(false, L"value='" + value + L"'");
+  ListValue* states = new ListValue;
   for (std::vector<string16>::const_iterator it = state_strings.begin();
        it != state_strings.end();
        ++it) {
-    Add(false, *it);
+    states->AppendString(UTF16ToUTF8(*it));
   }
+  dict->Set("states", states);
+
+  const std::vector<string16>& ia2_attributes = acc_obj->ia2_attributes();
+  ListValue* attributes = new ListValue;
   for (std::vector<string16>::const_iterator it = ia2_attributes.begin();
        it != ia2_attributes.end();
        ++it) {
-    Add(false, *it);
+    attributes->AppendString(UTF16ToUTF8(*it));
   }
-  Add(false, L"role_name='" + acc_obj->role_name() + L"'");
+  dict->Set("attributes", attributes);
+
+  dict->SetString("role_name", acc_obj->role_name());
+
   VARIANT currentValue;
   if (acc_obj->get_currentValue(&currentValue) == S_OK)
-    Add(false, base::StringPrintf(L"currentValue=%.2f", V_R8(&currentValue)));
+    dict->SetDouble("currentValue", V_R8(&currentValue));
+
   VARIANT minimumValue;
   if (acc_obj->get_minimumValue(&minimumValue) == S_OK)
-    Add(false, base::StringPrintf(L"minimumValue=%.2f", V_R8(&minimumValue)));
+    dict->SetDouble("minimumValue", V_R8(&minimumValue));
+
   VARIANT maximumValue;
   if (acc_obj->get_maximumValue(&maximumValue) == S_OK)
-    Add(false, base::StringPrintf(L"maximumValue=%.2f", V_R8(&maximumValue)));
-  Add(false, L"description='" + description + L"'");
-  Add(false, L"default_action='" + default_action + L"'");
-  Add(false, L"keyboard_shortcut='" + keyboard_shortcut + L"'");
-  BrowserAccessibility* root = node->manager()->GetRoot();
+    dict->SetDouble("maximumValue", V_R8(&maximumValue));
+
+  hresult = acc_obj->get_accDescription(variant_self, &msaa_variant);
+  if (hresult == S_OK)
+    dict->SetString("description", msaa_variant.m_str);
+
+  hresult = acc_obj->get_accDefaultAction(variant_self, &msaa_variant);
+  if (hresult == S_OK)
+    dict->SetString("default_action", msaa_variant.m_str);
+
+  hresult = acc_obj->get_accKeyboardShortcut(variant_self, &msaa_variant);
+  if (hresult == S_OK)
+    dict->SetString("keyboard_shortcut", msaa_variant.m_str);
+
+  hresult = acc_obj->get_accHelp(variant_self, &msaa_variant);
+  if (S_OK == hresult)
+    dict->SetString("help", msaa_variant.m_str);
+
+  BrowserAccessibility* root = node.manager()->GetRoot();
   LONG left, top, width, height;
   LONG root_left, root_top, root_width, root_height;
-  if (S_FALSE != acc_obj->accLocation(
-          &left, &top, &width, &height, variant_self) &&
-      S_FALSE != root->ToBrowserAccessibilityWin()->accLocation(
-          &root_left, &root_top, &root_width, &root_height, variant_self)) {
-    Add(false, base::StringPrintf(L"location=(%d, %d)",
-            left - root_left, top - root_top));
-    Add(false, base::StringPrintf(L"size=(%d, %d)", width, height));
+  if (acc_obj->accLocation(&left, &top, &width, &height, variant_self)
+      != S_FALSE
+      && root->ToBrowserAccessibilityWin()->accLocation(
+          &root_left, &root_top, &root_width, &root_height, variant_self)
+      != S_FALSE) {
+    DictionaryValue* location = new DictionaryValue;
+    location->SetInteger("x", left - root_left);
+    location->SetInteger("y", top - root_top);
+    dict->Set("location", location);
+
+    DictionaryValue* size = new DictionaryValue;
+    size->SetInteger("width", width);
+    size->SetInteger("height", height);
+    dict->Set("size", size);
   }
+
   LONG index_in_parent;
   if (acc_obj->get_indexInParent(&index_in_parent) == S_OK)
-    Add(false, base::StringPrintf(L"index_in_parent=%d", index_in_parent));
+    dict->SetInteger("index_in_parent", index_in_parent);
+
   LONG n_relations;
   if (acc_obj->get_nRelations(&n_relations) == S_OK)
-    Add(false, base::StringPrintf(L"n_relations=%d", n_relations));
+    dict->SetInteger("n_relations", n_relations);
+
   LONG group_level, similar_items_in_group, position_in_group;
   if (acc_obj->get_groupPosition(&group_level,
                                  &similar_items_in_group,
                                  &position_in_group) == S_OK) {
-    Add(false, base::StringPrintf(L"group_level=%d", group_level));
-    Add(false, base::StringPrintf(L"similar_items_in_group=%d",
-                            similar_items_in_group));
-    Add(false, base::StringPrintf(L"position_in_group=%d", position_in_group));
+    dict->SetInteger("group_level", group_level);
+    dict->SetInteger("similar_items_in_group", similar_items_in_group);
+    dict->SetInteger("position_in_group", position_in_group);
   }
   LONG table_rows;
   if (acc_obj->get_nRows(&table_rows) == S_OK)
-    Add(false, base::StringPrintf(L"table_rows=%d", table_rows));
+    dict->SetInteger("table_rows", table_rows);
   LONG table_columns;
   if (acc_obj->get_nRows(&table_columns) == S_OK)
-    Add(false, base::StringPrintf(L"table_columns=%d", table_columns));
+    dict->SetInteger("table_columns", table_columns);
   LONG row_index;
   if (acc_obj->get_rowIndex(&row_index) == S_OK)
-    Add(false, base::StringPrintf(L"row_index=%d", row_index));
+    dict->SetInteger("row_index", row_index);
   LONG column_index;
   if (acc_obj->get_columnIndex(&column_index) == S_OK)
-    Add(false, base::StringPrintf(L"column_index=%d", column_index));
+    dict->SetInteger("column_index", column_index);
   LONG n_characters;
   if (acc_obj->get_nCharacters(&n_characters) == S_OK)
-    Add(false, base::StringPrintf(L"n_characters=%d", n_characters));
+    dict->SetInteger("n_characters", n_characters);
   LONG caret_offset;
   if (acc_obj->get_caretOffset(&caret_offset) == S_OK)
-    Add(false, base::StringPrintf(L"caret_offset=%d", caret_offset));
+    dict->SetInteger("caret_offset", caret_offset);
   LONG n_selections;
   if (acc_obj->get_nSelections(&n_selections) == S_OK) {
-    Add(false, base::StringPrintf(L"n_selections=%d", n_selections));
+    dict->SetInteger("n_selections", n_selections);
     if (n_selections > 0) {
       LONG start, end;
       if (acc_obj->get_selection(0, &start, &end) == S_OK) {
-        Add(false, base::StringPrintf(L"selection_start=%d", start));
-        Add(false, base::StringPrintf(L"selection_end=%d", end));
+        dict->SetInteger("selection_start", start);
+        dict->SetInteger("selection_end", end);
+      }
+    }
+  }
+}
+
+string16 AccessibilityTreeFormatter::ToString(const DictionaryValue& dict,
+                                              const string16& indent) {
+  string16 line;
+
+  string16 role_value;
+  dict.GetString("role", &role_value);
+  WriteAttribute(true, UTF16ToUTF8(role_value), &line);
+
+  string16 name_value;
+  dict.GetString("name", &name_value);
+  WriteAttribute(true, base::StringPrintf(L"name='%ls'", name_value.c_str()),
+                 &line);
+
+  for (int i = 0; i < arraysize(ALL_ATTRIBUTES); i++) {
+    const char* attribute_name = ALL_ATTRIBUTES[i];
+    const Value* value;
+    if (!dict.Get(attribute_name, &value))
+      continue;
+
+    switch (value->GetType()) {
+      case Value::TYPE_STRING: {
+        string16 string_value;
+        value->GetAsString(&string_value);
+        WriteAttribute(false,
+                       StringPrintf(L"%ls='%ls'",
+                                    UTF8ToUTF16(attribute_name).c_str(),
+                                    string_value.c_str()),
+                       &line);
+        break;
+      }
+      case Value::TYPE_INTEGER: {
+        int int_value;
+        value->GetAsInteger(&int_value);
+        WriteAttribute(false,
+                       base::StringPrintf(L"%ls=%d",
+                                          UTF8ToUTF16(attribute_name).c_str(),
+                                          int_value),
+                       &line);
+        break;
+      }
+      case Value::TYPE_DOUBLE: {
+        double double_value;
+        value->GetAsDouble(&double_value);
+        WriteAttribute(false,
+                       base::StringPrintf(L"%ls=%.2f",
+                                          UTF8ToUTF16(attribute_name).c_str(),
+                                          double_value),
+                       &line);
+        break;
+      }
+      case Value::TYPE_LIST: {
+        // Currently all list values are string and are written without
+        // attribute names.
+        const ListValue* list_value;
+        value->GetAsList(&list_value);
+        for (ListValue::const_iterator it = list_value->begin();
+             it != list_value->end();
+             ++it) {
+          string16 string_value;
+          if ((*it)->GetAsString(&string_value))
+            WriteAttribute(false, string_value, &line);
+        }
+        break;
+      }
+      case Value::TYPE_DICTIONARY: {
+        // Currently all dictionary values are coordinates.
+        // Revisit this if that changes.
+        const DictionaryValue* dict_value;
+        value->GetAsDictionary(&dict_value);
+        if (strcmp(attribute_name, "size") == 0) {
+          WriteAttribute(false,
+                         FormatCoordinates("size", "width", "height",
+                                           *dict_value),
+                         &line);
+        } else if (strcmp(attribute_name, "location") == 0) {
+          WriteAttribute(false,
+                         FormatCoordinates("location", "x", "y", *dict_value),
+                         &line);
+        }
+        break;
       }
+      default:
+        NOTREACHED();
+        break;
     }
   }
 
-  return UTF8ToUTF16(prefix) + FinishLine() + ASCIIToUTF16("\n");
+  return indent + line + ASCIIToUTF16("\n");
 }
 
 // static