HTMLScriptRunner.cpp [plain text]
#include "config.h"
#include "HTMLScriptRunner.h"
#include "Attribute.h"
#include "CachedScript.h"
#include "CachedResourceLoader.h"
#include "Element.h"
#include "Event.h"
#include "Frame.h"
#include "HTMLInputStream.h"
#include "HTMLNames.h"
#include "HTMLScriptRunnerHost.h"
#include "IgnoreDestructiveWriteCountIncrementer.h"
#include "NestingLevelIncrementer.h"
#include "NotImplemented.h"
#include "ScriptElement.h"
#include "ScriptSourceCode.h"
namespace WebCore {
using namespace HTMLNames;
HTMLScriptRunner::HTMLScriptRunner(Document* document, HTMLScriptRunnerHost* host)
: m_document(document)
, m_host(host)
, m_scriptNestingLevel(0)
, m_hasScriptsWaitingForStylesheets(false)
{
ASSERT(m_host);
}
HTMLScriptRunner::~HTMLScriptRunner()
{
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())
return KURL();
return document->frame()->document()->url();
}
inline PassRefPtr<Event> createScriptLoadEvent()
{
return Event::create(eventNames().loadEvent, false, false);
}
ScriptSourceCode HTMLScriptRunner::sourceFromPendingScript(const PendingScript& script, bool& errorOccurred) const
{
if (script.cachedScript()) {
errorOccurred = script.cachedScript()->errorOccurred();
ASSERT(script.cachedScript()->isLoaded());
return ScriptSourceCode(script.cachedScript());
}
errorOccurred = false;
return ScriptSourceCode(script.element()->textContent(), documentURLForScriptExecution(m_document), script.startingPosition());
}
bool HTMLScriptRunner::isPendingScriptReady(const PendingScript& script)
{
m_hasScriptsWaitingForStylesheets = !m_document->haveStylesheetsLoaded();
if (m_hasScriptsWaitingForStylesheets)
return false;
if (script.cachedScript() && !script.cachedScript()->isLoaded())
return false;
return true;
}
void HTMLScriptRunner::executeParsingBlockingScript()
{
ASSERT(m_document);
ASSERT(!m_scriptNestingLevel);
ASSERT(m_document->haveStylesheetsLoaded());
ASSERT(isPendingScriptReady(m_parsingBlockingScript));
InsertionPointRecord insertionPointRecord(m_host->inputStream());
executePendingScriptAndDispatchEvent(m_parsingBlockingScript);
}
void HTMLScriptRunner::executePendingScriptAndDispatchEvent(PendingScript& pendingScript)
{
bool errorOccurred = false;
ScriptSourceCode sourceCode = sourceFromPendingScript(pendingScript, errorOccurred);
if (pendingScript.cachedScript() && pendingScript.watchingForLoad())
stopWatchingForLoad(pendingScript);
RefPtr<Element> element = pendingScript.releaseElementAndClear();
if (ScriptElement* scriptElement = toScriptElement(element.get())) {
NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWriteCountIncrementer(m_document);
if (errorOccurred)
scriptElement->dispatchErrorEvent();
else {
ASSERT(isExecutingScript());
scriptElement->executeScript(sourceCode);
element->dispatchEvent(createScriptLoadEvent());
}
}
ASSERT(!m_scriptNestingLevel);
}
void HTMLScriptRunner::watchForLoad(PendingScript& pendingScript)
{
ASSERT(!pendingScript.watchingForLoad());
m_host->watchForLoad(pendingScript.cachedScript());
pendingScript.setWatchingForLoad(true);
}
void HTMLScriptRunner::stopWatchingForLoad(PendingScript& pendingScript)
{
ASSERT(pendingScript.watchingForLoad());
m_host->stopWatchingForLoad(pendingScript.cachedScript());
pendingScript.setWatchingForLoad(false);
}
bool HTMLScriptRunner::execute(PassRefPtr<Element> scriptElement, const TextPosition& scriptStartPosition)
{
ASSERT(scriptElement);
bool hadPreloadScanner = m_host->hasPreloadScanner();
runScript(scriptElement.get(), scriptStartPosition);
if (haveParsingBlockingScript()) {
if (m_scriptNestingLevel)
return false; if (!hadPreloadScanner && m_host->hasPreloadScanner())
m_host->appendCurrentInputStreamToPreloadScannerAndScan();
if (!executeParsingBlockingScripts())
return false; }
return true; }
bool HTMLScriptRunner::haveParsingBlockingScript() const
{
return !!m_parsingBlockingScript.element();
}
bool HTMLScriptRunner::executeParsingBlockingScripts()
{
while (haveParsingBlockingScript()) {
if (!isPendingScriptReady(m_parsingBlockingScript))
return false;
executeParsingBlockingScript();
}
return true;
}
bool HTMLScriptRunner::executeScriptsWaitingForLoad(CachedResource* cachedScript)
{
ASSERT(!m_scriptNestingLevel);
ASSERT(haveParsingBlockingScript());
ASSERT_UNUSED(cachedScript, m_parsingBlockingScript.cachedScript() == cachedScript);
ASSERT(m_parsingBlockingScript.cachedScript()->isLoaded());
return executeParsingBlockingScripts();
}
bool HTMLScriptRunner::executeScriptsWaitingForStylesheets()
{
ASSERT(m_document);
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());
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());
pendingScript.setElement(script);
CachedScript* cachedScript = toScriptElement(script)->cachedScript().get();
if (!cachedScript) {
notImplemented(); return false;
}
pendingScript.setCachedScript(cachedScript);
return true;
}
void HTMLScriptRunner::runScript(Element* script, const TextPosition& scriptStartPosition)
{
ASSERT(m_document);
ASSERT(!haveParsingBlockingScript());
{
InsertionPointRecord insertionPointRecord(m_host->inputStream());
NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
ScriptElement* scriptElement = toScriptElement(script);
ASSERT(scriptElement);
if (!scriptElement)
return;
scriptElement->prepareScript(scriptStartPosition);
if (!scriptElement->willBeParserExecuted())
return;
if (scriptElement->willExecuteWhenDocumentFinishedParsing())
requestDeferredScript(script);
else if (scriptElement->readyToBeParserExecuted()) {
if (m_scriptNestingLevel == 1) {
m_parsingBlockingScript.setElement(script);
m_parsingBlockingScript.setStartingPosition(scriptStartPosition);
} else {
ScriptSourceCode sourceCode(script->textContent(), documentURLForScriptExecution(m_document), scriptStartPosition);
scriptElement->executeScript(sourceCode);
}
} else
requestParsingBlockingScript(script);
}
}
}