Make AccessibilityNodeData more compact.

content/common/accessibility_node_data.cc

 // 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/common/accessibility_node_data.h"
 
 #include <set>
 
 #include "base/containers/hash_tables.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 23 matching lines @@
 
 AccessibilityNodeData::AccessibilityNodeData()
     : id(-1),
       role(ROLE_UNKNOWN),
       state(-1) {
 }
 
 AccessibilityNodeData::~AccessibilityNodeData() {
 }
 
+void AccessibilityNodeData::AddStringAttribute(
+    StringAttribute attribute, const std::string& value) {
+  string_attributes.push_back(std::make_pair(attribute, value));
+}
+
+void AccessibilityNodeData::AddIntAttribute(
+    IntAttribute attribute, int value) {
+  int_attributes.push_back(std::make_pair(attribute, value));
+}
+
+void AccessibilityNodeData::AddFloatAttribute(
+    FloatAttribute attribute, float value) {
+  float_attributes.push_back(std::make_pair(attribute, value));
+}
+
+void AccessibilityNodeData::AddBoolAttribute(
+    BoolAttribute attribute, bool value) {
+  bool_attributes.push_back(std::make_pair(attribute, value));
+}
+
+void AccessibilityNodeData::AddIntListAttribute(
+    IntListAttribute attribute, const std::vector<int32>& value) {
+  intlist_attributes.push_back(std::make_pair(attribute, value));
+}
+
+void AccessibilityNodeData::SetName(std::string name) {
+  string_attributes.push_back(std::make_pair(ATTR_NAME, name));
+}
+
 AccessibilityNodeDataTreeNode::AccessibilityNodeDataTreeNode()
   : AccessibilityNodeData() {
 }
 
 AccessibilityNodeDataTreeNode::~AccessibilityNodeDataTreeNode() {
 }
 
 AccessibilityNodeDataTreeNode& AccessibilityNodeDataTreeNode::operator=(
     const AccessibilityNodeData& src) {
   AccessibilityNodeData::operator=(src);
@@ skipping 209 matching lines @@
     result += " SELECTED";
   if (state & (1 << STATE_TRAVERSED))
     result += " TRAVERSED";
   if (state & (1 << STATE_UNAVAILABLE))
     result += " UNAVAILABLE";
   if (state & (1 << STATE_VERTICAL))
     result += " VERTICAL";
   if (state & (1 << STATE_VISITED))
     result += " VISITED";
 
-  std::string tmp = UTF16ToUTF8(name);
-  RemoveChars(tmp, "\n", &tmp);
-  if (!tmp.empty())
-    result += " name=" + tmp;
-
-  tmp = UTF16ToUTF8(value);
-  RemoveChars(tmp, "\n", &tmp);
-  if (!tmp.empty())
-    result += " value=" + tmp;
-
   result += " (" + IntToString(location.x()) + ", " +
                    IntToString(location.y()) + ")-(" +
                    IntToString(location.width()) + ", " +
                    IntToString(location.height()) + ")";
 
-  for (std::map<IntAttribute, int32>::const_iterator iter =
-           int_attributes.begin();
-       iter != int_attributes.end();
-       ++iter) {
-    std::string value = IntToString(iter->second);
-    switch (iter->first) {
+  for (size_t i = 0; i < int_attributes.size(); ++i) {
+    std::string value = IntToString(int_attributes[i].second);
+    switch (int_attributes[i].first) {
       case ATTR_SCROLL_X:
         result += " scroll_x=" + value;
         break;
       case ATTR_SCROLL_X_MIN:
         result += " scroll_x_min=" + value;
         break;
       case ATTR_SCROLL_X_MAX:
         result += " scroll_x_max=" + value;
         break;
       case ATTR_SCROLL_Y:
@@ skipping 55 matching lines @@
         break;
       case ATTR_COLOR_VALUE_GREEN:
         result += " color_value_green=" + value;
         break;
       case ATTR_COLOR_VALUE_BLUE:
         result += " color_value_blue=" + value;
         break;
     }
   }
 
-  for (std::map<StringAttribute, string16>::const_iterator iter =
-           string_attributes.begin();
-       iter != string_attributes.end();
-       ++iter) {
-    std::string value = UTF16ToUTF8(iter->second);
-    switch (iter->first) {
+  for (size_t i = 0; i < string_attributes.size(); ++i) {
+    std::string value = string_attributes[i].second;
+    switch (string_attributes[i].first) {
       case ATTR_DOC_URL:
         result += " doc_url=" + value;
         break;
       case ATTR_DOC_TITLE:
         result += " doc_title=" + value;
         break;
       case ATTR_DOC_MIMETYPE:
         result += " doc_mimetype=" + value;
         break;
       case ATTR_DOC_DOCTYPE:
@@ skipping 31 matching lines @@
         break;
       case ATTR_ROLE:
         result += " role=" + value;
         break;
       case ATTR_SHORTCUT:
         result += " shortcut=" + value;
         break;
       case ATTR_URL:
         result += " url=" + value;
         break;
+      case ATTR_NAME:
+        result += " name=" + value;
+        break;
+      case ATTR_VALUE:
+        result += " value=" + value;
+        break;
     }
   }
 
-  for (std::map<FloatAttribute, float>::const_iterator iter =
-           float_attributes.begin();
-       iter != float_attributes.end();
-       ++iter) {
-    std::string value = DoubleToString(iter->second);
-    switch (iter->first) {
+  for (size_t i = 0; i < float_attributes.size(); ++i) {
+    std::string value = DoubleToString(float_attributes[i].second);
+    switch (float_attributes[i].first) {
       case ATTR_DOC_LOADING_PROGRESS:
         result += " doc_progress=" + value;
         break;
       case ATTR_VALUE_FOR_RANGE:
         result += " value_for_range=" + value;
         break;
       case ATTR_MAX_VALUE_FOR_RANGE:
         result += " max_value=" + value;
         break;
       case ATTR_MIN_VALUE_FOR_RANGE:
         result += " min_value=" + value;
         break;
     }
   }
 
-  for (std::map<BoolAttribute, bool>::const_iterator iter =
-           bool_attributes.begin();
-       iter != bool_attributes.end();
-       ++iter) {
-    std::string value = iter->second ? "true" : "false";
-    switch (iter->first) {
+  for (size_t i = 0; i < bool_attributes.size(); ++i) {
+    std::string value = bool_attributes[i].second ? "true" : "false";
+    switch (bool_attributes[i].first) {
       case ATTR_DOC_LOADED:
         result += " doc_loaded=" + value;
         break;
       case ATTR_BUTTON_MIXED:
         result += " mixed=" + value;
         break;
       case ATTR_LIVE_ATOMIC:
         result += " atomic=" + value;
         break;
       case ATTR_LIVE_BUSY:
@@ skipping 10 matching lines @@
         break;
       case ATTR_CAN_SET_VALUE:
         result += " can_set_value=" + value;
         break;
       case ATTR_UPDATE_LOCATION_ONLY:
         result += " update_location_only=" + value;
         break;
     }
   }
 
+  for (size_t i = 0; i < intlist_attributes.size(); ++i) {
+    const std::vector<int32>& values = intlist_attributes[i].second;
+    switch (intlist_attributes[i].first) {
+      case ATTR_INDIRECT_CHILD_IDS:
+        result += " indirect_child_ids=" + IntVectorToString(values);
+        break;
+      case ATTR_LINE_BREAKS:
+        result += " line_breaks=" + IntVectorToString(values);
+        break;
+      case ATTR_CELL_IDS:
+        result += " cell_ids=" + IntVectorToString(values);
+        break;
+      case ATTR_UNIQUE_CELL_IDS:
+        result += " unique_cell_ids=" + IntVectorToString(values);
+        break;
+    }
+  }
+
   if (!child_ids.empty())
     result += " child_ids=" + IntVectorToString(child_ids);
 
-  if (!indirect_child_ids.empty())
-    result += " indirect_child_ids=" + IntVectorToString(indirect_child_ids);
-
-  if (!line_breaks.empty())
-    result += " line_breaks=" + IntVectorToString(line_breaks);
-
-  if (!cell_ids.empty())
-    result += " cell_ids=" + IntVectorToString(cell_ids);
-
   return result;
 }
 
 std::string AccessibilityNodeDataTreeNode::DebugString(bool recursive) const {
   std::string result;
 
   static int indent = 0;
   result += "\n";
   for (int i = 0; i < indent; ++i)
     result += "  ";
 
   result += AccessibilityNodeData::DebugString(recursive);
 
   if (recursive) {
     result += "\n";
     ++indent;
     for (size_t i = 0; i < children.size(); ++i)
       result += children[i].DebugString(true);
     --indent;
   }
 
   return result;
 }
 
 #endif  // ifndef NDEBUG
 
 }  // namespace content