WorkerScriptController.cpp [plain text]
#include "config.h"
#if ENABLE(WORKERS)
#include "WorkerScriptController.h"
#include "DOMTimer.h"
#include "ScriptCallStack.h"
#include "ScriptSourceCode.h"
#include "ScriptValue.h"
#include "V8DOMMap.h"
#include "V8Proxy.h"
#include "V8WorkerContext.h"
#include "WorkerContext.h"
#include "WorkerContextExecutionProxy.h"
#include "WorkerObjectProxy.h"
#include "WorkerThread.h"
#include <v8.h>
namespace WebCore {
WorkerScriptController::WorkerScriptController(WorkerContext* workerContext)
: m_workerContext(workerContext)
, m_isolate(v8::Isolate::New())
, m_executionForbidden(false)
, m_executionScheduledToTerminate(false)
{
V8BindingPerIsolateData* data = V8BindingPerIsolateData::create(m_isolate);
data->allStores().append(&m_DOMDataStore);
data->setDOMDataStore(&m_DOMDataStore);
m_isolate->Enter();
m_proxy = adoptPtr(new WorkerContextExecutionProxy(workerContext));
}
WorkerScriptController::~WorkerScriptController()
{
removeAllDOMObjects();
#if PLATFORM(CHROMIUM)
PlatformSupport::didStopWorkerRunLoop(&m_workerContext->thread()->runLoop());
#endif
m_proxy.clear();
m_isolate->Exit();
V8BindingPerIsolateData::dispose(m_isolate);
m_isolate->Dispose();
}
void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode)
{
evaluate(sourceCode, 0);
}
void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, ScriptValue* exception)
{
if (isExecutionForbidden())
return;
WorkerContextExecutionState state;
m_proxy->evaluate(sourceCode.source(), sourceCode.url().string(), sourceCode.startPosition(), &state);
if (state.hadException) {
if (exception)
*exception = state.exception;
else
m_workerContext->reportException(state.errorMessage, state.lineNumber, state.sourceURL, 0);
}
}
void WorkerScriptController::scheduleExecutionTermination()
{
{
MutexLocker locker(m_scheduledTerminationMutex);
m_executionScheduledToTerminate = true;
}
v8::V8::TerminateExecution(m_isolate);
}
bool WorkerScriptController::isExecutionTerminating() const
{
MutexLocker locker(m_scheduledTerminationMutex);
return m_executionScheduledToTerminate;
}
void WorkerScriptController::forbidExecution()
{
ASSERT(m_workerContext->isContextThread());
m_executionForbidden = true;
}
bool WorkerScriptController::isExecutionForbidden() const
{
ASSERT(m_workerContext->isContextThread());
return m_executionForbidden;
}
void WorkerScriptController::disableEval()
{
}
void WorkerScriptController::setException(ScriptValue exception)
{
throwError(*exception.v8Value());
}
WorkerScriptController* WorkerScriptController::controllerForContext()
{
if (!v8::Context::InContext())
return 0;
v8::Handle<v8::Context> context = v8::Context::GetCurrent();
v8::Handle<v8::Object> global = context->Global();
global = V8DOMWrapper::lookupDOMWrapper(V8WorkerContext::GetTemplate(), global);
if (global.IsEmpty())
return 0;
WorkerContext* workerContext = V8WorkerContext::toNative(global);
return workerContext->script();
}
}
#endif // ENABLE(WORKERS)