Migrate WTF::Vector::append() to ::push_back() [part 13 of N]

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 465 matching lines @@
 // 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.
 
   if (!m_layoutObject) {
     if (ignoredReasons)
-      ignoredReasons->append(IgnoredReason(AXNotRendered));
+      ignoredReasons->push_back(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.
     if (equalIgnoringCase(getAttribute(aria_hiddenAttr), "false"))
       return DefaultBehavior;
 
     if (ignoredReasons)
-      ignoredReasons->append(IgnoredReason(AXNotVisible));
+      ignoredReasons->push_back(IgnoredReason(AXNotVisible));
     return IgnoreObject;
   }
 
   return AXObject::defaultObjectInclusion(ignoredReasons);
 }
 
 bool AXLayoutObject::computeAccessibilityIsIgnored(
     IgnoredReasons* ignoredReasons) const {
 #if ENABLE(ASSERT)
   ASSERT(m_initialized);
@@ skipping 11 matching lines @@
   if (decision == IgnoreObject)
     return true;
 
   if (m_layoutObject->isAnonymousBlock())
     return true;
 
   // If this element is within a parent that cannot have children, it should not
   // be exposed.
   if (isDescendantOfLeafNode()) {
     if (ignoredReasons)
-      ignoredReasons->append(
+      ignoredReasons->push_back(
           IgnoredReason(AXAncestorIsLeafNode, leafNodeAncestor()));
     return true;
   }
 
   if (roleValue() == IgnoredRole) {
     if (ignoredReasons)
-      ignoredReasons->append(IgnoredReason(AXUninteresting));
+      ignoredReasons->push_back(IgnoredReason(AXUninteresting));
     return true;
   }
 
   if (hasInheritedPresentationalRole()) {
     if (ignoredReasons) {
       const AXObject* inheritsFrom = inheritsPresentationalRoleFrom();
       if (inheritsFrom == this)
-        ignoredReasons->append(IgnoredReason(AXPresentationalRole));
+        ignoredReasons->push_back(IgnoredReason(AXPresentationalRole));
       else
-        ignoredReasons->append(
+        ignoredReasons->push_back(
             IgnoredReason(AXInheritsPresentation, inheritsFrom));
     }
     return true;
   }
 
   // An ARIA tree can only have tree items and static text as children.
   if (AXObject* treeAncestor = treeAncestorDisallowingChild()) {
     if (ignoredReasons)
-      ignoredReasons->append(
+      ignoredReasons->push_back(
           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.
   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.
   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->push_back(
+            IgnoredReason(AXLabelContainer, labelAXObject));
       }
 
-      ignoredReasons->append(IgnoredReason(AXLabelFor, controlObject));
+      ignoredReasons->push_back(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.
     AXObject* parent = parentObjectUnignored();
     if (parent && (parent->ariaRoleAttribute() == MenuItemRole ||
                    parent->ariaRoleAttribute() == MenuButtonRole)) {
       if (ignoredReasons)
-        ignoredReasons->append(
+        ignoredReasons->push_back(
             IgnoredReason(AXStaticTextUsedAsNameFor, parent));
       return true;
     }
     LayoutText* layoutText = toLayoutText(m_layoutObject);
     if (!layoutText->hasTextBoxes()) {
       if (ignoredReasons)
-        ignoredReasons->append(IgnoredReason(AXEmptyText));
+        ignoredReasons->push_back(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...
     if (layoutText->text().impl()->containsOnlyWhitespace()) {
       if (ignoredReasons)
-        ignoredReasons->append(IgnoredReason(AXEmptyText));
+        ignoredReasons->push_back(IgnoredReason(AXEmptyText));
       return true;
     }
     return false;
   }
 
   if (isHeading())
     return false;
 
   if (isLandmarkRelated())
     return false;
@@ skipping 74 matching lines @@
   // <span> tags are inline tags and not meant to convey information if they
   // have no other aria information on them. If we don't ignore them, they may
   // emit signals expected to come from their parent. In addition, because
   // included spans are GroupRole objects, and GroupRole objects are often
   // containers with meaningful information, the inclusion of a span can have
   // the side effect of causing the immediate parent accessible to be ignored.
   // This is especially problematic for platforms which have distinct roles for
   // textual block elements.
   if (isHTMLSpanElement(node)) {
     if (ignoredReasons)
-      ignoredReasons->append(IgnoredReason(AXUninteresting));
+      ignoredReasons->push_back(IgnoredReason(AXUninteresting));
     return true;
   }
 
   if (isImage())
     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));
+        ignoredReasons->push_back(IgnoredReason(AXProbablyPresentational));
       return true;
     }
     // 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
@@ skipping 24 matching lines @@
       !canSetFocusAttribute()) {
     // If the layout object has any plain text in it, that text will be
     // inside a LineBox, so the layout object will have a first LineBox.
     bool hasAnyText = !!toLayoutBlockFlow(m_layoutObject)->firstLineBox();
 
     // Always include interesting-looking objects.
     if (hasAnyText || mouseButtonListener())
       return false;
 
     if (ignoredReasons)
-      ignoredReasons->append(IgnoredReason(AXUninteresting));
+      ignoredReasons->push_back(IgnoredReason(AXUninteresting));
     return true;
   }
 
   // By default, objects should be ignored so that the AX hierarchy is not
   // filled with unnecessary items.
   if (ignoredReasons)
-    ignoredReasons->append(IgnoredReason(AXUninteresting));
+    ignoredReasons->push_back(IgnoredReason(AXUninteresting));
   return true;
 }
 
 //
 // Properties of static elements.
 //
 
 const AtomicString& AXLayoutObject::accessKey() const {
   Node* node = m_layoutObject->node();
   if (!node)
@@ skipping 421 matching lines @@
         textAlternative = layoutText->text();
       foundTextAlternative = true;
     } else if (m_layoutObject->isListMarker() && !recursive) {
       textAlternative = toLayoutListMarker(m_layoutObject)->text();
       foundTextAlternative = true;
     }
 
     if (foundTextAlternative) {
       nameFrom = AXNameFromContents;
       if (nameSources) {
-        nameSources->append(NameSource(false));
+        nameSources->push_back(NameSource(false));
         nameSources->back().type = nameFrom;
         nameSources->back().text = textAlternative;
       }
       return textAlternative;
     }
   }
 
   return AXNodeObject::textAlternative(recursive, inAriaLabelledByTraversal,
                                        visited, nameFrom, relatedObjects,
                                        nameSources);
@@ skipping 918 matching lines @@
     // the layoutObject calls AXObjectCacheImpl::inlineTextBoxesUpdated.
     return;
   }
 
   LayoutText* layoutText = toLayoutText(getLayoutObject());
   for (RefPtr<AbstractInlineTextBox> box =
            layoutText->firstAbstractInlineTextBox();
        box.get(); box = box->nextInlineTextBox()) {
     AXObject* axObject = axObjectCache().getOrCreate(box.get());
     if (!axObject->accessibilityIsIgnored())
-      m_children.append(axObject);
+      m_children.push_back(axObject);
   }
 }
 
 void AXLayoutObject::lineBreaks(Vector<int>& lineBreaks) const {
   if (!isTextControl())
     return;
 
   VisiblePosition visiblePos = visiblePositionForIndex(0);
   VisiblePosition prevVisiblePos = visiblePos;
   visiblePos = nextLinePosition(visiblePos, LayoutUnit(), HasEditableAXRole);
   // nextLinePosition moves to the end of the current line when there are
   // no more lines.
   while (visiblePos.isNotNull() && !inSameLine(prevVisiblePos, visiblePos)) {
-    lineBreaks.append(indexForVisiblePosition(visiblePos));
+    lineBreaks.push_back(indexForVisiblePosition(visiblePos));
     prevVisiblePos = visiblePos;
     visiblePos = nextLinePosition(visiblePos, LayoutUnit(), HasEditableAXRole);
 
     // Make sure we always make forward progress.
     if (visiblePos.deepEquivalent().compareTo(prevVisiblePos.deepEquivalent()) <
         0)
       break;
   }
 }
 
