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

WebCore/html/parser/HTMLDocumentParser.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 124 matching lines @@
     m_preloadScanner.clear();
     m_parserScheduler.clear(); // Deleting the scheduler will clear any timers.
 }
 
 void HTMLDocumentParser::stopParsing()
 {
     DocumentParser::stopParsing();
     m_parserScheduler.clear(); // Deleting the scheduler will clear any timers.
 }
 
-// This kicks off "Once the user agent stops parsing" as described by:
-// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#the-end
-void HTMLDocumentParser::prepareToStopParsing()
-{
-    ASSERT(!hasInsertionPoint());
-
-    // pumpTokenizer can cause this parser to be detached from the Document,
-    // but we need to ensure it isn't deleted yet.
-    RefPtr<HTMLDocumentParser> protect(this);
-
-    // FIXME: Set the current document readiness to "interactive".
-
-    // NOTE: This pump should only ever emit buffered character tokens,
-    // so ForceSynchronous vs. AllowYield should be meaningless.
-    pumpTokenizerIfPossible(ForceSynchronous);
-
-    DocumentParser::prepareToStopParsing();
-    if (m_scriptRunner && !m_scriptRunner->executeScriptsWaitingForParsing())
-        return;
-    end();
-}
-
 bool HTMLDocumentParser::processingData() const
 {
     return isScheduledForResume() || inWrite();
 }
 
 void HTMLDocumentParser::pumpTokenizerIfPossible(SynchronousMode mode)
 {
-    if (isStopped() || m_treeBuilder->isPaused())
+    if (m_parserStopped || m_treeBuilder->isPaused())
         return;
 
     // Once a resume is scheduled, HTMLParserScheduler controls when we next pump.
     if (isScheduledForResume()) {
         ASSERT(mode == AllowYield);
         return;
     }
 
     pumpTokenizer(mode);
 }
