Add custom action support

ui/accessibility/ax_node_data.cc

 // Copyright 2013 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 "ui/accessibility/ax_node_data.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 44 matching lines @@
 std::string IntVectorToString(const std::vector<int>& items) {
   std::string str;
   for (size_t i = 0; i < items.size(); ++i) {
     if (i > 0)
       str += ",";
     str += IntToString(items[i]);
   }
   return str;
 }
 
+std::string StringVectorToString(const std::vector<std::string>& items) {
+  std::string str;
+  for (size_t i = 0; i < items.size(); ++i) {
+    if (i > 0)
+      str += ",";
+    str += items[i];
+  }
+  return str;
+}
+
 // Predicate that returns true if the first value of a pair is |first|.
 template<typename FirstType, typename SecondType>
 struct FirstIs {
   FirstIs(FirstType first)
       : first_(first) {}
   bool operator()(std::pair<FirstType, SecondType> const& p) {
     return p.first == first_;
   }
   FirstType first_;
 };
@@ skipping 96 matching lines @@
     // a node id attribute or not.
     case AX_INT_LIST_ATTRIBUTE_NONE:
     case AX_ATTR_LINE_BREAKS:
     case AX_ATTR_MARKER_TYPES:
     case AX_ATTR_MARKER_STARTS:
     case AX_ATTR_MARKER_ENDS:
     case AX_ATTR_CHARACTER_OFFSETS:
     case AX_ATTR_CACHED_LINE_STARTS:
     case AX_ATTR_WORD_STARTS:
     case AX_ATTR_WORD_ENDS:
+    case AX_ATTR_CUSTOM_ACTION_IDS:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 AXNodeData::AXNodeData()
     : id(-1),
       role(AX_ROLE_UNKNOWN),
       state(AX_STATE_NONE),
       actions(AX_ACTION_NONE),
       offset_container_id(-1) {}
 
 AXNodeData::~AXNodeData() {
 }
 
 AXNodeData::AXNodeData(const AXNodeData& other) {
   id = other.id;
   role = other.role;
   state = other.state;
   actions = other.actions;
   string_attributes = other.string_attributes;
   int_attributes = other.int_attributes;
   float_attributes = other.float_attributes;
   bool_attributes = other.bool_attributes;
   intlist_attributes = other.intlist_attributes;
+  stringlist_attributes = other.stringlist_attributes;
   html_attributes = other.html_attributes;
   child_ids = other.child_ids;
   location = other.location;
   offset_container_id = other.offset_container_id;
   if (other.transform)
     transform.reset(new gfx::Transform(*other.transform));
 }
 
 AXNodeData& AXNodeData::operator=(AXNodeData other) {
   id = other.id;
   role = other.role;
   state = other.state;
   actions = other.actions;
   string_attributes = other.string_attributes;
   int_attributes = other.int_attributes;
   float_attributes = other.float_attributes;
   bool_attributes = other.bool_attributes;
   intlist_attributes = other.intlist_attributes;
+  stringlist_attributes = other.stringlist_attributes;
   html_attributes = other.html_attributes;
   child_ids = other.child_ids;
   location = other.location;
   offset_container_id = other.offset_container_id;
   if (other.transform)
     transform.reset(new gfx::Transform(*other.transform));
   else
     transform.reset(nullptr);
   return *this;
 }
@@ skipping 126 matching lines @@
                                      std::vector<int32_t>* value) const {
   auto iter = FindInVectorOfPairs(attribute, intlist_attributes);
   if (iter != intlist_attributes.end()) {
     *value = iter->second;
     return true;
   }
 
   return false;
 }
 
