Add sparse accessibility attribute interface to Blink

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 14 matching lines @@
  * (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/DocumentUserGestureToken.h"
 #include "core/dom/Element.h"
 #include "core/dom/NodeTraversal.h"
+#include "core/dom/QualifiedName.h"
 #include "core/dom/Text.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLDListElement.h"
 #include "core/html/HTMLFieldSetElement.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
@@ skipping 18 matching lines @@
 #include "core/svg/SVGElement.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/text/PlatformLocale.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
+class AddSparseAttributeHelper {
+ public:
+  virtual void Run(const AXObject*,
+                   AXSparseAttributeMap&,
+                   const AtomicString& value) = 0;
+};
+
+typedef HashMap<QualifiedName, AddSparseAttributeHelper*>
+    AXSparseAttributeHelperMap;
+
+class AddBoolAttributeHelper : public AddSparseAttributeHelper {
+ public:
+  AddBoolAttributeHelper(AXBoolAttribute attribute) : m_attribute(attribute) {}
+
+ private:
+  AXBoolAttribute m_attribute;
+
+  void Run(const AXObject* obj,
+           AXSparseAttributeMap& attributeMap,
+           const AtomicString& value) override {
+    attributeMap.addBoolAttribute(m_attribute,
+                                  equalIgnoringCase(value, "true"));
+  }
+};
+
+class AddStringAttributeHelper : public AddSparseAttributeHelper {
+ public:
+  AddStringAttributeHelper(AXStringAttribute attribute)
+      : m_attribute(attribute) {}
+
+ private:
+  AXStringAttribute m_attribute;
+
+  void Run(const AXObject* obj,
+           AXSparseAttributeMap& attributeMap,
+           const AtomicString& value) override {
+    attributeMap.addStringAttribute(m_attribute, value);
+  }
+};
+
+class AddObjectAttributeHelper : public AddSparseAttributeHelper {
+ public:
+  AddObjectAttributeHelper(AXObjectAttribute attribute)
+      : m_attribute(attribute) {}
+
+ private:
+  AXObjectAttribute m_attribute;
+
+  void Run(const AXObject* obj,
+           AXSparseAttributeMap& attributeMap,
+           const AtomicString& value) override {
+    if (value.isNull() || value.isEmpty())
+      return;
+
+    Node* node = obj->getNode();
+    if (!node || !node->isElementNode())
+      return;
+    Element* target = toElement(node)->treeScope().getElementById(value);
+    if (!target)
+      return;
+    AXObject* axTarget = obj->axObjectCache().getOrCreate(target);
+    if (axTarget)
+      attributeMap.addObjectAttribute(m_attribute, axTarget);
+  }
+};
+
+class AddObjectVectorAttributeHelper : public AddSparseAttributeHelper {
+ public:
+  AddObjectVectorAttributeHelper(AXObjectVectorAttribute attribute)
+      : m_attribute(attribute) {}
+
+ private:
+  AXObjectVectorAttribute m_attribute;
+
+  void Run(const AXObject* obj,
+           AXSparseAttributeMap& attributeMap,
+           const AtomicString& value) override {
+    Node* node = obj->getNode();
+    if (!node || !node->isElementNode())
+      return;
+
+    String attributeValue = value.getString();
+    if (attributeValue.isEmpty())
+      return;
+
+    attributeValue.simplifyWhiteSpace();
+    Vector<String> ids;
+    attributeValue.split(' ', ids);
+    if (ids.isEmpty())
+      return;
+
+    HeapVector<Member<AXObject>> objects;
+    TreeScope& scope = node->treeScope();
+    for (const auto& id : ids) {
+      if (Element* idElement = scope.getElementById(AtomicString(id))) {
+        AXObject* axIdElement = obj->axObjectCache().getOrCreate(idElement);
+        if (axIdElement && !axIdElement->accessibilityIsIgnored())
+          objects.append(axIdElement);
+      }
+    }
+
+    attributeMap.addObjectVectorAttribute(m_attribute, objects);
+  }
+};
+
 AXNodeObject::AXNodeObject(Node* node, AXObjectCacheImpl& axObjectCache)
     : AXObject(axObjectCache),
       m_ariaRole(UnknownRole),
       m_childrenDirty(false),
 #if ENABLE(ASSERT)
       m_initialized(false),
 #endif
       m_node(node) {
 }
 
@@ skipping 662 matching lines @@
   m_initialized = true;
 #endif
   m_role = determineAccessibilityRole();
 }
 
 void AXNodeObject::detach() {
   AXObject::detach();
   m_node = nullptr;
 }
 
