reflow comments in modules/accessiblity

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 229 matching lines @@
     return StaticTextRole;
   if (cssBox && isImageOrAltText(cssBox, node)) {
     if (node && node->isLink())
       return ImageMapRole;
     if (isHTMLInputElement(node))
       return ariaHasPopup() ? PopUpButtonRole : ButtonRole;
     if (isSVGImage())
       return SVGRootRole;
     return ImageRole;
   }
-  // Note: if JavaScript is disabled, the layoutObject won't be a LayoutHTMLCanvas.
+  // Note: if JavaScript is disabled, the layoutObject won't be a
+  // LayoutHTMLCanvas.
   if (isHTMLCanvasElement(node) && m_layoutObject->isCanvas())
     return CanvasRole;
 
   if (cssBox && cssBox->isLayoutView())
     return WebAreaRole;
 
   if (m_layoutObject->isSVGImage())
     return ImageRole;
   if (m_layoutObject->isSVGRoot())
     return SVGRootRole;
@@ skipping 15 matching lines @@
   if ((m_ariaRole = determineAriaRoleAttribute()) != UnknownRole)
     return m_ariaRole;
 
   AccessibilityRole role = nativeAccessibilityRoleIgnoringAria();
   if (role != UnknownRole)
     return role;
 
   if (m_layoutObject->isLayoutBlockFlow())
     return GroupRole;
 
-  // If the element does not have role, but it has ARIA attributes, accessibility should fallback to exposing it as a group.
+  // If the element does not have role, but it has ARIA attributes,
+  // accessibility should fallback to exposing it as a group.
   if (supportsARIAAttributes())
     return GroupRole;
 
   return UnknownRole;
 }
 
 void AXLayoutObject::init() {
   AXNodeObject::init();
 }
 
@@ skipping 98 matching lines @@
     if (body && hasEditableStyle(*body))
       return false;
 
     return !hasEditableStyle(document);
   }
 
   return AXNodeObject::isReadOnly();
 }
 
 bool AXLayoutObject::isVisited() const {
-  // FIXME: Is it a privacy violation to expose visited information to accessibility APIs?
+  // FIXME: Is it a privacy violation to expose visited information to
+  // accessibility APIs?
   return m_layoutObject->style()->isLink() &&
          m_layoutObject->style()->insideLink() == InsideVisitedLink;
 }
 
 //
 // Check object state.
 //
 
 bool AXLayoutObject::isFocused() const {
   if (!getDocument())
     return false;
 
   Element* focusedElement = getDocument()->focusedElement();
   if (!focusedElement)
     return false;
   AXObject* focusedObject = axObjectCache().getOrCreate(focusedElement);
   if (!focusedObject || !focusedObject->isAXLayoutObject())
     return false;
 
-  // A web area is represented by the Document node in the DOM tree, which isn't focusable.
-  // Check instead if the frame's selection controller is focused
+  // A web area is represented by the Document node in the DOM tree, which isn't
+  // focusable.  Check instead if the frame's selection controller is focused
   if (focusedObject == this ||
       (roleValue() == WebAreaRole &&
        getDocument()->frame()->selection().isFocusedAndActive()))
     return true;
 
   return false;
 }
 
 bool AXLayoutObject::isSelected() const {
   if (!getLayoutObject() || !getNode())
@@ skipping 14 matching lines @@
 
   return false;
 }
 
 //
 // Whether objects are ignored, i.e. not included in the tree.
 //
 
 AXObjectInclusion AXLayoutObject::defaultObjectInclusion(
     IgnoredReasons* ignoredReasons) const {
-  // The following cases can apply to any element that's a subclass of AXLayoutObject.
+  // The following cases can apply to any element that's a subclass of
+  // AXLayoutObject.
 
   if (!m_layoutObject) {
     if (ignoredReasons)
       ignoredReasons->append(IgnoredReason(AXNotRendered));
     return IgnoreObject;
   }
 
   if (m_layoutObject->style()->visibility() != EVisibility::Visible) {
-    // aria-hidden is meant to override visibility as the determinant in AX hierarchy inclusion.
+    // aria-hidden is meant to override visibility as the determinant in AX
+    // hierarchy inclusion.
     if (equalIgnoringCase(getAttribute(aria_hiddenAttr), "false"))
       return DefaultBehavior;
 
     if (ignoredReasons)
       ignoredReasons->append(IgnoredReason(AXNotVisible));
     return IgnoreObject;
   }
 
   return AXObject::defaultObjectInclusion(ignoredReasons);
 }
 
 bool AXLayoutObject::computeAccessibilityIsIgnored(
     IgnoredReasons* ignoredReasons) const {
 #if ENABLE(ASSERT)
   ASSERT(m_initialized);
 #endif
 
   if (!m_layoutObject)
     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.
+  // Then process other use cases that need to be applied to all the various
+  // roles that AXLayoutObjects take on.
   AXObjectInclusion decision = defaultObjectInclusion(ignoredReasons);
   if (decision == IncludeObject)
     return false;
   if (decision == IgnoreObject)
     return true;
 
-  // 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;
   }
 
   if (roleValue() == IgnoredRole) {
     if (ignoredReasons)
       ignoredReasons->append(IgnoredReason(AXUninteresting));
@@ skipping 13 matching lines @@
   }
 
   // An ARIA tree can only have tree items and static text as children.
   if (AXObject* treeAncestor = treeAncestorDisallowingChild()) {
     if (ignoredReasons)
       ignoredReasons->append(
           IgnoredReason(AXAncestorDisallowsChild, treeAncestor));
     return true;
   }
 
