#include "config.h"
#if ENABLE(WORKERS)
#include "WorkerContext.h"
#include "ActiveDOMObject.h"
#include "DOMTimer.h"
#include "DOMWindow.h"
#include "Database.h"
#include "ErrorEvent.h"
#include "Event.h"
#include "EventException.h"
#include "InspectorController.h"
#include "MessagePort.h"
#include "NotImplemented.h"
#include "ScriptSourceCode.h"
#include "ScriptValue.h"
#include "SecurityOrigin.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)
#include "NotificationCenter.h"
#endif
namespace WebCore {
class CloseWorkerContextTask : public ScriptExecutionContext::Task {
public:
static PassOwnPtr<CloseWorkerContextTask> create()
{
return 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)
: m_url(url)
, m_userAgent(userAgent)
, m_script(new WorkerScriptController(this))
, m_thread(thread)
, m_closing(false)
, m_reportingException(false)
{
setSecurityOrigin(SecurityOrigin::create(url));
}
WorkerContext::~WorkerContext()
{
ASSERT(currentThread() == thread()->threadID());
#if ENABLE(NOTIFICATIONS)
m_notifications.clear();
#endif
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;
}
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;
m_script->forbidExecution(WorkerScriptController::LetRunningScriptFinish);
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() || ((*iter)->isEntangled() && !(*iter)->locallyEntangledPort()))
return true;
}
return false;
}
void WorkerContext::postTask(PassOwnPtr<Task> task)
{
thread()->runLoop().postTask(task);
}
int WorkerContext::setTimeout(ScheduledAction* action, int timeout)
{
return DOMTimer::install(scriptExecutionContext(), action, timeout, true);
}
void WorkerContext::clearTimeout(int timeoutId)
{
DOMTimer::removeById(scriptExecutionContext(), timeoutId);
}
int WorkerContext::setInterval(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) {
WorkerScriptLoader scriptLoader(ResourceRequestBase::TargetIsScript);
scriptLoader.loadSynchronously(scriptExecutionContext(), *it, AllowCrossOriginRequests);
if (scriptLoader.failed()) {
ec = XMLHttpRequestException::NETWORK_ERR;
return;
}
#if ENABLE(INSPECTOR)
if (InspectorController* inspector = scriptExecutionContext()->inspectorController())
inspector->scriptImported(scriptLoader.identifier(), scriptLoader.script());
#endif
ScriptValue exception;
m_script->evaluate(ScriptSourceCode(scriptLoader.script(), *it), &exception);
if (!exception.hasNoValue()) {
m_script->setException(exception);
return;
}
}
}
void WorkerContext::reportException(const String& errorMessage, int lineNumber, const String& sourceURL)
{
bool errorHandled = false;
if (!m_reportingException) {
if (onerror()) {
m_reportingException = true;
RefPtr<ErrorEvent> errorEvent(ErrorEvent::create(errorMessage, sourceURL, lineNumber));
onerror()->handleEvent(this, errorEvent.get());
errorHandled = errorEvent->defaultPrevented();
m_reportingException = false;
}
}
if (!errorHandled)
thread()->workerReportingProxy().postExceptionToWorkerObject(errorMessage, lineNumber, sourceURL);
}
void WorkerContext::addMessage(MessageSource source, MessageType type, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceURL)
{
thread()->workerReportingProxy().postConsoleMessageToWorkerObject(source, type, level, message, lineNumber, sourceURL);
}
#if ENABLE(NOTIFICATIONS)
NotificationCenter* WorkerContext::webkitNotifications() const
{
if (!m_notifications)
m_notifications = NotificationCenter::create(scriptExecutionContext(), m_thread->getNotificationPresenter());
return m_notifications.get();
}
#endif
#if ENABLE(DATABASE)
PassRefPtr<Database> WorkerContext::openDatabase(const String& name, const String& version, const String& displayName, unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback, ExceptionCode& ec)
{
if (!securityOrigin()->canAccessDatabase()) {
ec = SECURITY_ERR;
return 0;
}
ASSERT(Database::isAvailable());
if (!Database::isAvailable())
return 0;
return Database::openDatabase(this, name, version, displayName, estimatedSize, creationCallback, ec);
}
#endif
bool WorkerContext::isContextThread() const
{
return currentThread() == thread()->threadID();
}
bool WorkerContext::isJSExecutionTerminated() const
{
return m_script->isExecutionForbidden();
}
EventTargetData* WorkerContext::eventTargetData()
{
return &m_eventTargetData;
}
EventTargetData* WorkerContext::ensureEventTargetData()
{
return &m_eventTargetData;
}
}
#endif // ENABLE(WORKERS)