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

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 116 matching lines @@
 #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 (isDescendantOfLeafNode()) {
     if (ignoredReasons)
-      ignoredReasons->append(
+      ignoredReasons->push_back(
           IgnoredReason(AXAncestorIsLeafNode, leafNodeAncestor()));
     return true;
   }
 
   // Ignore labels that are already referenced by a control.
   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;
   }
 
   Element* element = getNode()->isElementNode() ? toElement(getNode())
                                                 : getNode()->parentElement();
   if (!getLayoutObject() && (!element || !element->isInCanvasSubtree()) &&
       !equalIgnoringCase(getAttribute(aria_hiddenAttr), "false")) {
     if (ignoredReasons)
-      ignoredReasons->append(IgnoredReason(AXNotRendered));
+      ignoredReasons->push_back(IgnoredReason(AXNotRendered));
     return true;
   }
 
   if (m_role == UnknownRole) {
     if (ignoredReasons)
-      ignoredReasons->append(IgnoredReason(AXUninteresting));
+      ignoredReasons->push_back(IgnoredReason(AXUninteresting));
     return true;
   }
   return false;
 }
 
 static bool isListElement(Node* node) {
   return isHTMLUListElement(*node) || isHTMLOListElement(*node) ||
          isHTMLDListElement(*node);
 }
 
@@ skipping 387 matching lines @@
   elementsFromAttribute(elements, attr);
 
   AXObjectCacheImpl& cache = axObjectCache();
   for (const auto& element : elements) {
     if (AXObject* child = cache.getOrCreate(element)) {
       // Only aria-labelledby and aria-describedby can target hidden elements.
       if (child->accessibilityIsIgnored() && attr != aria_labelledbyAttr &&
           attr != aria_labeledbyAttr && attr != aria_describedbyAttr) {
         continue;
       }
-      children.append(child);
+      children.push_back(child);
     }
   }
 }
 
 // This only returns true if this is the element that actually has the
 // contentEditable attribute set, unlike node->hasEditableStyle() which will
 // also return true if an ancestor is editable.
 bool AXNodeObject::hasContentEditableAttributeSet() const {
   const AtomicString& contentEditableValue = getAttribute(contenteditableAttr);
   if (contentEditableValue.isNull())
@@ skipping 612 matching lines @@
     return;
 
   DocumentMarkerController& markerController = getDocument()->markers();
   DocumentMarkerVector markers = markerController.markersFor(getNode());
   for (size_t i = 0; i < markers.size(); ++i) {
     DocumentMarker* marker = markers[i];
     switch (marker->type()) {
       case DocumentMarker::Spelling:
       case DocumentMarker::Grammar:
       case DocumentMarker::TextMatch:
-        markerTypes.append(marker->type());
-        markerRanges.append(
+        markerTypes.push_back(marker->type());
+        markerRanges.push_back(
             AXRange(marker->startOffset(), marker->endOffset()));
         break;
       case DocumentMarker::InvisibleSpellcheck:
       case DocumentMarker::Composition:
         // No need for accessibility to know about these marker types.
         break;
     }
   }
 }
 
@@ skipping 358 matching lines @@
   // Step 2D from: http://www.w3.org/TR/accname-aam-1.1
   textAlternative = nativeTextAlternative(visited, nameFrom, relatedObjects,
                                           nameSources, &foundTextAlternative);
   if (!textAlternative.isEmpty() && !nameSources)
     return textAlternative;
 
   // Step 2F / 2G from: http://www.w3.org/TR/accname-aam-1.1
   if (recursive || nameFromContents()) {
     nameFrom = AXNameFromContents;
     if (nameSources) {
-      nameSources->append(NameSource(foundTextAlternative));
+      nameSources->push_back(NameSource(foundTextAlternative));
       nameSources->back().type = nameFrom;
     }
 
     Node* node = this->getNode();
     if (node && node->isTextNode())
       textAlternative = toText(node)->wholeText();
     else if (isHTMLBRElement(node))
       textAlternative = String("\n");
     else
       textAlternative = textFromDescendants(visited, false);
 
     if (!textAlternative.isEmpty()) {
       if (nameSources) {
         foundTextAlternative = true;
         nameSources->back().text = textAlternative;
       } else {
         return textAlternative;
       }
     }
   }
 
   // Step 2H from: http://www.w3.org/TR/accname-aam-1.1
   nameFrom = AXNameFromTitle;
   if (nameSources) {
-    nameSources->append(NameSource(foundTextAlternative, titleAttr));
+    nameSources->push_back(NameSource(foundTextAlternative, titleAttr));
     nameSources->back().type = nameFrom;
   }
   const AtomicString& title = getAttribute(titleAttr);
   if (!title.isEmpty()) {
     textAlternative = title;
     if (nameSources) {
       foundTextAlternative = true;
       nameSources->back().text = textAlternative;
     } else {
       return textAlternative;
@@ skipping 24 matching lines @@
 
   StringBuilder accumulatedText;
   AXObject* previous = nullptr;
 
   AXObjectVector children;
 
   HeapVector<Member<AXObject>> ownedChildren;
   computeAriaOwnsChildren(ownedChildren);
   for (AXObject* obj = rawFirstChild(); obj; obj = obj->rawNextSibling()) {
     if (!axObjectCache().isAriaOwned(obj))
-      children.append(obj);
+      children.push_back(obj);
   }
   for (const auto& ownedChild : ownedChildren)
-    children.append(ownedChild);
+    children.push_back(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).
     if (equalIgnoringCase(child->getAttribute(aria_hiddenAttr), "true"))
       continue;
 
@@ skipping 91 matching lines @@
   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);
+            rects.push_back(bounds);
           }
         }
       }
     }
 
     if (*outContainer) {
       outBoundsInContainer = unionRect(rects);
       return;
     }
   }
