Migrate WTF::Deque::append() to ::push_back()

third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.cpp

 /*
  * Copyright (C) 2000 Peter Kelly (pmk@post.com)
  * Copyright (C) 2005, 2006, 2008, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008 Holger Hans Peter Freyther
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  *
@@ skipping 963 matching lines @@
                                        int nbNamespaces,
                                        const xmlChar** libxmlNamespaces,
                                        int nbAttributes,
                                        int nbDefaulted,
                                        const xmlChar** libxmlAttributes) {
   if (isStopped())
     return;
 
   if (m_parserPaused) {
     m_scriptStartPosition = textPosition();
-    m_pendingCallbacks.append(WTF::wrapUnique(new PendingStartElementNSCallback(
-        localName, prefix, uri, nbNamespaces, libxmlNamespaces, nbAttributes,
-        nbDefaulted, libxmlAttributes)));
+    m_pendingCallbacks.push_back(
+        WTF::wrapUnique(new PendingStartElementNSCallback(
+            localName, prefix, uri, nbNamespaces, libxmlNamespaces,
+            nbAttributes, nbDefaulted, libxmlAttributes)));
     return;
   }
 
   if (!updateLeafTextNode())
     return;
 
   AtomicString adjustedURI = uri;
   if (m_parsingFragment && adjustedURI.isNull()) {
     if (!prefix.isNull())
       adjustedURI = m_prefixToNamespaceMap.at(prefix);
@@ skipping 59 matching lines @@
     document()->frame()->loader().runScriptsAtDocumentElementAvailable();
     // runScriptsAtDocumentElementAvailable might have invalidated the document.
   }
 }
 
 void XMLDocumentParser::endElementNs() {
   if (isStopped())
     return;
 
   if (m_parserPaused) {
-    m_pendingCallbacks.append(
+    m_pendingCallbacks.push_back(
         WTF::makeUnique<PendingEndElementNSCallback>(m_scriptStartPosition));
     return;
   }
 
   if (!updateLeafTextNode())
     return;
 
   ContainerNode* n = m_currentNode;
   if (m_currentNode->isElementNode())
     toElement(n)->finishParsingChildren();
@@ skipping 67 matching lines @@
 
 void XMLDocumentParser::setScriptStartPosition(TextPosition textPosition) {
   m_scriptStartPosition = textPosition;
 }
 
 void XMLDocumentParser::characters(const xmlChar* chars, int length) {
   if (isStopped())
     return;
 
   if (m_parserPaused) {
-    m_pendingCallbacks.append(
+    m_pendingCallbacks.push_back(
         WTF::makeUnique<PendingCharactersCallback>(chars, length));
     return;
   }
 
   createLeafTextNodeIfNeeded();
   m_bufferedText.append(chars, length);
 }
 
 void XMLDocumentParser::error(XMLErrors::ErrorType type,
                               const char* message,
                               va_list args) {
   if (isStopped())
     return;
 
   char formattedMessage[1024];
   vsnprintf(formattedMessage, sizeof(formattedMessage) - 1, message, args);
 
   if (m_parserPaused) {
-    m_pendingCallbacks.append(WTF::wrapUnique(new PendingErrorCallback(
+    m_pendingCallbacks.push_back(WTF::wrapUnique(new PendingErrorCallback(
         type, reinterpret_cast<const xmlChar*>(formattedMessage), lineNumber(),
         columnNumber())));
     return;
   }
 
   handleError(type, formattedMessage, textPosition());
 }
 
 void XMLDocumentParser::processingInstruction(const String& target,
                                               const String& data) {
   if (isStopped())
     return;
 
   if (m_parserPaused) {
-    m_pendingCallbacks.append(
+    m_pendingCallbacks.push_back(
         WTF::makeUnique<PendingProcessingInstructionCallback>(target, data));
     return;
   }
 
   if (!updateLeafTextNode())
     return;
 
   // ### handle exceptions
   DummyExceptionStateForTesting exceptionState;
   ProcessingInstruction* pi =
@@ skipping 21 matching lines @@
     // FIXME: This contradicts the contract of DocumentParser.
     stopParsing();
   }
 }
 
 void XMLDocumentParser::cdataBlock(const String& text) {
   if (isStopped())
     return;
 
   if (m_parserPaused) {
-    m_pendingCallbacks.append(WTF::makeUnique<PendingCDATABlockCallback>(text));
+    m_pendingCallbacks.push_back(
+        WTF::makeUnique<PendingCDATABlockCallback>(text));
     return;
   }
 
   if (!updateLeafTextNode())
     return;
 
   m_currentNode->parserAppendChild(
       CDATASection::create(m_currentNode->document(), text));
 }
 
 void XMLDocumentParser::comment(const String& text) {
   if (isStopped())
     return;
 
   if (m_parserPaused) {
-    m_pendingCallbacks.append(WTF::makeUnique<PendingCommentCallback>(text));
+    m_pendingCallbacks.push_back(WTF::makeUnique<PendingCommentCallback>(text));
     return;
   }
 
   if (!updateLeafTextNode())
     return;
 
   m_currentNode->parserAppendChild(
       Comment::create(m_currentNode->document(), text));
 }
 
@@ skipping 34 matching lines @@
   updateLeafTextNode();
 }
 
 void XMLDocumentParser::internalSubset(const String& name,
                                        const String& externalID,
                                        const String& systemID) {
   if (isStopped())
     return;
 
   if (m_parserPaused) {
-    m_pendingCallbacks.append(WTF::wrapUnique(
+    m_pendingCallbacks.push_back(WTF::wrapUnique(
         new PendingInternalSubsetCallback(name, externalID, systemID)));
     return;
   }
 
   if (document())
     document()->parserAppendChild(
         DocumentType::create(document(), name, externalID, systemID));
 }
 
 static inline XMLDocumentParser* getParser(void* closure) {
@@ skipping 397 matching lines @@
   RefPtr<XMLParserContext> parser =
       XMLParserContext::createStringParser(&sax, &state);
   String parseString = "<?xml version=\"1.0\"?><attrs " + string + " />";
   parseChunk(parser->context(), parseString);
   finishParsing(parser->context());
   attrsOK = state.gotAttributes;
   return state.attributes;
 }
 
 }  // namespace blink