#include "config.h"
#if ENABLE(WORKERS)
#include "WorkerContext.h"
#include "ActiveDOMObject.h"
#include "Database.h"
#include "DOMTimer.h"
#include "DOMWindow.h"
#include "Event.h"
#include "EventException.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 {
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)
{
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;
thread()->workerReportingProxy().workerContextClosed();
}
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::resourceRetrievedByXMLHttpRequest(unsigned long, const ScriptString&)
{
notImplemented();
}
void WorkerContext::scriptImported(unsigned long, const String&)
{
notImplemented();
}
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, const String& callerURL, int callerLine, ExceptionCode& ec)
{
#if !ENABLE(INSPECTOR)
UNUSED_PARAM(callerURL);
UNUSED_PARAM(callerLine);
#endif
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;
scriptLoader.loadSynchronously(scriptExecutionContext(), *it, AllowCrossOriginRequests);
if (scriptLoader.failed()) {
ec = XMLHttpRequestException::NETWORK_ERR;
return;
}
scriptExecutionContext()->scriptImported(scriptLoader.identifier(), scriptLoader.script());
#if ENABLE(INSPECTOR)
scriptExecutionContext()->addMessage(InspectorControllerDestination, JSMessageSource, LogMessageType, LogMessageLevel, "Worker script imported: \"" + *it + "\".", callerLine, callerURL);
#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 (onerror())
errorHandled = onerror()->reportError(this, errorMessage, sourceURL, lineNumber);
if (!errorHandled)
thread()->workerReportingProxy().postExceptionToWorkerObject(errorMessage, lineNumber, sourceURL);
}
void WorkerContext::addMessage(MessageDestination destination, MessageSource source, MessageType type, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceURL)
{
thread()->workerReportingProxy().postConsoleMessageToWorkerObject(destination, 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, 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, ec);
}
#endif
bool WorkerContext::isContextThread() const
{
return currentThread() == thread()->threadID();
}
EventTargetData* WorkerContext::eventTargetData()
{
return &m_eventTargetData;
}
EventTargetData* WorkerContext::ensureEventTargetData()
{
return &m_eventTargetData;
}
}
#endif // ENABLE(WORKERS)