WorkerGlobalScope.cpp [plain text]
#include "config.h"
#include "WorkerGlobalScope.h"
#include "ActiveDOMObject.h"
#include "ContentSecurityPolicy.h"
#include "DOMTimer.h"
#include "DOMURL.h"
#include "DOMWindow.h"
#include "ErrorEvent.h"
#include "Event.h"
#include "ExceptionCode.h"
#include "IDBConnectionProxy.h"
#include "InspectorConsoleInstrumentation.h"
#include "MessagePort.h"
#include "ScheduledAction.h"
#include "ScriptSourceCode.h"
#include "SecurityOrigin.h"
#include "SecurityOriginPolicy.h"
#include "SocketProvider.h"
#include "URL.h"
#include "WorkerLocation.h"
#include "WorkerNavigator.h"
#include "WorkerObjectProxy.h"
#include "WorkerScriptLoader.h"
#include "WorkerThread.h"
#include "WorkerThreadableLoader.h"
#include <bindings/ScriptValue.h>
#include <inspector/ConsoleMessage.h>
#include <inspector/ScriptCallStack.h>
#include <wtf/RefPtr.h>
#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
#include "NotificationCenter.h"
#endif
using namespace Inspector;
namespace WebCore {
WorkerGlobalScope::WorkerGlobalScope(const URL& url, const String& userAgent, WorkerThread& thread, bool shouldBypassMainWorldContentSecurityPolicy, RefPtr<SecurityOrigin>&& topOrigin, IDBClient::IDBConnectionProxy* connectionProxy, SocketProvider* socketProvider)
: m_url(url)
, m_userAgent(userAgent)
, m_script(std::make_unique<WorkerScriptController>(this))
, m_thread(thread)
, m_closing(false)
, m_shouldBypassMainWorldContentSecurityPolicy(shouldBypassMainWorldContentSecurityPolicy)
, m_eventQueue(*this)
, m_topOrigin(topOrigin)
#if ENABLE(INDEXED_DATABASE)
, m_connectionProxy(connectionProxy)
#endif
#if ENABLE(WEB_SOCKETS)
, m_socketProvider(socketProvider)
#endif
{
#if !ENABLE(INDEXED_DATABASE)
UNUSED_PARAM(connectionProxy);
#endif
#if !ENABLE(WEB_SOCKETS)
UNUSED_PARAM(socketProvider);
#endif
auto origin = SecurityOrigin::create(url);
if (m_topOrigin->hasUniversalAccess())
origin->grantUniversalAccess();
setSecurityOriginPolicy(SecurityOriginPolicy::create(WTFMove(origin)));
setContentSecurityPolicy(std::make_unique<ContentSecurityPolicy>(*this));
}
WorkerGlobalScope::~WorkerGlobalScope()
{
ASSERT(currentThread() == thread().threadID());
notifyObserversOfStop();
thread().workerReportingProxy().workerGlobalScopeDestroyed();
}
void WorkerGlobalScope::applyContentSecurityPolicyResponseHeaders(const ContentSecurityPolicyResponseHeaders& contentSecurityPolicyResponseHeaders)
{
contentSecurityPolicy()->didReceiveHeaders(contentSecurityPolicyResponseHeaders);
}
URL WorkerGlobalScope::completeURL(const String& url) const
{
if (url.isNull())
return URL();
return URL(m_url, url);
}
String WorkerGlobalScope::userAgent(const URL&) const
{
return m_userAgent;
}
void WorkerGlobalScope::disableEval(const String& errorMessage)
{
m_script->disableEval(errorMessage);
}
#if ENABLE(WEB_SOCKETS)
SocketProvider* WorkerGlobalScope::socketProvider()
{
return m_socketProvider.get();
}
#endif
#if ENABLE(INDEXED_DATABASE)
IDBClient::IDBConnectionProxy* WorkerGlobalScope::idbConnectionProxy()
{
#if ENABLE(INDEXED_DATABASE_IN_WORKERS)
return m_connectionProxy.get();
#else
return nullptr;
#endif
}
void WorkerGlobalScope::stopIndexedDatabase()
{
#if ENABLE(INDEXED_DATABASE_IN_WORKERS)
ASSERT(m_connectionProxy);
m_connectionProxy->forgetActivityForCurrentThread();
#endif
}
#endif // ENABLE(INDEXED_DATABASE)
WorkerLocation& WorkerGlobalScope::location() const
{
if (!m_location)
m_location = WorkerLocation::create(m_url);
return *m_location;
}
void WorkerGlobalScope::close()
{
if (m_closing)
return;
m_closing = true;
postTask({ ScriptExecutionContext::Task::CleanupTask, [] (ScriptExecutionContext& context) {
ASSERT_WITH_SECURITY_IMPLICATION(is<WorkerGlobalScope>(context));
WorkerGlobalScope& workerGlobalScope = downcast<WorkerGlobalScope>(context);
workerGlobalScope.thread().workerReportingProxy().workerGlobalScopeClosed();
} });
}
WorkerNavigator& WorkerGlobalScope::navigator() const
{
if (!m_navigator)
m_navigator = WorkerNavigator::create(m_userAgent);
return *m_navigator;
}
void WorkerGlobalScope::postTask(Task&& task)
{
thread().runLoop().postTask(WTFMove(task));
}
int WorkerGlobalScope::setTimeout(std::unique_ptr<ScheduledAction> action, int timeout)
{
return DOMTimer::install(*this, WTFMove(action), std::chrono::milliseconds(timeout), true);
}
void WorkerGlobalScope::clearTimeout(int timeoutId)
{
DOMTimer::removeById(*this, timeoutId);
}
int WorkerGlobalScope::setInterval(std::unique_ptr<ScheduledAction> action, int timeout)
{
return DOMTimer::install(*this, WTFMove(action), std::chrono::milliseconds(timeout), false);
}
void WorkerGlobalScope::clearInterval(int timeoutId)
{
DOMTimer::removeById(*this, timeoutId);
}
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) {
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 (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;
}
}
}
EventTarget* WorkerGlobalScope::errorEventTarget()
{
return this;
}
void WorkerGlobalScope::logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, RefPtr<ScriptCallStack>&&)
{
thread().workerReportingProxy().postExceptionToWorkerObject(errorMessage, lineNumber, columnNumber, sourceURL);
}
void WorkerGlobalScope::addConsoleMessage(std::unique_ptr<Inspector::ConsoleMessage> message)
{
if (!isContextThread()) {
postTask(AddConsoleMessageTask(message->source(), message->level(), message->message()));
return;
}
thread().workerReportingProxy().postConsoleMessageToWorkerObject(message->source(), message->level(), message->message(), message->line(), message->column(), message->url());
addMessageToWorkerConsole(WTFMove(message));
}
void WorkerGlobalScope::addConsoleMessage(MessageSource source, MessageLevel level, const String& message, unsigned long requestIdentifier)
{
if (!isContextThread()) {
postTask(AddConsoleMessageTask(source, level, message));
return;
}
thread().workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, 0, 0, String());
addMessageToWorkerConsole(source, level, message, String(), 0, 0, 0, 0, requestIdentifier);
}
void WorkerGlobalScope::addMessage(MessageSource source, MessageLevel level, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, RefPtr<ScriptCallStack>&& callStack, JSC::ExecState* state, unsigned long requestIdentifier)
{
if (!isContextThread()) {
postTask(AddConsoleMessageTask(source, level, message));
return;
}
thread().workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, lineNumber, columnNumber, sourceURL);
addMessageToWorkerConsole(source, level, message, sourceURL, lineNumber, columnNumber, WTFMove(callStack), state, requestIdentifier);
}
void WorkerGlobalScope::addMessageToWorkerConsole(MessageSource source, MessageLevel level, const String& messageText, const String& suggestedURL, unsigned suggestedLineNumber, unsigned suggestedColumnNumber, RefPtr<ScriptCallStack>&& callStack, JSC::ExecState* state, unsigned long requestIdentifier)
{
std::unique_ptr<Inspector::ConsoleMessage> message;
if (callStack)
message = std::make_unique<Inspector::ConsoleMessage>(source, MessageType::Log, level, messageText, WTFMove(callStack), requestIdentifier);
else
message = std::make_unique<Inspector::ConsoleMessage>(source, MessageType::Log, level, messageText, suggestedURL, suggestedLineNumber, suggestedColumnNumber, state, requestIdentifier);
addMessageToWorkerConsole(WTFMove(message));
}
void WorkerGlobalScope::addMessageToWorkerConsole(std::unique_ptr<Inspector::ConsoleMessage> message)
{
ASSERT(isContextThread());
InspectorInstrumentation::addMessageToConsole(this, WTFMove(message));
}
bool WorkerGlobalScope::isContextThread() const
{
return currentThread() == thread().threadID();
}
bool WorkerGlobalScope::isJSExecutionForbidden() const
{
return m_script->isExecutionForbidden();
}
WorkerGlobalScope::Observer::Observer(WorkerGlobalScope* context)
: m_context(context)
{
ASSERT(m_context && m_context->isContextThread());
m_context->registerObserver(this);
}
WorkerGlobalScope::Observer::~Observer()
{
if (!m_context)
return;
ASSERT(m_context->isContextThread());
m_context->unregisterObserver(this);
}
void WorkerGlobalScope::Observer::stopObserving()
{
if (!m_context)
return;
ASSERT(m_context->isContextThread());
m_context->unregisterObserver(this);
m_context = 0;
}
void WorkerGlobalScope::registerObserver(Observer* observer)
{
ASSERT(observer);
m_workerObservers.add(observer);
}
void WorkerGlobalScope::unregisterObserver(Observer* observer)
{
ASSERT(observer);
m_workerObservers.remove(observer);
}
void WorkerGlobalScope::notifyObserversOfStop()
{
HashSet<Observer*>::iterator iter = m_workerObservers.begin();
while (iter != m_workerObservers.end()) {
WorkerGlobalScope::Observer* observer = *iter;
observer->stopObserving();
observer->notifyStop();
iter = m_workerObservers.begin();
}
}
WorkerEventQueue& WorkerGlobalScope::eventQueue() const
{
return m_eventQueue;
}
#if ENABLE(SUBTLE_CRYPTO)
bool WorkerGlobalScope::wrapCryptoKey(const Vector<uint8_t>&, Vector<uint8_t>&)
{
return false;
}
bool WorkerGlobalScope::unwrapCryptoKey(const Vector<uint8_t>&, Vector<uint8_t>&)
{
return false;
}
#endif // ENABLE(SUBTLE_CRYPTO)
}