HTMLScriptRunner.cpp [plain text]
#include "config.h"
#include "HTMLScriptRunner.h"
#include "Element.h"
#include "Event.h"
#include "EventNames.h"
#include "Frame.h"
#include "HTMLInputStream.h"
#include "HTMLNames.h"
#include "HTMLScriptRunnerHost.h"
#include "IgnoreDestructiveWriteCountIncrementer.h"
#include "Microtasks.h"
#include "MutationObserver.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)
{
}
HTMLScriptRunner::~HTMLScriptRunner()
{
if (m_parserBlockingScript) {
if (m_parserBlockingScript->watchingForLoad())
stopWatchingForLoad(*m_parserBlockingScript);
}
while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
auto pendingScript = m_scriptsToExecuteAfterParsing.takeFirst();
if (pendingScript->watchingForLoad())
stopWatchingForLoad(pendingScript);
}
}
void HTMLScriptRunner::detach()
{
m_document = 0;
}
static URL documentURLForScriptExecution(Document* document)
{
if (!document || !document->frame())
return URL();
return document->frame()->document()->url();
}
inline Ref<Event> createScriptLoadEvent()
{
return Event::create(eventNames().loadEvent, false, false);
}
bool HTMLScriptRunner::isPendingScriptReady(const PendingScript& script)
{
if (!m_document)
return false;
m_hasScriptsWaitingForStylesheets = !m_document->haveStylesheetsLoaded();
if (m_hasScriptsWaitingForStylesheets)
return false;
if (script.needsLoading() && !script.isLoaded())
return false;
return true;
}
void HTMLScriptRunner::executeParsingBlockingScript()
{
ASSERT(m_document);
ASSERT(!isExecutingScript());
ASSERT(m_document->haveStylesheetsLoaded());
ASSERT(isPendingScriptReady(*m_parserBlockingScript));
InsertionPointRecord insertionPointRecord(m_host.inputStream());
executePendingScriptAndDispatchEvent(WTFMove(m_parserBlockingScript));
}
void HTMLScriptRunner::executePendingScriptAndDispatchEvent(RefPtr<PendingScript> pendingScript)
{
if (pendingScript->watchingForLoad())
stopWatchingForLoad(*pendingScript);
if (!isExecutingScript())
MicrotaskQueue::mainThreadQueue().performMicrotaskCheckpoint();
if (auto* scriptElement = toScriptElementIfPossible(&pendingScript->element())) {
NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
scriptElement->executePendingScript(*pendingScript);
}
ASSERT(!isExecutingScript());
}
void HTMLScriptRunner::watchForLoad(PendingScript& pendingScript)
{
ASSERT(!pendingScript.watchingForLoad());
m_host.watchForLoad(pendingScript);
}
void HTMLScriptRunner::stopWatchingForLoad(PendingScript& pendingScript)
{
ASSERT(pendingScript.watchingForLoad());
m_host.stopWatchingForLoad(pendingScript);
}
void HTMLScriptRunner::execute(PassRefPtr<Element> scriptElement, const TextPosition& scriptStartPosition)
{
ASSERT(scriptElement);
bool hadPreloadScanner = m_host.hasPreloadScanner();
runScript(scriptElement.get(), scriptStartPosition);
if (hasParserBlockingScript()) {
if (isExecutingScript())
return; if (!hadPreloadScanner && m_host.hasPreloadScanner())
m_host.appendCurrentInputStreamToPreloadScannerAndScan();
executeParsingBlockingScripts();
}
}
bool HTMLScriptRunner::hasParserBlockingScript() const
{
return !!m_parserBlockingScript;
}
void HTMLScriptRunner::executeParsingBlockingScripts()
{
while (hasParserBlockingScript() && isPendingScriptReady(*m_parserBlockingScript))
executeParsingBlockingScript();
}
void HTMLScriptRunner::executeScriptsWaitingForLoad(PendingScript& pendingScript)
{
ASSERT(!isExecutingScript());
ASSERT(hasParserBlockingScript());
ASSERT_UNUSED(pendingScript, m_parserBlockingScript.get() == &pendingScript);
ASSERT(m_parserBlockingScript->isLoaded());
executeParsingBlockingScripts();
}
void HTMLScriptRunner::executeScriptsWaitingForStylesheets()
{
ASSERT(m_document);
ASSERT(hasScriptsWaitingForStylesheets());
ASSERT(!isExecutingScript());
ASSERT(m_document->haveStylesheetsLoaded());
executeParsingBlockingScripts();
}
bool HTMLScriptRunner::executeScriptsWaitingForParsing()
{
while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
ASSERT(!isExecutingScript());
ASSERT(!hasParserBlockingScript());
ASSERT(m_scriptsToExecuteAfterParsing.first()->needsLoading());
if (!m_scriptsToExecuteAfterParsing.first()->isLoaded()) {
watchForLoad(m_scriptsToExecuteAfterParsing.first());
return false;
}
executePendingScriptAndDispatchEvent(m_scriptsToExecuteAfterParsing.takeFirst());
if (!m_document)
return false;
}
return true;
}
static Ref<PendingScript> requestPendingScript(Element* script)
{
auto& scriptElement = *toScriptElementIfPossible(script);
ASSERT(scriptElement.willBeParserExecuted());
ASSERT(scriptElement.loadableScript());
return PendingScript::create(*script, *scriptElement.loadableScript());
}
void HTMLScriptRunner::requestParsingBlockingScript(Element* element)
{
ASSERT(!m_parserBlockingScript);
m_parserBlockingScript = requestPendingScript(element);
ASSERT(m_parserBlockingScript->needsLoading());
if (!m_parserBlockingScript->isLoaded())
watchForLoad(*m_parserBlockingScript);
}
void HTMLScriptRunner::requestDeferredScript(Element* element)
{
auto pendingScript = requestPendingScript(element);
ASSERT(pendingScript->needsLoading());
m_scriptsToExecuteAfterParsing.append(WTFMove(pendingScript));
}
void HTMLScriptRunner::runScript(Element* script, const TextPosition& scriptStartPosition)
{
ASSERT(m_document);
ASSERT(!hasParserBlockingScript());
{
ScriptElement* scriptElement = toScriptElementIfPossible(script);
ASSERT(scriptElement);
if (!scriptElement)
return;
if (!isExecutingScript())
MicrotaskQueue::mainThreadQueue().performMicrotaskCheckpoint();
InsertionPointRecord insertionPointRecord(m_host.inputStream());
NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
scriptElement->prepareScript(scriptStartPosition);
if (!scriptElement->willBeParserExecuted())
return;
if (scriptElement->willExecuteWhenDocumentFinishedParsing())
requestDeferredScript(script);
else if (scriptElement->readyToBeParserExecuted()) {
if (m_scriptNestingLevel == 1)
m_parserBlockingScript = PendingScript::create(*script, scriptStartPosition);
else
scriptElement->executeClassicScript(ScriptSourceCode(script->textContent(), documentURLForScriptExecution(m_document), scriptStartPosition));
} else
requestParsingBlockingScript(script);
}
}
}