@@ skipping 453 matching lines @@
 
   // 5.1/5.5 Text inputs, Other labelable Elements
   // If you change this logic, update AXNodeObject::nameFromLabelElement, too.
   HTMLElement* htmlElement = nullptr;
   if (getNode()->isHTMLElement())
     htmlElement = toHTMLElement(getNode());
 
   if (htmlElement && htmlElement->isLabelable()) {
     nameFrom = AXNameFromRelatedElement;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative));
+      nameSources->push_back(NameSource(*foundTextAlternative));
       nameSources->back().type = nameFrom;
       nameSources->back().nativeSource = AXTextFromNativeHTMLLabel;
     }
 
     LabelsNodeList* labels = toLabelableElement(htmlElement)->labels();
     if (labels && labels->length() > 0) {
       HeapVector<Member<Element>> labelElements;
       for (unsigned labelIndex = 0; labelIndex < labels->length();
            ++labelIndex) {
         Element* label = labels->item(labelIndex);
         if (nameSources) {
           if (label->getAttribute(forAttr) == htmlElement->getIdAttribute())
             nameSources->back().nativeSource = AXTextFromNativeHTMLLabelFor;
           else
             nameSources->back().nativeSource = AXTextFromNativeHTMLLabelWrapped;
         }
-        labelElements.append(label);
+        labelElements.push_back(label);
       }
 
       textAlternative =
           textFromElements(false, visited, labelElements, relatedObjects);
       if (!textAlternative.isNull()) {
         *foundTextAlternative = true;
         if (nameSources) {
           NameSource& source = nameSources->back();
           source.relatedObjects = *relatedObjects;
           source.text = textAlternative;
         } else {
           return textAlternative;
         }
       } else if (nameSources) {
         nameSources->back().invalid = true;
       }
     }
   }
 
   // 5.2 input type="button", input type="submit" and input type="reset"
   if (inputElement && inputElement->isTextButton()) {
     // value attribue
     nameFrom = AXNameFromValue;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative, valueAttr));
+      nameSources->push_back(NameSource(*foundTextAlternative, valueAttr));
       nameSources->back().type = nameFrom;
     }
     String value = inputElement->value();
     if (!value.isNull()) {
       textAlternative = value;
       if (nameSources) {
         NameSource& source = nameSources->back();
         source.text = textAlternative;
         *foundTextAlternative = true;
       } else {
         return textAlternative;
       }
     }
     return textAlternative;
   }
 
   // 5.3 input type="image"
   if (inputElement &&
       inputElement->getAttribute(typeAttr) == InputTypeNames::image) {
     // alt attr
     nameFrom = AXNameFromAttribute;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative, altAttr));