@@ skipping 231 matching lines @@
   HTMLInputElement& input = toHTMLInputElement(*node);
   Element* spinButtonElement = input.userAgentShadowRoot()->getElementById(
       ShadowElementNames::spinButton());
   if (!spinButtonElement || !spinButtonElement->isSpinButtonElement())
     return;
 
   AXSpinButton* axSpinButton =
       toAXSpinButton(axObjectCache().getOrCreate(SpinButtonRole));
   axSpinButton->setSpinButtonElement(toSpinButtonElement(spinButtonElement));
   axSpinButton->setParent(this);
-  m_children.append(axSpinButton);
+  m_children.push_back(axSpinButton);
 }
 
 void AXLayoutObject::addImageMapChildren() {
   LayoutBoxModelObject* cssBox = getLayoutBoxModelObject();
   if (!cssBox || !cssBox->isLayoutImage())
     return;
 
   HTMLMapElement* map = toLayoutImage(cssBox)->imageMap();
   if (!map)
     return;
 
   for (HTMLAreaElement& area :
        Traversal<HTMLAreaElement>::descendantsOf(*map)) {
     // add an <area> element for this child if it has a link
     AXObject* obj = axObjectCache().getOrCreate(&area);
     if (obj) {
       AXImageMapLink* areaObject = toAXImageMapLink(obj);
       areaObject->setParent(this);
       ASSERT(areaObject->axObjectID() != 0);
       if (!areaObject->accessibilityIsIgnored())
-        m_children.append(areaObject);
+        m_children.push_back(areaObject);
       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.
   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);
+    m_children.push_back(axPopup);
 }
 
 void AXLayoutObject::addRemoteSVGChildren() {
   AXSVGRoot* root = remoteSVGRootElement();
   if (!root)
     return;
 
   root->setParent(this);
 
   if (root->accessibilityIsIgnored()) {
     for (const auto& child : root->children())
-      m_children.append(child);
+      m_children.push_back(child);
   } else {
-    m_children.append(root);
+    m_children.push_back(root);
   }
 }
 
 bool AXLayoutObject::elementAttributeValue(
     const QualifiedName& attributeName) const {
   if (!m_layoutObject)
     return false;
 
   return equalIgnoringCase(getAttribute(attributeName), "true");
 }
 
 }  // namespace blink