mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
509 lines
14 KiB
C++
509 lines
14 KiB
C++
/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is Web Workers.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* The Mozilla Foundation.
|
|
* Portions created by the Initial Developer are Copyright (C) 2011
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Ben Turner <bent.mozilla@gmail.com> (Original Author)
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
#include "Worker.h"
|
|
|
|
#include "jsapi.h"
|
|
#include "jsfriendapi.h"
|
|
|
|
#include "EventTarget.h"
|
|
#include "RuntimeService.h"
|
|
#include "WorkerPrivate.h"
|
|
|
|
#include "WorkerInlines.h"
|
|
|
|
#define PROPERTY_FLAGS \
|
|
JSPROP_ENUMERATE | JSPROP_SHARED
|
|
|
|
#define FUNCTION_FLAGS \
|
|
JSPROP_ENUMERATE
|
|
|
|
USING_WORKERS_NAMESPACE
|
|
|
|
namespace {
|
|
|
|
class Worker
|
|
{
|
|
static JSClass sClass;
|
|
static JSPropertySpec sProperties[];
|
|
static JSFunctionSpec sFunctions[];
|
|
|
|
enum
|
|
{
|
|
STRING_onerror = 0,
|
|
STRING_onmessage,
|
|
|
|
STRING_COUNT
|
|
};
|
|
|
|
static const char* const sEventStrings[STRING_COUNT];
|
|
|
|
protected:
|
|
enum {
|
|
// The constructor function holds a WorkerPrivate* in its first reserved
|
|
// slot.
|
|
CONSTRUCTOR_SLOT_PARENT = 0
|
|
};
|
|
|
|
public:
|
|
static JSClass*
|
|
Class()
|
|
{
|
|
return &sClass;
|
|
}
|
|
|
|
static JSObject*
|
|
InitClass(JSContext* aCx, JSObject* aObj, JSObject* aParentProto,
|
|
bool aMainRuntime)
|
|
{
|
|
JSObject* proto = js::InitClassWithReserved(aCx, aObj, aParentProto, &sClass, Construct,
|
|
0, sProperties, sFunctions, NULL, NULL);
|
|
if (!proto) {
|
|
return NULL;
|
|
}
|
|
|
|
if (!aMainRuntime) {
|
|
WorkerPrivate* parent = GetWorkerPrivateFromContext(aCx);
|
|
parent->AssertIsOnWorkerThread();
|
|
|
|
JSObject* constructor = JS_GetConstructor(aCx, proto);
|
|
if (!constructor)
|
|
return NULL;
|
|
js::SetFunctionNativeReserved(constructor, CONSTRUCTOR_SLOT_PARENT,
|
|
PRIVATE_TO_JSVAL(parent));
|
|
}
|
|
|
|
return proto;
|
|
}
|
|
|
|
static void
|
|
ClearPrivateSlot(JSContext* aCx, JSObject* aObj, bool aSaveEventHandlers)
|
|
{
|
|
JS_ASSERT(!JS_IsExceptionPending(aCx));
|
|
|
|
WorkerPrivate* worker = GetJSPrivateSafeish<WorkerPrivate>(aCx, aObj);
|
|
JS_ASSERT(worker);
|
|
|
|
if (aSaveEventHandlers) {
|
|
for (int index = 0; index < STRING_COUNT; index++) {
|
|
const char* name = sEventStrings[index];
|
|
jsval listener;
|
|
if (!worker->GetEventListenerOnEventTarget(aCx, name + 2, &listener) ||
|
|
!JS_DefineProperty(aCx, aObj, name, listener, NULL, NULL,
|
|
(PROPERTY_FLAGS & ~JSPROP_SHARED))) {
|
|
JS_ClearPendingException(aCx);
|
|
}
|
|
}
|
|
}
|
|
|
|
SetJSPrivateSafeish(aCx, aObj, NULL);
|
|
}
|
|
|
|
static WorkerPrivate*
|
|
GetInstancePrivate(JSContext* aCx, JSObject* aObj, const char* aFunctionName);
|
|
|
|
protected:
|
|
static JSBool
|
|
ConstructInternal(JSContext* aCx, uintN aArgc, jsval* aVp,
|
|
bool aIsChromeWorker)
|
|
{
|
|
if (!aArgc) {
|
|
JS_ReportError(aCx, "Constructor requires at least one argument!");
|
|
return false;
|
|
}
|
|
|
|
JSString* scriptURL = JS_ValueToString(aCx, JS_ARGV(aCx, aVp)[0]);
|
|
if (!scriptURL) {
|
|
return false;
|
|
}
|
|
|
|
jsval priv = js::GetFunctionNativeReserved(JSVAL_TO_OBJECT(JS_CALLEE(aCx, aVp)),
|
|
CONSTRUCTOR_SLOT_PARENT);
|
|
|
|
RuntimeService* runtimeService;
|
|
WorkerPrivate* parent;
|
|
|
|
if (JSVAL_IS_VOID(priv)) {
|
|
runtimeService = RuntimeService::GetOrCreateService();
|
|
if (!runtimeService) {
|
|
JS_ReportError(aCx, "Failed to create runtime service!");
|
|
return false;
|
|
}
|
|
parent = NULL;
|
|
}
|
|
else {
|
|
runtimeService = RuntimeService::GetService();
|
|
parent = static_cast<WorkerPrivate*>(JSVAL_TO_PRIVATE(priv));
|
|
parent->AssertIsOnWorkerThread();
|
|
}
|
|
|
|
JSObject* obj = JS_NewObject(aCx, &sClass, nsnull, nsnull);
|
|
if (!obj) {
|
|
return false;
|
|
}
|
|
|
|
WorkerPrivate* worker = WorkerPrivate::Create(aCx, obj, parent, scriptURL,
|
|
aIsChromeWorker);
|
|
if (!worker) {
|
|
return false;
|
|
}
|
|
|
|
// Worker now owned by the JS object.
|
|
SetJSPrivateSafeish(aCx, obj, worker);
|
|
|
|
if (!runtimeService->RegisterWorker(aCx, worker)) {
|
|
return false;
|
|
}
|
|
|
|
JS_SET_RVAL(aCx, aVp, OBJECT_TO_JSVAL(obj));
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
// No instance of this class should ever be created so these are explicitly
|
|
// left without an implementation to prevent linking in case someone tries to
|
|
// make one.
|
|
Worker();
|
|
~Worker();
|
|
|
|
static JSBool
|
|
GetEventListener(JSContext* aCx, JSObject* aObj, jsid aIdval, jsval* aVp)
|
|
{
|
|
JS_ASSERT(JSID_IS_INT(aIdval));
|
|
JS_ASSERT(JSID_TO_INT(aIdval) >= 0 && JSID_TO_INT(aIdval) < STRING_COUNT);
|
|
|
|
const char* name = sEventStrings[JSID_TO_INT(aIdval)];
|
|
WorkerPrivate* worker = GetInstancePrivate(aCx, aObj, name);
|
|
if (!worker) {
|
|
return !JS_IsExceptionPending(aCx);
|
|
}
|
|
|
|
return worker->GetEventListenerOnEventTarget(aCx, name + 2, aVp);
|
|
}
|
|
|
|
static JSBool
|
|
SetEventListener(JSContext* aCx, JSObject* aObj, jsid aIdval, JSBool aStrict,
|
|
jsval* aVp)
|
|
{
|
|
JS_ASSERT(JSID_IS_INT(aIdval));
|
|
JS_ASSERT(JSID_TO_INT(aIdval) >= 0 && JSID_TO_INT(aIdval) < STRING_COUNT);
|
|
|
|
const char* name = sEventStrings[JSID_TO_INT(aIdval)];
|
|
WorkerPrivate* worker = GetInstancePrivate(aCx, aObj, name);
|
|
if (!worker) {
|
|
return !JS_IsExceptionPending(aCx);
|
|
}
|
|
|
|
return worker->SetEventListenerOnEventTarget(aCx, name + 2, aVp);
|
|
}
|
|
|
|
static JSBool
|
|
Construct(JSContext* aCx, uintN aArgc, jsval* aVp)
|
|
{
|
|
return ConstructInternal(aCx, aArgc, aVp, false);
|
|
}
|
|
|
|
static void
|
|
Finalize(JSContext* aCx, JSObject* aObj)
|
|
{
|
|
JS_ASSERT(JS_GET_CLASS(aCx, aObj) == &sClass);
|
|
WorkerPrivate* worker = GetJSPrivateSafeish<WorkerPrivate>(aCx, aObj);
|
|
if (worker) {
|
|
worker->FinalizeInstance(aCx, true);
|
|
}
|
|
}
|
|
|
|
static void
|
|
Trace(JSTracer* aTrc, JSObject* aObj)
|
|
{
|
|
JS_ASSERT(JS_GET_CLASS(aTrc->context, aObj) == &sClass);
|
|
WorkerPrivate* worker =
|
|
GetJSPrivateSafeish<WorkerPrivate>(aTrc->context, aObj);
|
|
if (worker) {
|
|
worker->TraceInstance(aTrc);
|
|
}
|
|
}
|
|
|
|
static JSBool
|
|
Terminate(JSContext* aCx, uintN aArgc, jsval* aVp)
|
|
{
|
|
JSObject* obj = JS_THIS_OBJECT(aCx, aVp);
|
|
if (!obj) {
|
|
return false;
|
|
}
|
|
|
|
const char*& name = sFunctions[0].name;
|
|
WorkerPrivate* worker = GetInstancePrivate(aCx, obj, name);
|
|
if (!worker) {
|
|
return !JS_IsExceptionPending(aCx);
|
|
}
|
|
|
|
return worker->Terminate(aCx);
|
|
}
|
|
|
|
static JSBool
|
|
PostMessage(JSContext* aCx, uintN aArgc, jsval* aVp)
|
|
{
|
|
JSObject* obj = JS_THIS_OBJECT(aCx, aVp);
|
|
if (!obj) {
|
|
return false;
|
|
}
|
|
|
|
const char*& name = sFunctions[1].name;
|
|
WorkerPrivate* worker = GetInstancePrivate(aCx, obj, name);
|
|
if (!worker) {
|
|
return !JS_IsExceptionPending(aCx);
|
|
}
|
|
|
|
jsval message;
|
|
if (!JS_ConvertArguments(aCx, aArgc, JS_ARGV(aCx, aVp), "v", &message)) {
|
|
return false;
|
|
}
|
|
|
|
return worker->PostMessage(aCx, message);
|
|
}
|
|
};
|
|
|
|
JSClass Worker::sClass = {
|
|
"Worker",
|
|
JSCLASS_HAS_PRIVATE,
|
|
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
|
|
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, Finalize, NULL, NULL, NULL,
|
|
NULL, NULL, NULL, Trace, NULL
|
|
};
|
|
|
|
JSPropertySpec Worker::sProperties[] = {
|
|
{ sEventStrings[STRING_onerror], STRING_onerror, PROPERTY_FLAGS,
|
|
GetEventListener, SetEventListener },
|
|
{ sEventStrings[STRING_onmessage], STRING_onmessage, PROPERTY_FLAGS,
|
|
GetEventListener, SetEventListener },
|
|
{ 0, 0, 0, NULL, NULL }
|
|
};
|
|
|
|
JSFunctionSpec Worker::sFunctions[] = {
|
|
JS_FN("terminate", Terminate, 0, FUNCTION_FLAGS),
|
|
JS_FN("postMessage", PostMessage, 1, FUNCTION_FLAGS),
|
|
JS_FS_END
|
|
};
|
|
|
|
const char* const Worker::sEventStrings[STRING_COUNT] = {
|
|
"onerror",
|
|
"onmessage"
|
|
};
|
|
|
|
class ChromeWorker : public Worker
|
|
{
|
|
static JSClass sClass;
|
|
|
|
public:
|
|
static JSClass*
|
|
Class()
|
|
{
|
|
return &sClass;
|
|
}
|
|
|
|
static JSObject*
|
|
InitClass(JSContext* aCx, JSObject* aObj, JSObject* aParentProto,
|
|
bool aMainRuntime)
|
|
{
|
|
JSObject* proto = js::InitClassWithReserved(aCx, aObj, aParentProto, &sClass, Construct,
|
|
0, NULL, NULL, NULL, NULL);
|
|
if (!proto) {
|
|
return NULL;
|
|
}
|
|
|
|
if (!aMainRuntime) {
|
|
WorkerPrivate* parent = GetWorkerPrivateFromContext(aCx);
|
|
parent->AssertIsOnWorkerThread();
|
|
|
|
JSObject* constructor = JS_GetConstructor(aCx, proto);
|
|
if (!constructor)
|
|
return NULL;
|
|
js::SetFunctionNativeReserved(constructor, CONSTRUCTOR_SLOT_PARENT,
|
|
PRIVATE_TO_JSVAL(parent));
|
|
}
|
|
|
|
return proto;
|
|
}
|
|
|
|
static void
|
|
ClearPrivateSlot(JSContext* aCx, JSObject* aObj, bool aSaveEventHandlers)
|
|
{
|
|
Worker::ClearPrivateSlot(aCx, aObj, aSaveEventHandlers);
|
|
}
|
|
|
|
private:
|
|
// No instance of this class should ever be created so these are explicitly
|
|
// left without an implementation to prevent linking in case someone tries to
|
|
// make one.
|
|
ChromeWorker();
|
|
~ChromeWorker();
|
|
|
|
static WorkerPrivate*
|
|
GetInstancePrivate(JSContext* aCx, JSObject* aObj, const char* aFunctionName)
|
|
{
|
|
if (aObj) {
|
|
JSClass* classPtr = JS_GET_CLASS(aCx, aObj);
|
|
if (classPtr == &sClass) {
|
|
return GetJSPrivateSafeish<WorkerPrivate>(aCx, aObj);
|
|
}
|
|
}
|
|
|
|
return Worker::GetInstancePrivate(aCx, aObj, aFunctionName);
|
|
}
|
|
|
|
static JSBool
|
|
Construct(JSContext* aCx, uintN aArgc, jsval* aVp)
|
|
{
|
|
return ConstructInternal(aCx, aArgc, aVp, true);
|
|
}
|
|
|
|
static void
|
|
Finalize(JSContext* aCx, JSObject* aObj)
|
|
{
|
|
JS_ASSERT(JS_GET_CLASS(aCx, aObj) == &sClass);
|
|
WorkerPrivate* worker = GetJSPrivateSafeish<WorkerPrivate>(aCx, aObj);
|
|
if (worker) {
|
|
worker->FinalizeInstance(aCx, true);
|
|
}
|
|
}
|
|
|
|
static void
|
|
Trace(JSTracer* aTrc, JSObject* aObj)
|
|
{
|
|
JS_ASSERT(JS_GET_CLASS(aTrc->context, aObj) == &sClass);
|
|
WorkerPrivate* worker =
|
|
GetJSPrivateSafeish<WorkerPrivate>(aTrc->context, aObj);
|
|
if (worker) {
|
|
worker->TraceInstance(aTrc);
|
|
}
|
|
}
|
|
};
|
|
|
|
JSClass ChromeWorker::sClass = {
|
|
"ChromeWorker",
|
|
JSCLASS_HAS_PRIVATE,
|
|
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
|
|
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, Finalize, NULL, NULL, NULL,
|
|
NULL, NULL, NULL, Trace, NULL
|
|
};
|
|
|
|
WorkerPrivate*
|
|
Worker::GetInstancePrivate(JSContext* aCx, JSObject* aObj,
|
|
const char* aFunctionName)
|
|
{
|
|
JSClass* classPtr = NULL;
|
|
|
|
if (aObj) {
|
|
classPtr = JS_GET_CLASS(aCx, aObj);
|
|
if (classPtr == &sClass || classPtr == ChromeWorker::Class()) {
|
|
return GetJSPrivateSafeish<WorkerPrivate>(aCx, aObj);
|
|
}
|
|
}
|
|
|
|
JS_ReportErrorNumber(aCx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
|
|
sClass.name, aFunctionName,
|
|
classPtr ? classPtr->name : "object");
|
|
return NULL;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
BEGIN_WORKERS_NAMESPACE
|
|
|
|
namespace worker {
|
|
|
|
JSObject*
|
|
InitClass(JSContext* aCx, JSObject* aGlobal, JSObject* aProto,
|
|
bool aMainRuntime)
|
|
{
|
|
return Worker::InitClass(aCx, aGlobal, aProto, aMainRuntime);
|
|
}
|
|
|
|
void
|
|
ClearPrivateSlot(JSContext* aCx, JSObject* aObj, bool aSaveEventHandlers)
|
|
{
|
|
JSClass* clasp = JS_GET_CLASS(aCx, aObj);
|
|
JS_ASSERT(clasp == Worker::Class() || clasp == ChromeWorker::Class());
|
|
|
|
if (clasp == ChromeWorker::Class()) {
|
|
ChromeWorker::ClearPrivateSlot(aCx, aObj, aSaveEventHandlers);
|
|
}
|
|
else {
|
|
Worker::ClearPrivateSlot(aCx, aObj, aSaveEventHandlers);
|
|
}
|
|
}
|
|
|
|
} // namespace worker
|
|
|
|
WorkerCrossThreadDispatcher*
|
|
GetWorkerCrossThreadDispatcher(JSContext* aCx, jsval aWorker)
|
|
{
|
|
if (JSVAL_IS_PRIMITIVE(aWorker)) {
|
|
return NULL;
|
|
}
|
|
|
|
WorkerPrivate* w =
|
|
Worker::GetInstancePrivate(aCx, JSVAL_TO_OBJECT(aWorker),
|
|
"GetWorkerCrossThreadDispatcher");
|
|
if (!w) {
|
|
return NULL;
|
|
}
|
|
return w->GetCrossThreadDispatcher();
|
|
}
|
|
|
|
|
|
namespace chromeworker {
|
|
|
|
bool
|
|
InitClass(JSContext* aCx, JSObject* aGlobal, JSObject* aProto,
|
|
bool aMainRuntime)
|
|
{
|
|
return !!ChromeWorker::InitClass(aCx, aGlobal, aProto, aMainRuntime);
|
|
}
|
|
|
|
} // namespace chromeworker
|
|
|
|
bool
|
|
ClassIsWorker(JSClass* aClass)
|
|
{
|
|
return Worker::Class() == aClass || ChromeWorker::Class() == aClass;
|
|
}
|
|
|
|
END_WORKERS_NAMESPACE
|