Relation list 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 12 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/accessibility/AXNodeObject.h"
 
 #include "core/InputTypeNames.h"
 #include "core/dom/AccessibleNode.h"
+#include "core/dom/AccessibleNodeList.h"
 #include "core/dom/Element.h"
 #include "core/dom/FlatTreeTraversal.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/QualifiedName.h"
 #include "core/dom/Text.h"
 #include "core/dom/UserGestureIndicator.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/html/HTMLAnchorElement.h"
@@ skipping 218 matching lines @@
       default:
         return;
     }
 
     Element* target_element = value.element();
     AXObject* target_obj = ax_object_cache_->GetOrCreate(target_element);
     if (target_element)
       sparse_attribute_client_.AddObjectAttribute(attribute, *target_obj);
   }
 
+  void AddRelationListProperty(AOMRelationListProperty property,
+                               const AccessibleNodeList& relations) override {
+    AXObjectVectorAttribute attribute;
+    switch (property) {
+      case AOMRelationListProperty::kControls:
+        attribute = AXObjectVectorAttribute::kAriaControls;
+        break;
+      case AOMRelationListProperty::kFlowTo:
+        attribute = AXObjectVectorAttribute::kAriaFlowTo;
+        break;
+      default:
+        return;
+    }
+
+    HeapVector<Member<AXObject>> objects;
+    for (size_t i = 0; i < relations.length(); ++i) {
+      AccessibleNode* accessible_node = relations.item(i);
+      if (accessible_node) {
+        Element* element = accessible_node->element();
+        AXObject* ax_element = ax_object_cache_->GetOrCreate(element);
+        if (ax_element && !ax_element->AccessibilityIsIgnored())
+          objects.push_back(ax_element);
+      }
+    }
+
+    sparse_attribute_client_.AddObjectVectorAttribute(attribute, objects);
+  }
+
  private:
   Persistent<AXObjectCacheImpl> ax_object_cache_;
   AXSparseAttributeClient& sparse_attribute_client_;
 };
 
 AXNodeObject::AXNodeObject(Node* node, AXObjectCacheImpl& ax_object_cache)
     : AXObject(ax_object_cache),
       aria_role_(kUnknownRole),
       children_dirty_(false),
       node_(node) {}
@@ skipping 485 matching lines @@
     role = ButtonRoleType();
 
   role = RemapAriaRoleDueToParent(role);
 
   if (role)
     return role;
 
   return kUnknownRole;
 }
 
-void AXNodeObject::AccessibilityChildrenFromAttribute(
-    QualifiedName attr,
+void AXNodeObject::AccessibilityChildrenFromAOMProperty(
+    AOMRelationListProperty property,
     AXObject::AXObjectVector& children) const {
   HeapVector<Member<Element>> elements;
-  ElementsFromAttribute(elements, attr);
+  if (!HasAOMPropertyOrARIAAttribute(property, elements))
+    return;
 
   AXObjectCacheImpl& cache = AxObjectCache();
   for (const auto& element : elements) {
     if (AXObject* child = cache.GetOrCreate(element)) {
       // Only aria-labelledby and aria-describedby can target hidden elements.
-      if (child->AccessibilityIsIgnored() && attr != aria_labelledbyAttr &&
-          attr != aria_labeledbyAttr && attr != aria_describedbyAttr) {
+      if (child->AccessibilityIsIgnored() &&
+          property != AOMRelationListProperty::kLabeledBy &&
+          property != AOMRelationListProperty::kDescribedBy) {
         continue;
       }
       children.push_back(child);
     }
   }
 }
 
 // This only returns true if this is the element that actually has the
 // contentEditable attribute set, unlike node->hasEditableStyle() which will
 // also return true if an ancestor is editable.
@@ skipping 1731 matching lines @@
   bool ignored_status = AccessibilityIsIgnored();
 
   // The AX hierarchy only needs to be updated if the ignored status of an
   // element has changed.
   if (ignored_status != AccessibilityIsIgnored())
     ChildrenChanged();
 }
 
 void AXNodeObject::ComputeAriaOwnsChildren(
     HeapVector<Member<AXObject>>& owned_children) const {
+  Vector<String> id_vector;
+  if (!CanHaveChildren() || IsNativeTextControl() ||
+      HasContentEditableAttributeSet()) {
+    AxObjectCache().UpdateAriaOwns(this, id_vector, owned_children);
+    return;
+  }
+
+  HeapVector<Member<Element>> elements;
+  if (HasAOMProperty(AOMRelationListProperty::kOwns, elements)) {
+    AxObjectCache().UpdateAriaOwns(this, id_vector, owned_children);
+
+    for (const auto& element : elements) {
+      AXObject* ax_element = ax_object_cache_->GetOrCreate(&*element);
+      if (ax_element && !ax_element->AccessibilityIsIgnored())
+        owned_children.push_back(ax_element);
+    }
+
+    return;
+  }
+
   if (!HasAttribute(aria_ownsAttr))
     return;
 
-  Vector<String> id_vector;
-  if (CanHaveChildren() && !IsNativeTextControl() &&
-      !HasContentEditableAttributeSet())
-    TokenVectorFromAttribute(id_vector, aria_ownsAttr);
-
+  TokenVectorFromAttribute(id_vector, aria_ownsAttr);
   AxObjectCache().UpdateAriaOwns(this, id_vector, owned_children);
 }
 
 // Based on
 // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
 String AXNodeObject::NativeTextAlternative(
     AXObjectSet& visited,
     AXNameFrom& name_from,
     AXRelatedObjectVector* related_objects,
     NameSources* name_sources,
@@ skipping 504 matching lines @@
 
   description_from = kAXDescriptionFromRelatedElement;
   if (description_sources) {
     description_sources->push_back(
         DescriptionSource(found_description, aria_describedbyAttr));
     description_sources->back().type = description_from;
   }
 
   // aria-describedby overrides any other accessible description, from:
   // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
+  // AOM version.
+  HeapVector<Member<Element>> elements;
+  if (HasAOMProperty(AOMRelationListProperty::kDescribedBy, elements)) {
+    AXObjectSet visited;
+    description = TextFromElements(true, visited, elements, related_objects);
+    if (!description.IsNull()) {
+      if (description_sources) {
+        DescriptionSource& source = description_sources->back();
+        source.type = description_from;
+        source.related_objects = *related_objects;
+        source.text = description;
+        found_description = true;
+      } else {
+        return description;
+      }
+    } else if (description_sources) {
+      description_sources->back().invalid = true;
+    }
+  }
+
+  // aria-describedby overrides any other accessible description, from:
+  // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
   const AtomicString& aria_describedby = GetAttribute(aria_describedbyAttr);
   if (!aria_describedby.IsNull()) {
     if (description_sources)
       description_sources->back().attribute_value = aria_describedby;
 
     description = TextFromAriaDescribedby(related_objects);
 
     if (!description.IsNull()) {
       if (description_sources) {
         DescriptionSource& source = description_sources->back();
@@ skipping 177 matching lines @@
     return String();
   return ToTextControlElement(node)->StrippedPlaceholder();
 }
 
 DEFINE_TRACE(AXNodeObject) {
   visitor->Trace(node_);
   AXObject::Trace(visitor);
 }
 
 }  // namespace blink