Remove OwnPtr from Blink.

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/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 49 matching lines @@
 #include "core/xml/parser/XMLDocumentParserScope.h"
 #include "core/xml/parser/XMLParserInput.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "platform/TraceEvent.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/v8_inspector/public/ConsoleTypes.h"
 #include "platform/weborigin/SecurityOrigin.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/StringExtras.h"
 #include "wtf/TemporaryChange.h"
 #include "wtf/Threading.h"
 #include "wtf/Vector.h"
 #include "wtf/text/UTF8.h"
 #include <libxml/catalog.h>
 #include <libxml/parser.h>
 #include <libxml/parserInternals.h>
 #include <libxslt/xslt.h>
+#include <memory>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 // FIXME: HTMLConstructionSite has a limit of 512, should these match?
 static const unsigned maxXMLTreeDepth = 5000;
 
 static inline String toString(const xmlChar* string, size_t length)
 {
@@ skipping 864 matching lines @@
 }
 
 void XMLDocumentParser::startElementNs(const AtomicString& localName, const AtomicString& prefix, const AtomicString& uri, int nbNamespaces,
     const xmlChar** libxmlNamespaces, int nbAttributes, int nbDefaulted, const xmlChar** libxmlAttributes)
 {
     if (isStopped())
         return;
 
     if (m_parserPaused) {
         m_scriptStartPosition = textPosition();
-        m_pendingCallbacks.append(adoptPtr(new PendingStartElementNSCallback(localName, prefix, uri, nbNamespaces, libxmlNamespaces,
+        m_pendingCallbacks.append(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())
@@ skipping 58 matching lines @@
         // runScriptsAtDocumentElementAvailable might have invalidated the document.
     }
 }
 
 void XMLDocumentParser::endElementNs()
 {
     if (isStopped())
         return;
 
     if (m_parserPaused) {
-        m_pendingCallbacks.append(adoptPtr(new PendingEndElementNSCallback(m_scriptStartPosition)));
+        m_pendingCallbacks.append(wrapUnique(new PendingEndElementNSCallback(m_scriptStartPosition)));
         return;
     }
 
     if (!updateLeafTextNode())
         return;
 
     ContainerNode* n = m_currentNode;
     if (m_currentNode->isElementNode())
         toElement(n)->finishParsingChildren();
 
@@ skipping 61 matching lines @@
 {
     m_scriptStartPosition = textPosition;
 }
 
 void XMLDocumentParser::characters(const xmlChar* chars, int length)
 {
     if (isStopped())
         return;
 
     if (m_parserPaused) {
-        m_pendingCallbacks.append(adoptPtr(new PendingCharactersCallback(chars, length)));
+        m_pendingCallbacks.append(wrapUnique(new 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(adoptPtr(new PendingErrorCallback(type, reinterpret_cast<const xmlChar*>(formattedMessage), lineNumber(), columnNumber())));
+        m_pendingCallbacks.append(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(adoptPtr(new PendingProcessingInstructionCallback(target, data)));
+        m_pendingCallbacks.append(wrapUnique(new PendingProcessingInstructionCallback(target, data)));
         return;
     }
 
     if (!updateLeafTextNode())
         return;
 
     // ### handle exceptions
     TrackExceptionState exceptionState;
     ProcessingInstruction* pi = m_currentNode->document().createProcessingInstruction(target, data, exceptionState);
     if (exceptionState.hadException())
@@ skipping 18 matching lines @@
         stopParsing();
     }
 }
 
 void XMLDocumentParser::cdataBlock(const String& text)
 {
     if (isStopped())
         return;
 
     if (m_parserPaused) {
-        m_pendingCallbacks.append(adoptPtr(new PendingCDATABlockCallback(text)));
+        m_pendingCallbacks.append(wrapUnique(new 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(adoptPtr(new PendingCommentCallback(text)));
+        m_pendingCallbacks.append(wrapUnique(new PendingCommentCallback(text)));
         return;
     }
 
     if (!updateLeafTextNode())
         return;
 
     m_currentNode->parserAppendChild(Comment::create(m_currentNode->document(), text));
 }
 
 enum StandaloneInfo {
@@ skipping 24 matching lines @@
 {
     updateLeafTextNode();
 }
 
 void XMLDocumentParser::internalSubset(const String& name, const String& externalID, const String& systemID)
 {
     if (isStopped())
         return;
 
     if (m_parserPaused) {
-        m_pendingCallbacks.append(adoptPtr(new PendingInternalSubsetCallback(name, externalID, systemID)));
+        m_pendingCallbacks.append(wrapUnique(new PendingInternalSubsetCallback(name, externalID, systemID)));
         return;
     }
 
     if (document())
         document()->parserAppendChild(DocumentType::create(document(), name, externalID, systemID));
 }
 
 static inline XMLDocumentParser* getParser(void* closure)
 {
     xmlParserCtxtPtr ctxt = static_cast<xmlParserCtxtPtr>(closure);
@@ skipping 217 matching lines @@
         }
     }
 
     bool xmlViewerMode = !m_sawError && !m_sawCSS && !m_sawXSLTransform && hasNoStyleInformation(document());
     if (xmlViewerMode) {
         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(adoptPtr(new TransformSource(doc)));
+        document()->setTransformSource(wrapUnique(new 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
     // FIXME: Hook up error handlers so that a failure to parse the main
@@ skipping 30 matching lines @@
 
 void XMLDocumentParser::resumeParsing()
 {
     ASSERT(!isDetached());
     ASSERT(m_parserPaused);
 
     m_parserPaused = false;
 
     // First, execute any pending callbacks
     while (!m_pendingCallbacks.isEmpty()) {
-        OwnPtr<PendingCallback> callback = m_pendingCallbacks.takeFirst();
+        std::unique_ptr<PendingCallback> callback = m_pendingCallbacks.takeFirst();
         callback->call(this);
 
         // A callback paused the parser
         if (m_parserPaused)
             return;
     }
 
     // Then, write any pending data
     SegmentedString rest = m_pendingSrc;
     m_pendingSrc.clear();
@@ skipping 85 matching lines @@
     sax.initialized = XML_SAX2_MAGIC;
     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