@@ skipping 23 matching lines @@
     int scriptStartLine = 0;
     RefPtr<Element> scriptElement = m_treeBuilder->takeScriptToProcess(scriptStartLine);
     // We will not have a scriptRunner when parsing a DocumentFragment.
     if (!m_scriptRunner)
         return true;
     return m_scriptRunner->execute(scriptElement.release(), scriptStartLine);
 }
 
 void HTMLDocumentParser::pumpTokenizer(SynchronousMode mode)
 {
-    ASSERT(!isStopped());
+    ASSERT(!isDetached());
+    ASSERT(!m_parserStopped);
     ASSERT(!m_treeBuilder->isPaused());
     ASSERT(!isScheduledForResume());
     // ASSERT that this object is both attached to the Document and protected.
     ASSERT(refCount() >= 2);
 
     // We tell the InspectorTimelineAgent about every pump, even if we
     // end up pumping nothing.  It can filter out empty pumps itself.
     willPumpLexer();
 
     HTMLParserScheduler::PumpSession session;
     // FIXME: This loop body has is now too long and needs cleanup.
     while (mode == ForceSynchronous || m_parserScheduler->shouldContinueParsing(session)) {
         if (!m_tokenizer->nextToken(m_input.current(), m_token))
             break;
 
         m_treeBuilder->constructTreeFromToken(m_token);
         m_token.clear();
 
         // JavaScript may have stopped or detached the parser.
-        if (isStopped())
+        if (isDetached() || m_parserStopped)
             return;
 
         // The parser will pause itself when waiting on a script to load or run.
         if (!m_treeBuilder->isPaused())
             continue;
 
         // If we're paused waiting for a script, we try to execute scripts before continuing.
         bool shouldContinueParsing = runScriptsForPausedTreeBuilder();
         m_treeBuilder->setPaused(!shouldContinueParsing);
 
         // JavaScript may have stopped or detached the parser.
-        if (isStopped())
+        if (isDetached() || m_parserStopped)
             return;
 
         if (!shouldContinueParsing)
             break;
     }
 
     // Ensure we haven't been totally deref'ed after pumping. Any caller of this
     // function should be holding a RefPtr to this to ensure we weren't deleted.
     ASSERT(refCount() >= 1);
 
@@ skipping 28 matching lines @@
 #endif
 }
 
 bool HTMLDocumentParser::hasInsertionPoint()
 {
     return m_input.hasInsertionPoint();
 }
 
 void HTMLDocumentParser::insert(const SegmentedString& source)
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     // pumpTokenizer can cause this parser to be detached from the Document,
     // but we need to ensure it isn't deleted yet.
     RefPtr<HTMLDocumentParser> protect(this);
 
     {
         NestingLevelIncrementer nestingLevelIncrementer(m_writeNestingLevel);
 
         SegmentedString excludedLineNumberSource(source);
         excludedLineNumberSource.setExcludeLineNumbers();
         m_input.insertAtCurrentInsertionPoint(excludedLineNumberSource);
         pumpTokenizerIfPossible(ForceSynchronous);
     }
 
     endIfDelayed();
 }
 
 void HTMLDocumentParser::append(const SegmentedString& source)
 {
-    if (isStopped())
+    if (m_parserStopped)
         return;
 
     // pumpTokenizer can cause this parser to be detached from the Document,
     // but we need to ensure it isn't deleted yet.
     RefPtr<HTMLDocumentParser> protect(this);
 
     {
         NestingLevelIncrementer nestingLevelIncrementer(m_writeNestingLevel);
 
         m_input.appendToEnd(source);
@@ skipping 11 matching lines @@
     }
 
     endIfDelayed();
 }
 
 void HTMLDocumentParser::end()
 {
     ASSERT(!isDetached());
     ASSERT(!isScheduledForResume());
 
+    // pumpTokenizer can cause this parser to be detached from the Document,
+    // but we need to ensure it isn't deleted yet.
+    RefPtr<HTMLDocumentParser> protect(this);
+
+    // NOTE: This pump should only ever emit buffered character tokens,
+    // so ForceSynchronous vs. AllowYield should be meaningless.
+    pumpTokenizerIfPossible(ForceSynchronous);
+
     // Informs the the rest of WebCore that parsing is really finished (and deletes this).
     m_treeBuilder->finished();
 }
 
 void HTMLDocumentParser::attemptToEnd()
 {
     // finish() indicates we will not receive any more data. If we are waiting on
     // an external script to load, we can't finish parsing quite yet.
 
     if (shouldDelayEnd()) {
         m_endWasDelayed = true;
         return;
     }
-    prepareToStopParsing();
+    end();
 }
 
 void HTMLDocumentParser::endIfDelayed()
 {
     // If we've already been detached, don't bother ending.
     if (isDetached())
         return;
 
     if (!m_endWasDelayed || shouldDelayEnd())
         return;
 
     m_endWasDelayed = false;
-    prepareToStopParsing();
+    end();
 }
 
 void HTMLDocumentParser::finish()
 {
     // FIXME: We should ASSERT(!m_parserStopped) here, since it does not
     // makes sense to call any methods on DocumentParser once it's been stopped.
     // However, FrameLoader::stop calls Document::finishParsing unconditionally
     // which in turn calls m_parser->finish().
 
     // We're not going to get any more data off the network, so we tell the
@@ skipping 64 matching lines @@
 
 bool HTMLDocumentParser::shouldLoadExternalScriptFromSrc(const AtomicString& srcValue)
 {
     if (!xssAuditor())
         return true;
     return xssAuditor()->canLoadExternalScriptFromSrc(srcValue);
 }
 
 void HTMLDocumentParser::notifyFinished(CachedResource* cachedResource)
 {
-    if (isStopping()) {
-        prepareToStopParsing();
-        return;
-    }
-
     // pumpTokenizer can cause this parser to be detached from the Document,
     // but we need to ensure it isn't deleted yet.
     RefPtr<HTMLDocumentParser> protect(this);
 
     ASSERT(m_scriptRunner);
     ASSERT(!inScriptExecution());
     ASSERT(m_treeBuilder->isPaused());
     // Note: We only ever wait on one script at a time, so we always know this
     // is the one we were waiting on and can un-pause the tree builder.
     m_treeBuilder->setPaused(false);
@@ skipping 37 matching lines @@
 void HTMLDocumentParser::parseDocumentFragment(const String& source, DocumentFragment* fragment, Element* contextElement, FragmentScriptingPermission scriptingPermission)
 {
     RefPtr<HTMLDocumentParser> parser = HTMLDocumentParser::create(fragment, contextElement, scriptingPermission);
     parser->insert(source); // Use insert() so that the parser will not yield.
     parser->finish();
     ASSERT(!parser->processingData()); // Make sure we're done. <rdar://problem/3963151>
     parser->detach(); // Allows ~DocumentParser to assert it was detached before destruction.
 }
 
 }