-  // A LayoutPart is an iframe element or embedded object element or something like
-  // that. We don't want to ignore those.
+  // A LayoutPart is an iframe element or embedded object element or something
+  // like that. We don't want to ignore those.
   if (m_layoutObject->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
+  // 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* controlObject = correspondingControlForLabelElement();
   if (controlObject && controlObject->isCheckboxOrRadio() &&
       controlObject->nameFromLabelElement()) {
     if (ignoredReasons) {
       HTMLLabelElement* label = labelElementContainer();
       if (label && label != getNode()) {
         AXObject* labelAXObject = axObjectCache().getOrCreate(label);
         ignoredReasons->append(IgnoredReason(AXLabelContainer, labelAXObject));
       }
 
       ignoredReasons->append(IgnoredReason(AXLabelFor, controlObject));
     }
     return true;
   }
 
   if (m_layoutObject->isBR())
     return false;
 
   if (m_layoutObject->isText()) {
-    // static text beneath MenuItems and MenuButtons are just reported along with the menu item, so it's ignored on an individual level
+    // 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() == MenuItemRole ||
                    parent->ariaRoleAttribute() == MenuButtonRole)) {
       if (ignoredReasons)
         ignoredReasons->append(
             IgnoredReason(AXStaticTextUsedAsNameFor, parent));
       return true;
     }
     LayoutText* layoutText = toLayoutText(m_layoutObject);
     if (!layoutText->hasTextBoxes()) {
       if (ignoredReasons)
         ignoredReasons->append(IgnoredReason(AXEmptyText));
       return true;
     }
 
     // Don't ignore static text in editable text controls.
     for (AXObject* parent = parentObject(); parent;
          parent = parent->parentObject()) {
       if (parent->roleValue() == TextFieldRole)
         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...
+    // 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 (layoutText->text().impl()->containsOnlyWhitespace()) {
       if (ignoredReasons)
         ignoredReasons->append(IgnoredReason(AXEmptyText));
       return true;
     }
     return false;
   }
 
   if (isHeading())
     return false;
 
   if (isLandmarkRelated())
     return false;
 
-  // Header and footer tags may also be exposed as landmark roles but not always.
+  // Header and footer tags may also be exposed as landmark roles but not
+  // always.
   if (getNode() &&
       (getNode()->hasTagName(headerTag) || getNode()->hasTagName(footerTag)))
     return false;
 
   if (isLink())
     return false;
 
   // all controls are accessible
   if (isControl())
     return false;
 
   if (ariaRoleAttribute() != UnknownRole)
     return false;
 
   // don't ignore labels, because they serve as TitleUIElements
   Node* node = m_layoutObject->node();
   if (isHTMLLabelElement(node))
     return false;
 
   // Anything that is content editable should not be ignored.
-  // However, one cannot just call node->hasEditableStyle() since that will ask if its parents
-  // are also editable. Only the top level content editable region should be exposed.
+  // However, one cannot just call node->hasEditableStyle() since that will ask
+  // if its parents are also editable. Only the top level content editable
+  // region should be exposed.
   if (hasContentEditableAttributeSet())
     return false;
 
   if (roleValue() == AbbrRole)
     return false;
 
-  // List items play an important role in defining the structure of lists. They should not be ignored.
+  // List items play an important role in defining the structure of lists. They
+  // should not be ignored.
   if (roleValue() == ListItemRole)
     return false;
 
   if (roleValue() == BlockquoteRole)
     return false;
 
   if (roleValue() == DialogRole)
     return false;
 
   if (roleValue() == FigcaptionRole)
