Initial skeleton of Accessibility Object Model Phase 1

third_party/WebKit/Source/modules/accessibility/AXObject.cpp

 /*
  * Copyright (C) 2008, 2009, 2011 Apple 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/AXObject.h"
 
 #include "SkMatrix44.h"
 #include "core/css/resolver/StyleResolver.h"
+#include "core/dom/AccessibleNode.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLDialogElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/layout/LayoutBoxModelObject.h"
@@ skipping 328 matching lines @@
   // no children are left with dangling pointers to their parent.
   clearChildren();
 
   m_axObjectCache = nullptr;
 }
 
 bool AXObject::isDetached() const {
   return !m_axObjectCache;
 }
 
+using AOMStringPropertyToAriaMap = HashMap<AOMStringProperty,
+                                           QualifiedName,
+                                           WTF::IntHash<AOMStringProperty>,
+                                           AOMStringPropertyHashTraits>;
+
+static AOMStringPropertyToAriaMap& getAOMStringPropertyToAriaMap() {
+  DEFINE_STATIC_LOCAL(AOMStringPropertyToAriaMap, map, ());
+  if (map.isEmpty()) {
+    map.set(AOMStringProperty::Role, roleAttr);

[esprehn, 2017/03/22 03:40:32]

Can we just use roleAttr as the key into the AOM map instead? You're doing a lot
of mapping from X -> Y. If the AccessibleObject just stored a Vector or HashMap
of AtomicString and you used roleAttr as the key that'd be much simpler.

[dmazzoni, 2017/03/23 03:36:41]

I got rid of this HashMap, instead now we can just switch in AccessibleNode.

+    map.set(AOMStringProperty::Label, aria_labelAttr);

[esprehn, 2017/03/22 03:40:32]

calling set() repeatedly inlines the hash function at every call site. You want
a static array of pairs and to loop over it calling .set() instead if you want
this map to get bigger.

Since your whole thing is just a big table of enum -> AtomicString going through
a hash table is super expensive though you could just use the enum index and do
vector[enum] => AtomicString instead and avoid any hashing.

+  }
+  return map;
+}
+
+AccessibleNode* AXObject::getAccessibleNode() const {
+  if (!RuntimeEnabledFeatures::accessibilityObjectModelEnabled())
+    return nullptr;
+
+  Node* node = getNode();
+  if (!node || !node->isElementNode())
+    return nullptr;
+
+  Element* element = toElement(node);
+  return element->accessibleNode();
+}
+
+const AtomicString& AXObject::getAriaAttributeOrAOMProperty(
+    AOMStringProperty property) const {
+  AOMStringPropertyToAriaMap& ariaMap = getAOMStringPropertyToAriaMap();
+  QualifiedName attrName = ariaMap.at(property);
+  if (attrName != QualifiedName::null()) {
+    const AtomicString& result = getAttribute(attrName);
+    if (!result.isNull())
+      return result;
+  }
+
+  AccessibleNode* aomNode = getAccessibleNode();
+  if (aomNode)

[esprehn, 2017/03/22 03:40:32]

We often combines these like:

if (auto* node = getAccessibleNode())
  return node->getProperty(property);

[dmazzoni, 2017/03/23 03:36:41]

Done.

+    return aomNode->getProperty(property);
+
+  return nullAtom;
+}
+
 bool AXObject::isARIATextControl() const {
   return ariaRoleAttribute() == TextFieldRole ||
          ariaRoleAttribute() == SearchBoxRole ||
          ariaRoleAttribute() == ComboBoxRole;
 }
 
 bool AXObject::isButton() const {
   AccessibilityRole role = roleValue();
 
   return role == ButtonRole || role == PopUpButtonRole ||
@@ skipping 405 matching lines @@
     }
   }
 
   // Step 2C from: http://www.w3.org/TR/accname-aam-1.1
   // If you change this logic, update AXNodeObject::nameFromLabelElement, too.
   nameFrom = AXNameFromAttribute;
   if (nameSources) {
     nameSources->push_back(NameSource(*foundTextAlternative, aria_labelAttr));
     nameSources->back().type = nameFrom;
   }
-  const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
+  const AtomicString& ariaLabel =
+      getAriaAttributeOrAOMProperty(AOMStringProperty::Label);
   if (!ariaLabel.isEmpty()) {
     textAlternative = ariaLabel;
 
     if (nameSources) {
       NameSource& source = nameSources->back();
       source.text = textAlternative;
       source.attributeValue = ariaLabel;
       *foundTextAlternative = true;
     } else {
       *foundTextAlternative = true;
@@ skipping 945 matching lines @@
 }
 
 DEFINE_TRACE(AXObject) {
   visitor->trace(m_children);
   visitor->trace(m_parent);
   visitor->trace(m_cachedLiveRegionRoot);
   visitor->trace(m_axObjectCache);
 }
 
 }  // namespace blink