Boolean attributes 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/Element.h"
 #include "core/dom/QualifiedName.h"
 #include "core/frame/Settings.h"
@@ skipping 17 matching lines @@
   if (AccessibleNode* accessibleNode = element->existingAccessibleNode()) {
     for (const auto& item : accessibleNode->m_stringProperties) {
       if (item.first == property)
         return item.second;
     }
   }
 
   // Fall back on the equivalent ARIA attribute.
   switch (property) {
     case AOMStringProperty::kAutocomplete:
-      return element->getAttribute(aria_autocompleteAttr);
+      return element->fastGetAttribute(aria_autocompleteAttr);
     case AOMStringProperty::kChecked:
-      return element->getAttribute(aria_checkedAttr);
+      return element->fastGetAttribute(aria_checkedAttr);
     case AOMStringProperty::kCurrent:
-      return element->getAttribute(aria_currentAttr);
+      return element->fastGetAttribute(aria_currentAttr);
     case AOMStringProperty::kInvalid:
-      return element->getAttribute(aria_invalidAttr);
+      return element->fastGetAttribute(aria_invalidAttr);
     case AOMStringProperty::kKeyShortcuts:
-      return element->getAttribute(aria_keyshortcutsAttr);
+      return element->fastGetAttribute(aria_keyshortcutsAttr);
     case AOMStringProperty::kLabel:
-      return element->getAttribute(aria_labelAttr);
+      return element->fastGetAttribute(aria_labelAttr);
     case AOMStringProperty::kLive:
-      return element->getAttribute(aria_liveAttr);
+      return element->fastGetAttribute(aria_liveAttr);
     case AOMStringProperty::kOrientation:
-      return element->getAttribute(aria_orientationAttr);
+      return element->fastGetAttribute(aria_orientationAttr);
     case AOMStringProperty::kPlaceholder:
-      return element->getAttribute(aria_placeholderAttr);
+      return element->fastGetAttribute(aria_placeholderAttr);
     case AOMStringProperty::kRelevant:
-      return element->getAttribute(aria_relevantAttr);
+      return element->fastGetAttribute(aria_relevantAttr);
     case AOMStringProperty::kRole:
-      return element->getAttribute(roleAttr);
+      return element->fastGetAttribute(roleAttr);
     case AOMStringProperty::kRoleDescription:
-      return element->getAttribute(aria_roledescriptionAttr);
+      return element->fastGetAttribute(aria_roledescriptionAttr);
     case AOMStringProperty::kSort:
-      return element->getAttribute(aria_sortAttr);
+      return element->fastGetAttribute(aria_sortAttr);
     case AOMStringProperty::kValueText:
-      return element->getAttribute(aria_valuetextAttr);
+      return element->fastGetAttribute(aria_valuetextAttr);
   }
 
   NOTREACHED();
   return nullAtom;
 }
 
+// static
+bool AccessibleNode::getProperty(Element* element,
+                                 AOMBooleanProperty property,
+                                 bool& isNull) {
+  isNull = true;
+  if (!element)
+    return false;
+
+  if (AccessibleNode* accessibleNode = element->existingAccessibleNode()) {
+    for (const auto& item : accessibleNode->m_booleanProperties) {
+      if (item.first == property) {
+        isNull = false;
+        return item.second;
+      }
+    }
+  }
+
+  // Fall back on the equivalent ARIA attribute.
+  AtomicString attrValue;
+  switch (property) {
+    case AOMBooleanProperty::kAtomic:
+      attrValue = element->fastGetAttribute(aria_atomicAttr);
+      break;
+    case AOMBooleanProperty::kBusy:
+      attrValue = element->fastGetAttribute(aria_busyAttr);
+      break;
+    case AOMBooleanProperty::kDisabled:
+      attrValue = element->fastGetAttribute(aria_disabledAttr);
+      break;
+    case AOMBooleanProperty::kExpanded:
+      attrValue = element->fastGetAttribute(aria_expandedAttr);
+      break;
+    case AOMBooleanProperty::kHidden:
+      attrValue = element->fastGetAttribute(aria_hiddenAttr);
+      break;
+    case AOMBooleanProperty::kModal:
+      attrValue = element->fastGetAttribute(aria_modalAttr);
+      break;
+    case AOMBooleanProperty::kMultiline:
+      attrValue = element->fastGetAttribute(aria_multilineAttr);
+      break;
+    case AOMBooleanProperty::kMultiselectable:
+      attrValue = element->fastGetAttribute(aria_multiselectableAttr);
+      break;
+    case AOMBooleanProperty::kReadOnly:
+      attrValue = element->fastGetAttribute(aria_readonlyAttr);
+      break;
+    case AOMBooleanProperty::kRequired:
+      attrValue = element->fastGetAttribute(aria_requiredAttr);
+      break;
+    case AOMBooleanProperty::kSelected:
+      attrValue = element->fastGetAttribute(aria_selectedAttr);
+      break;
+  }
+
+  if (attrValue.isNull())
+    return false;
+
+  isNull = false;
+  return equalIgnoringASCIICase(attrValue, "true");
+}
+
+bool AccessibleNode::atomic(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kAtomic, isNull);
+}
+
+void AccessibleNode::setAtomic(bool atomic) {
+  setBooleanProperty(AOMBooleanProperty::kAtomic, atomic);
+  notifyAttributeChanged(aria_atomicAttr);
+}
+
 AtomicString AccessibleNode::autocomplete() const {
   return getProperty(m_element, AOMStringProperty::kAutocomplete);
 }
 
 void AccessibleNode::setAutocomplete(const AtomicString& autocomplete) {
   setStringProperty(AOMStringProperty::kAutocomplete, autocomplete);
   notifyAttributeChanged(aria_autocompleteAttr);
 }
 