@@ skipping 20 matching lines @@
   if (roleValue() == SplitterRole)
     return false;
 
   if (roleValue() == TimeRole)
     return false;
 
   // if this element has aria attributes on it, it should not be ignored.
   if (supportsARIAAttributes())
     return false;
 
-  // <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.
+  // <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 (ignoredReasons)
       ignoredReasons->append(IgnoredReason(AXUninteresting));
     return true;
   }
 
   // ignore images seemingly used as spacers
   if (isImage()) {
-    // If the image can take focus, it should not be ignored, lest the user not be able to interact with something important.
+    // If the image can take focus, it should not be ignored, lest the user not
+    // be able to interact with something important.
     if (canSetFocusAttribute())
       return false;
 
     if (node && node->isElementNode()) {
       Element* elt = toElement(node);
       const AtomicString& alt = elt->getAttribute(altAttr);
       // don't ignore an image that has an alt tag
       if (!alt.getString().containsOnlyWhitespace())
         return false;
       // informal standard is to ignore images with zero-length alt strings
       if (!alt.isNull()) {
         if (ignoredReasons)
           ignoredReasons->append(IgnoredReason(AXEmptyAlt));
         return true;
       }
     }
 
     if (isNativeImage() && m_layoutObject->isImage()) {
       // check for one-dimensional image
       LayoutImage* image = toLayoutImage(m_layoutObject);
       if (image->size().height() <= 1 || image->size().width() <= 1) {
         if (ignoredReasons)
           ignoredReasons->append(IgnoredReason(AXProbablyPresentational));
         return true;
       }
 
-      // check whether laid out image was stretched from one-dimensional file image
+      // Check whether laid out image was stretched from one-dimensional file
+      // image.
       if (image->cachedImage()) {
         LayoutSize imageSize = image->cachedImage()->imageSize(
             LayoutObject::shouldRespectImageOrientation(m_layoutObject),
             image->view()->zoomFactor());
         if (imageSize.height() <= 1 || imageSize.width() <= 1) {
           if (ignoredReasons)
             ignoredReasons->append(IgnoredReason(AXProbablyPresentational));
           return true;
         }
         return false;
       }
     }
     return false;
   }
 
   if (isCanvas()) {
     if (canvasHasFallbackContent())
       return false;
     LayoutHTMLCanvas* canvas = toLayoutHTMLCanvas(m_layoutObject);
     if (canvas->size().height() <= 1 || canvas->size().width() <= 1) {
       if (ignoredReasons)
         ignoredReasons->append(IgnoredReason(AXProbablyPresentational));
       return true;
     }
-    // Otherwise fall through; use presence of help text, title, or description to decide.
+    // Otherwise fall through; use presence of help text, title, or description
+    // to decide.
   }
 
   if (isWebArea() || m_layoutObject->isListMarker())
     return false;
 
   // Using the help text, title or accessibility description (so we
   // check if there's some kind of accessible name for the element)
   // to decide an element's visibility is not as definitive as
   // previous checks, so this should remain as one of the last.
   //
@@ skipping 273 matching lines @@
   AXObject* result = nullptr;
   for (InlineBox* next = inlineBox->nextOnLine(); next;
        next = next->nextOnLine()) {
     LayoutObject* layoutObject =
         LineLayoutAPIShim::layoutObjectFrom(next->getLineLayoutItem());
     result = axObjectCache().getOrCreate(layoutObject);
     if (result)
       break;
   }
 