+      nameSources->push_back(NameSource(*foundTextAlternative, altAttr));
       nameSources->back().type = nameFrom;
     }
     const AtomicString& alt = inputElement->getAttribute(altAttr);
     if (!alt.isNull()) {
       textAlternative = alt;
       if (nameSources) {
         NameSource& source = nameSources->back();
         source.attributeValue = alt;
         source.text = textAlternative;
         *foundTextAlternative = true;
       } else {
         return textAlternative;
       }
     }
 
     // value attr
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative, valueAttr));
+      nameSources->push_back(NameSource(*foundTextAlternative, valueAttr));
       nameSources->back().type = nameFrom;
     }
     nameFrom = AXNameFromAttribute;
     String value = inputElement->value();
     if (!value.isNull()) {
       textAlternative = value;
       if (nameSources) {
         NameSource& source = nameSources->back();
         source.text = textAlternative;
         *foundTextAlternative = true;
       } else {
         return textAlternative;
       }
     }
 
     // localised default value ("Submit")
     nameFrom = AXNameFromValue;
     textAlternative = inputElement->locale().queryString(
         WebLocalizedString::SubmitButtonDefaultLabel);
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative, typeAttr));
+      nameSources->push_back(NameSource(*foundTextAlternative, typeAttr));
       NameSource& source = nameSources->back();
       source.attributeValue = inputElement->getAttribute(typeAttr);
       source.type = nameFrom;
       source.text = textAlternative;
       *foundTextAlternative = true;
     } else {
       return textAlternative;
     }
     return textAlternative;
   }
 
   // 5.1 Text inputs - step 3 (placeholder attribute)
   if (htmlElement && htmlElement->isTextControl()) {
     nameFrom = AXNameFromPlaceholder;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative, placeholderAttr));
+      nameSources->push_back(
+          NameSource(*foundTextAlternative, placeholderAttr));
       NameSource& source = nameSources->back();
       source.type = nameFrom;
     }
     const String placeholder = placeholderFromNativeAttribute();
     if (!placeholder.isEmpty()) {
       textAlternative = placeholder;
       if (nameSources) {
         NameSource& source = nameSources->back();
         source.text = textAlternative;
         source.attributeValue = htmlElement->fastGetAttribute(placeholderAttr);
         *foundTextAlternative = true;
       } else {
         return textAlternative;
       }
     }
 
     // Also check for aria-placeholder.
     nameFrom = AXNameFromPlaceholder;
     if (nameSources) {
-      nameSources->append(
+      nameSources->push_back(
           NameSource(*foundTextAlternative, aria_placeholderAttr));
       NameSource& source = nameSources->back();
       source.type = nameFrom;
     }
     const AtomicString& ariaPlaceholder =
         htmlElement->fastGetAttribute(aria_placeholderAttr);
     if (!ariaPlaceholder.isEmpty()) {
       textAlternative = ariaPlaceholder;
       if (nameSources) {
         NameSource& source = nameSources->back();
         source.text = textAlternative;
         source.attributeValue = ariaPlaceholder;
         *foundTextAlternative = true;
       } else {
         return textAlternative;
       }
     }
 
     return textAlternative;
   }
 
   // 5.7 figure and figcaption Elements
   if (getNode()->hasTagName(figureTag)) {
     // figcaption
     nameFrom = AXNameFromRelatedElement;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative));
+      nameSources->push_back(NameSource(*foundTextAlternative));
       nameSources->back().type = nameFrom;
       nameSources->back().nativeSource = AXTextFromNativeHTMLFigcaption;
     }
     Element* figcaption = nullptr;
     for (Element& element : ElementTraversal::descendantsOf(*(getNode()))) {
       if (element.hasTagName(figcaptionTag)) {
         figcaption = &element;
         break;
       }
     }
     if (figcaption) {
       AXObject* figcaptionAXObject = axObjectCache().getOrCreate(figcaption);
       if (figcaptionAXObject) {
         textAlternative =
             recursiveTextAlternative(*figcaptionAXObject, false, visited);
 
         if (relatedObjects) {
-          localRelatedObjects.append(
+          localRelatedObjects.push_back(
               new NameSourceRelatedObject(figcaptionAXObject, textAlternative));
           *relatedObjects = localRelatedObjects;
           localRelatedObjects.clear();
         }
 
         if (nameSources) {
           NameSource& source = nameSources->back();
           source.relatedObjects = *relatedObjects;
           source.text = textAlternative;
           *foundTextAlternative = true;
         } else {
           return textAlternative;
         }
       }
     }
     return textAlternative;
   }
 
   // 5.8 img or area Element
   if (isHTMLImageElement(getNode()) || isHTMLAreaElement(getNode()) ||
       (getLayoutObject() && getLayoutObject()->isSVGImage())) {
     // alt
     nameFrom = AXNameFromAttribute;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative, altAttr));
