Make AccessibilityNodeData more compact.

content/browser/accessibility/browser_accessibility.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/browser/accessibility/browser_accessibility.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/common/accessibility_messages.h"
 
 namespace content {
 
 typedef AccessibilityNodeData::BoolAttribute BoolAttribute;
 typedef AccessibilityNodeData::FloatAttribute FloatAttribute;
 typedef AccessibilityNodeData::IntAttribute IntAttribute;
 typedef AccessibilityNodeData::StringAttribute StringAttribute;
 
@@ skipping 37 matching lines @@
     int32 renderer_id,
     int32 index_in_parent) {
   manager_ = manager;
   parent_ = parent;
   renderer_id_ = renderer_id;
   index_in_parent_ = index_in_parent;
 }
 
 void BrowserAccessibility::InitializeData(const AccessibilityNodeData& src) {
   DCHECK_EQ(renderer_id_, src.id);
-  name_ = src.name;
-  value_ = src.value;
   role_ = src.role;
   state_ = src.state;
   string_attributes_ = src.string_attributes;
   int_attributes_ = src.int_attributes;
   float_attributes_ = src.float_attributes;
   bool_attributes_ = src.bool_attributes;
+  intlist_attributes_ = src.intlist_attributes;
   html_attributes_ = src.html_attributes;
   location_ = src.location;
-  indirect_child_ids_ = src.indirect_child_ids;
-  line_breaks_ = src.line_breaks;
-  cell_ids_ = src.cell_ids;
-  unique_cell_ids_ = src.unique_cell_ids;
   instance_active_ = true;
 
+  GetStringAttribute(AccessibilityNodeData::ATTR_NAME, &name_);
+  GetStringAttribute(AccessibilityNodeData::ATTR_VALUE, &value_);
+
   PreInitialize();
 }
 
 bool BrowserAccessibility::IsNative() const {
   return false;
 }
 
 void BrowserAccessibility::SwapChildren(
     std::vector<BrowserAccessibility*>& children) {
   children.swap(children_);
@@ skipping 123 matching lines @@
 
   instance_active_ = false;
   manager_->RemoveNode(this);
   NativeReleaseReference();
 }
 
 void BrowserAccessibility::NativeReleaseReference() {
   delete this;
 }
 
