Boolean properties for 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 367 matching lines @@
 
   ax_object_cache_ = nullptr;
 }
 
 bool AXObject::IsDetached() const {
   return !ax_object_cache_;
 }
 
 const AtomicString& AXObject::GetAOMPropertyOrARIAAttribute(
     AOMStringProperty property) const {
-  Node* node = this->GetNode();
-  if (!node || !node->IsElementNode())
-    return g_null_atom;
+  if (Element* element = this->GetElement())
+    return AccessibleNode::GetProperty(element, property);
+  return g_null_atom;
+}
 
-  return AccessibleNode::GetProperty(ToElement(node), property);
+bool AXObject::HasAOMPropertyOrARIAAttribute(AOMBooleanProperty property,
+                                             bool& result) const {
+  Element* element = this->GetElement();
+  if (!element)
+    return false;
+
+  bool is_null = true;
+  result = AccessibleNode::GetProperty(element, property, is_null);
+  return !is_null;
+}
+
+bool AXObject::AOMPropertyOrARIAAttributeIsTrue(
+    AOMBooleanProperty property) const {
+  bool result;
+  if (HasAOMPropertyOrARIAAttribute(property, result))
+    return result;
+  return false;
+}
+
+bool AXObject::AOMPropertyOrARIAAttributeIsFalse(
+    AOMBooleanProperty property) const {
+  bool result;
+  if (HasAOMPropertyOrARIAAttribute(property, result))
+    return !result;
+  return false;
 }
 
 bool AXObject::IsARIATextControl() const {
   return AriaRoleAttribute() == kTextFieldRole ||
          AriaRoleAttribute() == kSearchBoxRole ||
          AriaRoleAttribute() == kComboBoxRole;
 }
 
 bool AXObject::IsButton() const {
   AccessibilityRole role = RoleValue();
@@ skipping 157 matching lines @@
   cached_live_region_root_ =
       IsLiveRegion()
           ? const_cast<AXObject*>(this)
           : (ParentObjectIfExists() ? ParentObjectIfExists()->LiveRegionRoot()
                                     : 0);
   cached_ancestor_exposes_active_descendant_ =
       ComputeAncestorExposesActiveDescendant();
 }
 
 bool AXObject::AccessibilityIsIgnoredByDefault(
-    IgnoredReasons* ignored_reasons) const {
-  return DefaultObjectInclusion(ignored_reasons) == kIgnoreObject;
+    IgnoredReasons* ignoredReasons) const {
+  return DefaultObjectInclusion(ignoredReasons) == kIgnoreObject;
 }
 
 AXObjectInclusion AXObject::AccessibilityPlatformIncludesObject() const {
   if (IsMenuListPopup() || IsMenuListOption())
     return kIncludeObject;
 
   return kDefaultBehavior;
 }
 
 AXObjectInclusion AXObject::DefaultObjectInclusion(
@@ skipping 15 matching lines @@
 
   return AccessibilityPlatformIncludesObject();
 }
 
 bool AXObject::IsInertOrAriaHidden() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_inert_or_aria_hidden_;
 }
 
 bool AXObject::ComputeIsInertOrAriaHidden(
-    IgnoredReasons* ignored_reasons) const {
+    IgnoredReasons* ignoredReasons) const {
   if (GetNode()) {
     if (GetNode()->IsInert()) {
-      if (ignored_reasons) {
+      if (ignoredReasons) {
         HTMLDialogElement* dialog = GetActiveDialogElement(GetNode());
         if (dialog) {
           AXObject* dialog_object = AxObjectCache().GetOrCreate(dialog);
           if (dialog_object)
-            ignored_reasons->push_back(
+            ignoredReasons->push_back(
                 IgnoredReason(kAXActiveModalDialog, dialog_object));
           else
-            ignored_reasons->push_back(IgnoredReason(kAXInert));
+            ignoredReasons->push_back(IgnoredReason(kAXInert));
         } else {
           // TODO(aboxhall): handle inert attribute if it eventuates
-          ignored_reasons->push_back(IgnoredReason(kAXInert));
+          ignoredReasons->push_back(IgnoredReason(kAXInert));
         }
       }
       return true;
     }
   } else {
     AXObject* parent = ParentObject();
     if (parent && parent->IsInertOrAriaHidden()) {
-      if (ignored_reasons)
-        parent->ComputeIsInertOrAriaHidden(ignored_reasons);
+      if (ignoredReasons)
+        parent->ComputeIsInertOrAriaHidden(ignoredReasons);
       return true;
     }
   }
 
   const AXObject* hidden_root = AriaHiddenRoot();
   if (hidden_root) {
-    if (ignored_reasons) {
+    if (ignoredReasons) {
       if (hidden_root == this)
-        ignored_reasons->push_back(IgnoredReason(kAXAriaHidden));
+        ignoredReasons->push_back(IgnoredReason(kAXAriaHidden));
       else
-        ignored_reasons->push_back(
+        ignoredReasons->push_back(
             IgnoredReason(kAXAriaHiddenRoot, hidden_root));
     }
     return true;
   }
 
   return false;
 }
 
 bool AXObject::IsDescendantOfLeafNode() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_descendant_of_leaf_node_;
 }
 
 AXObject* AXObject::LeafNodeAncestor() const {
   if (AXObject* parent = ParentObject()) {
     if (!parent->CanHaveChildren())
       return parent;
 
     return parent->LeafNodeAncestor();
   }
 
   return 0;
 }
 
 const AXObject* AXObject::AriaHiddenRoot() const {
   for (const AXObject* object = this; object; object = object->ParentObject()) {
-    if (EqualIgnoringASCIICase(object->GetAttribute(aria_hiddenAttr), "true"))
+    if (object->AOMPropertyOrARIAAttributeIsTrue(AOMBooleanProperty::kHidden))
       return object;
   }
 
   return 0;
 }
 
 bool AXObject::IsDescendantOfDisabledNode() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_descendant_of_disabled_node_;
 }
 
 const AXObject* AXObject::DisabledAncestor() const {
-  const AtomicString& disabled = GetAttribute(aria_disabledAttr);
-  if (EqualIgnoringASCIICase(disabled, "true"))
-    return this;
-  if (EqualIgnoringASCIICase(disabled, "false"))
-    return 0;
+  bool disabled = false;
+  if (HasAOMPropertyOrARIAAttribute(AOMBooleanProperty::kDisabled, disabled)) {
+    if (disabled)
+      return this;
+    return nullptr;
+  }
 
   if (AXObject* parent = ParentObject())
     return parent->DisabledAncestor();
 
-  return 0;
+  return nullptr;
 }
 
 bool AXObject::LastKnownIsIgnoredValue() {
   if (last_known_is_ignored_value_ == kDefaultBehavior)
     last_known_is_ignored_value_ =
         AccessibilityIsIgnored() ? kIgnoreObject : kIncludeObject;
 
   return last_known_is_ignored_value_ == kIgnoreObject;
 }
 
@@ skipping 84 matching lines @@
                                           AXObjectSet& visited) {
   if (visited.Contains(&ax_obj) && !in_aria_labelled_by_traversal)
     return String();
 
   AXNameFrom tmp_name_from;
   return ax_obj.TextAlternative(true, in_aria_labelled_by_traversal, visited,
                                 tmp_name_from, nullptr, nullptr);
 }
 
 bool AXObject::IsHiddenForTextAlternativeCalculation() const {
-  if (EqualIgnoringASCIICase(GetAttribute(aria_hiddenAttr), "false"))
+  if (AOMPropertyOrARIAAttributeIsFalse(AOMBooleanProperty::kHidden))
     return false;
 
   if (GetLayoutObject())
     return GetLayoutObject()->Style()->Visibility() != EVisibility::kVisible;
 
   // This is an obscure corner case: if a node has no LayoutObject, that means
   // it's not rendered, but we still may be exploring it as part of a text
   // alternative calculation, for example if it was explicitly referenced by
   // aria-labelledby. So we need to explicitly call the style resolver to check
   // whether it's invisible or display:none, rather than relying on the style
@@ skipping 125 matching lines @@
   }
   if (!found_valid_element)
     return String();
   if (related_objects)
     *related_objects = local_related_objects;
   return accumulated_text.ToString();
 }
 
 void AXObject::TokenVectorFromAttribute(Vector<String>& tokens,
                                         const QualifiedName& attribute) const {
-  Node* node = this->GetNode();
-  if (!node || !node->IsElementNode())
-    return;
-
   String attribute_value = GetAttribute(attribute).GetString();
   if (attribute_value.IsEmpty())
     return;
 
   attribute_value.SimplifyWhiteSpace();
   attribute_value.Split(' ', tokens);
 }
 
 void AXObject::ElementsFromAttribute(HeapVector<Member<Element>>& elements,
                                      const QualifiedName& attribute) const {
@@ skipping 76 matching lines @@
 
   if (isHTMLTextAreaElement(*node))
     return true;
 
   if (HasEditableStyle(*node))
     return true;
 
   if (!IsNativeTextControl() && !IsNonNativeTextControl())
     return false;
 
-  return EqualIgnoringASCIICase(GetAttribute(aria_multilineAttr), "true");
+  return AOMPropertyOrARIAAttributeIsTrue(AOMBooleanProperty::kMultiline);
 }
 
 bool AXObject::AriaPressedIsPresent() const {
   return !GetAttribute(aria_pressedAttr).IsEmpty();
 }
 
 bool AXObject::SupportsActiveDescendant() const {
   // According to the ARIA Spec, all ARIA composite widgets, ARIA text boxes
   // and ARIA groups should be able to expose an active descendant.
   // Implicitly, <input> and <textarea> elements should also have this ability.
@@ skipping 156 matching lines @@
 
 void AXObject::ClearChildren() {
   // Detach all weak pointers from objects to their parents.
   for (const auto& child : children_)
     child->DetachFromParent();
 
   children_.clear();
   have_children_ = false;
 }
 
+Element* AXObject::GetElement() const {
+  Node* node = GetNode();
+  return node && node->IsElementNode() ? ToElement(node) : nullptr;
+}
+
 Document* AXObject::GetDocument() const {
   FrameView* frame_view = DocumentFrameView();
   if (!frame_view)
     return 0;
 
   return frame_view->GetFrame().GetDocument();
 }
 
 FrameView* AXObject::DocumentFrameView() const {
   const AXObject* object = this;
@@ skipping 19 matching lines @@
     Document* doc = GetDocument();
     if (doc)
       return doc->ContentLanguage();
     return g_null_atom;
   }
 
   return parent->Language();
 }
 
 bool AXObject::HasAttribute(const QualifiedName& attribute) const {
-  Node* element_node = GetNode();
-  if (!element_node)
-    return false;
-
-  if (!element_node->IsElementNode())
-    return false;
-
-  Element* element = ToElement(element_node);
-  return element->FastHasAttribute(attribute);
+  if (Element* element = GetElement())
+    return element->FastHasAttribute(attribute);
+  return false;
 }
 
 const AtomicString& AXObject::GetAttribute(
     const QualifiedName& attribute) const {
-  Node* element_node = GetNode();
-  if (!element_node)
-    return g_null_atom;
-
-  if (!element_node->IsElementNode())
-    return g_null_atom;
-
-  Element* element = ToElement(element_node);
-  return element->FastGetAttribute(attribute);
+  if (Element* element = GetElement())
+    return element->FastGetAttribute(attribute);
+  return g_null_atom;
 }
 
 //
 // Scrollable containers.
 //
 
 bool AXObject::IsScrollableContainer() const {
   return !!GetScrollableAreaIfScrollable();
 }
 