+      nameSources->push_back(NameSource(*foundTextAlternative, altAttr));
       nameSources->back().type = nameFrom;
     }
     const AtomicString& alt = getAttribute(altAttr);
     if (!alt.isNull()) {
       textAlternative = alt;
       if (nameSources) {
         NameSource& source = nameSources->back();
         source.attributeValue = alt;
         source.text = textAlternative;
         *foundTextAlternative = true;
       } else {
         return textAlternative;
       }
     }
     return textAlternative;
   }
 
   // 5.9 table Element
   if (isHTMLTableElement(getNode())) {
     HTMLTableElement* tableElement = toHTMLTableElement(getNode());
 
     // caption
     nameFrom = AXNameFromCaption;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative));
+      nameSources->push_back(NameSource(*foundTextAlternative));
       nameSources->back().type = nameFrom;
       nameSources->back().nativeSource = AXTextFromNativeHTMLTableCaption;
     }
     HTMLTableCaptionElement* caption = tableElement->caption();
     if (caption) {
       AXObject* captionAXObject = axObjectCache().getOrCreate(caption);
       if (captionAXObject) {
         textAlternative =
             recursiveTextAlternative(*captionAXObject, false, visited);
         if (relatedObjects) {
-          localRelatedObjects.append(
+          localRelatedObjects.push_back(
               new NameSourceRelatedObject(captionAXObject, textAlternative));
           *relatedObjects = localRelatedObjects;
           localRelatedObjects.clear();
         }
 
         if (nameSources) {
           NameSource& source = nameSources->back();
           source.relatedObjects = *relatedObjects;
           source.text = textAlternative;
           *foundTextAlternative = true;
         } else {
           return textAlternative;
         }
       }
     }
 
     // summary
     nameFrom = AXNameFromAttribute;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative, summaryAttr));
+      nameSources->push_back(NameSource(*foundTextAlternative, summaryAttr));
       nameSources->back().type = nameFrom;
     }
     const AtomicString& summary = getAttribute(summaryAttr);
     if (!summary.isNull()) {
       textAlternative = summary;
       if (nameSources) {
         NameSource& source = nameSources->back();
         source.attributeValue = summary;
         source.text = textAlternative;
         *foundTextAlternative = true;
       } else {
         return textAlternative;
       }
     }
 
     return textAlternative;
   }
 
   // Per SVG AAM 1.0's modifications to 2D of this algorithm.
   if (getNode()->isSVGElement()) {
     nameFrom = AXNameFromRelatedElement;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative));
+      nameSources->push_back(NameSource(*foundTextAlternative));
       nameSources->back().type = nameFrom;
       nameSources->back().nativeSource = AXTextFromNativeHTMLTitleElement;
     }
     ASSERT(getNode()->isContainerNode());
     Element* title = ElementTraversal::firstChild(
         toContainerNode(*(getNode())), HasTagName(SVGNames::titleTag));
 
     if (title) {
       AXObject* titleAXObject = axObjectCache().getOrCreate(title);
       if (titleAXObject && !visited.contains(titleAXObject)) {
         textAlternative =
             recursiveTextAlternative(*titleAXObject, false, visited);
         if (relatedObjects) {
-          localRelatedObjects.append(
+          localRelatedObjects.push_back(
               new NameSourceRelatedObject(titleAXObject, textAlternative));
           *relatedObjects = localRelatedObjects;
           localRelatedObjects.clear();
         }
       }
       if (nameSources) {
         NameSource& source = nameSources->back();
         source.text = textAlternative;
         source.relatedObjects = *relatedObjects;
         *foundTextAlternative = true;
       } else {
         return textAlternative;
       }
     }
   }
 
   // Fieldset / legend.
   if (isHTMLFieldSetElement(getNode())) {
     nameFrom = AXNameFromRelatedElement;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative));
