Relation list properties for Accessibility Object Model phase 1

third_party/WebKit/Source/core/dom/AccessibleNode.cpp

 // Copyright 2017 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 "core/dom/AccessibleNode.h"
 
 #include "core/dom/AXObjectCache.h"
+#include "core/dom/AccessibleNodeList.h"
 #include "core/dom/Element.h"
 #include "core/dom/QualifiedName.h"
 #include "core/frame/Settings.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
@@ skipping 45 matching lines @@
       break;
     case AOMRelationProperty::kErrorMessage:
       return aria_errormessageAttr;
       break;
   }
 
   NOTREACHED();
   return g_null_name;
 }
 
+QualifiedName GetCorrespondingARIAAttribute(AOMRelationListProperty property) {
+  switch (property) {
+    case AOMRelationListProperty::kDescribedBy:
+      return aria_describedbyAttr;
+      break;
+    case AOMRelationListProperty::kControls:
+      return aria_controlsAttr;
+      break;
+    case AOMRelationListProperty::kFlowTo:
+      return aria_flowtoAttr;
+      break;
+    case AOMRelationListProperty::kLabeledBy:
+      // Note that there are two allowed spellings of this attribute.
+      // Callers should check both.
+      return aria_labelledbyAttr;
+      break;
+    case AOMRelationListProperty::kOwns:
+      return aria_ownsAttr;
+      break;
+  }
+
+  NOTREACHED();
+  return g_null_name;
+}
+
 QualifiedName GetCorrespondingARIAAttribute(AOMBooleanProperty property) {
   switch (property) {
     case AOMBooleanProperty::kAtomic:
       return aria_atomicAttr;
       break;
     case AOMBooleanProperty::kBusy:
       return aria_busyAttr;
       break;
     case AOMBooleanProperty::kDisabled:
       return aria_disabledAttr;
@@ skipping 122 matching lines @@
   if (AccessibleNode* accessible_node = element->ExistingAccessibleNode()) {
     for (const auto& item : accessible_node->relation_properties_) {
       if (item.first == property && item.second)
         return item.second;
     }
   }
 
   return nullptr;
 }
 
+// static
+AccessibleNodeList* AccessibleNode::GetProperty(
+    Element* element,
+    AOMRelationListProperty property) {
+  if (!element)
+    return nullptr;
+
+  if (AccessibleNode* accessible_node = element->ExistingAccessibleNode()) {
+    for (const auto& item : accessible_node->relation_list_properties_) {
+      if (item.first == property && item.second)
+        return item.second;
+    }
+  }
+
+  return nullptr;
+}
+
+// static
+bool AccessibleNode::GetProperty(Element* element,
+                                 AOMRelationListProperty property,
+                                 HeapVector<Member<Element>>& targets) {
+  AccessibleNodeList* node_list = GetProperty(element, property);
+  if (!node_list)
+    return false;
+
+  for (size_t i = 0; i < node_list->length(); ++i) {
+    AccessibleNode* accessible_node = node_list->item(i);
+    if (accessible_node) {
+      Element* element = accessible_node->element();
+      if (element)
+        targets.push_back(element);
+    }
+  }
+
+  return true;
+}
+
 template <typename P, typename T>
 static T FindPropertyValue(P property,
                            bool& is_null,
                            Vector<std::pair<P, T>>& properties,
                            T default_value) {
   for (const auto& item : properties) {
     if (item.first == property) {
       is_null = false;
       return item.second;
     }
@@ skipping 92 matching lines @@
   QualifiedName attribute = GetCorrespondingARIAAttribute(property);
   AtomicString value = element->FastGetAttribute(attribute);
   Element* target = element->GetTreeScope().getElementById(value);
   if (!target)
     return nullptr;
 
   return target->accessibleNode();
 }
 
 // static
+bool AccessibleNode::GetPropertyOrARIAAttribute(
+    Element* element,
+    AOMRelationListProperty property,
+    HeapVector<Member<Element>>& targets) {
+  if (!element)
+    return false;
+
+  if (GetProperty(element, property, targets))
+    return true;
+
+  // Fall back on the equivalent ARIA attribute.
+  QualifiedName attribute = GetCorrespondingARIAAttribute(property);
+  String value = element->FastGetAttribute(attribute).GetString();
+  if (value.IsEmpty() && property == AOMRelationListProperty::kLabeledBy)
+    value = element->FastGetAttribute(aria_labeledbyAttr).GetString();
+  if (value.IsEmpty())
+    return false;
+
+  value.SimplifyWhiteSpace();
+  Vector<String> ids;
+  value.Split(' ', ids);
+  if (ids.IsEmpty())
+    return false;
+
+  TreeScope& scope = element->GetTreeScope();
+  for (const auto& id : ids) {
+    if (Element* id_element = scope.getElementById(AtomicString(id)))
+      targets.push_back(id_element);
+  }
+  return true;
+}
+
+// static
 bool AccessibleNode::GetPropertyOrARIAAttribute(Element* element,
                                                 AOMBooleanProperty property,
                                                 bool& is_null) {
   is_null = true;
   if (!element)
     return false;
 
   bool result = GetProperty(element, property, is_null);
   if (!is_null)
     return result;
@@ skipping 85 matching lines @@
   }
   for (auto& item : accessible_node->int_properties_) {
     client->AddIntProperty(item.first, item.second);
     shadowed_aria_attributes.insert(GetCorrespondingARIAAttribute(item.first));
   }
   for (auto& item : accessible_node->uint_properties_) {
     client->AddUIntProperty(item.first, item.second);
     shadowed_aria_attributes.insert(GetCorrespondingARIAAttribute(item.first));
   }
   for (auto& item : accessible_node->relation_properties_) {
+    if (!item.second)
+      continue;
     client->AddRelationProperty(item.first, *item.second);
     shadowed_aria_attributes.insert(GetCorrespondingARIAAttribute(item.first));
   }
+  for (auto& item : accessible_node->relation_list_properties_) {
+    if (!item.second)
+      continue;
+    client->AddRelationListProperty(item.first, *item.second);
+    shadowed_aria_attributes.insert(GetCorrespondingARIAAttribute(item.first));
+  }
 }
 
 AccessibleNode* AccessibleNode::activeDescendant() const {
   return GetProperty(element_, AOMRelationProperty::kActiveDescendant);
 }
 
 void AccessibleNode::setActiveDescendant(AccessibleNode* active_descendant) {
   SetRelationProperty(AOMRelationProperty::kActiveDescendant,
                       active_descendant);
   NotifyAttributeChanged(aria_activedescendantAttr);
@@ skipping 55 matching lines @@
 
 uint32_t AccessibleNode::colSpan(bool& is_null) const {
   return GetProperty(element_, AOMUIntProperty::kColSpan, is_null);
 }
 
 void AccessibleNode::setColSpan(uint32_t col_span, bool is_null) {
   SetUIntProperty(AOMUIntProperty::kColSpan, col_span, is_null);
   NotifyAttributeChanged(aria_colspanAttr);
 }
 
+AccessibleNodeList* AccessibleNode::controls() const {
+  return GetProperty(element_, AOMRelationListProperty::kControls);
+}
+
+void AccessibleNode::setControls(AccessibleNodeList* controls) {
+  SetRelationListProperty(AOMRelationListProperty::kControls, controls);
+  NotifyAttributeChanged(aria_controlsAttr);
+}
+
 AtomicString AccessibleNode::current() const {
   return GetProperty(element_, AOMStringProperty::kCurrent);
 }
 
 void AccessibleNode::setCurrent(const AtomicString& current) {
   SetStringProperty(AOMStringProperty::kCurrent, current);
 
   if (AXObjectCache* cache = element_->GetDocument().ExistingAXObjectCache())
     cache->HandleAttributeChanged(aria_currentAttr, element_);
 }
 
+AccessibleNodeList* AccessibleNode::describedBy() {
+  return GetProperty(element_, AOMRelationListProperty::kDescribedBy);
+}
+
+void AccessibleNode::setDescribedBy(AccessibleNodeList* described_by) {
+  SetRelationListProperty(AOMRelationListProperty::kDescribedBy, described_by);
+  NotifyAttributeChanged(aria_describedbyAttr);
+}
+
 AccessibleNode* AccessibleNode::details() const {
   return GetProperty(element_, AOMRelationProperty::kDetails);
 }
 
 void AccessibleNode::setDetails(AccessibleNode* details) {
   SetRelationProperty(AOMRelationProperty::kDetails, details);
   NotifyAttributeChanged(aria_detailsAttr);
 }
 
 bool AccessibleNode::disabled(bool& is_null) const {
@@ skipping 16 matching lines @@
 
 bool AccessibleNode::expanded(bool& is_null) const {
   return GetProperty(element_, AOMBooleanProperty::kExpanded, is_null);
 }
 
 void AccessibleNode::setExpanded(bool expanded, bool is_null) {
   SetBooleanProperty(AOMBooleanProperty::kExpanded, expanded, is_null);
   NotifyAttributeChanged(aria_expandedAttr);
 }
 
+AccessibleNodeList* AccessibleNode::flowTo() const {
+  return GetProperty(element_, AOMRelationListProperty::kFlowTo);
+}
+
+void AccessibleNode::setFlowTo(AccessibleNodeList* flow_to) {
+  SetRelationListProperty(AOMRelationListProperty::kFlowTo, flow_to);
+  NotifyAttributeChanged(aria_flowtoAttr);
+}
+
 bool AccessibleNode::hidden(bool& is_null) const {
   return GetProperty(element_, AOMBooleanProperty::kHidden, is_null);
 }
 
 void AccessibleNode::setHidden(bool hidden, bool is_null) {
   SetBooleanProperty(AOMBooleanProperty::kHidden, hidden, is_null);
   NotifyAttributeChanged(aria_hiddenAttr);
 }
 
 AtomicString AccessibleNode::invalid() const {
@@ skipping 16 matching lines @@
 
 AtomicString AccessibleNode::label() const {
   return GetProperty(element_, AOMStringProperty::kLabel);
 }
 
 void AccessibleNode::setLabel(const AtomicString& label) {
   SetStringProperty(AOMStringProperty::kLabel, label);
   NotifyAttributeChanged(aria_labelAttr);
 }
 
+AccessibleNodeList* AccessibleNode::labeledBy() {
+  return GetProperty(element_, AOMRelationListProperty::kLabeledBy);
+}
+
+void AccessibleNode::setLabeledBy(AccessibleNodeList* labeled_by) {
+  SetRelationListProperty(AOMRelationListProperty::kLabeledBy, labeled_by);
+  NotifyAttributeChanged(aria_labelledbyAttr);
+}
+
 uint32_t AccessibleNode::level(bool& is_null) const {
   return GetProperty(element_, AOMUIntProperty::kLevel, is_null);
 }
 
 void AccessibleNode::setLevel(uint32_t level, bool is_null) {
   SetUIntProperty(AOMUIntProperty::kLevel, level, is_null);
   NotifyAttributeChanged(aria_levelAttr);
 }
 
 AtomicString AccessibleNode::live() const {
@@ skipping 35 matching lines @@
 
 AtomicString AccessibleNode::orientation() const {
   return GetProperty(element_, AOMStringProperty::kOrientation);
 }
 
 void AccessibleNode::setOrientation(const AtomicString& orientation) {
   SetStringProperty(AOMStringProperty::kOrientation, orientation);
   NotifyAttributeChanged(aria_orientationAttr);
 }
 
+AccessibleNodeList* AccessibleNode::owns() const {
+  return GetProperty(element_, AOMRelationListProperty::kOwns);
+}
+
+void AccessibleNode::setOwns(AccessibleNodeList* owns) {
+  SetRelationListProperty(AOMRelationListProperty::kOwns, owns);
+  NotifyAttributeChanged(aria_ownsAttr);
+}
+
 AtomicString AccessibleNode::placeholder() const {
   return GetProperty(element_, AOMStringProperty::kPlaceholder);
 }
 
 void AccessibleNode::setPlaceholder(const AtomicString& placeholder) {
   SetStringProperty(AOMStringProperty::kPlaceholder, placeholder);
   NotifyAttributeChanged(aria_placeholderAttr);
 }
 
 uint32_t AccessibleNode::posInSet(bool& is_null) const {
@@ skipping 166 matching lines @@
   for (auto& item : relation_properties_) {
     if (item.first == property) {
       item.second = value;
       return;
     }
   }
 
   relation_properties_.push_back(std::make_pair(property, value));
 }
 
+void AccessibleNode::SetRelationListProperty(AOMRelationListProperty property,
+                                             AccessibleNodeList* value) {
+  for (auto& item : relation_list_properties_) {
+    if (item.first == property) {
+      if (item.second)
+        item.second->RemoveOwner(property, this);
+      if (value)
+        value->AddOwner(property, this);
+      item.second = value;
+      return;
+    }
+  }
+
+  relation_list_properties_.push_back(std::make_pair(property, value));
+}
+
 template <typename P, typename T>
 static void SetProperty(P property,
                         T value,
                         bool is_null,
                         Vector<std::pair<P, T>>& properties) {
   for (size_t i = 0; i < properties.size(); i++) {
     auto& item = properties[i];
     if (item.first == property) {
       if (is_null)
         properties.erase(i);
@@ skipping 23 matching lines @@
                                      bool is_null) {
   SetProperty(property, value, is_null, uint_properties_);
 }
 
 void AccessibleNode::SetFloatProperty(AOMFloatProperty property,
                                       float value,
                                       bool is_null) {
   SetProperty(property, value, is_null, float_properties_);
 }
 
+void AccessibleNode::OnRelationListChanged(AOMRelationListProperty property) {
+  NotifyAttributeChanged(GetCorrespondingARIAAttribute(property));
+}
+
 void AccessibleNode::NotifyAttributeChanged(
     const blink::QualifiedName& attribute) {
   // TODO(dmazzoni): Make a cleaner API for this rather than pretending
   // the DOM attribute changed.
   if (AXObjectCache* cache = GetAXObjectCache())
     cache->HandleAttributeChanged(attribute, element_);
 }
 
 AXObjectCache* AccessibleNode::GetAXObjectCache() {
   return element_->GetDocument().ExistingAXObjectCache();
 }
 
 DEFINE_TRACE(AccessibleNode) {
   visitor->Trace(element_);
   visitor->Trace(relation_properties_);
+  visitor->Trace(relation_list_properties_);
 }
 
 }  // namespace blink