Re-land: Simplify parsing code in ax_enum_util

Original: http://crrev.com/c/2404164
Reverted: http://crrev.com/c/2416357 due to issue with death test.

Replace the hand-written code to parse each enum from ax_enums with a
templatized function that builds a map from string to attribute value
on-demand.

This saves a little bit of manual effort each time someone updates an enum.

Note that these parsing functions are only used by the automation API.

Bug: None
Change-Id: Ib710f15f2596b04d30ca177b8141b2dc953ed5c1
AX-Relnotes: N/A
Tbr: dtseng@chromium.org
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2418850Reviewed-by: Dominic Mazzoni <dmazzoni@chromium.org>
Commit-Queue: Dominic Mazzoni <dmazzoni@chromium.org>
Cr-Commit-Position: refs/heads/master@{#808468}

chrome/browser/chromeos/arc/accessibility/accessibility_node_info_data_wrapper.cc

@@ -208,7 +208,7 @@ void AccessibilityNodeInfoDataWrapper::PopulateAXRole(
 
   std::string chrome_role;
   if (GetProperty(AXStringProperty::CHROME_ROLE, &chrome_role)) {
-    ax::mojom::Role role_value = ui::ParseRole(chrome_role.c_str());
+    auto role_value = ui::ParseAXEnum<ax::mojom::Role>(chrome_role.c_str());
     if (role_value != ax::mojom::Role::kNone) {
       // The webView and rootWebArea roles differ between Android and Chrome. In
       // particular, Android includes far fewer attributes which leads to

chrome/test/data/extensions/api_test/automation/tests/tabs/detected_language.js

@@ -21,14 +21,6 @@ var allTests = [
     chrome.test.succeed();
   },
 
-  function detectedLanguageForInvalidAttribute() {
-    var item = rootNode.children[2].children[0];
-    var langAnnotation =
-      item.languageAnnotationForStringAttribute('invalid attribute');
-    assertEq(0, langAnnotation.length);
-    chrome.test.succeed();
-  },
-
   function detectedLanguageCharacter() {
     var item = rootNode.children[2].children[0];
     var langAnnotation = item.languageAnnotationForStringAttribute('name');

extensions/browser/api/automation_internal/automation_internal_api.cc

@@ -381,8 +381,8 @@ AutomationInternalPerformActionFunction::ConvertToAXActionData(
               params->opt_args.additional_properties, &hit_test_params));
       action->action = ax::mojom::Action::kHitTest;
       action->target_point = gfx::Point(hit_test_params.x, hit_test_params.y);
-      action->hit_test_event_to_fire =
-          ui::ParseEvent(hit_test_params.event_to_fire.c_str());
+      action->hit_test_event_to_fire = ui::ParseAXEnum<ax::mojom::Event>(
+          hit_test_params.event_to_fire.c_str());
       if (action->hit_test_event_to_fire == ax::mojom::Event::kNone)
         return RespondNow(NoArguments());
       break;

extensions/renderer/api/automation/automation_internal_custom_bindings.cc

@@ -483,8 +483,8 @@ class NodeIDPlusEventWrapper
     ui::AXTreeID tree_id =
         ui::AXTreeID::FromString(*v8::String::Utf8Value(isolate, args[0]));
     int node_id = args[1].As<v8::Int32>()->Value();
-    ax::mojom::Event event_type =
-        ui::ParseEvent(*v8::String::Utf8Value(isolate, args[2]));
+    auto event_type = ui::ParseAXEnum<ax::mojom::Event>(
+        *v8::String::Utf8Value(isolate, args[2]));
 
     AutomationAXTreeWrapper* tree_wrapper =
         automation_bindings_->GetAutomationAXTreeWrapperFromTreeID(tree_id);
@@ -999,8 +999,8 @@ void AutomationInternalCustomBindings::AddRoutes() {
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXTree* tree, ui::AXNode* node,
          const std::string& attribute_name) {
-        ax::mojom::StringAttribute attribute =
-            ui::ParseStringAttribute(attribute_name.c_str());
+        auto attribute =
+            ui::ParseAXEnum<ax::mojom::StringAttribute>(attribute_name.c_str());
         const char* attr_value;
         if (attribute == ax::mojom::StringAttribute::kFontFamily ||
             attribute == ax::mojom::StringAttribute::kLanguage) {
@@ -1019,8 +1019,8 @@ void AutomationInternalCustomBindings::AddRoutes() {
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXTree* tree, ui::AXNode* node,
          const std::string& attribute_name) {
-        ax::mojom::BoolAttribute attribute =
-            ui::ParseBoolAttribute(attribute_name.c_str());
+        auto attribute =
+            ui::ParseAXEnum<ax::mojom::BoolAttribute>(attribute_name.c_str());
         bool attr_value;
         if (!node->data().GetBoolAttribute(attribute, &attr_value))
           return;
@@ -1032,8 +1032,8 @@ void AutomationInternalCustomBindings::AddRoutes() {
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXTree* tree, ui::AXNode* node,
          const std::string& attribute_name) {
-        ax::mojom::IntAttribute attribute =
-            ui::ParseIntAttribute(attribute_name.c_str());
+        auto attribute =
+            ui::ParseAXEnum<ax::mojom::IntAttribute>(attribute_name.c_str());
         int attr_value;
 
         if (attribute == ax::mojom::IntAttribute::kPosInSet &&
@@ -1053,8 +1053,8 @@ void AutomationInternalCustomBindings::AddRoutes() {
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXTree* tree, ui::AXNode* node,
          const std::string& attribute_name) {
-        ax::mojom::IntAttribute attribute =
-            ui::ParseIntAttribute(attribute_name.c_str());
+        auto attribute =
+            ui::ParseAXEnum<ax::mojom::IntAttribute>(attribute_name.c_str());
         std::set<int32_t> ids =
             tree->GetReverseRelations(attribute, node->id());
         v8::Local<v8::Context> context = isolate->GetCurrentContext();
@@ -1073,8 +1073,8 @@ void AutomationInternalCustomBindings::AddRoutes() {
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXTree* tree, ui::AXNode* node,
          const std::string& attribute_name) {
-        ax::mojom::FloatAttribute attribute =
-            ui::ParseFloatAttribute(attribute_name.c_str());
+        auto attribute =
+            ui::ParseAXEnum<ax::mojom::FloatAttribute>(attribute_name.c_str());
         float attr_value;
 
         if (!node->data().GetFloatAttribute(attribute, &attr_value))
@@ -1091,8 +1091,8 @@ void AutomationInternalCustomBindings::AddRoutes() {
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXTree* tree, ui::AXNode* node,
          const std::string& attribute_name) {
-        ax::mojom::IntListAttribute attribute =
-            ui::ParseIntListAttribute(attribute_name.c_str());
+        auto attribute = ui::ParseAXEnum<ax::mojom::IntListAttribute>(
+            attribute_name.c_str());
         if (!node->data().HasIntListAttribute(attribute))
           return;
         const std::vector<int32_t>& attr_value =
@@ -1113,8 +1113,8 @@ void AutomationInternalCustomBindings::AddRoutes() {
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXTree* tree, ui::AXNode* node,
          const std::string& attribute_name) {
-        ax::mojom::IntListAttribute attribute =
-            ui::ParseIntListAttribute(attribute_name.c_str());
+        auto attribute = ui::ParseAXEnum<ax::mojom::IntListAttribute>(
+            attribute_name.c_str());
         std::set<int32_t> ids =
             tree->GetReverseRelations(attribute, node->id());
         v8::Local<v8::Context> context = isolate->GetCurrentContext();
@@ -1278,8 +1278,8 @@ void AutomationInternalCustomBindings::AddRoutes() {
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXTree* tree, ui::AXNode* node,
          const std::string& attribute_name) {
-        ax::mojom::StringAttribute attr =
-            ui::ParseStringAttribute(attribute_name.c_str());
+        auto attr =
+            ui::ParseAXEnum<ax::mojom::StringAttribute>(attribute_name.c_str());
         if (attr == ax::mojom::StringAttribute::kNone) {
           // Set result as empty array.
           result.Set(v8::Array::New(isolate, 0));
@@ -1383,7 +1383,7 @@ void AutomationInternalCustomBindings::AddRoutes() {
         // spin button.
         const std::string& role_string =
             node->GetStringAttribute(ax::mojom::StringAttribute::kRole);
-        ax::mojom::Role role = ui::ParseRole(role_string.c_str());
+        auto role = ui::ParseAXEnum<ax::mojom::Role>(role_string.c_str());
         if (role == ax::mojom::Role::kSlider ||
             role == ax::mojom::Role::kSpinButton) {
           standard_actions.push_back(

ui/accessibility/ax_enum_util.h

@@ -5,8 +5,13 @@
 #ifndef UI_ACCESSIBILITY_AX_ENUM_UTIL_H_
 #define UI_ACCESSIBILITY_AX_ENUM_UTIL_H_
 
+#include <map>
 #include <string>
 
+#include "base/logging.h"
+#include "base/no_destructor.h"
+#include "base/notreached.h"
+#include "base/stl_util.h"
 #include "ui/accessibility/ax_base_export.h"
 #include "ui/accessibility/ax_enums.mojom-forward.h"
 
@@ -14,24 +19,18 @@ namespace ui {
 
 // ax::mojom::Event
 AX_BASE_EXPORT const char* ToString(ax::mojom::Event event);
-AX_BASE_EXPORT ax::mojom::Event ParseEvent(const char* event);
 
 // ax::mojom::Role
 AX_BASE_EXPORT const char* ToString(ax::mojom::Role role);
-AX_BASE_EXPORT ax::mojom::Role ParseRole(const char* role);
 
 // ax::mojom::State
 AX_BASE_EXPORT const char* ToString(ax::mojom::State state);
-AX_BASE_EXPORT ax::mojom::State ParseState(const char* state);
 
 // ax::mojom::Action
 AX_BASE_EXPORT const char* ToString(ax::mojom::Action action);
-AX_BASE_EXPORT ax::mojom::Action ParseAction(const char* action);
 
 // ax::mojom::ActionFlags
 AX_BASE_EXPORT const char* ToString(ax::mojom::ActionFlags action_flags);
-AX_BASE_EXPORT ax::mojom::ActionFlags ParseActionFlags(
-    const char* action_flags);
 
 // ax::mojom::DefaultActionVerb
 AX_BASE_EXPORT const char* ToString(
@@ -41,156 +40,129 @@ AX_BASE_EXPORT const char* ToString(
 AX_BASE_EXPORT std::string ToLocalizedString(
     ax::mojom::DefaultActionVerb action_verb);
 
-AX_BASE_EXPORT ax::mojom::DefaultActionVerb ParseDefaultActionVerb(
-    const char* default_action_verb);
-
 // ax::mojom::Mutation
 AX_BASE_EXPORT const char* ToString(ax::mojom::Mutation mutation);
-AX_BASE_EXPORT ax::mojom::Mutation ParseMutation(const char* mutation);
 
 // ax::mojom::StringAttribute
 AX_BASE_EXPORT const char* ToString(
     ax::mojom::StringAttribute string_attribute);
-AX_BASE_EXPORT ax::mojom::StringAttribute ParseStringAttribute(
-    const char* string_attribute);
 
 // ax::mojom::IntAttribute
 AX_BASE_EXPORT const char* ToString(ax::mojom::IntAttribute int_attribute);
-AX_BASE_EXPORT ax::mojom::IntAttribute ParseIntAttribute(
-    const char* int_attribute);
 
 // ax::mojom::FloatAttribute
 AX_BASE_EXPORT const char* ToString(ax::mojom::FloatAttribute float_attribute);
-AX_BASE_EXPORT ax::mojom::FloatAttribute ParseFloatAttribute(
-    const char* float_attribute);
 
 // ax::mojom::BoolAttribute
 AX_BASE_EXPORT const char* ToString(ax::mojom::BoolAttribute bool_attribute);
-AX_BASE_EXPORT ax::mojom::BoolAttribute ParseBoolAttribute(
-    const char* bool_attribute);
 
 // ax::mojom::IntListAttribute
 AX_BASE_EXPORT const char* ToString(
     ax::mojom::IntListAttribute int_list_attribute);
-AX_BASE_EXPORT ax::mojom::IntListAttribute ParseIntListAttribute(
-    const char* int_list_attribute);
 
 // ax::mojom::StringListAttribute
 AX_BASE_EXPORT const char* ToString(
     ax::mojom::StringListAttribute string_list_attribute);
-AX_BASE_EXPORT ax::mojom::StringListAttribute ParseStringListAttribute(
-    const char* string_list_attribute);
 
 // ax::mojom::ListStyle
 AX_BASE_EXPORT const char* ToString(ax::mojom::ListStyle list_style);
-AX_BASE_EXPORT ax::mojom::ListStyle ParseListStyle(const char* list_style);
 
 // ax::mojom::MarkerType
 AX_BASE_EXPORT const char* ToString(ax::mojom::MarkerType marker_type);
-AX_BASE_EXPORT ax::mojom::MarkerType ParseMarkerType(const char* marker_type);
 
 // ax::mojom::MoveDirection
 AX_BASE_EXPORT const char* ToString(ax::mojom::MoveDirection move_direction);
-AX_BASE_EXPORT ax::mojom::MoveDirection ParseMoveDirection(
-    const char* move_direction);
 
 // ax::mojom::Command
 AX_BASE_EXPORT const char* ToString(ax::mojom::Command command);
-AX_BASE_EXPORT ax::mojom::Command ParseCommand(const char* command);
 
 // ax::mojom::TextBoundary
 AX_BASE_EXPORT const char* ToString(ax::mojom::TextBoundary text_boundary);
-AX_BASE_EXPORT ax::mojom::TextBoundary ParseTextBoundary(
-    const char* text_boundary);
 
 // ax:mojom::TextDecorationStyle
 AX_BASE_EXPORT const char* ToString(
     ax::mojom::TextDecorationStyle text_decoration_style);
-AX_BASE_EXPORT ax::mojom::TextDecorationStyle ParseTextDecorationStyle(
-    const char* text_decoration_style);
 
 // ax::mojom::TextAlign
 AX_BASE_EXPORT const char* ToString(ax::mojom::TextAlign text_align);
-AX_BASE_EXPORT ax::mojom::TextAlign ParseTextAlign(const char* text_align);
 
 // ax::mojom::WritingDirection
 AX_BASE_EXPORT const char* ToString(ax::mojom::WritingDirection text_direction);
-AX_BASE_EXPORT ax::mojom::WritingDirection ParseTextDirection(
-    const char* text_direction);
 
 // ax::mojom::TextPosition
 AX_BASE_EXPORT const char* ToString(ax::mojom::TextPosition text_position);
-AX_BASE_EXPORT ax::mojom::TextPosition ParseTextPosition(
-    const char* text_position);
 
 // ax::mojom::TextStyle
 AX_BASE_EXPORT const char* ToString(ax::mojom::TextStyle text_style);
-AX_BASE_EXPORT ax::mojom::TextStyle ParseTextStyle(const char* text_style);
 
 // ax::mojom::AriaCurrentState
 AX_BASE_EXPORT const char* ToString(
     ax::mojom::AriaCurrentState aria_current_state);
-AX_BASE_EXPORT ax::mojom::AriaCurrentState ParseAriaCurrentState(
-    const char* aria_current_state);
 
 // ax::mojom::HasPopup
 AX_BASE_EXPORT const char* ToString(ax::mojom::HasPopup has_popup);
-AX_BASE_EXPORT ax::mojom::HasPopup ParseHasPopup(const char* has_popup);
 
 // ax::mojom::InvalidState
 AX_BASE_EXPORT const char* ToString(ax::mojom::InvalidState invalid_state);
-AX_BASE_EXPORT ax::mojom::InvalidState ParseInvalidState(
-    const char* invalid_state);
 
 // ax::mojom::Restriction
 AX_BASE_EXPORT const char* ToString(ax::mojom::Restriction restriction);
-AX_BASE_EXPORT ax::mojom::Restriction ParseRestriction(const char* restriction);
 
 // ax::mojom::CheckedState
 AX_BASE_EXPORT const char* ToString(ax::mojom::CheckedState checked_state);
-AX_BASE_EXPORT ax::mojom::CheckedState ParseCheckedState(
-    const char* checked_state);
 
 // ax::mojom::SortDirection
 AX_BASE_EXPORT const char* ToString(ax::mojom::SortDirection sort_direction);
-AX_BASE_EXPORT ax::mojom::SortDirection ParseSortDirection(
-    const char* sort_direction);
 
 // ax::mojom::NameFrom
 AX_BASE_EXPORT const char* ToString(ax::mojom::NameFrom name_from);
-AX_BASE_EXPORT ax::mojom::NameFrom ParseNameFrom(const char* name_from);
 
 // ax::mojom::DescriptionFrom
 AX_BASE_EXPORT const char* ToString(
     ax::mojom::DescriptionFrom description_from);
-AX_BASE_EXPORT ax::mojom::DescriptionFrom ParseDescriptionFrom(
-    const char* description_from);
 
 // ax::mojom::EventFrom
 AX_BASE_EXPORT const char* ToString(ax::mojom::EventFrom event_from);
-AX_BASE_EXPORT ax::mojom::EventFrom ParseEventFrom(const char* event_from);
 
 // ax::mojom::Gesture
 AX_BASE_EXPORT const char* ToString(ax::mojom::Gesture gesture);
-AX_BASE_EXPORT ax::mojom::Gesture ParseGesture(const char* gesture);
 
 // ax::mojom::TextAffinity
 AX_BASE_EXPORT const char* ToString(ax::mojom::TextAffinity text_affinity);
-AX_BASE_EXPORT ax::mojom::TextAffinity ParseTextAffinity(
-    const char* text_affinity);
 
 // ax::mojom::TreeOrder
 AX_BASE_EXPORT const char* ToString(ax::mojom::TreeOrder tree_order);
-AX_BASE_EXPORT ax::mojom::TreeOrder ParseTreeOrder(const char* tree_order);
 
 // ax::mojom::ImageAnnotationStatus
 AX_BASE_EXPORT const char* ToString(ax::mojom::ImageAnnotationStatus status);
-AX_BASE_EXPORT ax::mojom::ImageAnnotationStatus ParseImageAnnotationStatus(
-    const char* status);
 
 // ax::mojom::Dropeffect
 AX_BASE_EXPORT const char* ToString(ax::mojom::Dropeffect dropeffect);
-AX_BASE_EXPORT ax::mojom::Dropeffect ParseDropeffect(const char* dropeffect);
+
+// Convert from the string representation of an enum defined in ax_enums.mojom
+// into the enum value. The first time this is called, builds up a map.
+// Relies on the existence of ui::ToString(enum).
+template <typename T>
+T ParseAXEnum(const char* attribute) {
+  static base::NoDestructor<std::map<std::string, T>> attr_map;
+  if (attr_map->empty()) {
+    (*attr_map)[""] = T::kNone;
+    for (int i = static_cast<int>(T::kMinValue);
+         i <= static_cast<int>(T::kMaxValue); i++) {
+      auto attr = static_cast<T>(i);
+      std::string str = ui::ToString(attr);
+      if (!base::Contains(*attr_map, str))
+        (*attr_map)[str] = attr;
+    }
+  }
+  auto iter = attr_map->find(attribute);
+  if (iter != attr_map->end())
+    return iter->second;
+
+  LOG(ERROR) << "Could not parse: " << attribute;
+  NOTREACHED();
+  return T::kNone;
+}
 
 }  // namespace ui
 

ui/accessibility/ax_enum_util_unittest.cc

@@ -16,24 +16,27 @@ namespace ui {
 // Templatized function that tests that for a mojom enum
 // such as ax::mojom::Role, ax::mojom::Event, etc. we can
 // call ToString() on the enum to get a string, and then
-// ParseEnumName() on the string to get back the original
+// ParseAXEnum() on the string to get back the original
 // value. Also tests what happens when we call ToString
-// or ParseEnumName on a bogus value.
+// or ParseAXEnum on a bogus value.
 template <typename T>
 void TestEnumStringConversion(
-    T(ParseFunction)(const char*),
     int32_t(step)(int32_t) = [](int32_t val) { return val + 1; }) {
   // Check every valid enum value.
   for (int i = static_cast<int>(T::kMinValue);
        i <= static_cast<int>(T::kMaxValue); i = step(i)) {
     T src = static_cast<T>(i);
     std::string str = ToString(src);
-    auto dst = ParseFunction(str.c_str());
+    auto dst = ParseAXEnum<T>(str.c_str());
     EXPECT_EQ(src, dst);
   }
 
-  // Parse a bogus string.
-  EXPECT_EQ(T::kNone, ParseFunction("bogus"));
+  // Trying to parse a bogus string should crash.
+  // TODO(http://crbug.com/1129919) - try to re-enable this death test.
+  // EXPECT_DEATH_IF_SUPPORTED(ParseAXEnum<T>("bogus"), "Check failed");
+
+  // Parse the empty string.
+  EXPECT_EQ(T::kNone, ParseAXEnum<T>(""));
 
   // Convert a bogus value to a string.
   int out_of_range_value = static_cast<int>(T::kMaxValue) + 1;
@@ -71,74 +74,72 @@ void TestAXNodeDataSetter(void (AXNodeData::*Setter)(T, U), U value) {
 }
 
 TEST(AXEnumUtilTest, Event) {
-  TestEnumStringConversion<ax::mojom::Event>(ParseEvent);
+  TestEnumStringConversion<ax::mojom::Event>();
 }
 
 TEST(AXEnumUtilTest, Role) {
-  TestEnumStringConversion<ax::mojom::Role>(ParseRole);
+  TestEnumStringConversion<ax::mojom::Role>();
 }
 
 TEST(AXEnumUtilTest, State) {
-  TestEnumStringConversion<ax::mojom::State>(ParseState);
+  TestEnumStringConversion<ax::mojom::State>();
 }
 
 TEST(AXEnumUtilTest, Action) {
-  TestEnumStringConversion<ax::mojom::Action>(ParseAction);
+  TestEnumStringConversion<ax::mojom::Action>();
 }
 
 TEST(AXEnumUtilTest, ActionFlags) {
-  TestEnumStringConversion<ax::mojom::ActionFlags>(ParseActionFlags);
+  TestEnumStringConversion<ax::mojom::ActionFlags>();
 }
 
 TEST(AXEnumUtilTest, DefaultActionVerb) {
-  TestEnumStringConversion<ax::mojom::DefaultActionVerb>(
-      ParseDefaultActionVerb);
+  TestEnumStringConversion<ax::mojom::DefaultActionVerb>();
 }
 
 TEST(AXEnumUtilTest, Mutation) {
-  TestEnumStringConversion<ax::mojom::Mutation>(ParseMutation);
+  TestEnumStringConversion<ax::mojom::Mutation>();
 }
 
 TEST(AXEnumUtilTest, StringAttribute) {
-  TestEnumStringConversion<ax::mojom::StringAttribute>(ParseStringAttribute);
+  TestEnumStringConversion<ax::mojom::StringAttribute>();
   TestAXNodeDataSetter<ax::mojom::StringAttribute>(
       &AXNodeData::AddStringAttribute, std::string());
 }
 
 TEST(AXEnumUtilTest, IntAttribute) {
-  TestEnumStringConversion<ax::mojom::IntAttribute>(ParseIntAttribute);
+  TestEnumStringConversion<ax::mojom::IntAttribute>();
   TestAXNodeDataSetter<ax::mojom::IntAttribute>(&AXNodeData::AddIntAttribute,
                                                 0);
 }
 
 TEST(AXEnumUtilTest, FloatAttribute) {
-  TestEnumStringConversion<ax::mojom::FloatAttribute>(ParseFloatAttribute);
+  TestEnumStringConversion<ax::mojom::FloatAttribute>();
   TestAXNodeDataSetter<ax::mojom::FloatAttribute>(
       &AXNodeData::AddFloatAttribute, 0.0f);
 }
 
 TEST(AXEnumUtilTest, BoolAttribute) {
-  TestEnumStringConversion<ax::mojom::BoolAttribute>(ParseBoolAttribute);
+  TestEnumStringConversion<ax::mojom::BoolAttribute>();
   TestAXNodeDataSetter<ax::mojom::BoolAttribute>(&AXNodeData::AddBoolAttribute,
                                                  false);
 }
 
 TEST(AXEnumUtilTest, IntListAttribute) {
-  TestEnumStringConversion<ax::mojom::IntListAttribute>(ParseIntListAttribute);
+  TestEnumStringConversion<ax::mojom::IntListAttribute>();
   TestAXNodeDataSetter<ax::mojom::IntListAttribute>(
       &AXNodeData::AddIntListAttribute, std::vector<int32_t>());
 }
 
 TEST(AXEnumUtilTest, StringListAttribute) {
-  TestEnumStringConversion<ax::mojom::StringListAttribute>(
-      ParseStringListAttribute);
+  TestEnumStringConversion<ax::mojom::StringListAttribute>();
   TestAXNodeDataSetter<ax::mojom::StringListAttribute>(
       &AXNodeData::AddStringListAttribute, std::vector<std::string>());
 }
 
 TEST(AXEnumUtilTest, MarkerType) {
   TestEnumStringConversion<ax::mojom::MarkerType>(
-      ParseMarkerType, [](int32_t val) {
+      [](int32_t val) {
         return val == 0 ? 1 :
                         // 8 (Composition) is
                         // explicitly skipped in
@@ -148,97 +149,95 @@ TEST(AXEnumUtilTest, MarkerType) {
 }
 
 TEST(AXEnumUtilTest, Text_Decoration_Style) {
-  TestEnumStringConversion<ax::mojom::TextDecorationStyle>(
-      ParseTextDecorationStyle);
+  TestEnumStringConversion<ax::mojom::TextDecorationStyle>();
 }
 
 TEST(AXEnumUtilTest, ListStyle) {
-  TestEnumStringConversion<ax::mojom::ListStyle>(ParseListStyle);
+  TestEnumStringConversion<ax::mojom::ListStyle>();
 }
 
 TEST(AXEnumUtilTest, MoveDirection) {
-  TestEnumStringConversion<ax::mojom::MoveDirection>(ParseMoveDirection);
+  TestEnumStringConversion<ax::mojom::MoveDirection>();
 }
 
 TEST(AXEnumUtilTest, Command) {
-  TestEnumStringConversion<ax::mojom::Command>(ParseCommand);
+  TestEnumStringConversion<ax::mojom::Command>();
 }
 
 TEST(AXEnumUtilTest, TextAlign) {
-  TestEnumStringConversion<ax::mojom::TextAlign>(ParseTextAlign);
+  TestEnumStringConversion<ax::mojom::TextAlign>();
 }
 
 TEST(AXEnumUtilTest, TextBoundary) {
-  TestEnumStringConversion<ax::mojom::TextBoundary>(ParseTextBoundary);
+  TestEnumStringConversion<ax::mojom::TextBoundary>();
 }
 
 TEST(AXEnumUtilTest, TextDirection) {
-  TestEnumStringConversion<ax::mojom::WritingDirection>(ParseTextDirection);
+  TestEnumStringConversion<ax::mojom::WritingDirection>();
 }
 
 TEST(AXEnumUtilTest, TextPosition) {
-  TestEnumStringConversion<ax::mojom::TextPosition>(ParseTextPosition);
+  TestEnumStringConversion<ax::mojom::TextPosition>();
 }
 
 TEST(AXEnumUtilTest, TextStyle) {
-  TestEnumStringConversion<ax::mojom::TextStyle>(ParseTextStyle);
+  TestEnumStringConversion<ax::mojom::TextStyle>();
 }
 
 TEST(AXEnumUtilTest, AriaCurrentState) {
-  TestEnumStringConversion<ax::mojom::AriaCurrentState>(ParseAriaCurrentState);
+  TestEnumStringConversion<ax::mojom::AriaCurrentState>();
 }
 
 TEST(AXEnumUtilTest, HasPopup) {
-  TestEnumStringConversion<ax::mojom::HasPopup>(ParseHasPopup);
+  TestEnumStringConversion<ax::mojom::HasPopup>();
 }
 
 TEST(AXEnumUtilTest, InvalidState) {
-  TestEnumStringConversion<ax::mojom::InvalidState>(ParseInvalidState);
+  TestEnumStringConversion<ax::mojom::InvalidState>();
 }
 
 TEST(AXEnumUtilTest, Restriction) {
-  TestEnumStringConversion<ax::mojom::Restriction>(ParseRestriction);
+  TestEnumStringConversion<ax::mojom::Restriction>();
 }
 
 TEST(AXEnumUtilTest, CheckedState) {
-  TestEnumStringConversion<ax::mojom::CheckedState>(ParseCheckedState);
+  TestEnumStringConversion<ax::mojom::CheckedState>();
 }
 
 TEST(AXEnumUtilTest, SortDirection) {
-  TestEnumStringConversion<ax::mojom::SortDirection>(ParseSortDirection);
+  TestEnumStringConversion<ax::mojom::SortDirection>();
 }
 
 TEST(AXEnumUtilTest, NameFrom) {
-  TestEnumStringConversion<ax::mojom::NameFrom>(ParseNameFrom);
+  TestEnumStringConversion<ax::mojom::NameFrom>();
 }
 
 TEST(AXEnumUtilTest, DescriptionFrom) {
-  TestEnumStringConversion<ax::mojom::DescriptionFrom>(ParseDescriptionFrom);
+  TestEnumStringConversion<ax::mojom::DescriptionFrom>();
 }
 
 TEST(AXEnumUtilTest, EventFrom) {
-  TestEnumStringConversion<ax::mojom::EventFrom>(ParseEventFrom);
+  TestEnumStringConversion<ax::mojom::EventFrom>();
 }
 
 TEST(AXEnumUtilTest, Gesture) {
-  TestEnumStringConversion<ax::mojom::Gesture>(ParseGesture);
+  TestEnumStringConversion<ax::mojom::Gesture>();
 }
 
 TEST(AXEnumUtilTest, TextAffinity) {
-  TestEnumStringConversion<ax::mojom::TextAffinity>(ParseTextAffinity);
+  TestEnumStringConversion<ax::mojom::TextAffinity>();
 }
 
 TEST(AXEnumUtilTest, TreeOrder) {
-  TestEnumStringConversion<ax::mojom::TreeOrder>(ParseTreeOrder);
+  TestEnumStringConversion<ax::mojom::TreeOrder>();
 }
 
 TEST(AXEnumUtilTest, ImageAnnotationStatus) {
-  TestEnumStringConversion<ax::mojom::ImageAnnotationStatus>(
-      ParseImageAnnotationStatus);
+  TestEnumStringConversion<ax::mojom::ImageAnnotationStatus>();
 }
 
 TEST(AXEnumUtilTest, Dropeffect) {
-  TestEnumStringConversion<ax::mojom::Dropeffect>(ParseDropeffect);
+  TestEnumStringConversion<ax::mojom::Dropeffect>();
 }
 
 }  // namespace ui