s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

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 964 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(wrapUnique(new PendingStartElementNSCallback(
+    m_pendingCallbacks.append(WTF::wrapUnique(new PendingStartElementNSCallback(
         localName, prefix, uri, nbNamespaces, libxmlNamespaces, nbAttributes,
         nbDefaulted, libxmlAttributes)));
     return;
   }
 
   if (!updateLeafTextNode())
     return;
 
   AtomicString adjustedURI = uri;
   if (m_parsingFragment && adjustedURI.isNull()) {
@@ skipping 62 matching lines @@
     // runScriptsAtDocumentElementAvailable might have invalidated the document.
   }
 }
 
 void XMLDocumentParser::endElementNs() {
   if (isStopped())
     return;
 
   if (m_parserPaused) {
     m_pendingCallbacks.append(
-        makeUnique<PendingEndElementNSCallback>(m_scriptStartPosition));
+        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(
-        makeUnique<PendingCharactersCallback>(chars, length));
+        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(wrapUnique(new PendingErrorCallback(
+    m_pendingCallbacks.append(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(
-        makeUnique<PendingProcessingInstructionCallback>(target, data));
+        WTF::makeUnique<PendingProcessingInstructionCallback>(target, data));
     return;
   }
 
   if (!updateLeafTextNode())
     return;
 
   // ### handle exceptions
   DummyExceptionStateForTesting exceptionState;
   ProcessingInstruction* pi =
       m_currentNode->document().createProcessingInstruction(target, data,
@@ skipping 20 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(makeUnique<PendingCDATABlockCallback>(text));
+    m_pendingCallbacks.append(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(makeUnique<PendingCommentCallback>(text));
+    m_pendingCallbacks.append(WTF::makeUnique<PendingCommentCallback>(text));
     return;
   }
 
   if (!updateLeafTextNode())
     return;
 
   m_currentNode->parserAppendChild(
       Comment::create(m_currentNode->document(), text));
 }
 
@@ skipping 27 matching lines @@
   updateLeafTextNode();
 }
 
 void XMLDocumentParser::internalSubset(const String& name,
                                        const String& externalID,
                                        const String& systemID) {
   if (isStopped())
     return;
 
   if (m_parserPaused) {
-    m_pendingCallbacks.append(wrapUnique(
+    m_pendingCallbacks.append(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 237 matching lines @@
     const char noStyleMessage[] =
         "This XML file does not appear to have any style information "
         "associated with it. The document tree is shown below.";
     document()->setIsViewSource(true);
     V8Document::PrivateScript::transformDocumentToTreeViewMethod(
         document()->frame(), document(), noStyleMessage);
   } else if (m_sawXSLTransform) {
     xmlDocPtr doc =
         xmlDocPtrForString(document(), m_originalSourceForTransform.toString(),
                            document()->url().getString());
-    document()->setTransformSource(makeUnique<TransformSource>(doc));
+    document()->setTransformSource(WTF::makeUnique<TransformSource>(doc));
     DocumentParser::stopParsing();
   }
 }
 
 xmlDocPtr xmlDocPtrForString(Document* document,
                              const String& source,
                              const String& url) {
   if (source.isEmpty())
     return 0;
   // Parse in a single chunk into an xmlDocPtr
@@ skipping 143 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