-  // A static text node might span multiple lines. Try to return the first inline
-  // text box within that static text if possible.
+  // A static text node might span multiple lines. Try to return the first
+  // inline text box within that static text if possible.
   if (result && result->roleValue() == StaticTextRole &&
       result->children().size())
     result = result->children()[0].get();
 
   return result;
 }
 
 AXObject* AXLayoutObject::previousOnLine() const {
   if (!getLayoutObject())
     return nullptr;
@@ skipping 31 matching lines @@
 //
 
 String AXLayoutObject::stringValue() const {
   if (!m_layoutObject)
     return String();
 
   LayoutBoxModelObject* cssBox = getLayoutBoxModelObject();
 
   if (cssBox && cssBox->isMenuList()) {
     // LayoutMenuList will go straight to the text() of its selected item.
-    // This has to be overridden in the case where the selected item has an ARIA label.
+    // This has to be overridden in the case where the selected item has an ARIA
+    // label.
     HTMLSelectElement* selectElement =
         toHTMLSelectElement(m_layoutObject->node());
     int selectedIndex = selectElement->selectedIndex();
     const HeapVector<Member<HTMLElement>>& listItems =
         selectElement->listItems();
     if (selectedIndex >= 0 &&
         static_cast<size_t>(selectedIndex) < listItems.size()) {
       const AtomicString& overriddenDescription =
           listItems[selectedIndex]->fastGetAttribute(aria_labelAttr);
       if (!overriddenDescription.isNull())
         return overriddenDescription;
     }
     return toLayoutMenuList(m_layoutObject)->text();
   }
 
   if (isWebArea()) {
-    // FIXME: Why would a layoutObject exist when the Document isn't attached to a frame?
+    // FIXME: Why would a layoutObject exist when the Document isn't attached to
+    // a frame?
     if (m_layoutObject->frame())
       return String();
 
     ASSERT_NOT_REACHED();
   }
 
   if (isTextControl())
     return text();
 
   if (m_layoutObject->isFileUploadControl())
     return toLayoutFileUploadControl(m_layoutObject)->fileTextValue();
 
-  // 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 (getNode() && isHTMLInputElement(getNode())) {
     HTMLInputElement* input = toHTMLInputElement(getNode());
     if (input->type() != InputTypeNames::checkbox &&
         input->type() != InputTypeNames::radio)
       return input->value();
   }
 
   // FIXME: We might need to implement a value here for more types
-  // FIXME: It would be better not to advertise a value at all for the types for which we don't implement one;
-  // this would require subclassing or making accessibilityAttributeNames do something other than return a
-  // single static array.
+  // FIXME: It would be better not to advertise a value at all for the types for
+  // which we don't implement one; this would require subclassing or making
+  // accessibilityAttributeNames do something other than return a single static
+  // array.
   return String();
 }
 
 String AXLayoutObject::textAlternative(bool recursive,
                                        bool inAriaLabelledByTraversal,
                                        AXObjectSet& visited,
                                        AXNameFrom& nameFrom,
                                        AXRelatedObjectVector* relatedObjects,
                                        NameSources* nameSources) const {
   if (m_layoutObject) {
@@ skipping 155 matching lines @@
   const AtomicString& relevant = getAttribute(aria_relevantAttr);
 
   // Default aria-relevant = "additions text".
   if (relevant.isEmpty())
     return defaultLiveRegionRelevant;
 
   return relevant;
 }
 
 bool AXLayoutObject::liveRegionAtomic() const {
-  // ARIA roles "alert" and "status" should have an implicit aria-atomic value of true.
+  // ARIA roles "alert" and "status" should have an implicit aria-atomic value
+  // of true.
   if (getAttribute(aria_atomicAttr).isEmpty() &&
       (roleValue() == AlertRole || roleValue() == StatusRole)) {
     return true;
   }
   return elementAttributeValue(aria_atomicAttr);
 }
 
 bool AXLayoutObject::liveRegionBusy() const {
   return elementAttributeValue(aria_busyAttr);
 }
@@ skipping 25 matching lines @@
       return nullptr;
   }
 
   LayoutObject* obj = node->layoutObject();
   if (!obj)
     return nullptr;
 
   AXObject* result = axObjectCache().getOrCreate(obj);
   result->updateChildrenIfNecessary();
 
-  // Allow the element to perform any hit-testing it might need to do to reach non-layout children.
+  // Allow the element to perform any hit-testing it might need to do to reach
+  // non-layout children.
   result = result->elementAccessibilityHitTest(point);
   if (result && result->accessibilityIsIgnored()) {
-    // If this element is the label of a control, a hit test should return the control.
+    // If this element is the label of a control, a hit test should return the
+    // control.
     if (result->isAXLayoutObject()) {
       AXObject* controlObject =
           toAXLayoutObject(result)->correspondingControlForLabelElement();
       if (controlObject && controlObject->nameFromLabelElement())
         return controlObject;
     }
 
     result = result->parentObjectUnignored();
   }
 