+bool AccessibleNode::busy(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kBusy, isNull);
+}
+
+void AccessibleNode::setBusy(bool busy) {
+  setBooleanProperty(AOMBooleanProperty::kBusy, busy);
+  notifyAttributeChanged(aria_busyAttr);
+}
+
 AtomicString AccessibleNode::checked() const {
   return getProperty(m_element, AOMStringProperty::kChecked);
 }
 
 void AccessibleNode::setChecked(const AtomicString& checked) {
   setStringProperty(AOMStringProperty::kChecked, checked);
   notifyAttributeChanged(aria_checkedAttr);
 }
 
 AtomicString AccessibleNode::current() const {
   return getProperty(m_element, AOMStringProperty::kCurrent);
 }
 
 void AccessibleNode::setCurrent(const AtomicString& current) {
   setStringProperty(AOMStringProperty::kCurrent, current);
 
   if (AXObjectCache* cache = m_element->document().existingAXObjectCache())
     cache->handleAttributeChanged(aria_currentAttr, m_element);
 }
 
+bool AccessibleNode::disabled(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kDisabled, isNull);
+}
+
+void AccessibleNode::setDisabled(bool disabled) {
+  setBooleanProperty(AOMBooleanProperty::kDisabled, disabled);
+  notifyAttributeChanged(aria_disabledAttr);
+}
+
+bool AccessibleNode::expanded(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kExpanded, isNull);
+}
+
+void AccessibleNode::setExpanded(bool expanded) {
+  setBooleanProperty(AOMBooleanProperty::kExpanded, expanded);
+  notifyAttributeChanged(aria_expandedAttr);
+}
+
+bool AccessibleNode::hidden(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kHidden, isNull);
+}
+
+void AccessibleNode::setHidden(bool hidden) {
+  setBooleanProperty(AOMBooleanProperty::kHidden, hidden);
+  notifyAttributeChanged(aria_hiddenAttr);
+}
+
 AtomicString AccessibleNode::invalid() const {
   return getProperty(m_element, AOMStringProperty::kInvalid);
 }
 
 void AccessibleNode::setInvalid(const AtomicString& invalid) {
   setStringProperty(AOMStringProperty::kInvalid, invalid);
   notifyAttributeChanged(aria_invalidAttr);
 }
 
 AtomicString AccessibleNode::keyShortcuts() const {
@@ skipping 16 matching lines @@
 
 AtomicString AccessibleNode::live() const {
   return getProperty(m_element, AOMStringProperty::kLive);
 }
 
 void AccessibleNode::setLive(const AtomicString& live) {
   setStringProperty(AOMStringProperty::kLive, live);
   notifyAttributeChanged(aria_liveAttr);
 }
 
+bool AccessibleNode::modal(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kModal, isNull);
+}
+
+void AccessibleNode::setModal(bool modal) {
+  setBooleanProperty(AOMBooleanProperty::kModal, modal);
+  notifyAttributeChanged(aria_modalAttr);
+}
+
+bool AccessibleNode::multiline(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kMultiline, isNull);
+}
+
+void AccessibleNode::setMultiline(bool multiline) {
+  setBooleanProperty(AOMBooleanProperty::kMultiline, multiline);
+  notifyAttributeChanged(aria_multilineAttr);
+}
+
+bool AccessibleNode::multiselectable(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kMultiselectable, isNull);
+}
+
+void AccessibleNode::setMultiselectable(bool multiselectable) {
+  setBooleanProperty(AOMBooleanProperty::kMultiselectable, multiselectable);
+  notifyAttributeChanged(aria_multiselectableAttr);
+}
+
 AtomicString AccessibleNode::orientation() const {
   return getProperty(m_element, AOMStringProperty::kOrientation);
 }
 
 void AccessibleNode::setOrientation(const AtomicString& orientation) {
   setStringProperty(AOMStringProperty::kOrientation, orientation);
   notifyAttributeChanged(aria_orientationAttr);
 }
 
 AtomicString AccessibleNode::placeholder() const {
   return getProperty(m_element, AOMStringProperty::kPlaceholder);
 }
 
 void AccessibleNode::setPlaceholder(const AtomicString& placeholder) {
   setStringProperty(AOMStringProperty::kPlaceholder, placeholder);
   notifyAttributeChanged(aria_placeholderAttr);
 }
 
