#include "config.h"
#if ENABLE(WORKERS)
#include "WorkerContext.h"
#include "ActiveDOMObject.h"
#include "ContentSecurityPolicy.h"
#include "DOMTimer.h"
#include "DOMURL.h"
#include "DOMWindow.h"
#include "ErrorEvent.h"
#include "Event.h"
#include "EventException.h"
#include "InspectorConsoleInstrumentation.h"
#include "KURL.h"
#include "MessagePort.h"
#include "NotImplemented.h"
#include "ScheduledAction.h"
#include "ScriptCallStack.h"
#include "ScriptSourceCode.h"
#include "ScriptValue.h"
#include "SecurityOrigin.h"
#include "WorkerInspectorController.h"
#include "WorkerLocation.h"
#include "WorkerNavigator.h"
#include "WorkerObjectProxy.h"
#include "WorkerScriptLoader.h"
#include "WorkerThread.h"
#include "WorkerThreadableLoader.h"
#include "XMLHttpRequestException.h"
#include <wtf/RefPtr.h>
#include <wtf/UnusedParam.h>
#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
#include "NotificationCenter.h"
#endif
#include "ExceptionCode.h"
namespace WebCore {
class CloseWorkerContextTask : public ScriptExecutionContext::Task {
public:
static PassOwnPtr<CloseWorkerContextTask> create()
{
return adoptPtr(new CloseWorkerContextTask);
}
virtual void performTask(ScriptExecutionContext *context)
{
ASSERT(context->isWorkerContext());
WorkerContext* workerContext = static_cast<WorkerContext*>(context);
workerContext->thread()->workerReportingProxy().workerContextClosed();
}
virtual bool isCleanupTask() const { return true; }
};
WorkerContext::WorkerContext(const KURL& url, const String& userAgent, WorkerThread* thread, const String& policy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
: m_url(url)
, m_userAgent(userAgent)
, m_script(adoptPtr(new WorkerScriptController(this)))
, m_thread(thread)
#if ENABLE(INSPECTOR)
, m_workerInspectorController(adoptPtr(new WorkerInspectorController(this)))
#endif
, m_closing(false)
, m_eventQueue(WorkerEventQueue::create(this))
{
setSecurityOrigin(SecurityOrigin::create(url));
setContentSecurityPolicy(ContentSecurityPolicy::create(this));
contentSecurityPolicy()->didReceiveHeader(policy, contentSecurityPolicyType);
}
WorkerContext::~WorkerContext()
{
ASSERT(currentThread() == thread()->threadID());
notifyObserversOfStop();
thread()->workerReportingProxy().workerContextDestroyed();
}
ScriptExecutionContext* WorkerContext::scriptExecutionContext() const
{
return const_cast<WorkerContext*>(this);
}
const KURL& WorkerContext::virtualURL() const
{
return m_url;
}
KURL WorkerContext::virtualCompleteURL(const String& url) const
{
return completeURL(url);
}
KURL WorkerContext::completeURL(const String& url) const
{
if (url.isNull())
return KURL();
return KURL(m_url, url);
}
String WorkerContext::userAgent(const KURL&) const
{
return m_userAgent;
}
void WorkerContext::disableEval()
{
m_script->disableEval();
}
WorkerLocation* WorkerContext::location() const
{
if (!m_location)
m_location = WorkerLocation::create(m_url);
return m_location.get();
}
void WorkerContext::close()
{
if (m_closing)
return;
m_closing = true;
postTask(CloseWorkerContextTask::create());
}
WorkerNavigator* WorkerContext::navigator() const
{
if (!m_navigator)
m_navigator = WorkerNavigator::create(m_userAgent);
return m_navigator.get();
}
bool WorkerContext::hasPendingActivity() const
{
ActiveDOMObjectsMap& activeObjects = activeDOMObjects();
ActiveDOMObjectsMap::const_iterator activeObjectsEnd = activeObjects.end();
for (ActiveDOMObjectsMap::const_iterator iter = activeObjects.begin(); iter != activeObjectsEnd; ++iter) {
if (iter->first->hasPendingActivity())
return true;
}
HashSet<MessagePort*>::const_iterator messagePortsEnd = messagePorts().end();
for (HashSet<MessagePort*>::const_iterator iter = messagePorts().begin(); iter != messagePortsEnd; ++iter) {
if ((*iter)->hasPendingActivity())
return true;
}
return false;
}
void WorkerContext::postTask(PassOwnPtr<Task> task)
{
thread()->runLoop().postTask(task);
}
int WorkerContext::setTimeout(PassOwnPtr<ScheduledAction> action, int timeout)
{
return DOMTimer::install(scriptExecutionContext(), action, timeout, true);
}
void WorkerContext::clearTimeout(int timeoutId)
{
DOMTimer::removeById(scriptExecutionContext(), timeoutId);
}
#if ENABLE(INSPECTOR)
void WorkerContext::clearInspector()
{
m_workerInspectorController.clear();
}
#endif
int WorkerContext::setInterval(PassOwnPtr<ScheduledAction> action, int timeout)
{
return DOMTimer::install(scriptExecutionContext(), action, timeout, false);
}
void WorkerContext::clearInterval(int timeoutId)
{
DOMTimer::removeById(scriptExecutionContext(), timeoutId);
}
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) {
RefPtr<WorkerScriptLoader> scriptLoader(WorkerScriptLoader::create());
#if PLATFORM(CHROMIUM) || PLATFORM(BLACKBERRY)
scriptLoader->setTargetType(ResourceRequest::TargetIsScript);
#endif
scriptLoader->loadSynchronously(scriptExecutionContext(), *it, AllowCrossOriginRequests);
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;
}
}
}
EventTarget* WorkerContext::errorEventTarget()
{
return this;
}
void WorkerContext::logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, PassRefPtr<ScriptCallStack>)
{
thread()->workerReportingProxy().postExceptionToWorkerObject(errorMessage, lineNumber, sourceURL);
}
void WorkerContext::addMessage(MessageSource source, MessageType type, MessageLevel level, const String& message, const String& sourceURL, unsigned lineNumber, PassRefPtr<ScriptCallStack> callStack)
{
if (!isContextThread()) {
postTask(AddConsoleMessageTask::create(source, type, level, message));
return;
}
thread()->workerReportingProxy().postConsoleMessageToWorkerObject(source, type, level, message, lineNumber, sourceURL);
addMessageToWorkerConsole(source, type, level, message, sourceURL, lineNumber, callStack);
}
void WorkerContext::addMessageToWorkerConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, const String& sourceURL, unsigned lineNumber, PassRefPtr<ScriptCallStack> callStack)
{
ASSERT(isContextThread());
if (callStack)
InspectorInstrumentation::addMessageToConsole(this, source, type, level, message, 0, callStack);
else
InspectorInstrumentation::addMessageToConsole(this, source, type, level, message, sourceURL, lineNumber);
}
bool WorkerContext::isContextThread() const
{
return currentThread() == thread()->threadID();
}
bool WorkerContext::isJSExecutionForbidden() const
{
return m_script->isExecutionForbidden();
}
EventTargetData* WorkerContext::eventTargetData()
{
return &m_eventTargetData;
}
EventTargetData* WorkerContext::ensureEventTargetData()
{
return &m_eventTargetData;
}
WorkerContext::Observer::Observer(WorkerContext* context)
: m_context(context)
{
ASSERT(m_context && m_context->isContextThread());
m_context->registerObserver(this);
}
WorkerContext::Observer::~Observer()
{
if (!m_context)
return;
ASSERT(m_context->isContextThread());
m_context->unregisterObserver(this);
}
void WorkerContext::Observer::stopObserving()
{
if (!m_context)
return;
ASSERT(m_context->isContextThread());
m_context->unregisterObserver(this);
m_context = 0;
}
void WorkerContext::registerObserver(Observer* observer)
{
ASSERT(observer);
m_workerObservers.add(observer);
}
void WorkerContext::unregisterObserver(Observer* observer)
{
ASSERT(observer);
m_workerObservers.remove(observer);
}
void WorkerContext::notifyObserversOfStop()
{
HashSet<Observer*>::iterator iter = m_workerObservers.begin();
while (iter != m_workerObservers.end()) {
WorkerContext::Observer* observer = *iter;
observer->stopObserving();
observer->notifyStop();
iter = m_workerObservers.begin();
}
}
WorkerEventQueue* WorkerContext::eventQueue() const
{
return m_eventQueue.get();
}
}
#endif // ENABLE(WORKERS)