reflow comments in modules/accessiblity

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 166 matching lines @@
 }
 
 bool AXNodeObject::computeAccessibilityIsIgnored(
     IgnoredReasons* ignoredReasons) const {
 #if ENABLE(ASSERT)
   // Double-check that an AXObject is never accessed before
   // it's been initialized.
   ASSERT(m_initialized);
 #endif
 
-  // If this element is within a parent that cannot have children, it should not be exposed.
+  // If this element is within a parent that cannot have children, it should not
+  // be exposed.
   if (isDescendantOfLeafNode()) {
     if (ignoredReasons)
       ignoredReasons->append(
           IgnoredReason(AXAncestorIsLeafNode, leafNodeAncestor()));
     return true;
   }
 
   // Ignore labels that are already referenced by a control.
   AXObject* controlObject = correspondingControlForLabelElement();
   if (controlObject && controlObject->isCheckboxOrRadio() &&
@@ skipping 35 matching lines @@
 static bool isPresentationalInTable(AXObject* parent,
                                     HTMLElement* currentElement) {
   if (!currentElement)
     return false;
 
   Node* parentNode = parent->getNode();
   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.
+  // 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).
+  // 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).
+  // cell(group)-> tr(unknown) -> tfoot, tbody, thead(ignored) ->
+  //     table(presentation).
   if (isHTMLTableCellElement(*currentElement) &&
       isHTMLTableRowElement(*parentNode))
     return parent->hasInheritedPresentationalRole();
 
   if (isHTMLTableRowElement(*currentElement) &&
       isHTMLTableSectionElement(toHTMLElement(*parentNode))) {
-    // Because TableSections have ignored role, presentation should be checked with its parent node
+    // Because TableSections have ignored role, presentation should be checked
+    // with its parent node.
     AXObject* tableObject = parent->parentObject();
     Node* tableNode = tableObject ? tableObject->getNode() : 0;
     return isHTMLTableElement(tableNode) &&
            tableObject->hasInheritedPresentationalRole();
   }
   return false;
 }
 
 static bool isRequiredOwnedElement(AXObject* parent,
                                    AccessibilityRole currentRole,
@@ skipping 10 matching lines @@
       currentRole == MenuItemRadioRole)
     return isHTMLMenuElement(*parentNode);
 
   if (!currentElement)
     return false;
   if (isHTMLTableCellElement(*currentElement))
     return isHTMLTableRowElement(*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.
+  // In case of ListboxRole and its 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
+  // 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;
 
   HTMLElement* element = nullptr;
   if (getNode() && getNode()->isHTMLElement())
     element = toHTMLElement(getNode());
   if (!parent->hasInheritedPresentationalRole()) {
     if (!getLayoutObject() || !getLayoutObject()->isBoxModelObject())
       return 0;
 
     LayoutBoxModelObject* cssBox = toLayoutBoxModelObject(getLayoutObject());
     if (!cssBox->isTableCell() && !cssBox->isTableRow())
       return 0;
 
     if (!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.
+  // is a required owned element of that parent, then this object is also
+  // presentational.
   if (isRequiredOwnedElement(parent, roleValue(), element))
     return parent;
   return 0;
 }
 
 bool AXNodeObject::isDescendantOfElementType(
     const HTMLQualifiedName& tagName) const {
   if (!getNode())
     return false;
 
   for (Element* parent = getNode()->parentElement(); parent;
        parent = parent->parentElement()) {
     if (parent->hasTagName(tagName))
       return true;
   }
   return false;
 }
 
 AccessibilityRole AXNodeObject::nativeAccessibilityRoleIgnoringAria() const {
   if (!getNode())
     return UnknownRole;
 
   // HTMLAnchorElement sets isLink only when it has hrefAttr.
-  // We assume that it is also LinkRole if it has event listners even though it doesn't have hrefAttr.
+  // We assume that it is also LinkRole if it has event listners even though it
+  // doesn't have hrefAttr.
   if (getNode()->isLink() || (isHTMLAnchorElement(*getNode()) && isClickable()))
     return LinkRole;
 
   if (isHTMLButtonElement(*getNode()))
     return buttonRoleType();
 
   if (isHTMLDetailsElement(*getNode()))
     return DetailsRole;
 
   if (isHTMLSummaryElement(*getNode())) {
@@ skipping 128 matching lines @@
 
   if (getNode()->hasTagName(sectionTag))
     return RegionRole;
 
   if (getNode()->hasTagName(addressTag))
     return ContentInfoRole;
 
   if (isHTMLDialogElement(*getNode()))
     return DialogRole;
 
-  // The HTML element should not be exposed as an element. That's what the LayoutView element does.
+  // The HTML element should not be exposed as an element. That's what the
+  // LayoutView element does.
   if (isHTMLHtmlElement(*getNode()))
     return IgnoredRole;
 
   if (isHTMLIFrameElement(*getNode())) {
     const AtomicString& ariaRole = getAttribute(roleAttr);
     if (ariaRole == "none" || ariaRole == "presentation")
       return IframePresentationalRole;
     return IframeRole;
   }
 
-  // There should only be one banner/contentInfo per page. If header/footer are being used within an article or section
-  // then it should not be exposed as whole page's banner/contentInfo but as a group role.
+  // There should only be one banner/contentInfo per page. If header/footer are
+  // being used within an article or section then it should not be exposed as
+  // whole page's banner/contentInfo but as a group role.
   if (getNode()->hasTagName(headerTag)) {
     if (isDescendantOfElementType(articleTag) ||
         isDescendantOfElementType(sectionTag) ||
         (getNode()->parentElement() &&
          getNode()->parentElement()->hasTagName(mainTag))) {
       return GroupRole;
     }
     return BannerRole;
   }
 
@@ skipping 133 matching lines @@
 
   // If it's a control, it's not generic.
   if (isControl())
     return false;
 
   // If it has an aria role, it's not generic.
   if (m_ariaRole != UnknownRole)
     return false;
 
   // If the content editable attribute is set on this element, that's the reason
-  // it's focusable, and existing logic should handle this case already - so it's not a
-  // generic focusable element.
+  // it's focusable, and existing logic should handle this case already - so
+  // it's not a generic focusable element.
 
   if (hasContentEditableAttributeSet())
     return false;
 
-  // The web area and body element are both focusable, but existing logic handles these
-  // cases already, so we don't need to include them here.
+  // The web area and body element are both focusable, but existing logic
+  // handles these cases already, so we don't need to include them here.
   if (roleValue() == WebAreaRole)
     return false;
   if (isHTMLBodyElement(getNode()))
     return false;
 
-  // An SVG root is focusable by default, but it's probably not interactive, so don't
-  // include it. It can still be made accessible by giving it an ARIA role.
+  // An SVG root is focusable by default, but it's probably not interactive, so
+  // don't include it. It can still be made accessible by giving it an ARIA
+  // role.
   if (roleValue() == SVGRootRole)
     return false;
 
   return true;
 }
 
 AXObject* AXNodeObject::menuButtonForMenu() const {
   Element* menuItem = menuItemElementForMenu();
 
   if (menuItem) {
-    // ARIA just has generic menu items. AppKit needs to know if this is a top level items like MenuBarButton or MenuBarItem
+    // ARIA just has generic menu items. AppKit needs to know if this is a top
+    // level items like MenuBarButton or MenuBarItem
     AXObject* menuItemAX = axObjectCache().getOrCreate(menuItem);
     if (menuItemAX && menuItemAX->isMenuButton())
       return menuItemAX;
   }
   return 0;
 }
 
 static Element* siblingWithAriaRole(String role, Node* node) {
   Node* parent = node->parentNode();
   if (!parent)
@@ skipping 22 matching lines @@
     return 0;
 
   if (!node->isElementNode())
     node = node->parentElement();
 
   if (!node)
     return 0;
 
   for (Element* element = toElement(node); element;
        element = element->parentElement()) {
-    // It's a pretty common practice to put click listeners on the body or document, but that's
-    // almost never what the user wants when clicking on an accessible element.
+    // It's a pretty common practice to put click listeners on the body or
+    // document, but that's almost never what the user wants when clicking on an
+    // accessible element.
     if (isHTMLBodyElement(element))
       break;
 
     if (element->hasEventListeners(EventTypeNames::click) ||
         element->hasEventListeners(EventTypeNames::mousedown) ||
         element->hasEventListeners(EventTypeNames::mouseup) ||
         element->hasEventListeners(EventTypeNames::DOMActivate))
       return element;
   }
 
   return 0;
 }
 
 AccessibilityRole AXNodeObject::remapAriaRoleDueToParent(
     AccessibilityRole role) const {
   // Some objects change their role based on their parent.
-  // However, asking for the unignoredParent calls accessibilityIsIgnored(), which can trigger a loop.
-  // While inside the call stack of creating an element, we need to avoid accessibilityIsIgnored().
+  // However, asking for the unignoredParent calls accessibilityIsIgnored(),
+  // which can trigger a loop.  While inside the call stack of creating an
+  // element, we need to avoid accessibilityIsIgnored().
   // https://bugs.webkit.org/show_bug.cgi?id=65174
 
   if (role != ListBoxOptionRole && role != MenuItemRole)
     return role;
 
   for (AXObject* parent = parentObject();
        parent && !parent->accessibilityIsIgnored();
        parent = parent->parentObject()) {
     AccessibilityRole parentAriaRole = parent->ariaRoleAttribute();
 
-    // Selects and listboxes both have options as child roles, but they map to different roles within WebCore.
+    // Selects and listboxes both have options as child roles, but they map to
+    // different roles within WebCore.
     if (role == ListBoxOptionRole && parentAriaRole == MenuRole)
       return MenuItemRole;
-    // An aria "menuitem" may map to MenuButton or MenuItem depending on its parent.
+    // An aria "menuitem" may map to MenuButton or MenuItem depending on its
+    // parent.
     if (role == MenuItemRole && parentAriaRole == GroupRole)
       return MenuButtonRole;
 
-    // If the parent had a different role, then we don't need to continue searching up the chain.
+    // If the parent had a different role, then we don't need to continue
+    // searching up the chain.
     if (parentAriaRole)
       break;
   }
 
   return role;
 }
 
 void AXNodeObject::init() {
 #if ENABLE(ASSERT)
   ASSERT(!m_initialized);
@@ skipping 208 matching lines @@
   // Otherwise it's not checked
   return false;
 }
 
 bool AXNodeObject::isClickable() const {
   if (getNode()) {
     if (getNode()->isElementNode() &&
         toElement(getNode())->isDisabledFormControl())
       return false;
 
-    // Note: we can't call getNode()->willRespondToMouseClickEvents() because that triggers a style recalc and can delete this.
+    // Note: we can't call getNode()->willRespondToMouseClickEvents() because
+    // that triggers a style recalc and can delete this.
     if (getNode()->hasEventListeners(EventTypeNames::mouseup) ||
         getNode()->hasEventListeners(EventTypeNames::mousedown) ||
         getNode()->hasEventListeners(EventTypeNames::click) ||
         getNode()->hasEventListeners(EventTypeNames::DOMActivate))
       return true;
   }
 
   return AXObject::isClickable();
 }
 
@@ skipping 27 matching lines @@
 }
 
 bool AXNodeObject::isPressed() const {
   if (!isButton())
     return false;
 
   Node* node = this->getNode();
   if (!node)
     return false;
 
-  // ARIA button with aria-pressed not undefined, then check for aria-pressed attribute rather than getNode()->active()
+  // ARIA button with aria-pressed not undefined, then check for aria-pressed
+  // attribute rather than getNode()->active()
   if (ariaRoleAttribute() == ToggleButtonRole) {
     if (equalIgnoringCase(getAttribute(aria_pressedAttr), "true") ||
         equalIgnoringCase(getAttribute(aria_pressedAttr), "mixed"))
       return true;
     return false;
   }
 
   return node->active();
 }
 
@@ skipping 33 matching lines @@
 
   if (isWebArea())
     return true;
 
   // Children of elements with an aria-activedescendant attribute should be
   // focusable if they have a (non-presentational) ARIA role.
   if (!isPresentational() && ariaRoleAttribute() != UnknownRole &&
       ancestorExposesActiveDescendant())
     return true;
 
-  // NOTE: It would be more accurate to ask the document whether setFocusedNode() would
-  // do anything. For example, setFocusedNode() will do nothing if the current focused
-  // node will not relinquish the focus.
+  // NOTE: It would be more accurate to ask the document whether
+  // setFocusedNode() would do anything. For example, setFocusedNode() will do
+  // nothing if the current focused node will not relinquish the focus.
   if (isDisabledFormControl(node))
     return false;
 
   return node->isElementNode() && toElement(node)->supportsFocus();
 }
 
 bool AXNodeObject::canSetValueAttribute() const {
   if (equalIgnoringCase(getAttribute(aria_readonlyAttr), "true"))
     return false;
 
@@ skipping 395 matching lines @@
         return overriddenDescription;
     }
     if (!selectElement.multiple())
       return selectElement.value();
     return String();
   }
 
   if (isNativeTextControl())
     return text();
 
-  // Handle other HTML input elements that aren't text controls, like date and time
-  // controls, by returning the string value, with the exception of checkboxes
-  // and radio buttons (which would return "on").
+  // Handle other HTML input elements that aren't text controls, like date and
+  // time controls, by returning the string value, with the exception of
+  // checkboxes and radio buttons (which would return "on").
   if (isHTMLInputElement(node)) {
     HTMLInputElement* input = toHTMLInputElement(node);
     if (input->type() != InputTypeNames::checkbox &&
         input->type() != InputTypeNames::radio)
       return input->value();
   }
 
   return String();
 }
 
@@ skipping 25 matching lines @@
       if (!blockFlow->inlineBoxWrapper())
         return blockFlow;
     }
     current = current->parent();
   }
 
   ASSERT_NOT_REACHED();
   return nullptr;
 }
 
