Relation properties for Accessibility Object Model phase 1

third_party/WebKit/Source/modules/accessibility/AXNodeObject.cpp

 /*
  * Copyright (C) 2012, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 196 matching lines @@
     ax_sparse_attribute_setter_map.Set(
         aria_keyshortcutsAttr,
         new StringAttributeSetter(AXStringAttribute::kAriaKeyShortcuts));
     ax_sparse_attribute_setter_map.Set(
         aria_roledescriptionAttr,
         new StringAttributeSetter(AXStringAttribute::kAriaRoleDescription));
   }
   return ax_sparse_attribute_setter_map;
 }
 
+class AXSparseAttributeAOMPropertyClient : public AOMPropertyClient {
+ public:
+  AXSparseAttributeAOMPropertyClient(
+      AXObjectCacheImpl& ax_object_cache,
+      AXSparseAttributeClient& sparse_attribute_client)
+      : ax_object_cache_(ax_object_cache),
+        sparse_attribute_client_(sparse_attribute_client) {}
+
+  void AddStringProperty(AOMStringProperty property,
+                         const String& value) override {
+    AXStringAttribute attribute;
+    switch (property) {
+      case AOMStringProperty::kKeyShortcuts:
+        attribute = AXStringAttribute::kAriaKeyShortcuts;
+        break;
+      case AOMStringProperty::kRoleDescription:
+        attribute = AXStringAttribute::kAriaRoleDescription;
+        break;
+      default:
+        return;
+    }
+    sparse_attribute_client_.AddStringAttribute(attribute, value);
+  }
+
+  void AddBooleanProperty(AOMBooleanProperty property, bool value) override {}

[aboxhall, 2017/06/20 01:11:43]

Are these still TODO..?

[dmazzoni, 2017/06/20 04:56:34]

Not exactly.

AOMPropertyClient iterates over every supported AOM property.

AXSparseAttributeClient only supports a handful of attributes so far.
Over time we'd like to have more sparse attributes, but right now the
only ones we support are 2 string, 3 object attributes, and 3 object
vector attributes (which will be added to AOM next).

The way this is written, making more accessibility attributes sparse
won't require any changes to AccessibleNode.

[aboxhall, 2017/06/22 01:12:39]

Ah, got it. Thanks for explaining.

+
+  void AddIntProperty(AOMIntProperty property, int32_t value) override {}
+
+  void AddUIntProperty(AOMUIntProperty property, uint32_t value) override {}
+
+  void AddFloatProperty(AOMFloatProperty property, float value) override {}
+
+  void AddRelationProperty(AOMRelationProperty property,
+                           const AccessibleNode& value) override {
+    AXObjectAttribute attribute;
+    switch (property) {
+      case AOMRelationProperty::kActiveDescendant:
+        attribute = AXObjectAttribute::kAriaActiveDescendant;
+        break;
+      case AOMRelationProperty::kDetails:
+        attribute = AXObjectAttribute::kAriaDetails;
+        break;
+      case AOMRelationProperty::kErrorMessage:
+        attribute = AXObjectAttribute::kAriaErrorMessage;
+        break;
+      default:
+        return;
+    }
+
+    Element* target_element = value.element();
+    AXObjectImpl* target_obj = ax_object_cache_->GetOrCreate(target_element);
+    if (target_element)
+      sparse_attribute_client_.AddObjectAttribute(attribute, *target_obj);
+  }
+
+ private:
+  Persistent<AXObjectCacheImpl> ax_object_cache_;
+  AXSparseAttributeClient& sparse_attribute_client_;
+};
+
 AXNodeObject::AXNodeObject(Node* node, AXObjectCacheImpl& ax_object_cache)
     : AXObjectImpl(ax_object_cache),
       aria_role_(kUnknownRole),
       children_dirty_(false),
       node_(node) {}
 
 AXNodeObject* AXNodeObject::Create(Node* node,
                                    AXObjectCacheImpl& ax_object_cache) {
   return new AXNodeObject(node, ax_object_cache);
 }
@@ skipping 10 matching lines @@
   float step = StepValueForRange();
 
   value += increase ? step : -step;
 
   SetValue(String::Number(value));
   AxObjectCache().PostNotification(GetNode(),
                                    AXObjectCacheImpl::kAXValueChanged);
 }
 
 AXObjectImpl* AXNodeObject::ActiveDescendant() {
-  if (!node_ || !node_->IsElementNode())
+  Element* element = GetElement();
+  if (!element)
     return nullptr;
 
-  const AtomicString& active_descendant_attr =
-      GetAttribute(aria_activedescendantAttr);
-  if (active_descendant_attr.IsNull() || active_descendant_attr.IsEmpty())
-    return nullptr;
-
-  Element* element = ToElement(GetNode());
   Element* descendant =
-      element->GetTreeScope().getElementById(active_descendant_attr);
+      GetAOMPropertyOrARIAAttribute(AOMRelationProperty::kActiveDescendant);
   if (!descendant)
     return nullptr;
 
   AXObjectImpl* ax_descendant = AxObjectCache().GetOrCreate(descendant);
   return ax_descendant;
 }
 
 bool AXNodeObject::ComputeAccessibilityIsIgnored(
     IgnoredReasons* ignored_reasons) const {
 #if DCHECK_IS_ON()
@@ skipping 641 matching lines @@
   role_ = DetermineAccessibilityRole();
 }
 
 void AXNodeObject::Detach() {
   AXObjectImpl::Detach();
   node_ = nullptr;
 }
 
 void AXNodeObject::GetSparseAXAttributes(
     AXSparseAttributeClient& sparse_attribute_client) const {
-  Node* node = this->GetNode();
-  if (!node || !node->IsElementNode())
+  Element* element = GetElement();
+  if (!element)
     return;
 
+  AXSparseAttributeAOMPropertyClient property_client(*ax_object_cache_,
+                                                     sparse_attribute_client);
+  HashSet<QualifiedName> shadowed_aria_attributes;
+  AccessibleNode::GetAllAOMProperties(element, &property_client,
+                                      shadowed_aria_attributes);
+
   AXSparseAttributeSetterMap& ax_sparse_attribute_setter_map =
       GetSparseAttributeSetterMap();
-  AttributeCollection attributes = ToElement(node)->AttributesWithoutUpdate();
+  AttributeCollection attributes = element->AttributesWithoutUpdate();
   for (const Attribute& attr : attributes) {
+    if (shadowed_aria_attributes.Contains(attr.GetName()))
+      continue;
+
     SparseAttributeSetter* setter =
         ax_sparse_attribute_setter_map.at(attr.GetName());
     if (setter)
       setter->Run(*this, sparse_attribute_client, attr.Value());
   }
-
-  // TODO(dmazzoni): Efficiently iterate over AccessibleNode properties that are
-  // set and merge the two loops somehow.
-  if (ToElement(node)->ExistingAccessibleNode()) {
-    AtomicString key_shortcuts =
-        GetAOMPropertyOrARIAAttribute(AOMStringProperty::kKeyShortcuts);
-    if (!key_shortcuts.IsNull()) {
-      ax_sparse_attribute_setter_map.at(aria_keyshortcutsAttr)
-          ->Run(*this, sparse_attribute_client, key_shortcuts);
-    }
-    AtomicString role_description =
-        GetAOMPropertyOrARIAAttribute(AOMStringProperty::kRoleDescription);
-    if (!role_description.IsNull()) {
-      ax_sparse_attribute_setter_map.at(aria_roledescriptionAttr)
-          ->Run(*this, sparse_attribute_client, role_description);
-    }
-  }
 }
 
 bool AXNodeObject::IsAnchor() const {
   return !IsNativeImage() && IsLink();
 }
 
 bool AXNodeObject::IsControl() const {
   Node* node = this->GetNode();
   if (!node)
     return false;
@@ skipping 2256 matching lines @@
     return String();
   return ToTextControlElement(node)->StrippedPlaceholder();
 }
 
 DEFINE_TRACE(AXNodeObject) {
   visitor->Trace(node_);
   AXObjectImpl::Trace(visitor);
 }
 
 }  // namespace blink