Finish all string 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 14 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(HTMLNames::aria_autocompleteAttr);
+    case AOMStringProperty::kChecked:
+      return element->getAttribute(HTMLNames::aria_checkedAttr);
+    case AOMStringProperty::kCurrent:
+      return element->getAttribute(HTMLNames::aria_currentAttr);
+    case AOMStringProperty::kInvalid:
+      return element->getAttribute(HTMLNames::aria_invalidAttr);
+    case AOMStringProperty::kKeyShortcuts:
+      return element->getAttribute(HTMLNames::aria_keyshortcutsAttr);
+    case AOMStringProperty::kLabel:
+      return element->getAttribute(HTMLNames::aria_labelAttr);
+    case AOMStringProperty::kLive:
+      return element->getAttribute(HTMLNames::aria_liveAttr);
+    case AOMStringProperty::kOrientation:
+      return element->getAttribute(HTMLNames::aria_orientationAttr);
+    case AOMStringProperty::kPlaceholder:
+      return element->getAttribute(HTMLNames::aria_placeholderAttr);
+    case AOMStringProperty::kRelevant:
+      return element->getAttribute(HTMLNames::aria_relevantAttr);
     case AOMStringProperty::kRole:
       return element->getAttribute(HTMLNames::roleAttr);
-    case AOMStringProperty::kLabel:
-      return element->getAttribute(HTMLNames::aria_labelAttr);
+    case AOMStringProperty::kRoleDescription:
+      return element->getAttribute(HTMLNames::aria_roledescriptionAttr);
+    case AOMStringProperty::kSort:
+      return element->getAttribute(HTMLNames::aria_sortAttr);
+    case AOMStringProperty::kValueText:
+      return element->getAttribute(HTMLNames::aria_valuetextAttr);
     default:

[esprehn, 2017/04/04 06:22:30]

If you remove the default it'll fail to compile if you forgot a case, we prefer
that and instead put the NOTREACHED() and return nullAtom below it outside the
switch

[dmazzoni, 2017/04/04 18:59:17]

Done.

       NOTREACHED();
       return nullAtom;
   }
 }
 
+AtomicString AccessibleNode::autocomplete() const {
+  return getProperty(m_element, AOMStringProperty::kAutocomplete);
+}
+
+void AccessibleNode::setAutocomplete(const AtomicString& autocomplete) {
+  setStringProperty(AOMStringProperty::kAutocomplete, autocomplete);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())

[esprehn, 2017/04/04 06:22:30]

You do this same thing everywhere, maybe you want a shared private method?

notifyAttributeChanged(HTMLNames::aria_autocompleteAttr)

we also sometimes do using namespace HTMLNames at the top of the .cpp file so
you can avoid writing HTMLNames:: repeatedly

[dmazzoni, 2017/04/04 18:59:17]

Done.

Actually, glad I looked at this. We should be calling
Document.existingAXObjectCache() here.
Done.

