Use explicit DOM cast template for presentationalRole handling.

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 165 matching lines @@
         return true;
 
     return m_role == UnknownRole;
 }
 
 static bool isListElement(Node* node)
 {
     return isHTMLUListElement(*node) || isHTMLOListElement(*node) || isHTMLDListElement(*node);
 }
 
-static bool isPresentationRoleInTable(AXObject* parent, Node* child)
+static bool isPresentationalInTable(AXObject* parent, HTMLElement* currentElement)
 {
+    if (!currentElement)
+        return false;
+
     Node* parentNode = parent->node();
-    if (!parentNode || !parentNode->isElementNode())
+    if (!parentNode || !parentNode->isHTMLElement())
         return false;
 
     // AXTable determines the role as checking isTableXXX.
     // If Table has explicit role including presentation, AXTable doesn't assign implicit Role
     // to a whole Table. That's why we should check it based on node.
     // Normal Table Tree is that
     // cell(its role)-> tr(tr role)-> tfoot, tbody, thead(ignored role) -> table(table role).
     // If table has presentation role, it will be like
     // cell(group)-> tr(unknown) -> tfoot, tbody, thead(ignored) -> table(presentation).
-    if (child && isHTMLTableCellElement(*child) && isHTMLTableRowElement(*parentNode))
+    if (isHTMLTableCellElement(*currentElement) && isHTMLTableRowElement(*parentNode))
         return parent->hasInheritedPresentationalRole();
 
-    if (isHTMLTableRowElement(child) && isHTMLTableSectionElement(*parentNode)) {
+    if (isHTMLTableRowElement(*currentElement) && isHTMLTableSectionElement(toHTMLElement(*parentNode))) {
         // Because TableSections have ignored role, presentation should be checked with its parent node
         AXObject* tableObject = parent->parentObject();
         Node* tableNode = tableObject ? tableObject->node() : 0;
         return isHTMLTableElement(tableNode) && tableObject->hasInheritedPresentationalRole();
     }
     return false;
 }
 
-static bool isRequiredOwnedElement(AXObject* parent, AccessibilityRole childRole, Node* childNode)
+static bool isRequiredOwnedElement(AXObject* parent, AccessibilityRole currentRole, HTMLElement* currentElement)
 {
     Node* parentNode = parent->node();
-    if (!parentNode || !parentNode->isElementNode())
+    if (!parentNode || !parentNode->isHTMLElement())
         return false;
 
-    if (childRole == ListItemRole)
+    if (currentRole == ListItemRole)
         return isListElement(parentNode);
-    if (childRole == ListMarkerRole)
+    if (currentRole == ListMarkerRole)
         return isHTMLLIElement(*parentNode);
-    if (childRole == MenuItemCheckBoxRole || childRole ==  MenuItemRole || childRole ==  MenuItemRadioRole)
+    if (currentRole == MenuItemCheckBoxRole || currentRole ==  MenuItemRole || currentRole ==  MenuItemRadioRole)
         return isHTMLMenuElement(*parentNode);
 
-    if (childNode && isHTMLTableCellElement(*childNode))
+    if (!currentElement)
+        return false;
+    if (isHTMLTableCellElement(*currentElement))
         return isHTMLTableRowElement(*parentNode);
-    if (isHTMLTableRowElement(childNode))
-        return isHTMLTableSectionElement(*parentNode);
+    if (isHTMLTableRowElement(*currentElement))
+        return isHTMLTableSectionElement(toHTMLElement(*parentNode));
 
     // In case of ListboxRole and it's child, ListBoxOptionRole,
     // Inheritance of presentation role is handled in AXListBoxOption
     // Because ListBoxOption Role doesn't have any child.
     // If it's just ignored because of presentation, we can't see any AX tree related to ListBoxOption.
     return false;
 }
 
 
 const AXObject* AXNodeObject::inheritsPresentationalRoleFrom() const
 {
     // ARIA states if an item can get focus, it should not be presentational.
     if (canSetFocusAttribute())
         return 0;
 
     if (isPresentational())
         return this;
 
     // http://www.w3.org/TR/wai-aria/complete#presentation
     // ARIA spec says that the user agent MUST apply an inherited role of presentation
     // to any owned elements that do not have an explicit role defined.
     if (ariaRoleAttribute() != UnknownRole)
         return 0;
 
     AXObject* parent = parentObject();
     if (!parent)
         return 0;
 
-    Node* curNode = node();
+    HTMLElement* element = nullptr;
+    if (node() && node()->isHTMLElement())
+        element = toHTMLElement(node());
     if (!parent->hasInheritedPresentationalRole()
-        && !isPresentationRoleInTable(parent, curNode))
+        && !isPresentationalInTable(parent, element))
         return 0;
-
     // ARIA spec says that when a parent object is presentational and this object
     // is a required owned element of that parent, then this object is also presentational.
-    if (isRequiredOwnedElement(parent, roleValue(), curNode))
+    if (isRequiredOwnedElement(parent, roleValue(), element))
         return parent;
     return 0;
 }
 
 bool AXNodeObject::isDescendantOfElementType(const HTMLQualifiedName& tagName) const
 {
     if (!node())
         return false;
 
     for (Element* parent = node()->parentElement(); parent; parent = parent->parentElement()) {
@@ skipping 1938 matching lines @@
         ariaLabeledByElements(elements);
 
         for (const auto& element : elements) {
             RefPtr<AXObject> axElement = axObjectCache()->getOrCreate(element);
             textOrder.append(AccessibilityText(ariaLabeledBy, AlternativeText, axElement));
         }
     }
 }
 
 } // namespace blink