Revert 66670 - 2010-09-01 Tony Gentilcore <tonyg@chromium.org>...

WebCore/dom/XMLDocumentParserLibxml2.cpp

 /*
  * Copyright (C) 2000 Peter Kelly (pmk@post.com)
  * Copyright (C) 2005, 2006, 2008 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, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 642 matching lines @@
         // JavaScript may cause the parser to detach during xmlParseChunk
         // keep this alive until this function is done.
         RefPtr<XMLDocumentParser> protect(this);
 
         switchToUTF16(context->context());
         XMLDocumentParserScope scope(document()->docLoader());
         xmlParseChunk(context->context(), reinterpret_cast<const char*>(parseString.characters()), sizeof(UChar) * parseString.length(), 0);
 
         // JavaScript (which may be run under the xmlParseChunk callstack) may
         // cause the parser to be stopped or detached.
-        if (isStopped())
+        if (isDetached() || m_parserStopped)
             return;
     }
 
     // FIXME: Why is this here?  And why is it after we process the passed source?
     if (document()->decoder() && document()->decoder()->sawError()) {
         // If the decoder saw an error, report it as fatal (stops parsing)
         handleError(fatal, "Encoding error", context->context()->input->line, context->context()->input->col);
     }
 }
 
@@ skipping 52 matching lines @@
 
         newElement->setAttributeNS(attrURI, attrQName, attrValue, ec, scriptingPermission);
         if (ec) // exception setting attributes
             return;
     }
 }
 
 void XMLDocumentParser::startElementNs(const xmlChar* xmlLocalName, const xmlChar* xmlPrefix, const xmlChar* xmlURI, int nb_namespaces,
                                   const xmlChar** libxmlNamespaces, int nb_attributes, int nb_defaulted, const xmlChar** libxmlAttributes)
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks->appendStartElementNSCallback(xmlLocalName, xmlPrefix, xmlURI, nb_namespaces, libxmlNamespaces,
                                                          nb_attributes, nb_defaulted, libxmlAttributes);
         return;
     }
 
 #if ENABLE(XHTMLMP)
     // check if the DOCTYPE Declaration of XHTMLMP document exists
@@ skipping 68 matching lines @@
     pushCurrentNode(newElement.get());
     if (m_view && !newElement->attached())
         newElement->attach();
 
     if (!m_parsingFragment && isFirstElement && document()->frame())
         document()->frame()->loader()->dispatchDocumentElementAvailable();
 }
 
 void XMLDocumentParser::endElementNs()
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks->appendEndElementNSCallback();
         return;
     }
 
     exitText();
 
     Node* n = m_currentNode;
@@ skipping 63 matching lines @@
         // JavaScript may have detached the parser
         if (isDetached())
             return;
     }
     m_requestingScript = false;
     popCurrentNode();
 }
 
 void XMLDocumentParser::characters(const xmlChar* s, int len)
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks->appendCharactersCallback(s, len);
         return;
     }
 
     if (!m_currentNode->isTextNode())
         enterText();
     m_bufferedText.append(s, len);
 }
 
 void XMLDocumentParser::error(ErrorType type, const char* message, va_list args)
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
 #if COMPILER(MSVC) || COMPILER(RVCT)
     char m[1024];
     vsnprintf(m, sizeof(m) - 1, message, args);
 #else
     char* m;
     if (vasprintf(&m, message, args) == -1)
         return;
 #endif
 
     if (m_parserPaused)
         m_pendingCallbacks->appendErrorCallback(type, reinterpret_cast<const xmlChar*>(m), lineNumber(), columnNumber());
     else
         handleError(type, m, lineNumber(), columnNumber());
 
 #if !COMPILER(MSVC) && !COMPILER(RVCT)
     free(m);
 #endif
 }
 
 void XMLDocumentParser::processingInstruction(const xmlChar* target, const xmlChar* data)
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks->appendProcessingInstructionCallback(target, data);
         return;
     }
 
     exitText();
 
     // ### handle exceptions
@@ skipping 13 matching lines @@
 
 #if ENABLE(XSLT)
     m_sawXSLTransform = !m_sawFirstElement && pi->isXSL();
     if (m_sawXSLTransform && !document()->transformSourceDocument())
         stopParsing();
 #endif
 }
 
 void XMLDocumentParser::cdataBlock(const xmlChar* s, int len)
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks->appendCDATABlockCallback(s, len);
         return;
     }
 
     exitText();
 
     RefPtr<Node> newNode = CDATASection::create(document(), toString(s, len));
     m_currentNode->deprecatedParserAddChild(newNode.get());
     if (m_view && !newNode->attached())
         newNode->attach();
 }
 
 void XMLDocumentParser::comment(const xmlChar* s)
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks->appendCommentCallback(s);
         return;
     }
 
     exitText();
 
     RefPtr<Node> newNode = Comment::create(document(), toString(s));
@@ skipping 16 matching lines @@
 void XMLDocumentParser::endDocument()
 {
     exitText();
 #if ENABLE(XHTMLMP)
     m_hasDocTypeDeclaration = false;
 #endif
 }
 
 void XMLDocumentParser::internalSubset(const xmlChar* name, const xmlChar* externalID, const xmlChar* systemID)
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks->appendInternalSubsetCallback(name, externalID, systemID);
         return;
     }
 
     if (document()) {
 #if ENABLE(WML) || ENABLE(XHTMLMP)
         String extId = toString(externalID);
@@ skipping 239 matching lines @@
     sax.startElementNs = startElementNsHandler;
     sax.endElementNs = endElementNsHandler;
     sax.getEntity = getEntityHandler;
     sax.startDocument = startDocumentHandler;
     sax.endDocument = endDocumentHandler;
     sax.internalSubset = internalSubsetHandler;
     sax.externalSubset = externalSubsetHandler;
     sax.ignorableWhitespace = ignorableWhitespaceHandler;
     sax.entityDecl = xmlSAX2EntityDecl;
     sax.initialized = XML_SAX2_MAGIC;
-    DocumentParser::startParsing();
+    m_parserStopped = false;
     m_sawError = false;
     m_sawXSLTransform = false;
     m_sawFirstElement = false;
 
     XMLDocumentParserScope scope(document()->docLoader());
     if (m_parsingFragment)
         m_context = XMLParserContext::createMemoryParser(&sax, this, chunk);
     else {
         ASSERT(!chunk);
         m_context = XMLParserContext::createStringParser(&sax, this);
     }
 }
 
 void XMLDocumentParser::doEnd()
 {
 #if ENABLE(XSLT)
     if (m_sawXSLTransform) {
         void* doc = xmlDocPtrForString(document()->docLoader(), m_originalSourceForTransform, document()->url().string());
         document()->setTransformSource(new TransformSource(doc));
 
         document()->setParsing(false); // Make the doc think it's done, so it will apply xsl sheets.
         document()->styleSelectorChanged(RecalcStyleImmediately);
         document()->setParsing(true);
-        DocumentParser::stopParsing();
+        m_parserStopped = true;
     }
 #endif
 
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     if (m_context) {
         // Tell libxml we're done.
         {
             XMLDocumentParserScope scope(document()->docLoader());
             xmlParseChunk(context(), 0, 0, 1);
         }
 
         m_context = 0;
@@ skipping 132 matching lines @@
     sax.startElementNs = attributesStartElementNsHandler;
     sax.initialized = XML_SAX2_MAGIC;
     RefPtr<XMLParserContext> parser = XMLParserContext::createStringParser(&sax, &state);
     String parseString = "<?xml version=\"1.0\"?><attrs " + string + " />";
     xmlParseChunk(parser->context(), reinterpret_cast<const char*>(parseString.characters()), parseString.length() * sizeof(UChar), 1);
     attrsOK = state.gotAttributes;
     return state.attributes;
 }
 
 }