Views a11y: Add AXNodeData.actions bitfield to indicate supported actions by UI.

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>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_text_utils.h"
 #include "ui/gfx/transform.h"
 
 using base::DoubleToString;
 using base::IntToString;
 
 namespace ui {
 
 namespace {
 
 bool IsFlagSet(uint32_t bitfield, uint32_t flag) {
   return 0 != (bitfield & (1 << flag));
 }
 
+uint32_t ModifyFlag(uint32_t bitfield, uint32_t flag, bool set) {
+  return set ? (bitfield |= (1 << flag)) : (bitfield &= ~(1 << flag));
+}
+
 std::string StateBitfieldToString(uint32_t state) {
   std::string str;
   for (uint32_t i = AX_STATE_NONE + 1; i <= AX_STATE_LAST; ++i) {
     if (IsFlagSet(state, i))
       str += " " + base::ToUpperASCII(ToString(static_cast<AXState>(i)));
   }
   return str;
 }
 
+std::string ActionsBitfieldToString(uint32_t actions) {
+  std::string str;
+  for (uint32_t i = AX_ACTION_NONE + 1; i <= AX_ACTION_LAST; ++i) {
+    if (IsFlagSet(actions, i)) {
+      str += ToString(static_cast<AXAction>(i));
+      actions = ModifyFlag(actions, i, false);
+      str += actions ? "," : "";
+    }
+  }
+  return str;
+}
+
 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;
 }
 
@@ skipping 114 matching lines @@
     case AX_ATTR_WORD_STARTS:
     case AX_ATTR_WORD_ENDS:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 AXNodeData::AXNodeData()
-    : id(-1), role(AX_ROLE_UNKNOWN), state(0), offset_container_id(-1) {}
+    : 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;
   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;
   html_attributes = other.html_attributes;
   child_ids = other.child_ids;
   location = other.location;
   offset_container_id = other.offset_container_id;
   if (other.transform)
@@ skipping 208 matching lines @@
     }
   }
 
   string_attributes.push_back(std::make_pair(AX_ATTR_VALUE, value));
 }
 
 void AXNodeData::SetValue(const base::string16& value) {
   SetValue(base::UTF16ToUTF8(value));
 }
 
-bool AXNodeData::HasState(AXState state_flag) const {
-  return IsFlagSet(state, state_flag);
+bool AXNodeData::HasState(AXState state_enum) const {
+  return IsFlagSet(state, state_enum);
 }
 
-void AXNodeData::AddState(AXState state_flag) {
-  DCHECK_NE(state_flag, AX_STATE_NONE);
-  state |= (1 << state_flag);
+bool AXNodeData::HasAction(AXAction action_enum) const {
+  return IsFlagSet(actions, action_enum);
+}
+
+void AXNodeData::AddState(AXState state_enum) {
+  DCHECK_NE(state_enum, AX_STATE_NONE);
+  state = ModifyFlag(state, state_enum, true);
+}
+
+void AXNodeData::AddAction(AXAction action_enum) {
+  switch (action_enum) {
+    case AX_ACTION_NONE:
+      NOTREACHED();
+      break;
+
+    // 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_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:
+    case AX_ACTION_SET_SELECTION:
+    case AX_ACTION_SET_SEQUENTIAL_FOCUS_NAVIGATION_STARTING_POINT:
+    case AX_ACTION_SET_VALUE:
+    case AX_ACTION_SHOW_CONTEXT_MENU:
+      break;
+  }
+
+  actions = ModifyFlag(actions, action_enum, true);
 }
 
 std::string AXNodeData::ToString() const {
   std::string result;
 
   result += "id=" + IntToString(id);
   result += " " + ui::ToString(role);
 
   result += StateBitfieldToString(state);
 
@@ skipping 356 matching lines @@
         break;
       case AX_ATTR_CONTAINER_LIVE_ATOMIC:
         result += " container_atomic=" + value;
         break;
       case AX_ATTR_CONTAINER_LIVE_BUSY:
         result += " container_busy=" + value;
         break;
       case AX_ATTR_ARIA_READONLY:
         result += " aria_readonly=" + value;
         break;
-      case AX_ATTR_CAN_SET_VALUE:
-        result += " can_set_value=" + value;
-        break;
       case AX_ATTR_UPDATE_LOCATION_ONLY:
         result += " update_location_only=" + value;
         break;
       case AX_ATTR_CANVAS_HAS_FALLBACK:
         result += " has_fallback=" + value;
         break;
       case AX_ATTR_MODAL:
         result += " modal=" + value;
         break;
       case AX_BOOL_ATTRIBUTE_NONE:
@@ skipping 75 matching lines @@
         result += " word_starts=" + IntVectorToString(values);
         break;
       case AX_ATTR_WORD_ENDS:
         result += " word_ends=" + IntVectorToString(values);
         break;
       case AX_INT_LIST_ATTRIBUTE_NONE:
         break;
     }
   }
 
+  result += " actions=" + ActionsBitfieldToString(actions);
+
   if (!child_ids.empty())
     result += " child_ids=" + IntVectorToString(child_ids);
 
   return result;
 }
 
 }  // namespace ui