@@ skipping 13 matching lines @@
 //
 
 AXObject* AXLayoutObject::computeParent() const {
   ASSERT(!isDetached());
   if (!m_layoutObject)
     return 0;
 
   if (ariaRoleAttribute() == MenuBarRole)
     return axObjectCache().getOrCreate(m_layoutObject->parent());
 
-  // menuButton and its corresponding menu are DOM siblings, but Accessibility needs them to be parent/child
+  // menuButton and its corresponding menu are DOM siblings, but Accessibility
+  // needs them to be parent/child.
   if (ariaRoleAttribute() == MenuRole) {
     AXObject* parent = menuButtonForMenu();
     if (parent)
       return parent;
   }
 
   LayoutObject* parentObj = layoutParentObject();
   if (parentObj)
     return axObjectCache().getOrCreate(parentObj);
 
   // A WebArea's parent should be the page popup owner, if any, otherwise null.
   if (isWebArea()) {
     LocalFrame* frame = m_layoutObject->frame();
     return axObjectCache().getOrCreate(frame->pagePopupOwner());
   }
 
   return 0;
 }
 
 AXObject* AXLayoutObject::computeParentIfExists() const {
   if (!m_layoutObject)
     return 0;
 
   if (ariaRoleAttribute() == MenuBarRole)
     return axObjectCache().get(m_layoutObject->parent());
 
-  // menuButton and its corresponding menu are DOM siblings, but Accessibility needs them to be parent/child
+  // menuButton and its corresponding menu are DOM siblings, but Accessibility
+  // needs them to be parent/child.
   if (ariaRoleAttribute() == MenuRole) {
     AXObject* parent = menuButtonForMenu();
     if (parent)
       return parent;
   }
 
   LayoutObject* parentObj = layoutParentObject();
   if (parentObj)
     return axObjectCache().get(parentObj);
 
   // A WebArea's parent should be the page popup owner, if any, otherwise null.
   if (isWebArea()) {
     LocalFrame* frame = m_layoutObject->frame();
     return axObjectCache().get(frame->pagePopupOwner());
   }
 
   return 0;
 }
 
 //
-// Low-level accessibility tree exploration, only for use within the accessibility module.
+// Low-level accessibility tree exploration, only for use within the
+// accessibility module.
 //
 
 AXObject* AXLayoutObject::rawFirstChild() const {
   if (!m_layoutObject)
     return 0;
 
   LayoutObject* firstChild = firstChildConsideringContinuation(m_layoutObject);
 
   if (!firstChild)
     return 0;
 
   return axObjectCache().getOrCreate(firstChild);
 }
 
 AXObject* AXLayoutObject::rawNextSibling() const {
   if (!m_layoutObject)
     return 0;
 
   LayoutObject* nextSibling = 0;
 
   LayoutInline* inlineContinuation =
       m_layoutObject->isLayoutBlockFlow()
           ? toLayoutBlockFlow(m_layoutObject)->inlineElementContinuation()
           : nullptr;
   if (inlineContinuation) {
-    // Case 1: node is a block and has an inline continuation. Next sibling is the inline continuation's first child.
+    // Case 1: node is a block and has an inline continuation. Next sibling is
+    // the inline continuation's first child.
     nextSibling = firstChildConsideringContinuation(inlineContinuation);
   } else if (m_layoutObject->isAnonymousBlock() &&
              lastChildHasContinuation(m_layoutObject)) {
-    // Case 2: Anonymous block parent of the start of a continuation - skip all the way to
-    // after the parent of the end, since everything in between will be linked up via the continuation.
+    // Case 2: Anonymous block parent of the start of a continuation - skip all
+    // the way to after the parent of the end, since everything in between will
+    // be linked up via the continuation.
     LayoutObject* lastParent =
         endOfContinuations(toLayoutBlock(m_layoutObject)->lastChild())
             ->parent();
     while (lastChildHasContinuation(lastParent))
       lastParent = endOfContinuations(lastParent->slowLastChild())->parent();
     nextSibling = lastParent->nextSibling();
   } else if (LayoutObject* ns = m_layoutObject->nextSibling()) {
     // Case 3: node has an actual next sibling
     nextSibling = ns;
   } else if (isInlineWithContinuation(m_layoutObject)) {
-    // Case 4: node is an inline with a continuation. Next sibling is the next sibling of the end
-    // of the continuation chain.
+    // Case 4: node is an inline with a continuation. Next sibling is the next
+    // sibling of the end of the continuation chain.
     nextSibling = endOfContinuations(m_layoutObject)->nextSibling();
   } else if (m_layoutObject->parent() &&
              isInlineWithContinuation(m_layoutObject->parent())) {
-    // Case 5: node has no next sibling, and its parent is an inline with a continuation.
+    // Case 5: node has no next sibling, and its parent is an inline with a
+    // continuation.
     LayoutObject* continuation =
         toLayoutInline(m_layoutObject->parent())->continuation();
 
     if (continuation->isLayoutBlock()) {
-      // Case 5a: continuation is a block - in this case the block itself is the next sibling.
+      // Case 5a: continuation is a block - in this case the block itself is the
+      // next sibling.
       nextSibling = continuation;
     } else {
-      // Case 5b: continuation is an inline - in this case the inline's first child is the next sibling.
+      // Case 5b: continuation is an inline - in this case the inline's first
+      // child is the next sibling.
       nextSibling = firstChildConsideringContinuation(continuation);
     }
   }
 
   if (!nextSibling)
     return 0;
 
   return axObjectCache().getOrCreate(nextSibling);
 }
 
 void AXLayoutObject::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);
 
   m_haveChildren = true;
 
   if (!canHaveChildren())
     return;
 
   HeapVector<Member<AXObject>> ownedChildren;
   computeAriaOwnsChildren(ownedChildren);
 
