reflow comments in modules/accessiblity

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

 /*
  * Copyright (C) 2008, 2009, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 623 matching lines @@
     return false;
 
   if (parent->supportsActiveDescendant() &&
       !parent->getAttribute(aria_activedescendantAttr).isEmpty()) {
     return true;
   }
 
   return parent->ancestorExposesActiveDescendant();
 }
 
-// Simplify whitespace, but preserve a single leading and trailing whitespace character if it's present.
+// Simplify whitespace, but preserve a single leading and trailing whitespace
+// character if it's present.
 // static
 String AXObject::collapseWhitespace(const String& str) {
   StringBuilder result;
   if (!str.isEmpty() && isHTMLSpace<UChar>(str[0]))
     result.append(' ');
   result.append(str.simplifyWhiteSpace(isHTMLSpace<UChar>));
   if (!str.isEmpty() && isHTMLSpace<UChar>(str[str.length() - 1]))
     result.append(' ');
   return result.toString();
 }
@@ skipping 46 matching lines @@
                                tmpNameFrom, nullptr, nullptr);
 }
 
 bool AXObject::isHiddenForTextAlternativeCalculation() const {
   if (equalIgnoringCase(getAttribute(aria_hiddenAttr), "false"))
     return false;
 
   if (getLayoutObject())
     return getLayoutObject()->style()->visibility() != EVisibility::Visible;
 
-  // This is an obscure corner case: if a node has no LayoutObject, that means it's not rendered,
-  // but we still may be exploring it as part of a text alternative calculation, for example if it
-  // was explicitly referenced by aria-labelledby. So we need to explicitly call the style resolver
-  // to check whether it's invisible or display:none, rather than relying on the style cached in the
-  // LayoutObject.
+  // This is an obscure corner case: if a node has no LayoutObject, that means
+  // it's not rendered, but we still may be exploring it as part of a text
+  // alternative calculation, for example if it was explicitly referenced by
+  // aria-labelledby. So we need to explicitly call the style resolver to check
+  // whether it's invisible or display:none, rather than relying on the style
+  // cached in the LayoutObject.
   Document* doc = getDocument();
   if (doc && doc->frame() && getNode() && getNode()->isElementNode()) {
     RefPtr<ComputedStyle> style =
         doc->ensureStyleResolver().styleForElement(toElement(getNode()));
     return style->display() == EDisplay::None ||
            style->visibility() != EVisibility::Visible;
   }
 
   return false;
 }
@@ skipping 28 matching lines @@
       nameSources->append(NameSource(*foundTextAlternative, attr));
       nameSources->last().type = nameFrom;
     }
 
     const AtomicString& ariaLabelledby = getAttribute(attr);
     if (!ariaLabelledby.isNull()) {
       if (nameSources)
         nameSources->last().attributeValue = ariaLabelledby;
 
       // Operate on a copy of |visited| so that if |nameSources| is not null,
-      // the set of visited objects is preserved unmodified for future calculations.
+      // the set of visited objects is preserved unmodified for future
+      // calculations.
       AXObjectSet visitedCopy = visited;
       textAlternative = textFromAriaLabelledby(visitedCopy, relatedObjects);
       if (!textAlternative.isNull()) {
         if (nameSources) {
           NameSource& source = nameSources->last();
           source.type = nameFrom;
           source.relatedObjects = *relatedObjects;
           source.text = textAlternative;
           *foundTextAlternative = true;
         } else {
@@ skipping 378 matching lines @@
   return object->documentFrameView();
 }
 
 String AXObject::language() const {
   const AtomicString& lang = getAttribute(langAttr);
   if (!lang.isEmpty())
     return lang;
 
   AXObject* parent = parentObject();
 
-  // as a last resort, fall back to the content language specified in the meta tag
+  // As a last resort, fall back to the content language specified in the meta
+  // tag.
   if (!parent) {
     Document* doc = getDocument();
     if (doc)
       return doc->contentLanguage();
     return nullAtom;
   }
 
   return parent->language();
 }
 
@@ skipping 66 matching lines @@
                           ProgrammaticScroll);
 }
 
 void AXObject::getRelativeBounds(AXObject** outContainer,
                                  FloatRect& outBoundsInContainer,
                                  SkMatrix44& outContainerTransform) const {
   *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;
     }
   }
 
   LayoutObject* layoutObject = layoutObjectForRelativeBounds();
   if (!layoutObject)
     return;
 
   if (isWebArea()) {
     if (layoutObject->frame()->view())
       outBoundsInContainer.setSize(
           FloatSize(layoutObject->frame()->view()->contentsSize()));
     return;
   }
 
-  // First compute the container. The container must be an ancestor in the accessibility tree, and
-  // its LayoutObject must be an ancestor in the layout tree. Get the first such ancestor that's
-  // either scrollable or has a paint layer.
+  // First compute the container. The container must be an ancestor in the
+  // accessibility tree, and its LayoutObject must be an ancestor in the layout
+  // tree. Get the first such ancestor that's either scrollable or has a paint
+  // layer.
   AXObject* container = parentObjectUnignored();
   LayoutObject* containerLayoutObject = nullptr;
   while (container) {
     containerLayoutObject = container->getLayoutObject();
     if (containerLayoutObject && containerLayoutObject->isBoxModelObject() &&
         layoutObject->isDescendantOf(containerLayoutObject)) {
       if (container->isScrollableContainer() ||
           containerLayoutObject->hasLayer())
         break;
     }
 
     container = container->parentObjectUnignored();
   }
 
   if (!container)
     return;
   *outContainer = container;
   outBoundsInContainer = layoutObject->localBoundingBoxRectForAccessibility();
 
   // If the container has a scroll offset, subtract that out because we want our
   // bounds to be relative to the *unscrolled* position of the container object.
   ScrollableArea* scrollableArea = container->getScrollableAreaIfScrollable();
   if (scrollableArea && !container->isWebArea()) {
     IntPoint scrollPosition = scrollableArea->scrollPosition();
     outBoundsInContainer.move(
         FloatSize(scrollPosition.x(), scrollPosition.y()));
   }
 
-  // Compute the transform between the container's coordinate space and this object.
-  // If the transform is just a simple translation, apply that to the bounding box, but
-  // if it's a non-trivial transformation like a rotation, scaling, etc. then return
-  // the full matrix instead.
+  // Compute the transform between the container's coordinate space and this
+  // object.  If the transform is just a simple translation, apply that to the
+  // bounding box, but if it's a non-trivial transformation like a rotation,
+  // scaling, etc. then return the full matrix instead.
   TransformationMatrix transform = layoutObject->localToAncestorTransform(
       toLayoutBoxModelObject(containerLayoutObject));
   if (transform.isIdentityOr2DTranslation()) {
     outBoundsInContainer.move(transform.to2DTranslation());
   } else {
     outContainerTransform = TransformationMatrix::toSkMatrix44(transform);
   }
 }
 
 LayoutRect AXObject::getBoundsInFrameCoordinates() const {
@@ skipping 107 matching lines @@
       return currentScrollOffset;
 
     // Subfocus must be within focus.
     subfocusMin = std::max(subfocusMin, objectMin);
     subfocusMax = std::min(subfocusMax, objectMax);
 
     // Subfocus must be no larger than the viewport size; favor top/left.
     if (subfocusMax - subfocusMin > viewportSize)
       subfocusMax = subfocusMin + viewportSize;
 
-    // Compute the size of an object centered on the subfocus, the size of the viewport.
+    // Compute the size of an object centered on the subfocus, the size of the
+    // viewport.
     int centeredObjectMin = (subfocusMin + subfocusMax - viewportSize) / 2;
     int centeredObjectMax = centeredObjectMin + viewportSize;
 
     objectMin = std::max(objectMin, centeredObjectMin);
     objectMax = std::min(objectMax, centeredObjectMax);
   }
 
   // Exit now if the focus is already within the viewport.
   if (objectMin - currentScrollOffset >= viewportMin &&
       objectMax - currentScrollOffset <= viewportMax)
@@ skipping 46 matching lines @@
       pixelSnappedIntRect(scrollParent->getBoundsInFrameCoordinates());
   newSubfocus.move(newElementRect.x(), newElementRect.y());
   newSubfocus.move(-scrollParentRect.x(), -scrollParentRect.y());
 
   // Recursively make sure the scroll parent itself is visible.
   if (scrollParent->parentObject())
     scrollParent->scrollToMakeVisibleWithSubFocus(newSubfocus);
 }
 
 void AXObject::scrollToGlobalPoint(const IntPoint& globalPoint) const {
-  // Search up the parent chain and create a vector of all scrollable parent objects
-  // and ending with this object itself.
+  // Search up the parent chain and create a vector of all scrollable parent
+  // objects and ending with this object itself.
   HeapVector<Member<const AXObject>> objects;
   AXObject* parentObject;
   for (parentObject = this->parentObject(); parentObject;
        parentObject = parentObject->parentObject()) {
     if (parentObject->getScrollableAreaIfScrollable())
       objects.prepend(parentObject);
   }
   objects.append(this);
 
   // Start with the outermost scrollable (the main window) and try to scroll the
@@ skipping 21 matching lines @@
 
     int desiredX = computeBestScrollOffset(0, objectRect.x(), objectRect.maxX(),
                                            objectRect.x(), objectRect.maxX(),
                                            point.x(), point.x());
     int desiredY = computeBestScrollOffset(0, objectRect.y(), objectRect.maxY(),
                                            objectRect.y(), objectRect.maxY(),
                                            point.y(), point.y());
     outer->setScrollOffset(IntPoint(desiredX, desiredY));
 
     if (outer->isWebArea() && !inner->isWebArea()) {
-      // If outer object we just scrolled is a web area (frame) but the inner object
-      // is not, keep track of the coordinate transformation to apply to
+      // If outer object we just scrolled is a web area (frame) but the inner
+      // object is not, keep track of the coordinate transformation to apply to
       // future nested calculations.
       scrollPosition = scrollableArea->scrollPosition();
       offsetX -= (scrollPosition.x() + point.x());
       offsetY -= (scrollPosition.y() + point.y());
       point.move(scrollPosition.x() - innerRect.x(),
                  scrollPosition.y() - innerRect.y());
     } else if (inner->isWebArea()) {
-      // Otherwise, if the inner object is a web area, reset the coordinate transformation.
+      // Otherwise, if the inner object is a web area, reset the coordinate
+      // transformation.
       offsetX = 0;
       offsetY = 0;
     }
   }
 }
 
 void AXObject::notifyIfIgnoredValueChanged() {
   bool isIgnored = accessibilityIsIgnored();
   if (lastKnownIsIgnoredValue() != isIgnored) {
     axObjectCache().childrenChanged(parentObject());
     setLastKnownIsIgnoredValue(isIgnored);
   }
 }
 
 void AXObject::selectionChanged() {
   if (AXObject* parent = parentObjectIfExists())
     parent->selectionChanged();
 }
 
 int AXObject::lineForPosition(const VisiblePosition& position) const {
   if (position.isNull() || !getNode())
     return -1;
 
-  // If the position is not in the same editable region as this AX object, return -1.
+  // If the position is not in the same editable region as this AX object,
+  // return -1.
   Node* containerNode = position.deepEquivalent().computeContainerNode();
   if (!containerNode->isShadowIncludingInclusiveAncestorOf(getNode()) &&
       !getNode()->isShadowIncludingInclusiveAncestorOf(containerNode))
     return -1;
 
   int lineCount = -1;
   VisiblePosition currentPosition = position;
   VisiblePosition previousPosition;
 
-  // move up until we get to the top
-  // FIXME: This only takes us to the top of the rootEditableElement, not the top of the
-  // top document.
+  // Move up until we get to the top.
+  // FIXME: This only takes us to the top of the rootEditableElement, not the
+  // top of the top document.
   do {
     previousPosition = currentPosition;
     currentPosition =
         previousLinePosition(currentPosition, LayoutUnit(), HasEditableAXRole);
     ++lineCount;
   } while (currentPosition.isNotNull() &&
            !inSameLine(currentPosition, previousPosition));
 
   return lineCount;
 }
@@ skipping 124 matching lines @@
 }
 
 DEFINE_TRACE(AXObject) {
   visitor->trace(m_children);
   visitor->trace(m_parent);
   visitor->trace(m_cachedLiveRegionRoot);
   visitor->trace(m_axObjectCache);
 }
 
 }  // namespace blink