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

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 485 matching lines @@
     IgnoredReasons* ignoredReasons) const {
   if (isInertOrAriaHidden()) {
     if (ignoredReasons)
       computeIsInertOrAriaHidden(ignoredReasons);
     return IgnoreObject;
   }
 
   if (isPresentationalChild()) {
     if (ignoredReasons) {
       AXObject* ancestor = ancestorForWhichThisIsAPresentationalChild();
-      ignoredReasons->append(IgnoredReason(AXAncestorDisallowsChild, ancestor));
+      ignoredReasons->push_back(
+          IgnoredReason(AXAncestorDisallowsChild, ancestor));
     }
     return IgnoreObject;
   }
 
   return accessibilityPlatformIncludesObject();
 }
 
 bool AXObject::isInertOrAriaHidden() const {
   updateCachedAttributeValuesIfNeeded();
   return m_cachedIsInertOrAriaHidden;
 }
 
 bool AXObject::computeIsInertOrAriaHidden(
     IgnoredReasons* ignoredReasons) const {
   if (getNode()) {
     if (getNode()->isInert()) {
       if (ignoredReasons) {
         HTMLDialogElement* dialog = getActiveDialogElement(getNode());
         if (dialog) {
           AXObject* dialogObject = axObjectCache().getOrCreate(dialog);
           if (dialogObject)
-            ignoredReasons->append(
+            ignoredReasons->push_back(
                 IgnoredReason(AXActiveModalDialog, dialogObject));
           else
-            ignoredReasons->append(IgnoredReason(AXInert));
+            ignoredReasons->push_back(IgnoredReason(AXInert));
         } else {
           // TODO(aboxhall): handle inert attribute if it eventuates
-          ignoredReasons->append(IgnoredReason(AXInert));
+          ignoredReasons->push_back(IgnoredReason(AXInert));
         }
       }
       return true;
     }
   } else {
     AXObject* parent = parentObject();
     if (parent && parent->isInertOrAriaHidden()) {
       if (ignoredReasons)
         parent->computeIsInertOrAriaHidden(ignoredReasons);
       return true;
     }
   }
 
   const AXObject* hiddenRoot = ariaHiddenRoot();
   if (hiddenRoot) {
     if (ignoredReasons) {
       if (hiddenRoot == this)
-        ignoredReasons->append(IgnoredReason(AXAriaHidden));
+        ignoredReasons->push_back(IgnoredReason(AXAriaHidden));
       else
-        ignoredReasons->append(IgnoredReason(AXAriaHiddenRoot, hiddenRoot));
+        ignoredReasons->push_back(IgnoredReason(AXAriaHiddenRoot, hiddenRoot));
     }
     return true;
   }
 
   return false;
 }
 
 bool AXObject::isDescendantOfLeafNode() const {
   updateCachedAttributeValuesIfNeeded();
   return m_cachedIsDescendantOfLeafNode;
@@ skipping 104 matching lines @@
                                 &relatedObjects, nullptr);
 
   AccessibilityRole role = roleValue();
   if (!getNode() || (!isHTMLBRElement(getNode()) && role != StaticTextRole &&
                      role != InlineTextBoxRole))
     text = collapseWhitespace(text);
 
   if (nameObjects) {
     nameObjects->clear();
     for (size_t i = 0; i < relatedObjects.size(); i++)
-      nameObjects->append(relatedObjects[i]->object);
+      nameObjects->push_back(relatedObjects[i]->object);
   }
 
   return text;
 }
 
 String AXObject::name(NameSources* nameSources) const {
   AXObjectSet visited;
   AXNameFrom tmpNameFrom;
   AXRelatedObjectVector tmpRelatedObjects;
   String text = textAlternative(false, false, visited, tmpNameFrom,
@@ skipping 57 matching lines @@
 
   // Step 2B from: http://www.w3.org/TR/accname-aam-1.1
   // If you change this logic, update AXNodeObject::nameFromLabelElement, too.
   if (!inAriaLabelledByTraversal && !alreadyVisited) {
     const QualifiedName& attr =
         hasAttribute(aria_labeledbyAttr) && !hasAttribute(aria_labelledbyAttr)
             ? aria_labeledbyAttr
             : aria_labelledbyAttr;
     nameFrom = AXNameFromRelatedElement;
     if (nameSources) {
-      nameSources->append(NameSource(*foundTextAlternative, attr));
+      nameSources->push_back(NameSource(*foundTextAlternative, attr));
       nameSources->back().type = nameFrom;
     }
 
     const AtomicString& ariaLabelledby = getAttribute(attr);
     if (!ariaLabelledby.isNull()) {
       if (nameSources)
         nameSources->back().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
@@ skipping 14 matching lines @@
       } else if (nameSources) {
         nameSources->back().invalid = true;
       }
     }
   }
 
   // Step 2C from: http://www.w3.org/TR/accname-aam-1.1
   // If you change this logic, update AXNodeObject::nameFromLabelElement, too.
   nameFrom = AXNameFromAttribute;
   if (nameSources) {
-    nameSources->append(NameSource(*foundTextAlternative, aria_labelAttr));
+    nameSources->push_back(NameSource(*foundTextAlternative, aria_labelAttr));
     nameSources->back().type = nameFrom;
   }
   const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
   if (!ariaLabel.isEmpty()) {
     textAlternative = ariaLabel;
 
     if (nameSources) {
       NameSource& source = nameSources->back();
       source.text = textAlternative;
       source.attributeValue = ariaLabel;
@@ skipping 15 matching lines @@
   bool foundValidElement = false;
   AXRelatedObjectVector localRelatedObjects;
 
   for (const auto& element : elements) {
     AXObject* axElement = axObjectCache().getOrCreate(element);
     if (axElement) {
       foundValidElement = true;
 
       String result = recursiveTextAlternative(
           *axElement, inAriaLabelledbyTraversal, visited);
-      localRelatedObjects.append(
+      localRelatedObjects.push_back(
           new NameSourceRelatedObject(axElement, result));
       if (!result.isEmpty()) {
         if (!accumulatedText.isEmpty())
           accumulatedText.append(' ');
         accumulatedText.append(result);
       }
     }
   }
   if (!foundValidElement)
     return String();
@@ skipping 19 matching lines @@
 void AXObject::elementsFromAttribute(HeapVector<Member<Element>>& elements,
                                      const QualifiedName& attribute) const {
   Vector<String> ids;
   tokenVectorFromAttribute(ids, attribute);
   if (ids.isEmpty())
     return;
 
   TreeScope& scope = getNode()->treeScope();
   for (const auto& id : ids) {
     if (Element* idElement = scope.getElementById(AtomicString(id)))
-      elements.append(idElement);
+      elements.push_back(idElement);
   }
 }
 
 void AXObject::ariaLabelledbyElementVector(
     HeapVector<Member<Element>>& elements) const {
   // Try both spellings, but prefer aria-labelledby, which is the official spec.
   elementsFromAttribute(elements, aria_labelledbyAttr);
   if (!elements.size())
     elementsFromAttribute(elements, aria_labeledbyAttr);
 }
@@ skipping 626 matching lines @@
 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.
   HeapVector<Member<const AXObject>> objects;
   AXObject* parentObject;
   for (parentObject = this->parentObject(); parentObject;
        parentObject = parentObject->parentObject()) {
     if (parentObject->getScrollableAreaIfScrollable())
       objects.prepend(parentObject);
   }
-  objects.append(this);
+  objects.push_back(this);
 
   // Start with the outermost scrollable (the main window) and try to scroll the
   // next innermost object to the given point.
   int offsetX = 0, offsetY = 0;
   IntPoint point = globalPoint;
   size_t levels = objects.size() - 1;
   for (size_t i = 0; i < levels; i++) {
     const AXObject* outer = objects[i];
     const AXObject* inner = objects[i + 1];
     ScrollableArea* scrollableArea = outer->getScrollableAreaIfScrollable();
@@ skipping 212 matching lines @@
 }
 
 DEFINE_TRACE(AXObject) {
   visitor->trace(m_children);
   visitor->trace(m_parent);
   visitor->trace(m_cachedLiveRegionRoot);
   visitor->trace(m_axObjectCache);
 }
 
 }  // namespace blink