@@ skipping 78 matching lines @@
   return getLayoutObject()->document().view();
 }
 
 Element* AXLayoutObject::anchorElement() const {
   if (!m_layoutObject)
     return 0;
 
   AXObjectCacheImpl& cache = axObjectCache();
   LayoutObject* currLayoutObject;
 
-  // Search up the layout tree for a LayoutObject with a DOM node. Defer to an earlier continuation, though.
+  // Search up the layout tree for a LayoutObject with a DOM node. Defer to an
+  // earlier continuation, though.
   for (currLayoutObject = m_layoutObject;
        currLayoutObject && !currLayoutObject->node();
        currLayoutObject = currLayoutObject->parent()) {
     if (currLayoutObject->isAnonymousBlock() &&
         currLayoutObject->isLayoutBlockFlow()) {
       LayoutObject* continuation =
           toLayoutBlockFlow(currLayoutObject)->continuation();
       if (continuation)
         return cache.getOrCreate(continuation)->anchorElement();
     }
   }
 
   // bail if none found
   if (!currLayoutObject)
     return 0;
 
-  // search up the DOM tree for an anchor element
-  // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement
+  // Search up the DOM tree for an anchor element.
+  // NOTE: this assumes that any non-image with an anchor is an
+  // HTMLAnchorElement
   Node* node = currLayoutObject->node();
   if (!node)
     return nullptr;
   for (Node& runner : NodeTraversal::inclusiveAncestorsOf(*node)) {
     if (isHTMLAnchorElement(runner) ||
         (runner.layoutObject() &&
          cache.getOrCreate(runner.layoutObject())->isAnchor()))
       return toElement(&runner);
   }
 
@@ skipping 178 matching lines @@
 
 // Convert from an accessible object and offset to a VisiblePosition.
 static VisiblePosition toVisiblePosition(AXObject* obj, int offset) {
   if (!obj->getNode())
     return VisiblePosition();
 
   Node* node = obj->getNode();
   if (!node->isTextNode()) {
     int childCount = obj->children().size();
 
-    // Place position immediately before the container node, if there was no children.
+    // Place position immediately before the container node, if there was no
+    // children.
     if (childCount == 0) {
       if (!obj->parentObject())
         return VisiblePosition();
       return toVisiblePosition(obj->parentObject(), obj->indexInParent());
     }
 
     // The offsets are child offsets over the AX tree. Note that we allow
     // for the offset to equal the number of children as |Range| does.
     if (offset < 0 || offset > childCount)
       return VisiblePosition();
@@ skipping 13 matching lines @@
 
     // If we had to clamp the offset above, the client wants to select the
     // end of the node.
     if (clampedOffset != offset)
       adjustedOffset++;
 
     return createVisiblePosition(
         Position::editingPositionOf(childNode->parentNode(), adjustedOffset));
   }
 
-  // If it is a text node, we need to call some utility functions that use a TextIterator
-  // to walk the characters of the node and figure out the position corresponding to the
-  // visible character at position |offset|.
+  // If it is a text node, we need to call some utility functions that use a
+  // TextIterator to walk the characters of the node and figure out the position
+  // corresponding to the visible character at position |offset|.
   ContainerNode* parent = node->parentNode();
   if (!parent)
     return VisiblePosition();
 
   VisiblePosition nodePosition = blink::visiblePositionBeforeNode(*node);
   int nodeIndex = blink::indexForVisiblePosition(nodePosition, parent);
   return blink::visiblePositionForIndex(nodeIndex + offset, parent);
 }
 
 void AXLayoutObject::setSelection(const AXRange& selection) {
@@ skipping 25 matching lines @@
                                      selection.anchorOffset,
                                      SelectionHasBackwardDirection);
     }
     return;
   }
 
   LocalFrame* frame = getLayoutObject()->frame();
   if (!frame)
     return;
 
-  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
   // This callsite should probably move up the stack.
   frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
-  // Set the selection based on visible positions, because the offsets in accessibility nodes
-  // are based on visible indexes, which often skips redundant whitespace, for example.
+  // Set the selection based on visible positions, because the offsets in
+  // accessibility nodes are based on visible indexes, which often skips
+  // redundant whitespace, for example.
   VisiblePosition anchorVisiblePosition =
       toVisiblePosition(anchorObject, selection.anchorOffset);
   VisiblePosition focusVisiblePosition =
       toVisiblePosition(focusObject, selection.focusOffset);
   if (anchorVisiblePosition.isNull() || focusVisiblePosition.isNull())
     return;
 
   frame->selection().setSelection(
       createVisibleSelection(anchorVisiblePosition, focusVisiblePosition));
 }