+bool AXNodeData::HasStringListAttribute(AXStringListAttribute attribute) const {
+  auto iter = FindInVectorOfPairs(attribute, stringlist_attributes);
+  return iter != stringlist_attributes.end();
+}
+
+const std::vector<std::string>& AXNodeData::GetStringListAttribute(
+    AXStringListAttribute attribute) const {
+  CR_DEFINE_STATIC_LOCAL(std::vector<std::string>, empty_vector, ());
+  auto iter = FindInVectorOfPairs(attribute, stringlist_attributes);
+  if (iter != stringlist_attributes.end())
+    return iter->second;
+  return empty_vector;
+}
+
+bool AXNodeData::GetStringListAttribute(AXStringListAttribute attribute,
+                                        std::vector<std::string>* value) const {
+  auto iter = FindInVectorOfPairs(attribute, stringlist_attributes);
+  if (iter != stringlist_attributes.end()) {
+    *value = iter->second;
+    return true;
+  }
+
+  return false;
+}
+
 bool AXNodeData::GetHtmlAttribute(
     const char* html_attr, std::string* value) const {
   for (size_t i = 0; i < html_attributes.size(); ++i) {
     const std::string& attr = html_attributes[i].first;
     if (base::LowerCaseEqualsASCII(attr, html_attr)) {
       *value = html_attributes[i].second;
       return true;
     }
   }
 
@@ skipping 27 matching lines @@
 void AXNodeData::AddBoolAttribute(
     AXBoolAttribute attribute, bool value) {
   bool_attributes.push_back(std::make_pair(attribute, value));
 }
 
 void AXNodeData::AddIntListAttribute(AXIntListAttribute attribute,
                                      const std::vector<int32_t>& value) {
   intlist_attributes.push_back(std::make_pair(attribute, value));
 }
 
+void AXNodeData::AddStringListAttribute(AXStringListAttribute attribute,
+                                        const std::vector<std::string>& value) {
+  stringlist_attributes.push_back(std::make_pair(attribute, value));
+}
+
 void AXNodeData::SetName(const std::string& name) {
   for (size_t i = 0; i < string_attributes.size(); ++i) {
     if (string_attributes[i].first == AX_ATTR_NAME) {
       string_attributes[i].second = name;
       return;
     }
   }
 
   string_attributes.push_back(std::make_pair(AX_ATTR_NAME, name));
 }
@@ skipping 39 matching lines @@
     // Note: all of the attributes are included here explicitly, rather than
     // using "default:", so that it's a compiler error to add a new action
     // without explicitly considering whether there are mutually exclusive
     // actions that can be performed on a UI control at the same time.
     case AX_ACTION_BLUR:
     case AX_ACTION_FOCUS: {
       AXAction excluded_action =
           (action_enum == AX_ACTION_BLUR) ? AX_ACTION_FOCUS : AX_ACTION_BLUR;
       DCHECK(HasAction(excluded_action));
     } break;
+    case AX_ACTION_CUSTOM_ACTION:
     case AX_ACTION_DECREMENT:
     case AX_ACTION_DO_DEFAULT:
     case AX_ACTION_GET_IMAGE_DATA:
     case AX_ACTION_HIT_TEST:
     case AX_ACTION_INCREMENT:
     case AX_ACTION_REPLACE_SELECTED_TEXT:
     case AX_ACTION_SCROLL_TO_MAKE_VISIBLE:
     case AX_ACTION_SCROLL_TO_POINT:
     case AX_ACTION_SET_ACCESSIBILITY_FOCUS:
     case AX_ACTION_SET_SCROLL_OFFSET:
@@ skipping 463 matching lines @@
         break;
       case AX_ATTR_CACHED_LINE_STARTS:
         result += " cached_line_start_offsets=" + IntVectorToString(values);
         break;
       case AX_ATTR_WORD_STARTS:
         result += " word_starts=" + IntVectorToString(values);
         break;
       case AX_ATTR_WORD_ENDS:
         result += " word_ends=" + IntVectorToString(values);
         break;
+      case AX_ATTR_CUSTOM_ACTION_IDS:
+        result += " custom_action_ids=" + IntVectorToString(values);
+        break;
       case AX_INT_LIST_ATTRIBUTE_NONE:
         break;
     }
   }
 
+  for (size_t i = 0; i < stringlist_attributes.size(); ++i) {
+    const std::vector<std::string>& values = stringlist_attributes[i].second;
+    switch (stringlist_attributes[i].first) {
+      case AX_ATTR_CUSTOM_ACTION_DESCRIPTIONS:
+        result +=
+            " custom_action_descriptions: " + StringVectorToString(values);
+        break;
+      case AX_STRING_LIST_ATTRIBUTE_NONE:
+        break;
+    }
+  }
+
   result += " actions=" + ActionsBitfieldToString(actions);
 
   if (!child_ids.empty())
     result += " child_ids=" + IntVectorToString(child_ids);
 
   return result;
 }
 
 }  // namespace ui