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

WebCore/html/parser/HTMLScriptRunner.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 57 matching lines @@
     , m_hasScriptsWaitingForStylesheets(false)
 {
     ASSERT(m_host);
 }
 
 HTMLScriptRunner::~HTMLScriptRunner()
 {
     // FIXME: Should we be passed a "done loading/parsing" callback sooner than destruction?
     if (m_parsingBlockingScript.cachedScript() && m_parsingBlockingScript.watchingForLoad())
         stopWatchingForLoad(m_parsingBlockingScript);
-
-    while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
-        PendingScript pendingScript = m_scriptsToExecuteAfterParsing.takeFirst();
-        if (pendingScript.cachedScript() && pendingScript.watchingForLoad())
-            stopWatchingForLoad(pendingScript);
-    }
 }
 
 void HTMLScriptRunner::detach()
 {
     m_document = 0;
 }
 
 static KURL documentURLForScriptExecution(Document* document)
 {
     if (!document || !document->frame())
@@ skipping 34 matching lines @@
     return true;
 }
 
 void HTMLScriptRunner::executeParsingBlockingScript()
 {
     ASSERT(m_document);
     ASSERT(!m_scriptNestingLevel);
     ASSERT(m_document->haveStylesheetsLoaded());
     ASSERT(isPendingScriptReady(m_parsingBlockingScript));
 
+    // Stop watching loads before executeScript to prevent recursion if the script reloads itself.
+    if (m_parsingBlockingScript.cachedScript() && m_parsingBlockingScript.watchingForLoad())
+        stopWatchingForLoad(m_parsingBlockingScript);
+
     InsertionPointRecord insertionPointRecord(m_host->inputStream());
     executePendingScriptAndDispatchEvent(m_parsingBlockingScript);
 }
 
 void HTMLScriptRunner::executePendingScriptAndDispatchEvent(PendingScript& pendingScript)
 {
     bool errorOccurred = false;
     ScriptSourceCode sourceCode = sourceFromPendingScript(pendingScript, errorOccurred);
 
-    // Stop watching loads before executeScript to prevent recursion if the script reloads itself.
-    if (pendingScript.cachedScript() && pendingScript.watchingForLoad())
-        stopWatchingForLoad(pendingScript);
-
     // Clear the pending script before possible rentrancy from executeScript()
     RefPtr<Element> scriptElement = pendingScript.releaseElementAndClear();
     {
         NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
         if (errorOccurred)
             scriptElement->dispatchEvent(createScriptErrorEvent());
         else {
             executeScript(scriptElement.get(), sourceCode);
             scriptElement->dispatchEvent(createScriptLoadEvent());
         }
@@ skipping 76 matching lines @@
 {
     ASSERT(m_document);
     // Callers should check hasScriptsWaitingForStylesheets() before calling
     // to prevent parser or script re-entry during </style> parsing.
     ASSERT(hasScriptsWaitingForStylesheets());
     ASSERT(!m_scriptNestingLevel);
     ASSERT(m_document->haveStylesheetsLoaded());
     return executeParsingBlockingScripts();
 }
 
-bool HTMLScriptRunner::executeScriptsWaitingForParsing()
-{
-    while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
-        ASSERT(!m_scriptNestingLevel);
-        ASSERT(!haveParsingBlockingScript());
-        ASSERT(m_scriptsToExecuteAfterParsing.first().cachedScript());
-        if (!m_scriptsToExecuteAfterParsing.first().cachedScript()->isLoaded()) {
-            watchForLoad(m_scriptsToExecuteAfterParsing.first());
-            return false;
-        }
-        PendingScript first = m_scriptsToExecuteAfterParsing.takeFirst();
-        executePendingScriptAndDispatchEvent(first);
-        if (!m_document)
-            return false;
-    }
-    return true;
-}
-
 void HTMLScriptRunner::requestParsingBlockingScript(Element* element)
 {
     if (!requestPendingScript(m_parsingBlockingScript, element))
         return;
 
     ASSERT(m_parsingBlockingScript.cachedScript());
 
     // We only care about a load callback if cachedScript is not already
     // in the cache.  Callers will attempt to run the m_parsingBlockingScript
     // if possible before returning control to the parser.
     if (!m_parsingBlockingScript.cachedScript()->isLoaded())
         watchForLoad(m_parsingBlockingScript);
 }
 
-void HTMLScriptRunner::requestDeferredScript(Element* element)
-{
-    PendingScript pendingScript;
-    if (!requestPendingScript(pendingScript, element))
-        return;
-
-    ASSERT(pendingScript.cachedScript());
-    m_scriptsToExecuteAfterParsing.append(pendingScript);
-}
-
 bool HTMLScriptRunner::requestPendingScript(PendingScript& pendingScript, Element* script) const
 {
     ASSERT(!pendingScript.element());
     const AtomicString& srcValue = script->getAttribute(srcAttr);
     // Allow the host to disllow script loads (using the XSSAuditor, etc.)
     if (!m_host->shouldLoadExternalScriptFromSrc(srcValue))
         return false;
     // FIXME: We need to resolve the url relative to the element.
     if (!script->dispatchBeforeLoadEvent(srcValue))
         return false;
@@ skipping 15 matching lines @@
     ASSERT(m_document);
     ASSERT(!haveParsingBlockingScript());
     {
         InsertionPointRecord insertionPointRecord(m_host->inputStream());
         NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
 
         // Check script type and language, current code uses ScriptElement::shouldExecuteAsJavaScript(), but that may not be HTML5 compliant.
         notImplemented(); // event for support
 
         if (script->hasAttribute(srcAttr)) {
-            // FIXME: Handle async.
-            if (script->hasAttribute(deferAttr))
-                requestDeferredScript(script);
-            else
-                requestParsingBlockingScript(script);
+            // FIXME: Handle defer and async
+            requestParsingBlockingScript(script);
         } else {
             // FIXME: We do not block inline <script> tags on stylesheets to match the
             // old parser for now.  When we do, the ASSERT below should be added.
             // See https://bugs.webkit.org/show_bug.cgi?id=40047
             // ASSERT(document()->haveStylesheetsLoaded());
             ASSERT(isExecutingScript());
             ScriptSourceCode sourceCode(script->textContent(), documentURLForScriptExecution(m_document), startingLineNumber);
             executeScript(script, sourceCode);
         }
     }
 }
 
 }