WorkerContextExecutionProxy.cpp [plain text]
#include "config.h"
#if ENABLE(WORKERS)
#include "WorkerContextExecutionProxy.h"
#include "V8Binding.h"
#include "V8Proxy.h"
#include "Event.h"
#include "V8WorkerContextEventListener.h"
#include "V8WorkerContextObjectEventListener.h"
#include "Worker.h"
#include "WorkerContext.h"
#include "WorkerLocation.h"
#include "WorkerNavigator.h"
#include "WorkerScriptController.h"
namespace WebCore {
static bool isWorkersEnabled = false;
static void reportFatalErrorInV8(const char* location, const char* message)
{
CRASH();
}
static void handleConsoleMessage(v8::Handle<v8::Message> message, v8::Handle<v8::Value> data)
{
WorkerContextExecutionProxy* proxy = WorkerContextExecutionProxy::retrieve();
if (!proxy)
return;
WorkerContext* workerContext = proxy->workerContext();
if (!workerContext)
return;
v8::Handle<v8::String> errorMessageString = message->Get();
ASSERT(!errorMessageString.IsEmpty());
String errorMessage = ToWebCoreString(errorMessageString);
v8::Handle<v8::Value> resourceName = message->GetScriptResourceName();
bool useURL = (resourceName.IsEmpty() || !resourceName->IsString());
String resourceNameString = useURL ? workerContext->url() : ToWebCoreString(resourceName);
workerContext->addMessage(ConsoleDestination, JSMessageSource, ErrorMessageLevel, errorMessage, message->GetLineNumber(), resourceNameString);
}
bool WorkerContextExecutionProxy::isWebWorkersEnabled()
{
return isWorkersEnabled;
}
void WorkerContextExecutionProxy::setIsWebWorkersEnabled(bool value)
{
isWorkersEnabled = value;
}
WorkerContextExecutionProxy::WorkerContextExecutionProxy(WorkerContext* workerContext)
: m_workerContext(workerContext)
, m_recursion(0)
{
initV8IfNeeded();
}
WorkerContextExecutionProxy::~WorkerContextExecutionProxy()
{
dispose();
}
void WorkerContextExecutionProxy::dispose()
{
if (m_listeners.get())
{
for (V8EventListenerList::iterator iterator(m_listeners->begin()); iterator != m_listeners->end(); ++iterator)
static_cast<V8WorkerContextEventListener*>(*iterator)->disconnect();
{
v8::Locker locker;
m_listeners->clear();
}
}
for (size_t eventIndex = 0; eventIndex < m_events.size(); ++eventIndex) {
Event* event = m_events[eventIndex];
if (forgetV8EventObject(event))
event->deref();
}
m_events.clear();
if (!m_context.IsEmpty()) {
m_context.Dispose();
m_context.Clear();
}
}
WorkerContextExecutionProxy* WorkerContextExecutionProxy::retrieve()
{
v8::Handle<v8::Context> context = v8::Context::GetCurrent();
v8::Handle<v8::Object> global = context->Global();
global = V8Proxy::LookupDOMWrapper(V8ClassIndex::WORKERCONTEXT, global);
if (global.IsEmpty())
return 0;
WorkerContext* workerContext = V8Proxy::ToNativeObject<WorkerContext>(V8ClassIndex::WORKERCONTEXT, global);
return workerContext->script()->proxy();
}
void WorkerContextExecutionProxy::initV8IfNeeded()
{
static bool v8Initialized = false;
v8::Locker locker;
if (v8Initialized)
return;
v8::V8::IgnoreOutOfMemoryException();
v8::V8::SetFatalErrorHandler(reportFatalErrorInV8);
v8::V8::AddMessageListener(handleConsoleMessage);
const int workerThreadPreemptionIntervalMs = 100;
v8::Locker::StartPreemption(workerThreadPreemptionIntervalMs);
v8Initialized = true;
}
void WorkerContextExecutionProxy::initContextIfNeeded()
{
if (!m_context.IsEmpty())
return;
v8::Persistent<v8::ObjectTemplate> globalTemplate;
m_context = v8::Context::New(0, globalTemplate);
v8::Local<v8::Context> context = v8::Local<v8::Context>::New(m_context);
v8::Context::Scope scope(context);
v8::Handle<v8::String> implicitProtoString = v8::String::New("__proto__");
v8::Handle<v8::Function> workerContextConstructor = GetConstructor(V8ClassIndex::WORKERCONTEXT);
v8::Local<v8::Object> jsWorkerContext = SafeAllocation::NewInstance(workerContextConstructor);
if (jsWorkerContext.IsEmpty()) {
dispose();
return;
}
V8Proxy::SetDOMWrapper(jsWorkerContext, V8ClassIndex::ToInt(V8ClassIndex::WORKERCONTEXT), m_workerContext);
V8Proxy::SetJSWrapperForDOMObject(m_workerContext, v8::Persistent<v8::Object>::New(jsWorkerContext));
m_workerContext->ref();
v8::Handle<v8::Object> globalObject = m_context->Global();
globalObject->Set(implicitProtoString, jsWorkerContext);
m_listeners.set(new V8EventListenerList());
}
v8::Local<v8::Function> WorkerContextExecutionProxy::GetConstructor(V8ClassIndex::V8WrapperType type)
{
v8::Context::Scope scope(m_context);
v8::Handle<v8::FunctionTemplate> functionTemplate = V8Proxy::GetTemplate(type);
v8::TryCatch tryCatch;
v8::Local<v8::Function> value = functionTemplate->GetFunction();
if (value.IsEmpty())
return v8::Local<v8::Function>();
return value;
}
v8::Handle<v8::Value> WorkerContextExecutionProxy::ToV8Object(V8ClassIndex::V8WrapperType type, void* impl)
{
if (!impl)
return v8::Null();
if (type == V8ClassIndex::WORKERCONTEXT)
return WorkerContextToV8Object(static_cast<WorkerContext*>(impl));
if (type == V8ClassIndex::WORKER) {
v8::Persistent<v8::Object> result = getActiveDOMObjectMap().get(impl);
if (!result.IsEmpty())
return result;
v8::Local<v8::Object> object = toV8(type, type, impl);
if (!object.IsEmpty())
static_cast<Worker*>(impl)->ref();
result = v8::Persistent<v8::Object>::New(object);
V8Proxy::SetJSWrapperForDOMObject(impl, result);
return result;
}
v8::Persistent<v8::Object> result = domObjectMap().get(impl);
if (result.IsEmpty()) {
v8::Local<v8::Object> object = toV8(type, type, impl);
if (!object.IsEmpty()) {
switch (type) {
case V8ClassIndex::WORKERLOCATION:
static_cast<WorkerLocation*>(impl)->ref();
break;
case V8ClassIndex::WORKERNAVIGATOR:
static_cast<WorkerNavigator*>(impl)->ref();
break;
default:
ASSERT(false);
}
result = v8::Persistent<v8::Object>::New(object);
V8Proxy::SetJSWrapperForDOMObject(impl, result);
}
}
return result;
}
v8::Handle<v8::Value> WorkerContextExecutionProxy::EventToV8Object(Event* event)
{
if (!event)
return v8::Null();
v8::Handle<v8::Object> wrapper = domObjectMap().get(event);
if (!wrapper.IsEmpty())
return wrapper;
V8ClassIndex::V8WrapperType type = V8ClassIndex::EVENT;
if (event->isMessageEvent())
type = V8ClassIndex::MESSAGEEVENT;
v8::Handle<v8::Object> result = toV8(type, V8ClassIndex::EVENT, event);
if (result.IsEmpty()) {
return v8::Null();
}
event->ref(); V8Proxy::SetJSWrapperForDOMObject(event, v8::Persistent<v8::Object>::New(result));
return result;
}
v8::Handle<v8::Value> WorkerContextExecutionProxy::EventTargetToV8Object(EventTarget* target)
{
if (!target)
return v8::Null();
WorkerContext* workerContext = target->toWorkerContext();
if (workerContext)
return WorkerContextToV8Object(workerContext);
Worker* worker = target->toWorker();
if (worker)
return ToV8Object(V8ClassIndex::WORKER, worker);
ASSERT_NOT_REACHED();
return v8::Handle<v8::Value>();
}
v8::Handle<v8::Value> WorkerContextExecutionProxy::WorkerContextToV8Object(WorkerContext* workerContext)
{
if (!workerContext)
return v8::Null();
v8::Handle<v8::Context> context = workerContext->script()->proxy()->GetContext();
v8::Handle<v8::Object> global = context->Global();
ASSERT(!global.IsEmpty());
return global;
}
v8::Local<v8::Object> WorkerContextExecutionProxy::toV8(V8ClassIndex::V8WrapperType descType, V8ClassIndex::V8WrapperType cptrType, void* impl)
{
v8::Local<v8::Function> function;
WorkerContextExecutionProxy* proxy = retrieve();
if (proxy)
function = proxy->GetConstructor(descType);
else
function = V8Proxy::GetTemplate(descType)->GetFunction();
v8::Local<v8::Object> instance = SafeAllocation::NewInstance(function);
if (!instance.IsEmpty()) {
V8Proxy::SetDOMWrapper(instance, V8ClassIndex::ToInt(cptrType), impl);
}
return instance;
}
bool WorkerContextExecutionProxy::forgetV8EventObject(Event* event)
{
if (domObjectMap().contains(event)) {
domObjectMap().forget(event);
return true;
} else
return false;
}
v8::Local<v8::Value> WorkerContextExecutionProxy::evaluate(const String& script, const String& fileName, int baseLine)
{
v8::Locker locker;
v8::HandleScope hs;
initContextIfNeeded();
v8::Context::Scope scope(m_context);
v8::Local<v8::String> scriptString = v8ExternalString(script);
v8::Handle<v8::Script> compiledScript = V8Proxy::CompileScript(scriptString, fileName, baseLine);
return runScript(compiledScript);
}
v8::Local<v8::Value> WorkerContextExecutionProxy::runScript(v8::Handle<v8::Script> script)
{
if (script.IsEmpty())
return v8::Local<v8::Value>();
if (m_recursion >= kMaxRecursionDepth) {
v8::Local<v8::String> code = v8ExternalString("throw RangeError('Recursion too deep')");
script = V8Proxy::CompileScript(code, "", 0);
}
if (V8Proxy::HandleOutOfMemory())
ASSERT(script.IsEmpty());
if (script.IsEmpty())
return v8::Local<v8::Value>();
v8::Local<v8::Value> result;
{
m_recursion++;
result = script->Run();
m_recursion--;
}
if (result.IsEmpty())
return v8::Local<v8::Value>();
return result;
}
PassRefPtr<V8EventListener> WorkerContextExecutionProxy::findOrCreateEventListenerHelper(v8::Local<v8::Value> object, bool isInline, bool findOnly, bool createObjectEventListener)
{
if (!object->IsObject())
return 0;
V8EventListener* listener = m_listeners->find(object->ToObject(), isInline);
if (findOnly)
return listener;
RefPtr<V8EventListener> newListener;
if (createObjectEventListener)
newListener = V8WorkerContextObjectEventListener::create(this, v8::Local<v8::Object>::Cast(object), isInline);
else
newListener = V8WorkerContextEventListener::create(this, v8::Local<v8::Object>::Cast(object), isInline);
{
v8::Locker locker;
m_listeners->add(newListener.get());
}
return newListener.release();
}
PassRefPtr<V8EventListener> WorkerContextExecutionProxy::findOrCreateEventListener(v8::Local<v8::Value> object, bool isInline, bool findOnly)
{
return findOrCreateEventListenerHelper(object, isInline, findOnly, false);
}
PassRefPtr<V8EventListener> WorkerContextExecutionProxy::findOrCreateObjectEventListener(v8::Local<v8::Value> object, bool isInline, bool findOnly)
{
return findOrCreateEventListenerHelper(object, isInline, findOnly, true);
}
void WorkerContextExecutionProxy::RemoveEventListener(V8EventListener* listener)
{
v8::Locker locker;
m_listeners->remove(listener);
}
void WorkerContextExecutionProxy::trackEvent(Event* event)
{
m_events.append(event);
}
}
#endif // ENABLE(WORKERS)