-// Returns true if |r1| and |r2| are both non-null, both inline, and are contained
-// within the same non-inline LayoutBlockFlow.
+// Returns true if |r1| and |r2| are both non-null, both inline, and are
+// contained within the same non-inline LayoutBlockFlow.
 static bool isInSameNonInlineBlockFlow(LayoutObject* r1, LayoutObject* r2) {
   if (!r1 || !r2)
     return false;
   if (!r1->isInline() || !r2->isInline())
     return false;
   LayoutBlockFlow* b1 = nonInlineBlockFlow(r1);
   LayoutBlockFlow* b2 = nonInlineBlockFlow(r2);
   return b1 && b2 && b1 == b2;
 }
 
 bool AXNodeObject::isNativeCheckboxInMixedState() const {
   if (!isHTMLInputElement(m_node))
     return false;
 
   HTMLInputElement* input = toHTMLInputElement(m_node);
   return input->type() == InputTypeNames::checkbox &&
          input->shouldAppearIndeterminate();
 }
 
 //
 // New AX name calculation.
 //
 
 String AXNodeObject::textAlternative(bool recursive,
                                      bool inAriaLabelledByTraversal,
                                      AXObjectSet& visited,
                                      AXNameFrom& nameFrom,
                                      AXRelatedObjectVector* relatedObjects,
                                      NameSources* nameSources) const {
-  // If nameSources is non-null, relatedObjects is used in filling it in, so it must be non-null as well.
+  // If nameSources is non-null, relatedObjects is used in filling it in, so it
+  // must be non-null as well.
   if (nameSources)
     ASSERT(relatedObjects);
 
   bool foundTextAlternative = false;
 
   if (!getNode() && !getLayoutObject())
     return String();
 
   String textAlternative = ariaTextAlternative(
       recursive, inAriaLabelledByTraversal, visited, nameFrom, relatedObjects,
@@ skipping 97 matching lines @@
   computeAriaOwnsChildren(ownedChildren);
   for (AXObject* obj = rawFirstChild(); obj; obj = obj->rawNextSibling()) {
     if (!axObjectCache().isAriaOwned(obj))
       children.append(obj);
   }
   for (const auto& ownedChild : ownedChildren)
     children.append(ownedChild);
 
   for (AXObject* child : children) {
     // Don't recurse into children that are explicitly marked as aria-hidden.
-    // Note that we don't call isInertOrAriaHidden because that would return true
-    // if any ancestor is hidden, but we need to be able to compute the accessible
-    // name of object inside hidden subtrees (for example, if aria-labelledby points
-    // to an object that's hidden).
+    // Note that we don't call isInertOrAriaHidden because that would return
+    // true if any ancestor is hidden, but we need to be able to compute the
+    // accessible name of object inside hidden subtrees (for example, if
+    // aria-labelledby points to an object that's hidden).
     if (equalIgnoringCase(child->getAttribute(aria_hiddenAttr), "true"))
       continue;
 
-    // If we're going between two layoutObjects that are in separate LayoutBoxes, add
-    // whitespace if it wasn't there already. Intuitively if you have
-    // <span>Hello</span><span>World</span>, those are part of the same LayoutBox
-    // so we should return "HelloWorld", but given <div>Hello</div><div>World</div> the
-    // strings are in separate boxes so we should return "Hello World".
+    // If we're going between two layoutObjects that are in separate
+    // LayoutBoxes, add whitespace if it wasn't there already. Intuitively if
+    // you have <span>Hello</span><span>World</span>, those are part of the same
+    // LayoutBox so we should return "HelloWorld", but given
+    // <div>Hello</div><div>World</div> the strings are in separate boxes so we
+    // should return "Hello World".
     if (previous && accumulatedText.length() &&
         !isHTMLSpace(accumulatedText[accumulatedText.length() - 1])) {
       if (!isInSameNonInlineBlockFlow(child->getLayoutObject(),
                                       previous->getLayoutObject()))
         accumulatedText.append(' ');
     }
 
     String result;
     if (child->isPresentational())
       result = child->textFromDescendants(visited, true);
     else
       result = recursiveTextAlternative(*child, false, visited);
     accumulatedText.append(result);
     previous = child;
   }
 
   return accumulatedText.toString();
 }
 
 bool AXNodeObject::nameFromLabelElement() const {
-  // This unfortunately duplicates a bit of logic from textAlternative and nativeTextAlternative,
-  // but it's necessary because nameFromLabelElement needs to be called from
-  // computeAccessibilityIsIgnored, which isn't allowed to call axObjectCache->getOrCreate.
+  // This unfortunately duplicates a bit of logic from textAlternative and
+  // nativeTextAlternative, but it's necessary because nameFromLabelElement
+  // needs to be called from computeAccessibilityIsIgnored, which isn't allowed
+  // to call axObjectCache->getOrCreate.
 
   if (!getNode() && !getLayoutObject())
     return false;
 
   // Step 2A from: http://www.w3.org/TR/accname-aam-1.1
   if (isHiddenForTextAlternativeCalculation())
     return false;
 
   // Step 2B from: http://www.w3.org/TR/accname-aam-1.1
   HeapVector<Member<Element>> elements;
   ariaLabelledbyElementVector(elements);
   if (elements.size() > 0)
     return false;
 
   // Step 2C from: http://www.w3.org/TR/accname-aam-1.1
   const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
   if (!ariaLabel.isEmpty())
     return false;
 
-  // Based on http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
+  // Based on
+  // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
   // 5.1/5.5 Text inputs, Other labelable Elements
   HTMLElement* htmlElement = nullptr;
   if (getNode()->isHTMLElement())
     htmlElement = toHTMLElement(getNode());
   if (htmlElement && isLabelableElement(htmlElement)) {
     if (toLabelableElement(htmlElement)->labels() &&
         toLabelableElement(htmlElement)->labels()->length() > 0)
       return true;
   }
 
   return false;
 }
 
 void AXNodeObject::getRelativeBounds(AXObject** outContainer,
                                      FloatRect& outBoundsInContainer,
                                      SkMatrix44& outContainerTransform) const {
   if (layoutObjectForRelativeBounds()) {
     AXObject::getRelativeBounds(outContainer, outBoundsInContainer,
                                 outContainerTransform);
     return;
   }
 
   *outContainer = nullptr;
   outBoundsInContainer = FloatRect();
   outContainerTransform.setIdentity();
 
-  // First check if it has explicit bounds, for example if this element is tied to a
-  // canvas path. When explicit coordinates are provided, the ID of the explicit container
-  // element that the coordinates are relative to must be provided too.
+  // First check if it has explicit bounds, for example if this element is tied
+  // to a canvas path. When explicit coordinates are provided, the ID of the
+  // explicit container element that the coordinates are relative to must be
+  // provided too.
   if (!m_explicitElementRect.isEmpty()) {
     *outContainer = axObjectCache().objectFromAXID(m_explicitContainerID);
     if (*outContainer) {
       outBoundsInContainer = FloatRect(m_explicitElementRect);
       return;
     }
   }
 
-  // If it's in a canvas but doesn't have an explicit rect, get the bounding rect of its children.
+  // If it's in a canvas but doesn't have an explicit rect, get the bounding
+  // rect of its children.
   if (getNode()->parentElement()->isInCanvasSubtree()) {
     Vector<FloatRect> rects;
     for (Node& child : NodeTraversal::childrenOf(*getNode())) {
       if (child.isHTMLElement()) {
         if (AXObject* obj = axObjectCache().get(&child)) {
           AXObject* container;
           FloatRect bounds;
           obj->getRelativeBounds(&container, bounds, outContainerTransform);
           if (container) {
             *outContainer = container;
             rects.append(bounds);
           }
         }
       }
     }
 
     if (*outContainer) {
       outBoundsInContainer = unionRect(rects);
       return;
     }
   }
 
-  // If this object doesn't have an explicit element rect or computable from its children,
-  // for now, let's return the position of the ancestor that does have a position,
-  // and make it the width of that parent, and about the height of a line of text, so that
-  // it's clear the object is a child of the parent.
+  // If this object doesn't have an explicit element rect or computable from its
+  // children, for now, let's return the position of the ancestor that does have
+  // a position, and make it the width of that parent, and about the height of a
+  // line of text, so that it's clear the object is a child of the parent.
   for (AXObject* positionProvider = parentObject(); positionProvider;
        positionProvider = positionProvider->parentObject()) {
     if (positionProvider->isAXLayoutObject()) {
       positionProvider->getRelativeBounds(outContainer, outBoundsInContainer,
                                           outContainerTransform);
       if (*outContainer)
         outBoundsInContainer.setSize(
             FloatSize(outBoundsInContainer.width(),
                       std::min(10.0f, outBoundsInContainer.height())));
       break;
     }
   }
 }
 
 static Node* getParentNodeForComputeParent(Node* node) {
   if (!node)
     return nullptr;
 
   Node* parentNode = nullptr;
 
-  // Skip over <optgroup> and consider the <select> the immediate parent of an <option>.
+  // Skip over <optgroup> and consider the <select> the immediate parent of an
+  // <option>.
   if (isHTMLOptionElement(node))
     parentNode = toHTMLOptionElement(node)->ownerSelectElement();
 
   if (!parentNode)
     parentNode = node->parentNode();
 
   return parentNode;
 }
 
 AXObject* AXNodeObject::computeParent() const {
@@ skipping 30 matching lines @@
   Node* nextSibling = getNode()->nextSibling();
   if (!nextSibling)
     return 0;
 
   return axObjectCache().getOrCreate(nextSibling);
 }
 
 void AXNodeObject::addChildren() {
   ASSERT(!isDetached());
   // If the need to add more children in addition to existing children arises,
-  // childrenChanged should have been called, leaving the object with no children.
+  // childrenChanged should have been called, leaving the object with no
+  // children.
   ASSERT(!m_haveChildren);
 
   if (!m_node)
     return;
 
   m_haveChildren = true;
 
-  // The only time we add children from the DOM tree to a node with a layoutObject is when it's a canvas.
+  // The only time we add children from the DOM tree to a node with a
+  // layoutObject is when it's a canvas.
   if (getLayoutObject() && !isHTMLCanvasElement(*m_node))
     return;
 
   HeapVector<Member<AXObject>> ownedChildren;
   computeAriaOwnsChildren(ownedChildren);
 
   for (Node& child : NodeTraversal::childrenOf(*m_node)) {
     AXObject* childObj = axObjectCache().getOrCreate(&child);
     if (childObj && !axObjectCache().isAriaOwned(childObj))
       addChild(childObj);
   }
 
   for (const auto& ownedChild : ownedChildren)
     addChild(ownedChild);
 
   for (const auto& child : m_children)
     child->setParent(this);
 }
 
 void AXNodeObject::addChild(AXObject* child) {
   insertChild(child, m_children.size());
 }
 
 void AXNodeObject::insertChild(AXObject* child, unsigned index) {
   if (!child)
     return;
 
-  // If the parent is asking for this child's children, then either it's the first time (and clearing is a no-op),
-  // or its visibility has changed. In the latter case, this child may have a stale child cached.
-  // This can prevent aria-hidden changes from working correctly. Hence, whenever a parent is getting children, ensure data is not stale.
+  // If the parent is asking for this child's children, then either it's the
+  // first time (and clearing is a no-op), or its visibility has changed. In the
+  // latter case, this child may have a stale child cached.  This can prevent
+  // aria-hidden changes from working correctly. Hence, whenever a parent is
+  // getting children, ensure data is not stale.
   child->clearChildren();
 
   if (child->accessibilityIsIgnored()) {
     const auto& children = child->children();
     size_t length = children.size();
     for (size_t i = 0; i < length; ++i)
       m_children.insert(index + i, children[i]);
   } else {
     ASSERT(child->parentObject() == this);
     m_children.insert(index, child);
   }
 }
 
 bool AXNodeObject::canHaveChildren() const {
   // If this is an AXLayoutObject, then it's okay if this object
-  // doesn't have a node - there are some layoutObjects that don't have associated
-  // nodes, like scroll areas and css-generated text.
+  // doesn't have a node - there are some layoutObjects that don't have
+  // associated nodes, like scroll areas and css-generated text.
   if (!getNode() && !isAXLayoutObject())
     return false;
 
   if (getNode() && isHTMLMapElement(getNode()))
     return false;
 
   AccessibilityRole role = roleValue();
 
-  // If an element has an ARIA role of presentation, we need to consider the native
-  // role when deciding whether it can have children or not - otherwise giving something
-  // a role of presentation could expose inner implementation details.
+  // If an element has an ARIA role of presentation, we need to consider the
+  // native role when deciding whether it can have children or not - otherwise
+  // giving something a role of presentation could expose inner implementation
+  // details.
   if (isPresentational())
     role = nativeAccessibilityRoleIgnoringAria();
 
   switch (role) {
     case ImageRole:
     case ButtonRole:
     case PopUpButtonRole:
     case CheckBoxRole:
     case RadioButtonRole:
     case SwitchRole:
@@ skipping 55 matching lines @@
 }
 
 Element* AXNodeObject::anchorElement() const {
   Node* node = this->getNode();
   if (!node)
     return 0;
 
   AXObjectCacheImpl& cache = axObjectCache();
 
   // search up the DOM tree for an anchor element
-  // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement
+  // NOTE: this assumes that any non-image with an anchor is an
+  // HTMLAnchorElement
   for (; node; node = node->parentNode()) {
     if (isHTMLAnchorElement(*node) ||
         (node->layoutObject() &&
          cache.getOrCreate(node->layoutObject())->isAnchor()))
       return toElement(node);
   }
 
   return 0;
 }
 
@@ skipping 44 matching lines @@
 void AXNodeObject::setFocused(bool on) {
   if (!canSetFocusAttribute())
     return;
 
   Document* document = this->getDocument();
   if (!on) {
     document->clearFocusedElement();
   } else {
     Node* node = this->getNode();
     if (node && node->isElementNode()) {
-      // If this node is already the currently focused node, then calling focus() won't do anything.
-      // That is a problem when focus is removed from the webpage to chrome, and then returns.
-      // In these cases, we need to do what keyboard and mouse focus do, which is reset focus first.
+      // If this node is already the currently focused node, then calling
+      // focus() won't do anything.  That is a problem when focus is removed
+      // from the webpage to chrome, and then returns.  In these cases, we need
+      // to do what keyboard and mouse focus do, which is reset focus first.
       if (document->focusedElement() == node)
         document->clearFocusedElement();
 
       toElement(node)->focus();
     } else {
       document->clearFocusedElement();
     }
   }
 }
 
 void AXNodeObject::increment() {
   UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
   alterSliderValue(true);
 }
 
 void AXNodeObject::decrement() {
   UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
   alterSliderValue(false);
 }
 
 void AXNodeObject::childrenChanged() {
-  // This method is meant as a quick way of marking a portion of the accessibility tree dirty.
+  // This method is meant as a quick way of marking a portion of the
+  // accessibility tree dirty.
   if (!getNode() && !getLayoutObject())
     return;
 
   // If this is not part of the accessibility tree because an ancestor
   // has only presentational children, invalidate this object's children but
   // skip sending a notification and skip walking up the ancestors.
   if (ancestorForWhichThisIsAPresentationalChild()) {
     setNeedsToUpdateChildren();
     return;
   }
 
   axObjectCache().postNotification(this, AXObjectCacheImpl::AXChildrenChanged);
 
-  // Go up the accessibility parent chain, but only if the element already exists. This method is
-  // called during layout, minimal work should be done.
-  // If AX elements are created now, they could interrogate the layout tree while it's in a funky state.
-  // At the same time, process ARIA live region changes.
+  // Go up the accessibility parent chain, but only if the element already
+  // exists. This method is called during layout, minimal work should be done.
+  // If AX elements are created now, they could interrogate the layout tree
+  // while it's in a funky state.  At the same time, process ARIA live region
+  // changes.
   for (AXObject* parent = this; parent;
        parent = parent->parentObjectIfExists()) {
     parent->setNeedsToUpdateChildren();
 
-    // These notifications always need to be sent because screenreaders are reliant on them to perform.
-    // In other words, they need to be sent even when the screen reader has not accessed this live region since the last update.
+    // These notifications always need to be sent because screenreaders are
+    // reliant on them to perform.  In other words, they need to be sent even
+    // when the screen reader has not accessed this live region since the last
+    // update.
 
-    // If this element supports ARIA live regions, then notify the AT of changes.
+    // If this element supports ARIA live regions, then notify the AT of
+    // changes.
     if (parent->isLiveRegion())
       axObjectCache().postNotification(parent,
                                        AXObjectCacheImpl::AXLiveRegionChanged);
 
-    // If this element is an ARIA text box or content editable, post a "value changed" notification on it
-    // so that it behaves just like a native input element or textarea.
+    // If this element is an ARIA text box or content editable, post a "value
+    // changed" notification on it so that it behaves just like a native input
+    // element or textarea.
     if (isNonNativeTextControl())
       axObjectCache().postNotification(parent,
                                        AXObjectCacheImpl::AXValueChanged);
   }
 }
 
 void AXNodeObject::selectionChanged() {
   // Post the selected text changed event on the first ancestor that's
   // focused (to handle form controls, ARIA text boxes and contentEditable),
   // or the web area if the selection is just in the document somewhere.
   if (isFocused() || isWebArea()) {
     axObjectCache().postNotification(this,
                                      AXObjectCacheImpl::AXSelectedTextChanged);
     if (getDocument()) {
       AXObject* documentObject = axObjectCache().getOrCreate(getDocument());
       axObjectCache().postNotification(
           documentObject, AXObjectCacheImpl::AXDocumentSelectionChanged);
     }
   } else {
     AXObject::selectionChanged();  // Calls selectionChanged on parent.
   }
 }
 
 void AXNodeObject::textChanged() {
-  // If this element supports ARIA live regions, or is part of a region with an ARIA editable role,
-  // then notify the AT of changes.
+  // If this element supports ARIA live regions, or is part of a region with an
+  // ARIA editable role, then notify the AT of changes.
   AXObjectCacheImpl& cache = axObjectCache();
   for (Node* parentNode = getNode(); parentNode;
        parentNode = parentNode->parentNode()) {
     AXObject* parent = cache.get(parentNode);
     if (!parent)
       continue;
 
     if (parent->isLiveRegion())
       cache.postNotification(parentNode,
                              AXObjectCacheImpl::AXLiveRegionChanged);
 
-    // If this element is an ARIA text box or content editable, post a "value changed" notification on it
-    // so that it behaves just like a native input element or textarea.
+    // If this element is an ARIA text box or content editable, post a "value
+    // changed" notification on it so that it behaves just like a native input
+    // element or textarea.
     if (parent->isNonNativeTextControl())
       cache.postNotification(parentNode, AXObjectCacheImpl::AXValueChanged);
   }
 }
 
 void AXNodeObject::updateAccessibilityRole() {
   bool ignoredStatus = accessibilityIsIgnored();
   m_role = determineAccessibilityRole();
 
-  // The AX hierarchy only needs to be updated if the ignored status of an element has changed.
+  // The AX hierarchy only needs to be updated if the ignored status of an
+  // element has changed.
   if (ignoredStatus != accessibilityIsIgnored())
     childrenChanged();
 }
 
 void AXNodeObject::computeAriaOwnsChildren(
     HeapVector<Member<AXObject>>& ownedChildren) const {
   if (!hasAttribute(aria_ownsAttr))
     return;
 
   Vector<String> idVector;
   if (canHaveChildren() && !isNativeTextControl() &&
       !hasContentEditableAttributeSet())
     tokenVectorFromAttribute(idVector, aria_ownsAttr);
 
   axObjectCache().updateAriaOwns(this, idVector, ownedChildren);
 }
 
-// Based on http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
+// Based on
+// http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
 String AXNodeObject::nativeTextAlternative(
     AXObjectSet& visited,
     AXNameFrom& nameFrom,
     AXRelatedObjectVector* relatedObjects,
     NameSources* nameSources,
     bool* foundTextAlternative) const {
   if (!getNode())
     return String();
 
-  // If nameSources is non-null, relatedObjects is used in filling it in, so it must be non-null as well.
+  // If nameSources is non-null, relatedObjects is used in filling it in, so it
+  // must be non-null as well.
   if (nameSources)
     ASSERT(relatedObjects);
 
   String textAlternative;
   AXRelatedObjectVector localRelatedObjects;
 
   const HTMLInputElement* inputElement = nullptr;
   if (isHTMLInputElement(getNode()))
     inputElement = toHTMLInputElement(getNode());
 
@@ skipping 407 matching lines @@
       description(nameFrom, descriptionFrom, nullptr, &relatedObjects);
   if (descriptionObjects) {
     descriptionObjects->clear();
     for (size_t i = 0; i < relatedObjects.size(); i++)
       descriptionObjects->append(relatedObjects[i]->object);
   }
 
   return collapseWhitespace(result);
 }
 
-// Based on http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
+// Based on
+// http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
 String AXNodeObject::description(AXNameFrom nameFrom,
                                  AXDescriptionFrom& descriptionFrom,
                                  DescriptionSources* descriptionSources,
                                  AXRelatedObjectVector* relatedObjects) const {
-  // If descriptionSources is non-null, relatedObjects is used in filling it in, so it must be non-null as well.
+  // If descriptionSources is non-null, relatedObjects is used in filling it in,
+  // so it must be non-null as well.
   if (descriptionSources)
     ASSERT(relatedObjects);
 
   if (!getNode())
     return String();
 
   String description;
   bool foundDescription = false;
 
   descriptionFrom = AXDescriptionFromRelatedElement;
   if (descriptionSources) {
     descriptionSources->append(
         DescriptionSource(foundDescription, aria_describedbyAttr));
     descriptionSources->last().type = descriptionFrom;
   }
 
-  // aria-describedby overrides any other accessible description, from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
+  // aria-describedby overrides any other accessible description, from:
+  // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
   const AtomicString& ariaDescribedby = getAttribute(aria_describedbyAttr);
   if (!ariaDescribedby.isNull()) {
     if (descriptionSources)
       descriptionSources->last().attributeValue = ariaDescribedby;
 
     description = textFromAriaDescribedby(relatedObjects);
 
     if (!description.isNull()) {
       if (descriptionSources) {
         DescriptionSource& source = descriptionSources->last();
         source.type = descriptionFrom;
         source.relatedObjects = *relatedObjects;
         source.text = description;
         foundDescription = true;
       } else {
         return description;
       }
     } else if (descriptionSources) {
       descriptionSources->last().invalid = true;
     }
   }
 
   HTMLElement* htmlElement = nullptr;
   if (getNode()->isHTMLElement())
     htmlElement = toHTMLElement(getNode());
 
-  // placeholder, 5.1.2 from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
+  // placeholder, 5.1.2 from:
+  // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
   if (nameFrom != AXNameFromPlaceholder && htmlElement &&
       htmlElement->isTextFormControl()) {
     descriptionFrom = AXDescriptionFromPlaceholder;
     if (descriptionSources) {
       descriptionSources->append(
           DescriptionSource(foundDescription, placeholderAttr));
       DescriptionSource& source = descriptionSources->last();
       source.type = descriptionFrom;
     }
     HTMLElement* element = toHTMLElement(getNode());
@@ skipping 31 matching lines @@
       if (descriptionSources) {
         DescriptionSource& source = descriptionSources->last();
         source.text = description;
         foundDescription = true;
       } else {
         return description;
       }
     }
   }
 
-  // table caption, 5.9.2 from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
+  // table caption, 5.9.2 from:
+  // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
   if (nameFrom != AXNameFromCaption && isHTMLTableElement(getNode())) {
     HTMLTableElement* tableElement = toHTMLTableElement(getNode());
 
     descriptionFrom = AXDescriptionFromRelatedElement;
     if (descriptionSources) {
       descriptionSources->append(DescriptionSource(foundDescription));
       descriptionSources->last().type = descriptionFrom;
       descriptionSources->last().nativeSource =
           AXTextFromNativeHTMLTableCaption;
     }
@@ skipping 13 matching lines @@
           source.relatedObjects = *relatedObjects;
           source.text = description;
           foundDescription = true;
         } else {
           return description;
         }
       }
     }
   }
 