-bool BrowserAccessibility::GetBoolAttribute(
-    BoolAttribute attribute, bool* value) const {
-  BoolAttrMap::const_iterator iter = bool_attributes_.find(attribute);
-  if (iter != bool_attributes_.end()) {
-    *value = iter->second;
-    return true;
+bool BrowserAccessibility::HasBoolAttribute(BoolAttribute attribute) const {
+  for (size_t i = 0; i < bool_attributes_.size(); ++i) {
+    if (bool_attributes_[i].first == attribute)
+      return true;
   }
 
   return false;
 }
 
-bool BrowserAccessibility::GetFloatAttribute(
-    FloatAttribute attribute, float* value) const {
-  FloatAttrMap::const_iterator iter = float_attributes_.find(attribute);
-  if (iter != float_attributes_.end()) {
-    *value = iter->second;
-    return true;
+
+bool BrowserAccessibility::GetBoolAttribute(BoolAttribute attribute) const {
+  for (size_t i = 0; i < bool_attributes_.size(); ++i) {
+    if (bool_attributes_[i].first == attribute)
+      return bool_attributes_[i].second;
   }
 
   return false;
 }
 
-bool BrowserAccessibility::GetIntAttribute(
-    IntAttribute attribute, int* value) const {
-  IntAttrMap::const_iterator iter = int_attributes_.find(attribute);
-  if (iter != int_attributes_.end()) {
-    *value = iter->second;
-    return true;
+bool BrowserAccessibility::GetBoolAttribute(
+    BoolAttribute attribute, bool* value) const {
+  for (size_t i = 0; i < bool_attributes_.size(); ++i) {
+    if (bool_attributes_[i].first == attribute) {
+      *value = bool_attributes_[i].second;
+      return true;
+    }
   }
 
   return false;
 }
 
+bool BrowserAccessibility::HasFloatAttribute(FloatAttribute attribute) const {
+  for (size_t i = 0; i < float_attributes_.size(); ++i) {
+    if (float_attributes_[i].first == attribute)
+      return true;
+  }
+
+  return false;
+}
+
+float BrowserAccessibility::GetFloatAttribute(FloatAttribute attribute) const {
+  for (size_t i = 0; i < float_attributes_.size(); ++i) {
+    if (float_attributes_[i].first == attribute)
+      return float_attributes_[i].second;
+  }
+
+  return 0.0;
+}
+
+bool BrowserAccessibility::GetFloatAttribute(
+    FloatAttribute attribute, float* value) const {
+  for (size_t i = 0; i < float_attributes_.size(); ++i) {
+    if (float_attributes_[i].first == attribute) {
+      *value = float_attributes_[i].second;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool BrowserAccessibility::HasIntAttribute(IntAttribute attribute) const {
+  for (size_t i = 0; i < int_attributes_.size(); ++i) {
+    if (int_attributes_[i].first == attribute)
+      return true;
+  }
+
+  return false;
+}
+
+int BrowserAccessibility::GetIntAttribute(IntAttribute attribute) const {
+  for (size_t i = 0; i < int_attributes_.size(); ++i) {
+    if (int_attributes_[i].first == attribute)
+      return int_attributes_[i].second;
+  }
+
+  return 0;
+}
+
+bool BrowserAccessibility::GetIntAttribute(
+    IntAttribute attribute, int* value) const {
+  for (size_t i = 0; i < int_attributes_.size(); ++i) {
+    if (int_attributes_[i].first == attribute) {
+      *value = int_attributes_[i].second;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool BrowserAccessibility::HasStringAttribute(StringAttribute attribute) const {
+  for (size_t i = 0; i < string_attributes_.size(); ++i) {
+    if (string_attributes_[i].first == attribute)
+      return true;
+  }
+
+  return false;
+}
+
+const std::string& BrowserAccessibility::GetStringAttribute(
+    StringAttribute attribute) const {
+  CR_DEFINE_STATIC_LOCAL(std::string, empty_string, ());
+  for (size_t i = 0; i < string_attributes_.size(); ++i) {
+    if (string_attributes_[i].first == attribute)
+      return string_attributes_[i].second;
+  }
+
+  return empty_string;
+}
+
 bool BrowserAccessibility::GetStringAttribute(
+    StringAttribute attribute, std::string* value) const {
+  for (size_t i = 0; i < string_attributes_.size(); ++i) {
+    if (string_attributes_[i].first == attribute) {
+      *value = string_attributes_[i].second;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+string16 BrowserAccessibility::GetString16Attribute(
+    StringAttribute attribute) const {
+  std::string value_utf8;
+  if (!GetStringAttribute(attribute, &value_utf8))
+    return string16();
+  return UTF8ToUTF16(value_utf8);
+}
+
+bool BrowserAccessibility::GetString16Attribute(
     StringAttribute attribute,
     string16* value) const {
-  StringAttrMap::const_iterator iter = string_attributes_.find(attribute);
-  if (iter != string_attributes_.end()) {
-    *value = iter->second;
-    return true;
+  std::string value_utf8;
+  if (!GetStringAttribute(attribute, &value_utf8))
+    return false;
+  *value = UTF8ToUTF16(value_utf8);
+  return true;
+}
+
+void BrowserAccessibility::SetStringAttribute(
+    StringAttribute attribute, const std::string& value) {
+  for (size_t i = 0; i < string_attributes_.size(); ++i) {
+    if (string_attributes_[i].first == attribute) {
+      string_attributes_[i].second = value;
+      return;
+    }
+  }
+  if (!value.empty())
+    string_attributes_.push_back(std::make_pair(attribute, value));
+}
+
+bool BrowserAccessibility::HasIntListAttribute(
+    AccessibilityNodeData::IntListAttribute attribute) const {
+  for (size_t i = 0; i < intlist_attributes_.size(); ++i) {
+    if (intlist_attributes_[i].first == attribute)
+      return true;
+  }
+
+  return false;
+}
+
+const std::vector<int32>& BrowserAccessibility::GetIntListAttribute(
+    AccessibilityNodeData::IntListAttribute attribute) const {
+  CR_DEFINE_STATIC_LOCAL(std::vector<int32>, empty_vector, ());
+  for (size_t i = 0; i < intlist_attributes_.size(); ++i) {
+    if (intlist_attributes_[i].first == attribute)
+      return intlist_attributes_[i].second;
+  }
+
+  return empty_vector;
+}
+
+bool BrowserAccessibility::GetIntListAttribute(
+    AccessibilityNodeData::IntListAttribute attribute,
+    std::vector<int32>* value) const {
+  for (size_t i = 0; i < intlist_attributes_.size(); ++i) {
+    if (intlist_attributes_[i].first == attribute) {
+      *value = intlist_attributes_[i].second;
+      return true;
+    }
   }
 
   return false;
 }
 
 bool BrowserAccessibility::GetHtmlAttribute(
-    const char* html_attr, string16* value) const {
+    const char* html_attr, std::string* value) const {
   for (size_t i = 0; i < html_attributes_.size(); i++) {
-    const string16& attr = html_attributes_[i].first;
+    const std::string& attr = html_attributes_[i].first;
     if (LowerCaseEqualsASCII(attr, html_attr)) {
       *value = html_attributes_[i].second;
       return true;
     }
   }
 
   return false;
 }
 
+bool BrowserAccessibility::GetHtmlAttribute(
+    const char* html_attr, string16* value) const {
+  std::string value_utf8;
+  if (!GetHtmlAttribute(html_attr, &value_utf8))
+    return false;
+  *value = UTF8ToUTF16(value_utf8);
+  return true;
+}
+
 bool BrowserAccessibility::GetAriaTristate(
     const char* html_attr,
     bool* is_defined,
     bool* is_mixed) const {
   *is_defined = false;
   *is_mixed = false;
 
   string16 value;
   if (!GetHtmlAttribute(html_attr, &value) ||
       value.empty() ||
@@ skipping 26 matching lines @@
   }
 
   // Note: STATE_READONLY being false means it's either a text control,
   // or contenteditable. We also check for editable text roles to cover
   // another element that has role=textbox set on it.
   return (!HasState(AccessibilityNodeData::STATE_READONLY) ||
           role_ == AccessibilityNodeData::ROLE_TEXT_FIELD ||
           role_ == AccessibilityNodeData::ROLE_TEXTAREA);
 }
 
-string16 BrowserAccessibility::GetTextRecursive() const {
+std::string BrowserAccessibility::GetTextRecursive() const {
   if (!name_.empty()) {
     return name_;
   }
 
-  string16 result;
+  std::string result;
   for (size_t i = 0; i < children_.size(); ++i)
     result += children_[i]->GetTextRecursive();
   return result;
 }
 
 }  // namespace content