Replace ASSERT*() with DCHECK*() in core/xml/.

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 293 matching lines @@
 
 private:
     XMLErrors::ErrorType m_type;
     xmlChar* m_message;
     OrdinalNumber m_lineNumber;
     OrdinalNumber m_columnNumber;
 };
 
 void XMLDocumentParser::pushCurrentNode(ContainerNode* n)
 {
-    ASSERT(n);
-    ASSERT(m_currentNode);
+    DCHECK(n);
+    DCHECK(m_currentNode);
     m_currentNodeStack.append(m_currentNode);
     m_currentNode = n;
     if (m_currentNodeStack.size() > maxXMLTreeDepth)
         handleError(XMLErrors::ErrorTypeFatal, "Excessive node nesting.", textPosition());
 }
 
 void XMLDocumentParser::popCurrentNode()
 {
     if (!m_currentNode)
         return;
-    ASSERT(m_currentNodeStack.size());
+    DCHECK(m_currentNodeStack.size());
     m_currentNode = m_currentNodeStack.last();
     m_currentNodeStack.removeLast();
 }
 
 void XMLDocumentParser::clearCurrentNodeStack()
 {
     m_currentNode = nullptr;
     m_leafTextNode = nullptr;
 
     if (m_currentNodeStack.size()) { // Aborted parsing.
         m_currentNodeStack.clear();
     }
 }
 
 void XMLDocumentParser::insert(const SegmentedString&)
 {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
 }
 
 void XMLDocumentParser::append(const String& inputSource)
 {
     const SegmentedString source(inputSource);
     if (m_sawXSLTransform || !m_sawFirstElement)
         m_originalSourceForTransform.append(source);
 
     if (isStopped() || m_sawXSLTransform)
         return;
@@ skipping 13 matching lines @@
         m_sawError = true;
     if (type == XMLErrors::ErrorTypeFatal)
         stopParsing();
 }
 
 void XMLDocumentParser::createLeafTextNodeIfNeeded()
 {
     if (m_leafTextNode)
         return;
 
-    ASSERT(m_bufferedText.size() == 0);
+    DCHECK_EQ(m_bufferedText.size(), 0u);
     m_leafTextNode = Text::create(m_currentNode->document(), "");
     m_currentNode->parserAppendChild(m_leafTextNode.get());
 }
 
 bool XMLDocumentParser::updateLeafTextNode()
 {
     if (isStopped())
         return false;
 
     if (!m_leafTextNode)
@@ skipping 16 matching lines @@
     }
     clearCurrentNodeStack();
     ScriptableDocumentParser::detach();
 }
 
 void XMLDocumentParser::end()
 {
     TRACE_EVENT0("blink", "XMLDocumentParser::end");
     // XMLDocumentParserLibxml2 will do bad things to the document if doEnd() is called.
     // I don't believe XMLDocumentParserQt needs doEnd called in the fragment case.
-    ASSERT(!m_parsingFragment);
+    DCHECK(!m_parsingFragment);
 
     doEnd();
 
     // doEnd() call above can detach the parser and null out its document.
     // In that case, we just bail out.
     if (isDetached())
         return;
 
     // doEnd() could process a script tag, thus pausing parsing.
     if (m_parserPaused)
         return;
 
     if (m_sawError)
         insertErrorMessageBlock();
     else
         updateLeafTextNode();
 
     if (isParsing())
         prepareToStopParsing();
     document()->setReadyState(Document::Interactive);
     clearCurrentNodeStack();
     document()->finishedParsing();
 }
 
 void XMLDocumentParser::finish()
 {
-    // FIXME: We should ASSERT(!m_parserStopped) here, since it does not
+    // FIXME: We should DCHECK(!m_parserStopped) here, since it does not
     // makes sense to call any methods on DocumentParser once it's been stopped.
     // However, FrameLoader::stop calls DocumentParser::finish unconditionally.
 
     flush();
     if (isDetached())
         return;
 
     if (m_parserPaused)
         m_finishCalled = true;
     else
         end();
 }
 
 void XMLDocumentParser::insertErrorMessageBlock()
 {
     m_xmlErrors.insertErrorMessageBlock();
 }
 
 void XMLDocumentParser::notifyFinished(Resource* unusedResource)
 {
-    ASSERT_UNUSED(unusedResource, unusedResource == m_pendingScript);
+    DCHECK_EQ(unusedResource, m_pendingScript);
 
     ScriptSourceCode sourceCode(m_pendingScript.get());
     bool errorOccurred = m_pendingScript->errorOccurred();
     bool wasCanceled = m_pendingScript->wasCanceled();
     double scriptParserBlockingTime = m_parserBlockingPendingScriptLoadStartTime;
     m_parserBlockingPendingScriptLoadStartTime = 0.0;
 
     m_pendingScript->removeClient(this);
     m_pendingScript = nullptr;
 
     Element* e = m_scriptElement;
     m_scriptElement = nullptr;
 
     ScriptLoader* scriptLoader = toScriptLoaderIfPossible(e);
-    ASSERT(scriptLoader);
+    DCHECK(scriptLoader);
 
     if (errorOccurred) {
         scriptLoader->dispatchErrorEvent();
     } else if (!wasCanceled) {
         if (scriptParserBlockingTime > 0.0) {
             DocumentParserTiming::from(*document()).recordParserBlockedOnScriptLoadDuration(monotonicallyIncreasingTime() - scriptParserBlockingTime, scriptLoader->wasCreatedDuringDocumentWrite());
         }
 
         if (!scriptLoader->executeScript(sourceCode))
             scriptLoader->dispatchErrorEvent();
@@ skipping 144 matching lines @@
             XMLDocumentParserScope::currentDocument->addConsoleMessage(ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, message));
         }
         return false;
     }
 
     return true;
 }
 
 static void* openFunc(const char* uri)
 {
-    ASSERT(XMLDocumentParserScope::currentDocument);
-    ASSERT(currentThread() == libxmlLoaderThread);
+    DCHECK(XMLDocumentParserScope::currentDocument);
+    DCHECK_EQ(currentThread(), libxmlLoaderThread);
 
     KURL url(KURL(), uri);
 
     if (!shouldAllowExternalLoad(url))
         return &globalDescriptor;
 
     KURL finalURL;
     RefPtr<SharedBuffer> data;
 
     {
@@ skipping 189 matching lines @@
 
 XMLParserContext::~XMLParserContext()
 {
     if (m_context->myDoc)
         xmlFreeDoc(m_context->myDoc);
     xmlFreeParserCtxt(m_context);
 }
 
 XMLDocumentParser::~XMLDocumentParser()
 {
-    ASSERT(!m_pendingScript);
+    DCHECK(!m_pendingScript);
 }
 
 DEFINE_TRACE(XMLDocumentParser)
 {
     visitor->trace(m_currentNode);
     visitor->trace(m_currentNodeStack);
     visitor->trace(m_leafTextNode);
     visitor->trace(m_xmlErrors);
     visitor->trace(m_pendingScript);
     visitor->trace(m_scriptElement);
     ScriptableDocumentParser::trace(visitor);
     ScriptResourceClient::trace(visitor);
 }
 
 void XMLDocumentParser::doWrite(const String& parseString)
 {
     TRACE_EVENT0("blink", "XMLDocumentParser::doWrite");
-    ASSERT(!isDetached());
+    DCHECK(!isDetached());
     if (!m_context)
         initializeParserContext();
 
     // Protect the libxml context from deletion during a callback
     RefPtr<XMLParserContext> context = m_context;
 
     // libXML throws an error if you try to switch the encoding for an empty
     // string.
     if (parseString.length()) {
         XMLDocumentParserScope scope(document());
@@ skipping 198 matching lines @@
         return;
     }
 
     ScriptLoader* scriptLoader = toScriptLoaderIfPossible(element);
     if (!scriptLoader) {
         popCurrentNode();
         return;
     }
 
     // Don't load external scripts for standalone documents (for now).
-    ASSERT(!m_pendingScript);
+    DCHECK(!m_pendingScript);
     m_requestingScript = true;
 
     if (scriptLoader->prepareScript(m_scriptStartPosition, ScriptLoader::AllowLegacyTypeInTypeAttribute)) {
         // FIXME: Script execution should be shared between
         // the libxml2 and Qt XMLDocumentParser implementations.
 
 
         if (scriptLoader->readyToBeParserExecuted()) {
             if (!scriptLoader->executeScript(ScriptSourceCode(scriptLoader->scriptContent(), document()->url(), m_scriptStartPosition))) {
                 scriptLoader->dispatchErrorEvent();
@@ skipping 243 matching lines @@
 
 static size_t convertUTF16EntityToUTF8(const UChar* utf16Entity, size_t numberOfCodeUnits, char* target, size_t targetSize)
 {
     const char* originalTarget = target;
     WTF::Unicode::ConversionResult conversionResult = WTF::Unicode::convertUTF16ToUTF8(&utf16Entity,
         utf16Entity + numberOfCodeUnits, &target, target + targetSize);
     if (conversionResult != WTF::Unicode::conversionOK)
         return 0;
 
     // Even though we must pass the length, libxml expects the entity string to be null terminated.
-    ASSERT(target > originalTarget + 1);
+    DCHECK_GT(target, originalTarget + 1);
     *target = '\0';
     return target - originalTarget;
 }
 
 static xmlEntityPtr getXHTMLEntity(const xmlChar* name)
 {
     UChar utf16DecodedEntity[4];
     size_t numberOfCodeUnits = decodeNamedEntityToUCharArray(reinterpret_cast<const char*>(name), utf16DecodedEntity);
     if (!numberOfCodeUnits)
         return 0;
 
-    ASSERT(numberOfCodeUnits <= 4);
+    DCHECK_LE(numberOfCodeUnits, 4u);
     size_t entityLengthInUTF8 = convertUTF16EntityToUTF8(utf16DecodedEntity, numberOfCodeUnits,
         reinterpret_cast<char*>(sharedXHTMLEntityResult), WTF_ARRAY_LENGTH(sharedXHTMLEntityResult));
     if (!entityLengthInUTF8)
         return 0;
 
     xmlEntityPtr entity = sharedXHTMLEntity();
     entity->length = entityLengthInUTF8;
     entity->name = name;
     return entity;
 }
@@ skipping 91 matching lines @@
     sax.initialized = XML_SAX2_MAGIC;
     m_sawError = false;
     m_sawCSS = false;
     m_sawXSLTransform = false;
     m_sawFirstElement = false;
 
     XMLDocumentParserScope scope(document());
     if (m_parsingFragment) {
         m_context = XMLParserContext::createMemoryParser(&sax, this, chunk);
     } else {
-        ASSERT(!chunk.data());
+        DCHECK(!chunk.data());
         m_context = XMLParserContext::createStringParser(&sax, this);
     }
 }
 
 void XMLDocumentParser::doEnd()
 {
     if (!isStopped()) {
         if (m_context) {
             // Tell libxml we're done.
             {
@@ skipping 49 matching lines @@
 
 void XMLDocumentParser::stopParsing()
 {
     DocumentParser::stopParsing();
     if (context())
         xmlStopParser(context());
 }
 
 void XMLDocumentParser::resumeParsing()
 {
-    ASSERT(!isDetached());
-    ASSERT(m_parserPaused);
+    DCHECK(!isDetached());
+    DCHECK(m_parserPaused);
 
     m_parserPaused = false;
 
     // First, execute any pending callbacks
     while (!m_pendingCallbacks.isEmpty()) {
         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();
     // There is normally only one string left, so toString() shouldn't copy.
     // In any case, the XML parser runs on the main thread and it's OK if
     // the passed string has more than one reference.
     append(rest.toString().impl());
 
     // Finally, if finish() has been called and write() didn't result
     // in any further callbacks being queued, call end()
     if (m_finishCalled && m_pendingCallbacks.isEmpty())
         end();
 }
 
 bool XMLDocumentParser::appendFragmentSource(const String& chunk)
 {
-    ASSERT(!m_context);
-    ASSERT(m_parsingFragment);
+    DCHECK(!m_context);
+    DCHECK(m_parsingFragment);
 
     CString chunkAsUtf8 = chunk.utf8();
 
     // libxml2 takes an int for a length, and therefore can't handle XML chunks
     // larger than 2 GiB.
     if (chunkAsUtf8.length() > INT_MAX)
         return false;
 
     TRACE_EVENT0("blink", "XMLDocumentParser::appendFragmentSource");
     initializeParserContext(chunkAsUtf8);
     xmlParseContent(context());
     endDocument(); // Close any open text nodes.
 
     // FIXME: If this code is actually needed, it should probably move to
     // finish()
     // XMLDocumentParserQt has a similar check (m_stream.error() ==
     // QXmlStreamReader::PrematureEndOfDocumentError) in doEnd(). Check if all
     // the chunk has been processed.
     long bytesProcessed = xmlByteConsumed(context());
     if (bytesProcessed == -1 || static_cast<unsigned long>(bytesProcessed) != chunkAsUtf8.length()) {
         // FIXME: I don't believe we can hit this case without also having seen
-        // an error or a null byte. If we hit this ASSERT, we've found a test
+        // an error or a null byte. If we hit this DCHECK, we've found a test
         // case which demonstrates the need for this code.
-        ASSERT(m_sawError || (bytesProcessed >= 0 && !chunkAsUtf8.data()[bytesProcessed]));
+        DCHECK(m_sawError || (bytesProcessed >= 0 && !chunkAsUtf8.data()[bytesProcessed]));
         return false;
     }
 
     // No error if the chunk is well formed or it is not but we have no error.
     return context()->wellFormed || !xmlCtxtGetLastError(context());
 }
 
 // --------------------------------
 
 struct AttributeParseState {
@@ skipping 36 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