@@ skipping 424 matching lines @@
     previous_position = current_position;
     current_position = PreviousLinePosition(current_position, LayoutUnit(),
                                             kHasEditableAXRole);
     ++line_count;
   } while (current_position.IsNotNull() &&
            !InSameLine(current_position, previous_position));
 
   return line_count;
 }
 
-bool AXObject::IsARIAControl(AccessibilityRole aria_role) {
-  return IsARIAInput(aria_role) || aria_role == kButtonRole ||
-         aria_role == kComboBoxRole || aria_role == kSliderRole;
+bool AXObject::IsARIAControl(AccessibilityRole ariaRole) {
+  return IsARIAInput(ariaRole) || ariaRole == kButtonRole ||
+         ariaRole == kComboBoxRole || ariaRole == kSliderRole;
 }
 
-bool AXObject::IsARIAInput(AccessibilityRole aria_role) {
-  return aria_role == kRadioButtonRole || aria_role == kCheckBoxRole ||
-         aria_role == kTextFieldRole || aria_role == kSwitchRole ||
-         aria_role == kSearchBoxRole;
+bool AXObject::IsARIAInput(AccessibilityRole ariaRole) {
+  return ariaRole == kRadioButtonRole || ariaRole == kCheckBoxRole ||
+         ariaRole == kTextFieldRole || ariaRole == kSwitchRole ||
+         ariaRole == kSearchBoxRole;
 }
 
 AccessibilityRole AXObject::AriaRoleToWebCoreRole(const String& value) {
   DCHECK(!value.IsEmpty());
 
   static const ARIARoleMap* role_map = CreateARIARoleMap();
 
   Vector<String> role_vector;
   value.Split(' ', role_vector);
   AccessibilityRole role = kUnknownRole;
@@ skipping 78 matching lines @@
     case kTreeItemRole:
     case kUserInterfaceTooltipRole:
       return true;
     case kRowRole: {
       // Spec says we should always expose the name on rows,
       // but for performance reasons we only do it
       // if the row might receive focus
       if (AncestorExposesActiveDescendant()) {
         return true;
       }
-      const Node* node = this->GetNode();
-      return node && node->IsElementNode() && ToElement(node)->IsFocusable();
+      const Element* element = this->GetElement();
+      return element && element->IsFocusable();
     }
     default:
       return false;
   }
 }
 
 AccessibilityRole AXObject::ButtonRoleType() const {
   // If aria-pressed is present, then it should be exposed as a toggle button.
   // http://www.w3.org/TR/wai-aria/states_and_properties#aria-pressed
   if (AriaPressedIsPresent())
@@ skipping 20 matching lines @@
 }
 
 DEFINE_TRACE(AXObject) {
   visitor->Trace(children_);
   visitor->Trace(parent_);
   visitor->Trace(cached_live_region_root_);
   visitor->Trace(ax_object_cache_);
 }
 
 }  // namespace blink