void XMLTreeViewer::transformDocumentToTreeView()
{
m_document->setIsViewSource(true);
String scriptString(reinterpret_cast<const char*>(XMLViewer_js), sizeof(XMLViewer_js));
m_document->frame()->script()->executeScriptInMainWorld(ScriptSourceCode(scriptString));
String noStyleMessage("This XML file does not appear to have any style information associated with it. The document tree is shown below.");
m_document->frame()->script()->executeScriptInMainWorld(ScriptSourceCode("prepareWebKitXMLViewer('" + noStyleMessage + "');"));
String cssString(reinterpret_cast<const char*>(XMLViewer_css), sizeof(XMLViewer_css));
RefPtr<Text> text = m_document->createTextNode(cssString);
m_document->getElementById("xml-viewer-style")->appendChild(text, IGNORE_EXCEPTION);
}
ScriptSourceCode PendingScript::getSource(const KURL& documentURL, bool& errorOccurred) const
{
if (resource()) {
errorOccurred = resource()->errorOccurred() || m_integrityFailure;
ASSERT(resource()->isLoaded());
if (m_streamer && !m_streamer->streamingSuppressed())
return ScriptSourceCode(m_streamer, resource());
return ScriptSourceCode(resource());
}
errorOccurred = false;
return ScriptSourceCode(m_element->textContent(), documentURL, startingPosition());
}
void XMLTreeViewer::transformDocumentToTreeView()
{
m_document.setSecurityOriginPolicy(SecurityOriginPolicy::create(SecurityOrigin::createUnique()));
String scriptString = StringImpl::createWithoutCopying(XMLViewer_js, sizeof(XMLViewer_js));
m_document.frame()->script().evaluate(ScriptSourceCode(scriptString));
m_document.frame()->script().evaluate(ScriptSourceCode(AtomicString("prepareWebKitXMLViewer('This XML file does not appear to have any style information associated with it. The document tree is shown below.');")));
String cssString = StringImpl::createWithoutCopying(XMLViewer_css, sizeof(XMLViewer_css));
Ref<Text> text = m_document.createTextNode(cssString);
m_document.getElementById(String(ASCIILiteral("xml-viewer-style")))->appendChild(WTFMove(text), IGNORE_EXCEPTION);
m_document.styleResolverChanged(RecalcStyleImmediately);
}
void XMLTreeViewer::transformDocumentToTreeView()
{
String scriptString(reinterpret_cast<const char*>(XMLViewer_js), sizeof(XMLViewer_js));
m_document->frame()->script()->evaluate(ScriptSourceCode(scriptString));
String noStyleMessage("This XML file does not appear to have any style information associated with it. The document tree is shown below.");
m_document->frame()->script()->evaluate(ScriptSourceCode("prepareWebKitXMLViewer('" + noStyleMessage + "');"));
String cssString(reinterpret_cast<const char*>(XMLViewer_css), sizeof(XMLViewer_css));
RefPtr<Text> text = m_document->createTextNode(cssString);
ExceptionCode exceptionCode;
m_document->getElementById("xml-viewer-style")->appendChild(text, exceptionCode);
m_document->setUsesViewSourceStyles(true);
m_document->styleSelectorChanged(RecalcStyleImmediately);
}
void InspectorOverlay::evaluateInOverlay(const String& method, PassRefPtr<InspectorValue> argument)
{
RefPtr<InspectorArray> command = InspectorArray::create();
command->pushString(method);
command->pushValue(argument);
overlayPage()->mainFrame()->script()->executeScriptInMainWorld(ScriptSourceCode("dispatch(" + command->toJSONString() + ")"));
}
void WorkerContext::importScripts(const Vector<String>& urls, ExceptionCode& ec)
{
ec = 0;
Vector<String>::const_iterator urlsEnd = urls.end();
Vector<KURL> completedURLs;
for (Vector<String>::const_iterator it = urls.begin(); it != urlsEnd; ++it) {
const KURL& url = scriptExecutionContext()->completeURL(*it);
if (!url.isValid()) {
ec = SYNTAX_ERR;
return;
}
completedURLs.append(url);
}
Vector<KURL>::const_iterator end = completedURLs.end();
for (Vector<KURL>::const_iterator it = completedURLs.begin(); it != end; ++it) {
WorkerScriptLoader scriptLoader(ResourceRequestBase::TargetIsScript);
scriptLoader.loadSynchronously(scriptExecutionContext(), *it, AllowCrossOriginRequests);
// If the fetching attempt failed, throw a NETWORK_ERR exception and abort all these steps.
if (scriptLoader.failed()) {
ec = XMLHttpRequestException::NETWORK_ERR;
return;
}
InspectorInstrumentation::scriptImported(scriptExecutionContext(), scriptLoader.identifier(), scriptLoader.script());
ScriptValue exception;
m_script->evaluate(ScriptSourceCode(scriptLoader.script(), scriptLoader.responseURL()), &exception);
if (!exception.hasNoValue()) {
m_script->setException(exception);
return;
}
}
}
void WorkerGlobalScope::importScripts(const Vector<String>& urls, ExceptionCode& ec)
{
ASSERT(contentSecurityPolicy());
ec = 0;
Vector<URL> completedURLs;
for (auto& entry : urls) {
URL url = scriptExecutionContext()->completeURL(entry);
if (!url.isValid()) {
ec = SYNTAX_ERR;
return;
}
completedURLs.append(WTFMove(url));
}
for (auto& url : completedURLs) {
Ref<WorkerScriptLoader> scriptLoader = WorkerScriptLoader::create();
scriptLoader->loadSynchronously(scriptExecutionContext(), url, AllowCrossOriginRequests);
// If the fetching attempt failed, throw a NETWORK_ERR exception and abort all these steps.
if (scriptLoader->failed()) {
ec = NETWORK_ERR;
return;
}
InspectorInstrumentation::scriptImported(scriptExecutionContext(), scriptLoader->identifier(), scriptLoader->script());
NakedPtr<JSC::Exception> exception;
m_script->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->responseURL()), exception);
if (exception) {
m_script->setException(exception);
return;
}
}
}
void* WorkerThread::workerThread()
{
{
MutexLocker lock(m_threadCreationMutex);
m_workerContext = createWorkerContext(m_startupData->m_scriptURL, m_startupData->m_userAgent);
if (m_runLoop.terminated()) {
// The worker was terminated before the thread had a chance to run. Since the context didn't exist yet,
// forbidExecution() couldn't be called from stop().
m_workerContext->script()->forbidExecution();
}
}
WorkerScriptController* script = m_workerContext->script();
script->evaluate(ScriptSourceCode(m_startupData->m_sourceCode, m_startupData->m_scriptURL));
// Free the startup data to cause its member variable deref's happen on the worker's thread (since
// all ref/derefs of these objects are happening on the thread at this point). Note that
// WorkerThread::~WorkerThread happens on a different thread where it was created.
m_startupData.clear();
runEventLoop();
ThreadIdentifier threadID = m_threadID;
ASSERT(m_workerContext->hasOneRef());
// The below assignment will destroy the context, which will in turn notify messaging proxy.
// We cannot let any objects survive past thread exit, because no other thread will run GC or otherwise destroy them.
m_workerContext = 0;
// The thread object may be already destroyed from notification now, don't try to access "this".
detachThread(threadID);
return 0;
}
void executeScriptInWorker(WorkerThread* worker, WaitableEvent* waitEvent)
{
WorkerOrWorkletScriptController* scriptController = worker->workerGlobalScope()->scriptController();
bool evaluateResult = scriptController->evaluate(ScriptSourceCode("var counter = 0; ++counter;"));
ASSERT_UNUSED(evaluateResult, evaluateResult);
waitEvent->signal();
}
void InspectorOverlay::evaluateInOverlay(const String& method, PassRefPtr<InspectorValue> argument)
{
RefPtr<InspectorArray> command = InspectorArray::create();
command->pushString(method);
command->pushValue(argument);
overlayPage()->mainFrame().script().evaluate(ScriptSourceCode(makeString("dispatch(", command->toJSONString(), ")")));
}
void InspectorClient::doDispatchMessageOnFrontendPage(Page* frontendPage, const String& message)
{
if (!frontendPage)
return;
SuspendExceptionScope scope(&frontendPage->inspectorController().vm());
String dispatchToFrontend = makeString("InspectorFrontendAPI.dispatchMessageAsync(", message, ");");
frontendPage->mainFrame().script().evaluate(ScriptSourceCode(dispatchToFrontend));
}
void XMLDocumentParser::parseEndElement()
{
exitText();
RefPtr<ContainerNode> n = m_currentNode;
n->finishParsingChildren();
if (!scriptingContentIsAllowed(m_scriptingPermission) && n->isElementNode() && toScriptElement(static_cast<Element*>(n.get()))) {
popCurrentNode();
ExceptionCode ec;
n->remove(ec);
return;
}
if (!n->isElementNode() || !m_view) {
if (!m_currentNodeStack.isEmpty())
popCurrentNode();
return;
}
Element* element = static_cast<Element*>(n.get());
// The element's parent may have already been removed from document.
// Parsing continues in this case, but scripts aren't executed.
if (!element->inDocument()) {
popCurrentNode();
return;
}
ScriptElement* scriptElement = toScriptElement(element);
if (!scriptElement) {
popCurrentNode();
return;
}
// don't load external scripts for standalone documents (for now)
ASSERT(!m_pendingScript);
m_requestingScript = true;
if (scriptElement->prepareScript(m_scriptStartPosition, ScriptElement::AllowLegacyTypeInTypeAttribute)) {
if (scriptElement->readyToBeParserExecuted())
scriptElement->executeScript(ScriptSourceCode(scriptElement->scriptContent(), document()->url(), m_scriptStartPosition));
else if (scriptElement->willBeParserExecuted()) {
m_pendingScript = scriptElement->cachedScript();
m_scriptElement = element;
m_pendingScript->addClient(this);
// m_pendingScript will be 0 if script was already loaded and addClient() executed it.
if (m_pendingScript)
pauseParsing();
} else
m_scriptElement = 0;
}
m_requestingScript = false;
popCurrentNode();
}
void ScriptElement::executeScriptForScriptRunner(PendingScript& pendingScript)
{
if (auto* loadableScript = pendingScript.loadableScript())
executeScriptAndDispatchEvent(*loadableScript);
else {
ASSERT(!pendingScript.wasErrored());
executeScript(ScriptSourceCode(scriptContent(), m_element.document().url(), pendingScript.startingPosition()));
dispatchLoadEvent();
}
}
bool InspectorClient::doDispatchMessageOnFrontendPage(Page* frontendPage, const String& message)
{
if (!frontendPage)
return false;
String dispatchToFrontend = "InspectorFrontendAPI.dispatchMessageAsync(" + message + ");";
// FIXME: This should execute the script in the appropriate world.
frontendPage->mainFrame().script().evaluate(ScriptSourceCode(dispatchToFrontend));
return true;
}
void ScriptElementData::execute(CachedScript* cachedScript)
{
ASSERT(cachedScript);
if (cachedScript->errorOccurred())
m_scriptElement->dispatchErrorEvent();
else {
evaluateScript(ScriptSourceCode(cachedScript));
m_scriptElement->dispatchLoadEvent();
}
cachedScript->removeClient(this);
}
String InspectorOverlay::evaluateInOverlayForTest(const String& script) {
ScriptForbiddenScope::AllowUserAgentScript allowScript;
v8::HandleScope handleScope(toIsolate(overlayMainFrame()));
v8::Local<v8::Value> string =
toLocalFrame(overlayPage()->mainFrame())
->script()
.executeScriptInMainWorldAndReturnValue(
ScriptSourceCode(script),
ScriptController::ExecuteScriptWhenScriptsDisabled);
return toCoreStringWithUndefinedOrNullCheck(string);
}
void ScriptController::collectGarbage()
{
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = V8Proxy::mainWorldContext(m_proxy->frame());
if (v8Context.IsEmpty())
return;
v8::Context::Scope scope(v8Context);
m_proxy->evaluate(ScriptSourceCode("if (window.gc) void(gc());"), 0);
}
void ScriptLoader::execute(ScriptResource* resource)
{
ASSERT(!m_willBeParserExecuted);
ASSERT(resource);
if (resource->errorOccurred()) {
dispatchErrorEvent();
} else if (!resource->wasCanceled()) {
executeScript(ScriptSourceCode(resource));
dispatchLoadEvent();
}
resource->removeClient(this);
}
void ScriptElement::execute(CachedScript* cachedScript)
{
ASSERT(!m_willBeParserExecuted);
ASSERT(cachedScript);
if (cachedScript->errorOccurred())
dispatchErrorEvent();
else if (!cachedScript->wasCanceled()) {
executeScript(ScriptSourceCode(cachedScript));
dispatchLoadEvent();
}
cachedScript->removeClient(this);
}
void WorkerThread::workerThread()
{
// Propagate the mainThread's fenv to workers.
#if PLATFORM(IOS)
FloatingPointEnvironment::singleton().propagateMainThreadEnvironment();
#endif
#if PLATFORM(GTK)
GRefPtr<GMainContext> mainContext = adoptGRef(g_main_context_new());
g_main_context_push_thread_default(mainContext.get());
#endif
{
LockHolder lock(m_threadCreationMutex);
m_workerGlobalScope = createWorkerGlobalScope(m_startupData->m_scriptURL, m_startupData->m_userAgent, m_startupData->m_contentSecurityPolicyResponseHeaders, m_startupData->m_shouldBypassMainWorldContentSecurityPolicy, WTFMove(m_startupData->m_topOrigin));
if (m_runLoop.terminated()) {
// The worker was terminated before the thread had a chance to run. Since the context didn't exist yet,
// forbidExecution() couldn't be called from stop().
m_workerGlobalScope->script()->forbidExecution();
}
}
WorkerScriptController* script = m_workerGlobalScope->script();
script->evaluate(ScriptSourceCode(m_startupData->m_sourceCode, m_startupData->m_scriptURL));
// Free the startup data to cause its member variable deref's happen on the worker's thread (since
// all ref/derefs of these objects are happening on the thread at this point). Note that
// WorkerThread::~WorkerThread happens on a different thread where it was created.
m_startupData = nullptr;
runEventLoop();
#if PLATFORM(GTK)
g_main_context_pop_thread_default(mainContext.get());
#endif
ThreadIdentifier threadID = m_threadID;
ASSERT(m_workerGlobalScope->hasOneRef());
// The below assignment will destroy the context, which will in turn notify messaging proxy.
// We cannot let any objects survive past thread exit, because no other thread will run GC or otherwise destroy them.
m_workerGlobalScope = nullptr;
// Clean up WebCore::ThreadGlobalData before WTF::WTFThreadData goes away!
threadGlobalData().destroy();
// The thread object may be already destroyed from notification now, don't try to access "this".
detachThread(threadID);
}
void ScriptModuleLoader::notifyFinished(CachedModuleScriptLoader& loader, RefPtr<DeferredPromise> promise)
{
// https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script
if (!m_loaders.remove(&loader))
return;
loader.clearClient();
auto& cachedScript = *loader.cachedScript();
bool failed = false;
if (cachedScript.resourceError().isAccessControl()) {
promise->reject(TypeError, ASCIILiteral("Cross-origin script load denied by Cross-Origin Resource Sharing policy."));
return;
}
if (cachedScript.errorOccurred())
failed = true;
else if (!MIMETypeRegistry::isSupportedJavaScriptMIMEType(cachedScript.response().mimeType())) {
// https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script
// The result of extracting a MIME type from response's header list (ignoring parameters) is not a JavaScript MIME type.
// For historical reasons, fetching a classic script does not include MIME type checking. In contrast, module scripts will fail to load if they are not of a correct MIME type.
promise->reject(TypeError, makeString("'", cachedScript.response().mimeType(), "' is not a valid JavaScript MIME type."));
return;
}
auto* frame = m_document.frame();
if (!frame)
return;
if (failed) {
// Reject a promise to propagate the error back all the way through module promise chains to the script element.
promise->reject(frame->script().moduleLoaderAlreadyReportedErrorSymbol());
return;
}
if (cachedScript.wasCanceled()) {
promise->reject(frame->script().moduleLoaderFetchingIsCanceledSymbol());
return;
}
m_requestURLToResponseURLMap.add(cachedScript.url(), cachedScript.response().url());
// FIXME: Let's wrap around ScriptSourceCode to propagate it directly through the module pipeline.
promise->resolve<IDLDOMString>(ScriptSourceCode(&cachedScript, JSC::SourceProviderSourceType::Module).source().toString());
}
void ScheduledAction::execute(LocalFrame* frame)
{
if (m_scriptState->contextIsEmpty())
return;
TRACE_EVENT0("v8", "ScheduledAction::execute");
ScriptState::Scope scope(m_scriptState.get());
if (!m_function.isEmpty()) {
Vector<v8::Handle<v8::Value> > info;
createLocalHandlesForArgs(&info);
frame->script().callFunction(m_function.newLocal(m_scriptState->isolate()), m_scriptState->context()->Global(), info.size(), info.data());
} else {
frame->script().executeScriptAndReturnValue(m_scriptState->context(), ScriptSourceCode(m_code));
}
// The frame might be invalid at this point because JavaScript could have released it.
}
void WorkerGlobalScope::importScripts(const Vector<String>& urls, ExceptionState& exceptionState)
{
ASSERT(contentSecurityPolicy());
ASSERT(getExecutionContext());
ExecutionContext& executionContext = *this->getExecutionContext();
Vector<KURL> completedURLs;
for (const String& urlString : urls) {
const KURL& url = executionContext.completeURL(urlString);
if (!url.isValid()) {
exceptionState.throwDOMException(SyntaxError, "The URL '" + urlString + "' is invalid.");
return;
}
if (!contentSecurityPolicy()->allowScriptFromSource(url)) {
exceptionState.throwDOMException(NetworkError, "The script at '" + url.elidedString() + "' failed to load.");
return;
}
completedURLs.append(url);
}
for (const KURL& completeURL : completedURLs) {
RefPtr<WorkerScriptLoader> scriptLoader(WorkerScriptLoader::create());
scriptLoader->setRequestContext(WebURLRequest::RequestContextScript);
scriptLoader->loadSynchronously(executionContext, completeURL, AllowCrossOriginRequests, executionContext.securityContext().addressSpace());
// If the fetching attempt failed, throw a NetworkError exception and abort all these steps.
if (scriptLoader->failed()) {
exceptionState.throwDOMException(NetworkError, "The script at '" + completeURL.elidedString() + "' failed to load.");
return;
}
InspectorInstrumentation::scriptImported(&executionContext, scriptLoader->identifier(), scriptLoader->script());
scriptLoaded(scriptLoader->script().length(), scriptLoader->cachedMetadata() ? scriptLoader->cachedMetadata()->size() : 0);
RawPtr<ErrorEvent> errorEvent = nullptr;
OwnPtr<Vector<char>> cachedMetaData(scriptLoader->releaseCachedMetadata());
RawPtr<CachedMetadataHandler> handler(createWorkerScriptCachedMetadataHandler(completeURL, cachedMetaData.get()));
m_scriptController->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->responseURL()), &errorEvent, handler.get(), m_v8CacheOptions);
if (errorEvent) {
m_scriptController->rethrowExceptionFromImportedScript(errorEvent.release(), exceptionState);
return;
}
}
}
void ScriptElementData::notifyFinished(CachedResource* o)
{
CachedScript* cs = static_cast<CachedScript*>(o);
ASSERT(cs == m_cachedScript);
// Evaluating the script could lead to a garbage collection which can
// delete the script element so we need to protect it and us with it!
RefPtr<Element> protector(m_element);
if (cs->errorOccurred())
m_scriptElement->dispatchErrorEvent();
else {
evaluateScript(ScriptSourceCode(cs));
m_scriptElement->dispatchLoadEvent();
}
stopLoadRequest();
}
void WorkerThread::workerThread()
{
// Propagate the mainThread's fenv to workers.
#if PLATFORM(IOS)
fesetenv(&mainThreadFEnv);
#endif
{
MutexLocker lock(m_threadCreationMutex);
m_workerGlobalScope = createWorkerGlobalScope(m_startupData->m_scriptURL, m_startupData->m_userAgent, std::move(m_startupData->m_groupSettings), m_startupData->m_contentSecurityPolicy, m_startupData->m_contentSecurityPolicyType, m_startupData->m_topOrigin.release());
if (m_runLoop.terminated()) {
// The worker was terminated before the thread had a chance to run. Since the context didn't exist yet,
// forbidExecution() couldn't be called from stop().
m_workerGlobalScope->script()->forbidExecution();
}
}
WorkerScriptController* script = m_workerGlobalScope->script();
#if ENABLE(INSPECTOR)
InspectorInstrumentation::willEvaluateWorkerScript(workerGlobalScope(), m_startupData->m_startMode);
#endif
script->evaluate(ScriptSourceCode(m_startupData->m_sourceCode, m_startupData->m_scriptURL));
// Free the startup data to cause its member variable deref's happen on the worker's thread (since
// all ref/derefs of these objects are happening on the thread at this point). Note that
// WorkerThread::~WorkerThread happens on a different thread where it was created.
m_startupData.clear();
runEventLoop();
ThreadIdentifier threadID = m_threadID;
ASSERT(m_workerGlobalScope->hasOneRef());
// The below assignment will destroy the context, which will in turn notify messaging proxy.
// We cannot let any objects survive past thread exit, because no other thread will run GC or otherwise destroy them.
m_workerGlobalScope = 0;
// Clean up WebCore::ThreadGlobalData before WTF::WTFThreadData goes away!
threadGlobalData().destroy();
// The thread object may be already destroyed from notification now, don't try to access "this".
detachThread(threadID);
}
void Worklet::onFinished(WorkerScriptLoader* scriptLoader, ScriptPromiseResolver* resolver)
{
if (scriptLoader->failed()) {
resolver->reject(DOMException::create(NetworkError));
} else {
// TODO(ikilpatrick): Worklets don't have the same error behaviour
// as workers, etc. For a SyntaxError we should reject, however if
// the script throws a normal error, resolve. For now just resolve.
m_workletGlobalScope->scriptController()->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->url()));
resolver->resolve();
}
size_t index = m_scriptLoaders.find(scriptLoader);
ASSERT(index != kNotFound);
ASSERT(m_resolvers[index] == resolver);
m_scriptLoaders.remove(index);
m_resolvers.remove(index);
}
void WorkerGlobalScope::importScripts(const Vector<String>& urls, ExceptionCode& ec)
{
ASSERT(contentSecurityPolicy());
ec = 0;
Vector<URL> completedURLs;
for (auto& entry : urls) {
URL url = scriptExecutionContext()->completeURL(entry);
if (!url.isValid()) {
ec = SYNTAX_ERR;
return;
}
completedURLs.append(WTFMove(url));
}
for (auto& url : completedURLs) {
// FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved.
bool shouldBypassMainWorldContentSecurityPolicy = scriptExecutionContext()->shouldBypassMainWorldContentSecurityPolicy();
if (!scriptExecutionContext()->contentSecurityPolicy()->allowScriptFromSource(url, shouldBypassMainWorldContentSecurityPolicy)) {
ec = NETWORK_ERR;
return;
}
Ref<WorkerScriptLoader> scriptLoader = WorkerScriptLoader::create();
scriptLoader->loadSynchronously(scriptExecutionContext(), url, AllowCrossOriginRequests, shouldBypassMainWorldContentSecurityPolicy ? ContentSecurityPolicyEnforcement::DoNotEnforce : ContentSecurityPolicyEnforcement::EnforceScriptSrcDirective);
// If the fetching attempt failed, throw a NETWORK_ERR exception and abort all these steps.
if (scriptLoader->failed()) {
ec = NETWORK_ERR;
return;
}
InspectorInstrumentation::scriptImported(scriptExecutionContext(), scriptLoader->identifier(), scriptLoader->script());
NakedPtr<JSC::Exception> exception;
m_script->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->responseURL()), exception);
if (exception) {
m_script->setException(exception);
return;
}
}
}
bool InspectorClient::doDispatchMessageOnFrontendPage(Page* frontendPage, const String& message)
{
if (!frontendPage)
return false;
Frame* frame = frontendPage->mainFrame();
if (!frame)
return false;
ScriptController* scriptController = frame->script();
if (!scriptController)
return false;
String dispatchToFrontend("WebInspector.dispatchMessageFromBackend(");
dispatchToFrontend += message;
dispatchToFrontend += ");";
// FIXME: This should execute the script in the appropriate world.
scriptController->evaluate(ScriptSourceCode(dispatchToFrontend));
return true;
}
void WorkerGlobalScope::importScripts(const Vector<String>& urls, ExceptionCode& ec)
{
ASSERT(contentSecurityPolicy());
ec = 0;
Vector<String>::const_iterator urlsEnd = urls.end();
Vector<KURL> completedURLs;
for (Vector<String>::const_iterator it = urls.begin(); it != urlsEnd; ++it) {
const KURL& url = scriptExecutionContext()->completeURL(*it);
if (!url.isValid()) {
ec = SYNTAX_ERR;
return;
}
completedURLs.append(url);
}
Vector<KURL>::const_iterator end = completedURLs.end();
for (Vector<KURL>::const_iterator it = completedURLs.begin(); it != end; ++it) {
RefPtr<WorkerScriptLoader> scriptLoader(WorkerScriptLoader::create());
#if PLATFORM(BLACKBERRY)
scriptLoader->setTargetType(ResourceRequest::TargetIsScript);
#endif
scriptLoader->loadSynchronously(scriptExecutionContext(), *it, AllowCrossOriginRequests);
// If the fetching attempt failed, throw a NETWORK_ERR exception and abort all these steps.
if (scriptLoader->failed()) {
ec = XMLHttpRequestException::NETWORK_ERR;
return;
}
InspectorInstrumentation::scriptImported(scriptExecutionContext(), scriptLoader->identifier(), scriptLoader->script());
ScriptValue exception;
m_script->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->responseURL()), &exception);
if (!exception.hasNoValue()) {
m_script->setException(exception);
return;
}
}
}
void WorkerContext::importScripts(const Vector<String>& urls, const String& callerURL, int callerLine, ExceptionCode& ec)
{
ec = 0;
Vector<String>::const_iterator urlsEnd = urls.end();
Vector<KURL> completedURLs;
for (Vector<String>::const_iterator it = urls.begin(); it != urlsEnd; ++it) {
const KURL& url = scriptExecutionContext()->completeURL(*it);
if (!url.isValid()) {
ec = SYNTAX_ERR;
return;
}
completedURLs.append(url);
}
String securityOrigin = scriptExecutionContext()->securityOrigin()->toString();
Vector<KURL>::const_iterator end = completedURLs.end();
for (Vector<KURL>::const_iterator it = completedURLs.begin(); it != end; ++it) {
WorkerScriptLoader scriptLoader;
scriptLoader.loadSynchronously(scriptExecutionContext(), *it, AllowCrossOriginRedirect);
// If the fetching attempt failed, throw a NETWORK_ERR exception and abort all these steps.
if (scriptLoader.failed()) {
ec = XMLHttpRequestException::NETWORK_ERR;
return;
}
scriptExecutionContext()->scriptImported(scriptLoader.identifier(), scriptLoader.script());
scriptExecutionContext()->addMessage(InspectorControllerDestination, JSMessageSource, LogMessageType, LogMessageLevel, "Worker script imported: \"" + *it + "\".", callerLine, callerURL);
ScriptValue exception;
m_script->evaluate(ScriptSourceCode(scriptLoader.script(), *it), &exception);
if (!exception.hasNoValue()) {
m_script->setException(exception);
return;
}
}
}