+    cache->handleAttributeChanged(HTMLNames::aria_autocompleteAttr, m_element);
+}
+
+AtomicString AccessibleNode::checked() const {
+  return getProperty(m_element, AOMStringProperty::kChecked);
+}
+
+void AccessibleNode::setChecked(const AtomicString& checked) {
+  setStringProperty(AOMStringProperty::kChecked, checked);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_checkedAttr, m_element);
+}
+
+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().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_currentAttr, m_element);
+}
+
+AtomicString AccessibleNode::invalid() const {
+  return getProperty(m_element, AOMStringProperty::kInvalid);
+}
+
+void AccessibleNode::setInvalid(const AtomicString& invalid) {
+  setStringProperty(AOMStringProperty::kInvalid, invalid);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_invalidAttr, m_element);
+}
+
+AtomicString AccessibleNode::keyShortcuts() const {
+  return getProperty(m_element, AOMStringProperty::kKeyShortcuts);
+}
+
+void AccessibleNode::setKeyShortcuts(const AtomicString& keyShortcuts) {
+  setStringProperty(AOMStringProperty::kKeyShortcuts, keyShortcuts);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_keyshortcutsAttr, m_element);
+}
+
+AtomicString AccessibleNode::label() const {
+  return getProperty(m_element, AOMStringProperty::kLabel);
+}
+
+void AccessibleNode::setLabel(const AtomicString& label) {
+  setStringProperty(AOMStringProperty::kLabel, label);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_labelAttr, m_element);
+}
+
+AtomicString AccessibleNode::live() const {
+  return getProperty(m_element, AOMStringProperty::kLive);
+}
+
+void AccessibleNode::setLive(const AtomicString& live) {
+  setStringProperty(AOMStringProperty::kLive, live);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_liveAttr, m_element);
+}
+
+AtomicString AccessibleNode::orientation() const {
+  return getProperty(m_element, AOMStringProperty::kOrientation);
+}
+
+void AccessibleNode::setOrientation(const AtomicString& orientation) {
+  setStringProperty(AOMStringProperty::kOrientation, orientation);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_orientationAttr, m_element);
+}
+
+AtomicString AccessibleNode::placeholder() const {
+  return getProperty(m_element, AOMStringProperty::kPlaceholder);
+}
+
+void AccessibleNode::setPlaceholder(const AtomicString& placeholder) {
+  setStringProperty(AOMStringProperty::kPlaceholder, placeholder);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_placeholderAttr, m_element);
+}
+
+AtomicString AccessibleNode::relevant() const {
+  return getProperty(m_element, AOMStringProperty::kRelevant);
+}
+
+void AccessibleNode::setRelevant(const AtomicString& relevant) {
+  setStringProperty(AOMStringProperty::kRelevant, relevant);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_relevantAttr, m_element);
+}
+
 AtomicString AccessibleNode::role() const {
   return getProperty(m_element, AOMStringProperty::kRole);
 }
 
 void AccessibleNode::setRole(const AtomicString& role) {
   setStringProperty(AOMStringProperty::kRole, role);
 
   // TODO(dmazzoni): Make a cleaner API for this rather than pretending
   // the DOM attribute changed.
   if (AXObjectCache* cache = m_element->document().axObjectCache())
     cache->handleAttributeChanged(HTMLNames::roleAttr, m_element);
 }
 
-AtomicString AccessibleNode::label() const {
-  return getProperty(m_element, AOMStringProperty::kLabel);
+AtomicString AccessibleNode::roleDescription() const {
+  return getProperty(m_element, AOMStringProperty::kRoleDescription);
 }
 
-void AccessibleNode::setLabel(const AtomicString& label) {
-  setStringProperty(AOMStringProperty::kLabel, label);
+void AccessibleNode::setRoleDescription(const AtomicString& roleDescription) {
+  setStringProperty(AOMStringProperty::kRoleDescription, roleDescription);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache()) {
+    cache->handleAttributeChanged(HTMLNames::aria_roledescriptionAttr,
+                                  m_element);
+  }
+}
+
+AtomicString AccessibleNode::sort() const {
+  return getProperty(m_element, AOMStringProperty::kSort);
+}
+
+void AccessibleNode::setSort(const AtomicString& sort) {
+  setStringProperty(AOMStringProperty::kSort, sort);
 
   if (AXObjectCache* cache = m_element->document().axObjectCache())
-    cache->handleAttributeChanged(HTMLNames::aria_labelAttr, m_element);
+    cache->handleAttributeChanged(HTMLNames::aria_sortAttr, m_element);
+}
+
+AtomicString AccessibleNode::valueText() const {
+  return getProperty(m_element, AOMStringProperty::kValueText);
+}
+
+void AccessibleNode::setValueText(const AtomicString& valueText) {
+  setStringProperty(AOMStringProperty::kValueText, valueText);
+
+  if (AXObjectCache* cache = m_element->document().axObjectCache())
+    cache->handleAttributeChanged(HTMLNames::aria_valuetextAttr, m_element);
 }
 
 void AccessibleNode::setStringProperty(AOMStringProperty property,
                                        const AtomicString& value) {
   for (auto& item : m_stringProperties) {
     if (item.first == property) {
       item.second = value;
       return;
     }
   }
 
   m_stringProperties.push_back(std::make_pair(property, value));
 }
 
 DEFINE_TRACE(AccessibleNode) {
   visitor->trace(m_element);
 }
 
 }  // namespace blink