+void AXNodeObject::getSparseAXAttributes(
+    AXSparseAttributeMap& sparseAttributeMap) const {
+  Node* node = this->getNode();
+  if (!node || !node->isElementNode())
+    return;
+
+  // Use a map from attribute name to properties of that attribute.
+  // That way we only need to iterate over the list of attributes once,
+  // rather than calling getAttribute() once for each possible obscure
+  // accessibility attribute.
+  DEFINE_STATIC_LOCAL(AXSparseAttributeHelperMap, axSparseAttributeHelperMap,
+                      ());
+  if (axSparseAttributeHelperMap.isEmpty()) {
+    axSparseAttributeHelperMap.set(

[aboxhall, 2017/01/10 05:59:59]

Perhaps pull this block out into a helper function? It dominates this method
even though it should only run once.

[dmazzoni, 2017/01/12 03:36:24]

Done.

+        aria_activedescendantAttr,
+        new AddObjectAttributeHelper(AXObjectAttribute::AriaActiveDescendant));
+    axSparseAttributeHelperMap.set(aria_controlsAttr,
+                                   new AddObjectVectorAttributeHelper(
+                                       AXObjectVectorAttribute::AriaControls));
+    axSparseAttributeHelperMap.set(aria_detailsAttr,
+                                   new AddObjectVectorAttributeHelper(
+                                       AXObjectVectorAttribute::AriaDetails));
+    axSparseAttributeHelperMap.set(
+        aria_errormessageAttr,
+        new AddObjectAttributeHelper(AXObjectAttribute::AriaErrorMessage));
+    axSparseAttributeHelperMap.set(aria_flowtoAttr,
+                                   new AddObjectVectorAttributeHelper(
+                                       AXObjectVectorAttribute::AriaFlowTo));
+    axSparseAttributeHelperMap.set(
+        aria_keyshortcutsAttr,
+        new AddStringAttributeHelper(AXStringAttribute::AriaKeyShortcuts));
+    axSparseAttributeHelperMap.set(
+        aria_modalAttr, new AddBoolAttributeHelper(AXBoolAttribute::AriaModal));
+    axSparseAttributeHelperMap.set(
+        aria_roledescriptionAttr,
+        new AddStringAttributeHelper(AXStringAttribute::AriaRoleDescription));
+  }
+
+  AttributeCollection attributes = toElement(node)->attributesWithoutUpdate();
+  for (const Attribute& attr : attributes) {
+    AddSparseAttributeHelper* helper =
+        axSparseAttributeHelperMap.get(attr.name());
+    if (helper)
+      helper->Run(this, sparseAttributeMap, attr.value());
+  }
+}
+
 bool AXNodeObject::isAnchor() const {
   return !isNativeImage() && isLink();
 }
 
 bool AXNodeObject::isControl() const {
   Node* node = this->getNode();
   if (!node)
     return false;
 
   return ((node->isElementNode() && toElement(node)->isFormControlElement()) ||
@@ skipping 2127 matching lines @@
     return String();
   return toTextControlElement(node)->strippedPlaceholder();
 }
 
 DEFINE_TRACE(AXNodeObject) {
   visitor->trace(m_node);
   AXObject::trace(visitor);
 }
 
 }  // namespace blink