-  // summary, 5.6.2 from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
+  // summary, 5.6.2 from:
+  // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
   if (nameFrom != AXNameFromContents && isHTMLSummaryElement(getNode())) {
     descriptionFrom = AXDescriptionFromContents;
     if (descriptionSources) {
       descriptionSources->append(DescriptionSource(foundDescription));
       descriptionSources->last().type = descriptionFrom;
     }
 
     AXObjectSet visited;
     description = textFromDescendants(visited, false);
 
     if (!description.isEmpty()) {
       if (descriptionSources) {
         foundDescription = true;
         descriptionSources->last().text = description;
       } else {
         return description;
       }
     }
   }
 
-  // title attribute, from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
+  // title attribute, from:
+  // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
   if (nameFrom != AXNameFromTitle) {
     descriptionFrom = AXDescriptionFromAttribute;
     if (descriptionSources) {
       descriptionSources->append(
           DescriptionSource(foundDescription, titleAttr));
       descriptionSources->last().type = descriptionFrom;
     }
     const AtomicString& title = getAttribute(titleAttr);
     if (!title.isEmpty()) {
       description = title;
       if (descriptionSources) {
         foundDescription = true;
         descriptionSources->last().text = description;
       } else {
         return description;
       }
     }
   }
 
   // aria-help.
-  // FIXME: this is not part of the official standard, but it's needed because the built-in date/time controls use it.
+  // FIXME: this is not part of the official standard, but it's needed because
+  // the built-in date/time controls use it.
   descriptionFrom = AXDescriptionFromAttribute;
   if (descriptionSources) {
     descriptionSources->append(
         DescriptionSource(foundDescription, aria_helpAttr));
     descriptionSources->last().type = descriptionFrom;
   }
   const AtomicString& help = getAttribute(aria_helpAttr);
   if (!help.isEmpty()) {
     description = help;
     if (descriptionSources) {
@@ skipping 43 matching lines @@
   }
   return placeholder;
 }
 
 DEFINE_TRACE(AXNodeObject) {
   visitor->trace(m_node);
   AXObject::trace(visitor);
 }
 
 }  // namespace blink