@@ skipping 182 matching lines @@
         0)
       break;
   }
 }
 
 //
 // Private.
 //
 
 AXObject* AXLayoutObject::treeAncestorDisallowingChild() const {
-  // Determine if this is in a tree. If so, we apply special behavior to make it work like an AXOutline.
+  // Determine if this is in a tree. If so, we apply special behavior to make it
+  // work like an AXOutline.
   AXObject* axObj = parentObject();
   AXObject* treeAncestor = 0;
   while (axObj) {
     if (axObj->isTree()) {
       treeAncestor = axObj;
       break;
     }
     axObj = axObj->parentObject();
   }
 
-  // If the object is in a tree, only tree items should be exposed (and the children of tree items).
+  // If the object is in a tree, only tree items should be exposed (and the
+  // children of tree items).
   if (treeAncestor) {
     AccessibilityRole role = roleValue();
     if (role != TreeItemRole && role != StaticTextRole)
       return treeAncestor;
   }
   return 0;
 }
 
 bool AXLayoutObject::isTabItemSelected() const {
   if (!isTabItem() || !getLayoutObject())
     return false;
 
   Node* node = getNode();
   if (!node || !node->isElementNode())
     return false;
 
-  // The ARIA spec says a tab item can also be selected if it is aria-labeled by a tabpanel
-  // that has keyboard focus inside of it, or if a tabpanel in its aria-controls list has KB
-  // focus inside of it.
+  // The ARIA spec says a tab item can also be selected if it is aria-labeled by
+  // a tabpanel that has keyboard focus inside of it, or if a tabpanel in its
+  // aria-controls list has KB focus inside of it.
   AXObject* focusedElement = axObjectCache().focusedObject();
   if (!focusedElement)
     return false;
 
   HeapVector<Member<Element>> elements;
   elementsFromAttribute(elements, aria_controlsAttr);
 
   for (const auto& element : elements) {
     AXObject* tabPanel = axObjectCache().getOrCreate(element);
 
     // A tab item should only control tab panels.
     if (!tabPanel || tabPanel->roleValue() != TabPanelRole)
       continue;
 
     AXObject* checkFocusElement = focusedElement;
-    // Check if the focused element is a descendant of the element controlled by the tab item.
+    // Check if the focused element is a descendant of the element controlled by
+    // the tab item.
     while (checkFocusElement) {
       if (tabPanel == checkFocusElement)
         return true;
       checkFocusElement = checkFocusElement->parentObject();
     }
   }
 
   return false;
 }
 