+bool AccessibleNode::readOnly(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kReadOnly, isNull);
+}
+
+void AccessibleNode::setReadOnly(bool readOnly) {
+  setBooleanProperty(AOMBooleanProperty::kReadOnly, readOnly);
+  notifyAttributeChanged(aria_readonlyAttr);
+}
+
 AtomicString AccessibleNode::relevant() const {
   return getProperty(m_element, AOMStringProperty::kRelevant);
 }
 
 void AccessibleNode::setRelevant(const AtomicString& relevant) {
   setStringProperty(AOMStringProperty::kRelevant, relevant);
   notifyAttributeChanged(aria_relevantAttr);
 }
 
+bool AccessibleNode::required(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kRequired, isNull);
+}
+
+void AccessibleNode::setRequired(bool required) {
+  setBooleanProperty(AOMBooleanProperty::kRequired, required);
+  notifyAttributeChanged(aria_requiredAttr);
+}
+
 AtomicString AccessibleNode::role() const {
   return getProperty(m_element, AOMStringProperty::kRole);
 }
 
 void AccessibleNode::setRole(const AtomicString& role) {
   setStringProperty(AOMStringProperty::kRole, role);
   notifyAttributeChanged(roleAttr);
 }
 
 AtomicString AccessibleNode::roleDescription() const {
   return getProperty(m_element, AOMStringProperty::kRoleDescription);
 }
 
 void AccessibleNode::setRoleDescription(const AtomicString& roleDescription) {
   setStringProperty(AOMStringProperty::kRoleDescription, roleDescription);
   notifyAttributeChanged(aria_roledescriptionAttr);
 }
 
+bool AccessibleNode::selected(bool& isNull) const {
+  return getProperty(m_element, AOMBooleanProperty::kSelected, isNull);
+}
+
+void AccessibleNode::setSelected(bool selected) {
+  setBooleanProperty(AOMBooleanProperty::kSelected, selected);
+  notifyAttributeChanged(aria_selectedAttr);
+}
+
 AtomicString AccessibleNode::sort() const {
   return getProperty(m_element, AOMStringProperty::kSort);
 }
 
 void AccessibleNode::setSort(const AtomicString& sort) {
   setStringProperty(AOMStringProperty::kSort, sort);
   notifyAttributeChanged(aria_sortAttr);
 }
 
 AtomicString AccessibleNode::valueText() const {
@@ skipping 10 matching lines @@
   for (auto& item : m_stringProperties) {
     if (item.first == property) {
       item.second = value;
       return;
     }
   }
 
   m_stringProperties.push_back(std::make_pair(property, value));
 }
 
+void AccessibleNode::setBooleanProperty(AOMBooleanProperty property,
+                                        bool value) {
+  for (auto& item : m_booleanProperties) {
+    if (item.first == property) {
+      item.second = value;
+      return;
+    }
+  }
+
+  m_booleanProperties.push_back(std::make_pair(property, value));
+}
+
 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, m_element);
 }
 
 AXObjectCache* AccessibleNode::getAXObjectCache() {
   return m_element->document().existingAXObjectCache();
 }
 
 DEFINE_TRACE(AccessibleNode) {
   visitor->trace(m_element);
 }
 
 }  // namespace blink