Boolean properties for Accessibility Object Model Phase 1

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

 /*
 * Copyright (C) 2008 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 159 matching lines @@
       cur = ToLayoutInline(cur)->InlineElementContinuation();
       DCHECK(cur || !ToLayoutInline(prev)->Continuation());
     } else {
       cur = ToLayoutBlockFlow(cur)->InlineElementContinuation();
     }
   }
 
   return prev;
 }
 
-static inline bool LastChildHasContinuation(LayoutObject* layout_object) {
-  LayoutObject* last_child = layout_object->SlowLastChild();
+static inline bool LastChildHasContinuation(LayoutObject* layoutObject) {
+  LayoutObject* last_child = layoutObject->SlowLastChild();
   return last_child && IsInlineWithContinuation(last_child);
 }
 
 static LayoutBoxModelObject* NextContinuation(LayoutObject* layout_object) {
   DCHECK(layout_object);
   if (layout_object->IsLayoutInline() && !layout_object->IsAtomicInlineLevel())
     return ToLayoutInline(layout_object)->Continuation();
   if (layout_object->IsLayoutBlockFlow())
     return ToLayoutBlockFlow(layout_object)->InlineElementContinuation();
   return 0;
 }
 
 AXLayoutObject::AXLayoutObject(LayoutObject* layout_object,
                                AXObjectCacheImpl& ax_object_cache)
     : AXNodeObject(layout_object->GetNode(), ax_object_cache),
       layout_object_(layout_object) {
 #if DCHECK_IS_ON()
-  layout_object_->SetHasAXObject(true);
+  m_layoutObject->setHasAXObject(true);
 #endif
 }
 
 AXLayoutObject* AXLayoutObject::Create(LayoutObject* layout_object,
                                        AXObjectCacheImpl& ax_object_cache) {
   return new AXLayoutObject(layout_object, ax_object_cache);
 }
 
 AXLayoutObject::~AXLayoutObject() {
   DCHECK(IsDetached());
@@ skipping 99 matching lines @@
 void AXLayoutObject::Init() {
   AXNodeObject::Init();
 }
 
 void AXLayoutObject::Detach() {
   AXNodeObject::Detach();
 
   DetachRemoteSVGRoot();
 
 #if DCHECK_IS_ON()
-  if (layout_object_)
-    layout_object_->SetHasAXObject(false);
+  if (m_layoutObject)
+    m_layoutObject->setHasAXObject(false);
 #endif
   layout_object_ = 0;
 }
 
 //
 // Check object role or purpose.
 //
 
 static bool IsLinkable(const AXObject& object) {
   if (!object.GetLayoutObject())
@@ skipping 120 matching lines @@
        GetDocument()->GetFrame()->Selection().IsFocusedAndActive()))
     return true;
 
   return false;
 }
 
 bool AXLayoutObject::IsSelected() const {
   if (!GetLayoutObject() || !GetNode())
     return false;
 
-  const AtomicString& aria_selected = GetAttribute(aria_selectedAttr);
-  if (EqualIgnoringASCIICase(aria_selected, "true"))
+  if (AOMPropertyOrARIAAttributeIsTrue(AOMBooleanProperty::kSelected))
     return true;
 
   AXObject* focused_object = AxObjectCache().FocusedObject();
   if (AriaRoleAttribute() == kListBoxOptionRole && focused_object &&
       focused_object->ActiveDescendant() == this) {
     return true;
   }
 
   if (IsTabItem() && IsTabItemSelected())
     return true;
@@ skipping 12 matching lines @@
 
   if (!layout_object_) {
     if (ignored_reasons)
       ignored_reasons->push_back(IgnoredReason(kAXNotRendered));
     return kIgnoreObject;
   }
 
   if (layout_object_->Style()->Visibility() != EVisibility::kVisible) {
     // aria-hidden is meant to override visibility as the determinant in AX
     // hierarchy inclusion.
-    if (EqualIgnoringASCIICase(GetAttribute(aria_hiddenAttr), "false"))
+    if (AOMPropertyOrARIAAttributeIsFalse(AOMBooleanProperty::kHidden))
       return kDefaultBehavior;
 
     if (ignored_reasons)
       ignored_reasons->push_back(IgnoredReason(kAXNotVisible));
     return kIgnoreObject;
   }
 
   return AXObject::DefaultObjectInclusion(ignored_reasons);
 }
 
 bool AXLayoutObject::ComputeAccessibilityIsIgnored(
-    IgnoredReasons* ignored_reasons) const {
+    IgnoredReasons* ignoredReasons) const {
 #if DCHECK_IS_ON()
-  DCHECK(initialized_);
+  DCHECK(m_initialized);
 #endif
 
   if (!layout_object_)
     return true;
 
   // Check first if any of the common reasons cause this element to be ignored.
   // Then process other use cases that need to be applied to all the various
   // roles that AXLayoutObjects take on.
-  AXObjectInclusion decision = DefaultObjectInclusion(ignored_reasons);
+  AXObjectInclusion decision = DefaultObjectInclusion(ignoredReasons);
   if (decision == kIncludeObject)
     return false;
   if (decision == kIgnoreObject)
     return true;
 
   if (layout_object_->IsAnonymousBlock())
     return true;
 
   // If this element is within a parent that cannot have children, it should not
   // be exposed.
   if (IsDescendantOfLeafNode()) {
-    if (ignored_reasons)
-      ignored_reasons->push_back(
+    if (ignoredReasons)
+      ignoredReasons->push_back(
           IgnoredReason(kAXAncestorIsLeafNode, LeafNodeAncestor()));
     return true;
   }
 
   if (RoleValue() == kIgnoredRole) {
-    if (ignored_reasons)
-      ignored_reasons->push_back(IgnoredReason(kAXUninteresting));
+    if (ignoredReasons)
+      ignoredReasons->push_back(IgnoredReason(kAXUninteresting));
     return true;
   }
 
   if (HasInheritedPresentationalRole()) {
-    if (ignored_reasons) {
+    if (ignoredReasons) {
       const AXObject* inherits_from = InheritsPresentationalRoleFrom();
       if (inherits_from == this)
-        ignored_reasons->push_back(IgnoredReason(kAXPresentationalRole));
+        ignoredReasons->push_back(IgnoredReason(kAXPresentationalRole));
       else
-        ignored_reasons->push_back(
+        ignoredReasons->push_back(
             IgnoredReason(kAXInheritsPresentation, inherits_from));
     }
     return true;
   }
 
   // An ARIA tree can only have tree items and static text as children.
   if (AXObject* tree_ancestor = TreeAncestorDisallowingChild()) {
-    if (ignored_reasons)
-      ignored_reasons->push_back(
+    if (ignoredReasons)
+      ignoredReasons->push_back(
           IgnoredReason(kAXAncestorDisallowsChild, tree_ancestor));
     return true;
   }
 
   // A LayoutPart is an iframe element or embedded object element or something
   // like that. We don't want to ignore those.
   if (layout_object_->IsLayoutPart())
     return false;
 
   // Make sure renderers with layers stay in the tree.
   if (GetLayoutObject() && GetLayoutObject()->HasLayer() && GetNode() &&
       GetNode()->hasChildren())
     return false;
 
   // Find out if this element is inside of a label element.  If so, it may be
   // ignored because it's the label for a checkbox or radio button.
   AXObject* control_object = CorrespondingControlForLabelElement();
   if (control_object && control_object->IsCheckboxOrRadio() &&
       control_object->NameFromLabelElement()) {
-    if (ignored_reasons) {
+    if (ignoredReasons) {
       HTMLLabelElement* label = LabelElementContainer();
       if (label && label != GetNode()) {
         AXObject* label_ax_object = AxObjectCache().GetOrCreate(label);
-        ignored_reasons->push_back(
+        ignoredReasons->push_back(
             IgnoredReason(kAXLabelContainer, label_ax_object));
       }
 
-      ignored_reasons->push_back(IgnoredReason(kAXLabelFor, control_object));
+      ignoredReasons->push_back(IgnoredReason(kAXLabelFor, control_object));
     }
     return true;
   }
 
   if (layout_object_->IsBR())
     return false;
 
   if (IsLink())
     return false;
 
   if (IsInPageLinkTarget())
     return false;
 
   if (layout_object_->IsText()) {
     // Static text beneath MenuItems and MenuButtons are just reported along
     // with the menu item, so it's ignored on an individual level.
     AXObject* parent = ParentObjectUnignored();
     if (parent && (parent->AriaRoleAttribute() == kMenuItemRole ||
                    parent->AriaRoleAttribute() == kMenuButtonRole)) {
-      if (ignored_reasons)
-        ignored_reasons->push_back(
+      if (ignoredReasons)
+        ignoredReasons->push_back(
             IgnoredReason(kAXStaticTextUsedAsNameFor, parent));
       return true;
     }
     LayoutText* layout_text = ToLayoutText(layout_object_);
     if (!layout_text->HasTextBoxes()) {
-      if (ignored_reasons)
-        ignored_reasons->push_back(IgnoredReason(kAXEmptyText));
+      if (ignoredReasons)
+        ignoredReasons->push_back(IgnoredReason(kAXEmptyText));
       return true;
     }
 
     // Don't ignore static text in editable text controls.
     for (AXObject* parent = ParentObject(); parent;
          parent = parent->ParentObject()) {
       if (parent->RoleValue() == kTextFieldRole)
         return false;
     }
 
     // Text elements that are just empty whitespace should not be returned.
     // FIXME(dmazzoni): we probably shouldn't ignore this if the style is 'pre',
     // or similar...
     if (layout_text->GetText().Impl()->ContainsOnlyWhitespace()) {
-      if (ignored_reasons)
-        ignored_reasons->push_back(IgnoredReason(kAXEmptyText));
+      if (ignoredReasons)
+        ignoredReasons->push_back(IgnoredReason(kAXEmptyText));
       return true;
     }
     return false;
   }
 
   if (IsHeading())
     return false;
 
   if (IsLandmarkRelated())
     return false;
@@ skipping 70 matching lines @@
 
   // <span> tags are inline tags and not meant to convey information if they
   // have no other aria information on them. If we don't ignore them, they may
   // emit signals expected to come from their parent. In addition, because
   // included spans are GroupRole objects, and GroupRole objects are often
   // containers with meaningful information, the inclusion of a span can have
   // the side effect of causing the immediate parent accessible to be ignored.
   // This is especially problematic for platforms which have distinct roles for
   // textual block elements.
   if (isHTMLSpanElement(node)) {
-    if (ignored_reasons)
-      ignored_reasons->push_back(IgnoredReason(kAXUninteresting));
+    if (ignoredReasons)
+      ignoredReasons->push_back(IgnoredReason(kAXUninteresting));
     return true;
   }
 
   if (IsImage())
     return false;
 
   if (IsCanvas()) {
     if (CanvasHasFallbackContent())
       return false;
     LayoutHTMLCanvas* canvas = ToLayoutHTMLCanvas(layout_object_);
     if (canvas->Size().Height() <= 1 || canvas->Size().Width() <= 1) {
-      if (ignored_reasons)
-        ignored_reasons->push_back(IgnoredReason(kAXProbablyPresentational));
+      if (ignoredReasons)
+        ignoredReasons->push_back(IgnoredReason(kAXProbablyPresentational));
       return true;
     }
     // Otherwise fall through; use presence of help text, title, or description
     // to decide.
   }
 
   if (IsWebArea() || layout_object_->IsListMarker())
     return false;
 
   // Using the help text, title or accessibility description (so we
@@ skipping 23 matching lines @@
   if (layout_object_->IsLayoutBlockFlow() && layout_object_->ChildrenInline() &&
       !CanSetFocusAttribute()) {
     // If the layout object has any plain text in it, that text will be
     // inside a LineBox, so the layout object will have a first LineBox.
     bool has_any_text = !!ToLayoutBlockFlow(layout_object_)->FirstLineBox();
 
     // Always include interesting-looking objects.
     if (has_any_text || MouseButtonListener())
       return false;
 
-    if (ignored_reasons)
-      ignored_reasons->push_back(IgnoredReason(kAXUninteresting));
+    if (ignoredReasons)
+      ignoredReasons->push_back(IgnoredReason(kAXUninteresting));
     return true;
   }
 
   // By default, objects should be ignored so that the AX hierarchy is not
   // filled with unnecessary items.
-  if (ignored_reasons)
-    ignored_reasons->push_back(IgnoredReason(kAXUninteresting));
+  if (ignoredReasons)
+    ignoredReasons->push_back(IgnoredReason(kAXUninteresting));
   return true;
 }
 
 //
 // Properties of static elements.
 //
 
 const AtomicString& AXLayoutObject::AccessKey() const {
   Node* node = layout_object_->GetNode();
   if (!node)
@@ skipping 568 matching lines @@
       GetAOMPropertyOrARIAAttribute(AOMStringProperty::kRelevant);
 
   // Default aria-relevant = "additions text".
   if (relevant.IsEmpty())
     return default_live_region_relevant;
 
   return relevant;
 }
 
 bool AXLayoutObject::LiveRegionAtomic() const {
+  bool atomic = false;
+  if (HasAOMPropertyOrARIAAttribute(AOMBooleanProperty::kAtomic, atomic))
+    return atomic;
+
   // ARIA roles "alert" and "status" should have an implicit aria-atomic value
   // of true.
-  if (GetAttribute(aria_atomicAttr).IsEmpty() &&
-      (RoleValue() == kAlertRole || RoleValue() == kStatusRole)) {
-    return true;
-  }
-  return ElementAttributeValue(aria_atomicAttr);
+  return RoleValue() == kAlertRole || RoleValue() == kStatusRole;
 }
 
 bool AXLayoutObject::LiveRegionBusy() const {
-  return ElementAttributeValue(aria_busyAttr);
+  return AOMPropertyOrARIAAttributeIsTrue(AOMBooleanProperty::kBusy);
 }
 
 //
 // Hit testing.
 //
 
 AXObject* AXLayoutObject::AccessibilityHitTest(const IntPoint& point) const {
   if (!layout_object_ || !layout_object_->HasLayer())
     return nullptr;
 
@@ skipping 612 matching lines @@
   if (anchor_visible_position.IsNull() || focus_visible_position.IsNull())
     return;
 
   frame->Selection().SetSelection(
       SelectionInDOMTree::Builder()
           .Collapse(anchor_visible_position.ToPositionWithAffinity())
           .Extend(focus_visible_position.DeepEquivalent())
           .Build());
 }
 
-bool AXLayoutObject::IsValidSelectionBound(const AXObject* bound_object) const {
-  return GetLayoutObject() && bound_object && !bound_object->IsDetached() &&
-         bound_object->IsAXLayoutObject() && bound_object->GetLayoutObject() &&
-         bound_object->GetLayoutObject()->GetFrame() ==
+bool AXLayoutObject::IsValidSelectionBound(const AXObject* boundObject) const {
+  return GetLayoutObject() && boundObject && !boundObject->IsDetached() &&
+         boundObject->IsAXLayoutObject() && boundObject->GetLayoutObject() &&
+         boundObject->GetLayoutObject()->GetFrame() ==
              GetLayoutObject()->GetFrame() &&
-         &bound_object->AxObjectCache() == &AxObjectCache();
+         &boundObject->AxObjectCache() == &AxObjectCache();
 }
 
 void AXLayoutObject::SetValue(const String& string) {
   if (!GetNode() || !GetNode()->IsElementNode())
     return;
   if (!layout_object_ || !layout_object_->IsBoxModelObject())
     return;
 
   LayoutBoxModelObject* layout_object = ToLayoutBoxModelObject(layout_object_);
   if (layout_object->IsTextField() && isHTMLInputElement(*GetNode()))
@@ skipping 469 matching lines @@
 
   if (root->AccessibilityIsIgnored()) {
     for (const auto& child : root->Children())
       children_.push_back(child);
   } else {
     children_.push_back(root);
   }
 }
 
 bool AXLayoutObject::ElementAttributeValue(
-    const QualifiedName& attribute_name) const {
+    const QualifiedName& attributeName) const {
   if (!layout_object_)
     return false;
 
-  return EqualIgnoringASCIICase(GetAttribute(attribute_name), "true");
+  return EqualIgnoringASCIICase(GetAttribute(attributeName), "true");
 }
 
 }  // namespace blink