+      nameSources->push_back(NameSource(*foundTextAlternative));
       nameSources->back().type = nameFrom;
       nameSources->back().nativeSource = AXTextFromNativeHTMLLegend;
     }
     HTMLElement* legend = toHTMLFieldSetElement(getNode())->legend();
     if (legend) {
       AXObject* legendAXObject = axObjectCache().getOrCreate(legend);
       // Avoid an infinite loop
       if (legendAXObject && !visited.contains(legendAXObject)) {
         textAlternative =
             recursiveTextAlternative(*legendAXObject, false, visited);
 
         if (relatedObjects) {
-          localRelatedObjects.append(
+          localRelatedObjects.push_back(
               new NameSourceRelatedObject(legendAXObject, textAlternative));
           *relatedObjects = localRelatedObjects;
           localRelatedObjects.clear();
         }
 
         if (nameSources) {
           NameSource& source = nameSources->back();
           source.relatedObjects = *relatedObjects;
           source.text = textAlternative;
           *foundTextAlternative = true;
         } else {
           return textAlternative;
         }
       }
     }
   }
 
   // Document.
   if (isWebArea()) {
     Document* document = this->getDocument();
     if (document) {
       nameFrom = AXNameFromAttribute;
       if (nameSources) {
-        nameSources->append(NameSource(foundTextAlternative, aria_labelAttr));
+        nameSources->push_back(
+            NameSource(foundTextAlternative, aria_labelAttr));
         nameSources->back().type = nameFrom;
       }
       if (Element* documentElement = document->documentElement()) {
         const AtomicString& ariaLabel =
             documentElement->getAttribute(aria_labelAttr);
         if (!ariaLabel.isEmpty()) {
           textAlternative = ariaLabel;
 
           if (nameSources) {
             NameSource& source = nameSources->back();
             source.text = textAlternative;
             source.attributeValue = ariaLabel;
             *foundTextAlternative = true;
           } else {
             return textAlternative;
           }
         }
       }
 
       nameFrom = AXNameFromRelatedElement;
       if (nameSources) {
-        nameSources->append(NameSource(*foundTextAlternative));
+        nameSources->push_back(NameSource(*foundTextAlternative));
         nameSources->back().type = nameFrom;
         nameSources->back().nativeSource = AXTextFromNativeHTMLTitleElement;
       }
 
       textAlternative = document->title();
 
       Element* titleElement = document->titleElement();
       AXObject* titleAXObject = axObjectCache().getOrCreate(titleElement);
       if (titleAXObject) {
         if (relatedObjects) {
-          localRelatedObjects.append(
+          localRelatedObjects.push_back(
               new NameSourceRelatedObject(titleAXObject, textAlternative));
           *relatedObjects = localRelatedObjects;
           localRelatedObjects.clear();
         }
 
         if (nameSources) {
           NameSource& source = nameSources->back();
           source.relatedObjects = *relatedObjects;
           source.text = textAlternative;
           *foundTextAlternative = true;
         } else {
           return textAlternative;
         }
       }
     }
   }
 
   return textAlternative;
 }
 
 String AXNodeObject::description(AXNameFrom nameFrom,
                                  AXDescriptionFrom& descriptionFrom,
                                  AXObjectVector* descriptionObjects) const {
   AXRelatedObjectVector relatedObjects;
   String result =
       description(nameFrom, descriptionFrom, nullptr, &relatedObjects);
   if (descriptionObjects) {
     descriptionObjects->clear();
     for (size_t i = 0; i < relatedObjects.size(); i++)
-      descriptionObjects->append(relatedObjects[i]->object);
+      descriptionObjects->push_back(relatedObjects[i]->object);
   }
 
   return collapseWhitespace(result);
 }
 
 // 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)
     ASSERT(relatedObjects);
 
   if (!getNode())
     return String();
 
   String description;
   bool foundDescription = false;
 
   descriptionFrom = AXDescriptionFromRelatedElement;
   if (descriptionSources) {
-    descriptionSources->append(
+    descriptionSources->push_back(
         DescriptionSource(foundDescription, aria_describedbyAttr));
     descriptionSources->back().type = descriptionFrom;
   }
 
   // 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->back().attributeValue = ariaDescribedby;
@@ skipping 17 matching lines @@
 
   const HTMLInputElement* inputElement = nullptr;
   if (isHTMLInputElement(getNode()))
     inputElement = toHTMLInputElement(getNode());
 
   // value, 5.2.2 from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
   if (nameFrom != AXNameFromValue && inputElement &&
       inputElement->isTextButton()) {
     descriptionFrom = AXDescriptionFromAttribute;
     if (descriptionSources) {
-      descriptionSources->append(
+      descriptionSources->push_back(
           DescriptionSource(foundDescription, valueAttr));
       descriptionSources->back().type = descriptionFrom;
     }
     String value = inputElement->value();
     if (!value.isNull()) {
       description = value;
       if (descriptionSources) {
         DescriptionSource& source = descriptionSources->back();
         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
   if (nameFrom != AXNameFromCaption && isHTMLTableElement(getNode())) {
     HTMLTableElement* tableElement = toHTMLTableElement(getNode());
 
     descriptionFrom = AXDescriptionFromRelatedElement;
     if (descriptionSources) {
-      descriptionSources->append(DescriptionSource(foundDescription));
+      descriptionSources->push_back(DescriptionSource(foundDescription));
       descriptionSources->back().type = descriptionFrom;
       descriptionSources->back().nativeSource =
           AXTextFromNativeHTMLTableCaption;
     }
     HTMLTableCaptionElement* caption = tableElement->caption();
     if (caption) {
       AXObject* captionAXObject = axObjectCache().getOrCreate(caption);
       if (captionAXObject) {
         AXObjectSet visited;
         description =
             recursiveTextAlternative(*captionAXObject, false, visited);
         if (relatedObjects)
-          relatedObjects->append(
+          relatedObjects->push_back(
               new NameSourceRelatedObject(captionAXObject, description));
 
         if (descriptionSources) {
           DescriptionSource& source = descriptionSources->back();
           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
   if (nameFrom != AXNameFromContents && isHTMLSummaryElement(getNode())) {
     descriptionFrom = AXDescriptionFromContents;
     if (descriptionSources) {
-      descriptionSources->append(DescriptionSource(foundDescription));
+      descriptionSources->push_back(DescriptionSource(foundDescription));
       descriptionSources->back().type = descriptionFrom;
     }
 
     AXObjectSet visited;
     description = textFromDescendants(visited, false);
 
     if (!description.isEmpty()) {
       if (descriptionSources) {
         foundDescription = true;
         descriptionSources->back().text = description;
       } else {
         return description;
       }
     }
   }
 
   // title attribute, from:
   // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
   if (nameFrom != AXNameFromTitle) {
     descriptionFrom = AXDescriptionFromAttribute;
     if (descriptionSources) {
-      descriptionSources->append(
+      descriptionSources->push_back(
           DescriptionSource(foundDescription, titleAttr));
       descriptionSources->back().type = descriptionFrom;
     }
     const AtomicString& title = getAttribute(titleAttr);
     if (!title.isEmpty()) {
       description = title;
       if (descriptionSources) {
         foundDescription = true;
         descriptionSources->back().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.
   descriptionFrom = AXDescriptionFromAttribute;
   if (descriptionSources) {
-    descriptionSources->append(
+    descriptionSources->push_back(
         DescriptionSource(foundDescription, aria_helpAttr));
     descriptionSources->back().type = descriptionFrom;
   }
   const AtomicString& help = getAttribute(aria_helpAttr);
   if (!help.isEmpty()) {
     description = help;
     if (descriptionSources) {
       foundDescription = true;
       descriptionSources->back().text = description;
     } else {
@@ skipping 45 matching lines @@
     return String();
   return toTextControlElement(node)->strippedPlaceholder();
 }
 
 DEFINE_TRACE(AXNodeObject) {
   visitor->trace(m_node);
   AXObject::trace(visitor);
 }
 
 }  // namespace blink