@@ skipping 25 matching lines @@
   if (startOfConts) {
     // Case 1: node is a block and is an inline's continuation. Parent
     // is the start of the continuation chain.
     return startOfConts;
   }
 
   LayoutObject* parent = m_layoutObject->parent();
   startOfConts =
       parent && parent->isLayoutInline() ? startOfContinuations(parent) : 0;
   if (startOfConts) {
-    // Case 2: node's parent is an inline which is some node's continuation; parent is
-    // the earliest node in the continuation chain.
+    // Case 2: node's parent is an inline which is some node's continuation;
+    // parent is the earliest node in the continuation chain.
     return startOfConts;
   }
 
   LayoutObject* firstChild = parent ? parent->slowFirstChild() : 0;
   if (firstChild && firstChild->node()) {
-    // Case 3: The first sibling is the beginning of a continuation chain. Find the origin of that continuation.
-    // Get the node's layoutObject and follow that continuation chain until the first child is found.
+    // Case 3: The first sibling is the beginning of a continuation chain. Find
+    // the origin of that continuation.  Get the node's layoutObject and follow
+    // that continuation chain until the first child is found.
     for (LayoutObject* nodeLayoutFirstChild =
              firstChild->node()->layoutObject();
          nodeLayoutFirstChild != firstChild;
          nodeLayoutFirstChild = firstChild->node()->layoutObject()) {
       for (LayoutObject* contsTest = nodeLayoutFirstChild; contsTest;
            contsTest = nextContinuation(contsTest)) {
         if (contsTest == firstChild) {
           parent = nodeLayoutFirstChild->parent();
           break;
         }
@@ skipping 13 matching lines @@
 bool AXLayoutObject::isSVGImage() const {
   return remoteSVGRootElement();
 }
 
 void AXLayoutObject::detachRemoteSVGRoot() {
   if (AXSVGRoot* root = remoteSVGRootElement())
     root->setParent(0);
 }
 
 AXSVGRoot* AXLayoutObject::remoteSVGRootElement() const {
-  // FIXME(dmazzoni): none of this code properly handled multiple references to the same
-  // remote SVG document. I'm disabling this support until it can be fixed properly.
+  // FIXME(dmazzoni): none of this code properly handled multiple references to
+  // the same remote SVG document. I'm disabling this support until it can be
+  // fixed properly.
   return 0;
 }
 
 AXObject* AXLayoutObject::remoteSVGElementHitTest(const IntPoint& point) const {
   AXObject* remote = remoteSVGRootElement();
   if (!remote)
     return 0;
 
   IntSize offset =
       point - roundedIntPoint(getBoundsInFrameCoordinates().location());
   return remote->accessibilityHitTest(IntPoint(offset));
 }
 
-// The boundingBox for elements within the remote SVG element needs to be offset by its position
-// within the parent page, otherwise they are in relative coordinates only.
+// The boundingBox for elements within the remote SVG element needs to be offset
+// by its position within the parent page, otherwise they are in relative
+// coordinates only.
 void AXLayoutObject::offsetBoundingBoxForRemoteSVGElement(
     LayoutRect& rect) const {
   for (AXObject* parent = parentObject(); parent;
        parent = parent->parentObject()) {
     if (parent->isAXSVGRoot()) {
       rect.moveBy(
           parent->parentObject()->getBoundsInFrameCoordinates().location());
       break;
     }
   }
 }
 
-// Hidden children are those that are not laid out or visible, but are specifically marked as aria-hidden=false,
+// Hidden children are those that are not laid out or visible, but are
+// specifically marked as aria-hidden=false,
 // meaning that they should be exposed to the AX hierarchy.
 void AXLayoutObject::addHiddenChildren() {
   Node* node = this->getNode();
   if (!node)
     return;
 
-  // First do a quick run through to determine if we have any hidden nodes (most often we will not).
-  // If we do have hidden nodes, we need to determine where to insert them so they match DOM order as close as possible.
+  // First do a quick run through to determine if we have any hidden nodes (most
+  // often we will not).  If we do have hidden nodes, we need to determine where
+  // to insert them so they match DOM order as close as possible.
   bool shouldInsertHiddenNodes = false;
   for (Node& child : NodeTraversal::childrenOf(*node)) {
     if (!child.layoutObject() && isNodeAriaVisible(&child)) {
       shouldInsertHiddenNodes = true;
       break;
     }
   }
 
   if (!shouldInsertHiddenNodes)
     return;
 
-  // Iterate through all of the children, including those that may have already been added, and
-  // try to insert hidden nodes in the correct place in the DOM order.
+  // Iterate through all of the children, including those that may have already
+  // been added, and try to insert hidden nodes in the correct place in the DOM
+  // order.
   unsigned insertionIndex = 0;
   for (Node& child : NodeTraversal::childrenOf(*node)) {
     if (child.layoutObject()) {
       // Find out where the last layout sibling is located within m_children.
       if (AXObject* childObject = axObjectCache().get(child.layoutObject())) {
         if (childObject->accessibilityIsIgnored()) {
           const auto& children = childObject->children();
           childObject = children.size() ? children.last().get() : 0;
         }
         if (childObject)
@@ skipping 54 matching lines @@
       else
         axObjectCache().remove(areaObject->axObjectID());
     }
   }
 }
 
 void AXLayoutObject::addCanvasChildren() {
   if (!isHTMLCanvasElement(getNode()))
     return;
 
-  // If it's a canvas, it won't have laid out children, but it might have accessible fallback content.
-  // Clear m_haveChildren because AXNodeObject::addChildren will expect it to be false.
+  // If it's a canvas, it won't have laid out children, but it might have
+  // accessible fallback content.  Clear m_haveChildren because
+  // AXNodeObject::addChildren will expect it to be false.
   ASSERT(!m_children.size());
   m_haveChildren = false;
   AXNodeObject::addChildren();
 }
 
 void AXLayoutObject::addPopupChildren() {
   if (!isHTMLInputElement(getNode()))
     return;
   if (AXObject* axPopup = toHTMLInputElement(getNode())->popupRootAXObject())
     m_children.append(axPopup);
@@ skipping 16 matching lines @@
 
 bool AXLayoutObject::elementAttributeValue(
     const QualifiedName& attributeName) const {
   if (!m_layoutObject)
     return false;
 
   return equalIgnoringCase(getAttribute(attributeName), "true");
 }
 
 }  // namespace blink