forked from mirrors/gecko-dev
c4745d28b1
CLOSED TREE Backed out changeset 7613fc978d36 (bug 1142794) Backed out changeset e5f0cb31263d (bug 1142784) Backed out changeset dcd0af73ac84 (bug 1142784) Backed out changeset 034f9c8e79ee (bug 1142784) Backed out changeset ce0ee37e3ca9 (bug 1142775) Backed out changeset 1519b8f2bbba (bug 1142761) Backed out changeset 26fd55677841 (bug 1139683) Backed out changeset 7ebc76a450c3 (bug 1144819) Backed out changeset 92adb459d519 (bug 1143810)
1156 lines
32 KiB
C++
1156 lines
32 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=4 sw=4 et tw=80:
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "WrapperOwner.h"
|
|
#include "JavaScriptLogging.h"
|
|
#include "mozilla/unused.h"
|
|
#include "mozilla/dom/BindingUtils.h"
|
|
#include "jsfriendapi.h"
|
|
#include "js/CharacterEncoding.h"
|
|
#include "xpcprivate.h"
|
|
#include "CPOWTimer.h"
|
|
#include "WrapperFactory.h"
|
|
|
|
#include "nsIRemoteTagService.h"
|
|
|
|
using namespace js;
|
|
using namespace JS;
|
|
using namespace mozilla;
|
|
using namespace mozilla::jsipc;
|
|
|
|
struct AuxCPOWData
|
|
{
|
|
ObjectId id;
|
|
bool isCallable;
|
|
bool isConstructor;
|
|
bool isDOMObject;
|
|
|
|
// The object tag is just some auxilliary information that clients can use
|
|
// however they see fit.
|
|
nsCString objectTag;
|
|
|
|
AuxCPOWData(ObjectId id,
|
|
bool isCallable,
|
|
bool isConstructor,
|
|
bool isDOMObject,
|
|
const nsACString &objectTag)
|
|
: id(id),
|
|
isCallable(isCallable),
|
|
isConstructor(isConstructor),
|
|
isDOMObject(isDOMObject),
|
|
objectTag(objectTag)
|
|
{}
|
|
};
|
|
|
|
WrapperOwner::WrapperOwner(JSRuntime *rt)
|
|
: JavaScriptShared(rt),
|
|
inactive_(false)
|
|
{
|
|
}
|
|
|
|
static inline AuxCPOWData *
|
|
AuxCPOWDataOf(JSObject *obj)
|
|
{
|
|
MOZ_ASSERT(IsCPOW(obj));
|
|
return static_cast<AuxCPOWData *>(GetProxyExtra(obj, 1).toPrivate());
|
|
}
|
|
|
|
static inline WrapperOwner *
|
|
OwnerOf(JSObject *obj)
|
|
{
|
|
MOZ_ASSERT(IsCPOW(obj));
|
|
return reinterpret_cast<WrapperOwner *>(GetProxyExtra(obj, 0).toPrivate());
|
|
}
|
|
|
|
ObjectId
|
|
WrapperOwner::idOfUnchecked(JSObject *obj)
|
|
{
|
|
MOZ_ASSERT(IsCPOW(obj));
|
|
|
|
AuxCPOWData *aux = AuxCPOWDataOf(obj);
|
|
MOZ_ASSERT(!aux->id.isNull());
|
|
return aux->id;
|
|
}
|
|
|
|
ObjectId
|
|
WrapperOwner::idOf(JSObject *obj)
|
|
{
|
|
ObjectId objId = idOfUnchecked(obj);
|
|
MOZ_ASSERT(findCPOWById(objId) == obj);
|
|
return objId;
|
|
}
|
|
|
|
class CPOWProxyHandler : public BaseProxyHandler
|
|
{
|
|
public:
|
|
MOZ_CONSTEXPR CPOWProxyHandler()
|
|
: BaseProxyHandler(&family) {}
|
|
|
|
virtual bool finalizeInBackground(Value priv) const override {
|
|
return false;
|
|
}
|
|
|
|
virtual bool getOwnPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc) const override;
|
|
virtual bool defineProperty(JSContext *cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc,
|
|
ObjectOpResult &result) const override;
|
|
virtual bool ownPropertyKeys(JSContext *cx, HandleObject proxy,
|
|
AutoIdVector &props) const override;
|
|
virtual bool delete_(JSContext *cx, HandleObject proxy, HandleId id,
|
|
ObjectOpResult &result) const override;
|
|
virtual bool enumerate(JSContext *cx, HandleObject proxy, MutableHandleObject objp) const override;
|
|
virtual bool preventExtensions(JSContext *cx, HandleObject proxy,
|
|
ObjectOpResult &result) const override;
|
|
virtual bool isExtensible(JSContext *cx, HandleObject proxy, bool *extensible) const override;
|
|
virtual bool has(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const override;
|
|
virtual bool get(JSContext *cx, HandleObject proxy, HandleObject receiver,
|
|
HandleId id, MutableHandleValue vp) const override;
|
|
virtual bool set(JSContext *cx, JS::HandleObject proxy, JS::HandleObject receiver,
|
|
JS::HandleId id, JS::MutableHandleValue vp,
|
|
JS::ObjectOpResult &result) const override;
|
|
virtual bool call(JSContext *cx, HandleObject proxy, const CallArgs &args) const override;
|
|
virtual bool construct(JSContext *cx, HandleObject proxy, const CallArgs &args) const override;
|
|
|
|
virtual bool getPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc) const override;
|
|
virtual bool hasOwn(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const override;
|
|
virtual bool getOwnEnumerablePropertyKeys(JSContext *cx, HandleObject proxy,
|
|
AutoIdVector &props) const override;
|
|
virtual bool hasInstance(JSContext *cx, HandleObject proxy,
|
|
MutableHandleValue v, bool *bp) const override;
|
|
virtual bool objectClassIs(HandleObject obj, js::ESClassValue classValue,
|
|
JSContext *cx) const override;
|
|
virtual const char* className(JSContext *cx, HandleObject proxy) const override;
|
|
virtual bool regexp_toShared(JSContext *cx, HandleObject proxy, RegExpGuard *g) const override;
|
|
virtual void finalize(JSFreeOp *fop, JSObject *proxy) const override;
|
|
virtual void objectMoved(JSObject *proxy, const JSObject *old) const override;
|
|
virtual bool isCallable(JSObject *obj) const override;
|
|
virtual bool isConstructor(JSObject *obj) const override;
|
|
virtual bool getPrototype(JSContext *cx, HandleObject proxy, MutableHandleObject protop) const override;
|
|
|
|
static const char family;
|
|
static const CPOWProxyHandler singleton;
|
|
};
|
|
|
|
const char CPOWProxyHandler::family = 0;
|
|
const CPOWProxyHandler CPOWProxyHandler::singleton;
|
|
|
|
#define FORWARD(call, args) \
|
|
WrapperOwner *owner = OwnerOf(proxy); \
|
|
if (!owner->active()) { \
|
|
JS_ReportError(cx, "cannot use a CPOW whose process is gone"); \
|
|
return false; \
|
|
} \
|
|
{ \
|
|
CPOWTimer timer; \
|
|
return owner->call args; \
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::getPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc) const
|
|
{
|
|
FORWARD(getPropertyDescriptor, (cx, proxy, id, desc));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::getPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
JSIDVariant idVar;
|
|
if (!toJSIDVariant(cx, id, &idVar))
|
|
return false;
|
|
|
|
ReturnStatus status;
|
|
PPropertyDescriptor result;
|
|
if (!SendGetPropertyDescriptor(objId, idVar, &status, &result))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
if (!ok(cx, status))
|
|
return false;
|
|
|
|
return toDescriptor(cx, result, desc);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::getOwnPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc) const
|
|
{
|
|
FORWARD(getOwnPropertyDescriptor, (cx, proxy, id, desc));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::getOwnPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
JSIDVariant idVar;
|
|
if (!toJSIDVariant(cx, id, &idVar))
|
|
return false;
|
|
|
|
ReturnStatus status;
|
|
PPropertyDescriptor result;
|
|
if (!SendGetOwnPropertyDescriptor(objId, idVar, &status, &result))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
if (!ok(cx, status))
|
|
return false;
|
|
|
|
return toDescriptor(cx, result, desc);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::defineProperty(JSContext *cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc,
|
|
ObjectOpResult &result) const
|
|
{
|
|
FORWARD(defineProperty, (cx, proxy, id, desc, result));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::defineProperty(JSContext *cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc,
|
|
ObjectOpResult &result)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
JSIDVariant idVar;
|
|
if (!toJSIDVariant(cx, id, &idVar))
|
|
return false;
|
|
|
|
PPropertyDescriptor descriptor;
|
|
if (!fromDescriptor(cx, desc, &descriptor))
|
|
return false;
|
|
|
|
ReturnStatus status;
|
|
if (!SendDefineProperty(objId, idVar, descriptor, &status))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
return ok(cx, status, result);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::ownPropertyKeys(JSContext *cx, HandleObject proxy,
|
|
AutoIdVector &props) const
|
|
{
|
|
FORWARD(ownPropertyKeys, (cx, proxy, props));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::ownPropertyKeys(JSContext *cx, HandleObject proxy, AutoIdVector &props)
|
|
{
|
|
return getPropertyKeys(cx, proxy, JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, props);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::delete_(JSContext *cx, HandleObject proxy, HandleId id,
|
|
ObjectOpResult &result) const
|
|
{
|
|
FORWARD(delete_, (cx, proxy, id, result));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::delete_(JSContext *cx, HandleObject proxy, HandleId id, ObjectOpResult &result)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
JSIDVariant idVar;
|
|
if (!toJSIDVariant(cx, id, &idVar))
|
|
return false;
|
|
|
|
ReturnStatus status;
|
|
if (!SendDelete(objId, idVar, &status))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
return ok(cx, status, result);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::enumerate(JSContext *cx, HandleObject proxy, MutableHandleObject objp) const
|
|
{
|
|
// Using a CPOW for the Iterator would slow down for .. in performance, instead
|
|
// call the base hook, that will use our implementation of getOwnEnumerablePropertyKeys
|
|
// and follow the proto chain.
|
|
return BaseProxyHandler::enumerate(cx, proxy, objp);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::has(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const
|
|
{
|
|
FORWARD(has, (cx, proxy, id, bp));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::has(JSContext *cx, HandleObject proxy, HandleId id, bool *bp)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
JSIDVariant idVar;
|
|
if (!toJSIDVariant(cx, id, &idVar))
|
|
return false;
|
|
|
|
ReturnStatus status;
|
|
if (!SendHas(objId, idVar, &status, bp))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
return ok(cx, status);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::hasOwn(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const
|
|
{
|
|
FORWARD(hasOwn, (cx, proxy, id, bp));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::hasOwn(JSContext *cx, HandleObject proxy, HandleId id, bool *bp)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
JSIDVariant idVar;
|
|
if (!toJSIDVariant(cx, id, &idVar))
|
|
return false;
|
|
|
|
ReturnStatus status;
|
|
if (!SendHasOwn(objId, idVar, &status, bp))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
return !!ok(cx, status);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::get(JSContext *cx, HandleObject proxy, HandleObject receiver,
|
|
HandleId id, MutableHandleValue vp) const
|
|
{
|
|
FORWARD(get, (cx, proxy, receiver, id, vp));
|
|
}
|
|
|
|
static bool
|
|
CPOWDOMQI(JSContext *cx, unsigned argc, Value *vp)
|
|
{
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
if (!args.thisv().isObject() || !IsCPOW(&args.thisv().toObject())) {
|
|
JS_ReportError(cx, "bad this object passed to special QI");
|
|
return false;
|
|
}
|
|
|
|
RootedObject proxy(cx, &args.thisv().toObject());
|
|
FORWARD(DOMQI, (cx, proxy, args));
|
|
}
|
|
|
|
static bool
|
|
CPOWToString(JSContext *cx, unsigned argc, Value *vp)
|
|
{
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
RootedObject callee(cx, &args.callee());
|
|
RootedValue cpowValue(cx);
|
|
if (!JS_GetProperty(cx, callee, "__cpow__", &cpowValue))
|
|
return false;
|
|
|
|
if (!cpowValue.isObject() || !IsCPOW(&cpowValue.toObject())) {
|
|
JS_ReportError(cx, "CPOWToString called on an incompatible object");
|
|
return false;
|
|
}
|
|
|
|
RootedObject proxy(cx, &cpowValue.toObject());
|
|
FORWARD(toString, (cx, proxy, args));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::toString(JSContext *cx, HandleObject cpow, JS::CallArgs &args)
|
|
{
|
|
// Ask the other side to call its toString method. Update the callee so that
|
|
// it points to the CPOW and not to the synthesized CPOWToString function.
|
|
args.setCallee(ObjectValue(*cpow));
|
|
if (!callOrConstruct(cx, cpow, args, false))
|
|
return false;
|
|
|
|
if (!args.rval().isString())
|
|
return true;
|
|
|
|
RootedString cpowResult(cx, args.rval().toString());
|
|
nsAutoJSString toStringResult;
|
|
if (!toStringResult.init(cx, cpowResult))
|
|
return false;
|
|
|
|
// We don't want to wrap toString() results for things like the location
|
|
// object, where toString() is supposed to return a URL and nothing else.
|
|
nsAutoString result;
|
|
if (toStringResult[0] == '[') {
|
|
result.AppendLiteral("[object CPOW ");
|
|
result += toStringResult;
|
|
result.AppendLiteral("]");
|
|
} else {
|
|
result += toStringResult;
|
|
}
|
|
|
|
JSString *str = JS_NewUCStringCopyN(cx, result.get(), result.Length());
|
|
if (!str)
|
|
return false;
|
|
|
|
args.rval().setString(str);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::DOMQI(JSContext *cx, JS::HandleObject proxy, JS::CallArgs &args)
|
|
{
|
|
// Someone's calling us, handle nsISupports specially to avoid unnecessary
|
|
// CPOW traffic.
|
|
HandleValue id = args[0];
|
|
if (id.isObject()) {
|
|
RootedObject idobj(cx, &id.toObject());
|
|
nsCOMPtr<nsIJSID> jsid;
|
|
|
|
nsresult rv = UnwrapArg<nsIJSID>(idobj, getter_AddRefs(jsid));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
MOZ_ASSERT(jsid, "bad wrapJS");
|
|
const nsID *idptr = jsid->GetID();
|
|
if (idptr->Equals(NS_GET_IID(nsISupports))) {
|
|
args.rval().set(args.thisv());
|
|
return true;
|
|
}
|
|
|
|
// Webidl-implemented DOM objects never have nsIClassInfo.
|
|
if (idptr->Equals(NS_GET_IID(nsIClassInfo)))
|
|
return Throw(cx, NS_ERROR_NO_INTERFACE);
|
|
}
|
|
}
|
|
|
|
// It wasn't nsISupports, call into the other process to do the QI for us
|
|
// (since we don't know what other interfaces our object supports). Note
|
|
// that we have to use JS_GetPropertyDescriptor here to avoid infinite
|
|
// recursion back into CPOWDOMQI via WrapperOwner::get().
|
|
// We could stash the actual QI function on our own function object to avoid
|
|
// if we're called multiple times, but since we're transient, there's no
|
|
// point right now.
|
|
JS::Rooted<JSPropertyDescriptor> propDesc(cx);
|
|
if (!JS_GetPropertyDescriptor(cx, proxy, "QueryInterface", &propDesc))
|
|
return false;
|
|
|
|
if (!propDesc.value().isObject()) {
|
|
MOZ_ASSERT_UNREACHABLE("We didn't get QueryInterface off a node");
|
|
return Throw(cx, NS_ERROR_UNEXPECTED);
|
|
}
|
|
return JS_CallFunctionValue(cx, proxy, propDesc.value(), args, args.rval());
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::get(JSContext *cx, HandleObject proxy, HandleObject receiver,
|
|
HandleId id, MutableHandleValue vp)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
ObjectVariant receiverVar;
|
|
if (!toObjectVariant(cx, receiver, &receiverVar))
|
|
return false;
|
|
|
|
JSIDVariant idVar;
|
|
if (!toJSIDVariant(cx, id, &idVar))
|
|
return false;
|
|
|
|
AuxCPOWData *data = AuxCPOWDataOf(proxy);
|
|
if (data->isDOMObject &&
|
|
idVar.type() == JSIDVariant::TnsString &&
|
|
idVar.get_nsString().EqualsLiteral("QueryInterface"))
|
|
{
|
|
// Handle QueryInterface on DOM Objects specially since we can assume
|
|
// certain things about their implementation.
|
|
RootedFunction qi(cx, JS_NewFunction(cx, CPOWDOMQI, 1, 0,
|
|
"QueryInterface"));
|
|
if (!qi)
|
|
return false;
|
|
|
|
vp.set(ObjectValue(*JS_GetFunctionObject(qi)));
|
|
return true;
|
|
}
|
|
|
|
JSVariant val;
|
|
ReturnStatus status;
|
|
if (!SendGet(objId, receiverVar, idVar, &status, &val))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
if (!ok(cx, status))
|
|
return false;
|
|
|
|
if (!fromVariant(cx, val, vp))
|
|
return false;
|
|
|
|
if (idVar.type() == JSIDVariant::TnsString &&
|
|
idVar.get_nsString().EqualsLiteral("toString")) {
|
|
RootedFunction toString(cx, JS_NewFunction(cx, CPOWToString, 0, 0,
|
|
"toString"));
|
|
if (!toString)
|
|
return false;
|
|
|
|
RootedObject toStringObj(cx, JS_GetFunctionObject(toString));
|
|
|
|
if (!JS_DefineProperty(cx, toStringObj, "__cpow__", vp, JSPROP_PERMANENT | JSPROP_READONLY))
|
|
return false;
|
|
|
|
vp.set(ObjectValue(*toStringObj));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::set(JSContext *cx, JS::HandleObject proxy, JS::HandleObject receiver,
|
|
JS::HandleId id, JS::MutableHandleValue vp, JS::ObjectOpResult &result) const
|
|
{
|
|
FORWARD(set, (cx, proxy, receiver, id, vp, result));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::set(JSContext *cx, JS::HandleObject proxy, JS::HandleObject receiver,
|
|
JS::HandleId id, JS::MutableHandleValue vp, JS::ObjectOpResult &result)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
ObjectVariant receiverVar;
|
|
if (!toObjectVariant(cx, receiver, &receiverVar))
|
|
return false;
|
|
|
|
JSIDVariant idVar;
|
|
if (!toJSIDVariant(cx, id, &idVar))
|
|
return false;
|
|
|
|
JSVariant val;
|
|
if (!toVariant(cx, vp, &val))
|
|
return false;
|
|
|
|
ReturnStatus status;
|
|
JSVariant resultValue;
|
|
if (!SendSet(objId, receiverVar, idVar, val, &status, &resultValue))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
if (!ok(cx, status, result))
|
|
return false;
|
|
|
|
return fromVariant(cx, resultValue, vp);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::getOwnEnumerablePropertyKeys(JSContext *cx, HandleObject proxy,
|
|
AutoIdVector &props) const
|
|
{
|
|
FORWARD(getOwnEnumerablePropertyKeys, (cx, proxy, props));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::getOwnEnumerablePropertyKeys(JSContext *cx, HandleObject proxy, AutoIdVector &props)
|
|
{
|
|
return getPropertyKeys(cx, proxy, JSITER_OWNONLY, props);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::preventExtensions(JSContext *cx, HandleObject proxy, ObjectOpResult &result) const
|
|
{
|
|
FORWARD(preventExtensions, (cx, proxy, result));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::preventExtensions(JSContext *cx, HandleObject proxy, ObjectOpResult &result)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
ReturnStatus status;
|
|
if (!SendPreventExtensions(objId, &status))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
return ok(cx, status, result);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::isExtensible(JSContext *cx, HandleObject proxy, bool *extensible) const
|
|
{
|
|
FORWARD(isExtensible, (cx, proxy, extensible));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::isExtensible(JSContext *cx, HandleObject proxy, bool *extensible)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
ReturnStatus status;
|
|
if (!SendIsExtensible(objId, &status, extensible))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
return ok(cx, status);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::call(JSContext *cx, HandleObject proxy, const CallArgs &args) const
|
|
{
|
|
FORWARD(callOrConstruct, (cx, proxy, args, false));
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::construct(JSContext *cx, HandleObject proxy, const CallArgs &args) const
|
|
{
|
|
FORWARD(callOrConstruct, (cx, proxy, args, true));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::callOrConstruct(JSContext *cx, HandleObject proxy, const CallArgs &args,
|
|
bool construct)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
InfallibleTArray<JSParam> vals;
|
|
AutoValueVector outobjects(cx);
|
|
|
|
RootedValue v(cx);
|
|
for (size_t i = 0; i < args.length() + 2; i++) {
|
|
// The |this| value for constructors is a magic value that we won't be
|
|
// able to convert, so skip it.
|
|
if (i == 1 && construct)
|
|
v = UndefinedValue();
|
|
else
|
|
v = args.base()[i];
|
|
if (v.isObject()) {
|
|
RootedObject obj(cx, &v.toObject());
|
|
if (xpc::IsOutObject(cx, obj)) {
|
|
// Make sure it is not an in-out object.
|
|
bool found;
|
|
if (!JS_HasProperty(cx, obj, "value", &found))
|
|
return false;
|
|
if (found) {
|
|
JS_ReportError(cx, "in-out objects cannot be sent via CPOWs yet");
|
|
return false;
|
|
}
|
|
|
|
vals.AppendElement(JSParam(void_t()));
|
|
if (!outobjects.append(ObjectValue(*obj)))
|
|
return false;
|
|
continue;
|
|
}
|
|
}
|
|
JSVariant val;
|
|
if (!toVariant(cx, v, &val))
|
|
return false;
|
|
vals.AppendElement(JSParam(val));
|
|
}
|
|
|
|
JSVariant result;
|
|
ReturnStatus status;
|
|
InfallibleTArray<JSParam> outparams;
|
|
if (!SendCallOrConstruct(objId, vals, construct, &status, &result, &outparams))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
if (!ok(cx, status))
|
|
return false;
|
|
|
|
if (outparams.Length() != outobjects.length())
|
|
return ipcfail(cx);
|
|
|
|
RootedObject obj(cx);
|
|
for (size_t i = 0; i < outparams.Length(); i++) {
|
|
// Don't bother doing anything for outparams that weren't set.
|
|
if (outparams[i].type() == JSParam::Tvoid_t)
|
|
continue;
|
|
|
|
// Take the value the child process returned, and set it on the XPC
|
|
// object.
|
|
if (!fromVariant(cx, outparams[i], &v))
|
|
return false;
|
|
|
|
obj = &outobjects[i].toObject();
|
|
if (!JS_SetProperty(cx, obj, "value", v))
|
|
return false;
|
|
}
|
|
|
|
if (!fromVariant(cx, result, args.rval()))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::hasInstance(JSContext *cx, HandleObject proxy, MutableHandleValue v, bool *bp) const
|
|
{
|
|
FORWARD(hasInstance, (cx, proxy, v, bp));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::hasInstance(JSContext *cx, HandleObject proxy, MutableHandleValue v, bool *bp)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
JSVariant vVar;
|
|
if (!toVariant(cx, v, &vVar))
|
|
return false;
|
|
|
|
ReturnStatus status;
|
|
JSVariant result;
|
|
if (!SendHasInstance(objId, vVar, &status, bp))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
return ok(cx, status);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::objectClassIs(HandleObject proxy, js::ESClassValue classValue, JSContext *cx) const
|
|
{
|
|
FORWARD(objectClassIs, (cx, proxy, classValue));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::objectClassIs(JSContext *cx, HandleObject proxy, js::ESClassValue classValue)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
// This function is assumed infallible, so we just return false if the IPC
|
|
// channel fails.
|
|
bool result;
|
|
if (!SendObjectClassIs(objId, classValue, &result))
|
|
return false;
|
|
|
|
LOG_STACK();
|
|
|
|
return result;
|
|
}
|
|
|
|
const char *
|
|
CPOWProxyHandler::className(JSContext *cx, HandleObject proxy) const
|
|
{
|
|
WrapperOwner *parent = OwnerOf(proxy);
|
|
if (!parent->active())
|
|
return "<dead CPOW>";
|
|
return parent->className(cx, proxy);
|
|
}
|
|
|
|
const char *
|
|
WrapperOwner::className(JSContext *cx, HandleObject proxy)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
nsString name;
|
|
if (!SendClassName(objId, &name))
|
|
return "<error>";
|
|
|
|
LOG_STACK();
|
|
|
|
return ToNewCString(name);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::getPrototype(JSContext *cx, HandleObject proxy, MutableHandleObject objp) const
|
|
{
|
|
FORWARD(getPrototype, (cx, proxy, objp));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::getPrototype(JSContext *cx, HandleObject proxy, MutableHandleObject objp)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
ObjectOrNullVariant val;
|
|
ReturnStatus status;
|
|
if (!SendGetPrototype(objId, &status, &val))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
if (!ok(cx, status))
|
|
return false;
|
|
|
|
objp.set(fromObjectOrNullVariant(cx, val));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::regexp_toShared(JSContext *cx, HandleObject proxy, RegExpGuard *g) const
|
|
{
|
|
FORWARD(regexp_toShared, (cx, proxy, g));
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::regexp_toShared(JSContext *cx, HandleObject proxy, RegExpGuard *g)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
ReturnStatus status;
|
|
nsString source;
|
|
unsigned flags = 0;
|
|
if (!SendRegExpToShared(objId, &status, &source, &flags))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
if (!ok(cx, status))
|
|
return false;
|
|
|
|
RootedObject regexp(cx);
|
|
RootedObject global(cx, JS::CurrentGlobalOrNull(cx));
|
|
regexp = JS_NewUCRegExpObject(cx, global, source.get(), source.Length(), flags);
|
|
if (!regexp)
|
|
return false;
|
|
|
|
return js::RegExpToSharedNonInline(cx, regexp, g);
|
|
}
|
|
|
|
void
|
|
CPOWProxyHandler::finalize(JSFreeOp *fop, JSObject *proxy) const
|
|
{
|
|
AuxCPOWData *aux = AuxCPOWDataOf(proxy);
|
|
|
|
OwnerOf(proxy)->drop(proxy);
|
|
|
|
if (aux)
|
|
delete aux;
|
|
}
|
|
|
|
void
|
|
CPOWProxyHandler::objectMoved(JSObject *proxy, const JSObject *old) const
|
|
{
|
|
OwnerOf(proxy)->updatePointer(proxy, old);
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::isCallable(JSObject *proxy) const
|
|
{
|
|
AuxCPOWData *aux = AuxCPOWDataOf(proxy);
|
|
return aux->isCallable;
|
|
}
|
|
|
|
bool
|
|
CPOWProxyHandler::isConstructor(JSObject *proxy) const
|
|
{
|
|
AuxCPOWData *aux = AuxCPOWDataOf(proxy);
|
|
return aux->isConstructor;
|
|
}
|
|
|
|
void
|
|
WrapperOwner::drop(JSObject *obj)
|
|
{
|
|
ObjectId objId = idOf(obj);
|
|
|
|
cpows_.remove(objId);
|
|
if (active())
|
|
unused << SendDropObject(objId);
|
|
decref();
|
|
}
|
|
|
|
void
|
|
WrapperOwner::updatePointer(JSObject *obj, const JSObject *old)
|
|
{
|
|
ObjectId objId = idOfUnchecked(obj);
|
|
MOZ_ASSERT(findCPOWById(objId) == old);
|
|
cpows_.add(objId, obj);
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::init()
|
|
{
|
|
if (!JavaScriptShared::init())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::getPropertyKeys(JSContext *cx, HandleObject proxy, uint32_t flags, AutoIdVector &props)
|
|
{
|
|
ObjectId objId = idOf(proxy);
|
|
|
|
ReturnStatus status;
|
|
InfallibleTArray<JSIDVariant> ids;
|
|
if (!SendGetPropertyKeys(objId, flags, &status, &ids))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
if (!ok(cx, status))
|
|
return false;
|
|
|
|
for (size_t i = 0; i < ids.Length(); i++) {
|
|
RootedId id(cx);
|
|
if (!fromJSIDVariant(cx, ids[i], &id))
|
|
return false;
|
|
if (!props.append(id))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
namespace mozilla {
|
|
namespace jsipc {
|
|
|
|
bool
|
|
IsCPOW(JSObject *obj)
|
|
{
|
|
return IsProxy(obj) && GetProxyHandler(obj) == &CPOWProxyHandler::singleton;
|
|
}
|
|
|
|
bool
|
|
IsWrappedCPOW(JSObject *obj)
|
|
{
|
|
JSObject *unwrapped = js::UncheckedUnwrap(obj, true);
|
|
if (!unwrapped)
|
|
return false;
|
|
return IsCPOW(unwrapped);
|
|
}
|
|
|
|
void
|
|
GetWrappedCPOWTag(JSObject *obj, nsACString &out)
|
|
{
|
|
JSObject *unwrapped = js::UncheckedUnwrap(obj, true);
|
|
MOZ_ASSERT(IsCPOW(unwrapped));
|
|
|
|
AuxCPOWData *aux = AuxCPOWDataOf(unwrapped);
|
|
if (aux)
|
|
out = aux->objectTag;
|
|
}
|
|
|
|
nsresult
|
|
InstanceOf(JSObject *proxy, const nsID *id, bool *bp)
|
|
{
|
|
WrapperOwner *parent = OwnerOf(proxy);
|
|
if (!parent->active())
|
|
return NS_ERROR_UNEXPECTED;
|
|
return parent->instanceOf(proxy, id, bp);
|
|
}
|
|
|
|
bool
|
|
DOMInstanceOf(JSContext *cx, JSObject *proxy, int prototypeID, int depth, bool *bp)
|
|
{
|
|
FORWARD(domInstanceOf, (cx, proxy, prototypeID, depth, bp));
|
|
}
|
|
|
|
} /* namespace jsipc */
|
|
} /* namespace mozilla */
|
|
|
|
nsresult
|
|
WrapperOwner::instanceOf(JSObject *obj, const nsID *id, bool *bp)
|
|
{
|
|
ObjectId objId = idOf(obj);
|
|
|
|
JSIID iid;
|
|
ConvertID(*id, &iid);
|
|
|
|
ReturnStatus status;
|
|
if (!SendInstanceOf(objId, iid, &status, bp))
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
if (status.type() != ReturnStatus::TReturnSuccess)
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::domInstanceOf(JSContext *cx, JSObject *obj, int prototypeID, int depth, bool *bp)
|
|
{
|
|
ObjectId objId = idOf(obj);
|
|
|
|
ReturnStatus status;
|
|
if (!SendDOMInstanceOf(objId, prototypeID, depth, &status, bp))
|
|
return ipcfail(cx);
|
|
|
|
LOG_STACK();
|
|
|
|
return ok(cx, status);
|
|
}
|
|
|
|
void
|
|
WrapperOwner::ActorDestroy(ActorDestroyReason why)
|
|
{
|
|
inactive_ = true;
|
|
|
|
objects_.clear();
|
|
unwaivedObjectIds_.clear();
|
|
waivedObjectIds_.clear();
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::ipcfail(JSContext *cx)
|
|
{
|
|
JS_ReportError(cx, "child process crashed or timedout");
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::ok(JSContext *cx, const ReturnStatus &status)
|
|
{
|
|
if (status.type() == ReturnStatus::TReturnSuccess)
|
|
return true;
|
|
|
|
if (status.type() == ReturnStatus::TReturnStopIteration)
|
|
return JS_ThrowStopIteration(cx);
|
|
|
|
RootedValue exn(cx);
|
|
if (!fromVariant(cx, status.get_ReturnException().exn(), &exn))
|
|
return false;
|
|
|
|
JS_SetPendingException(cx, exn);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::ok(JSContext *cx, const ReturnStatus &status, ObjectOpResult &result)
|
|
{
|
|
if (status.type() == ReturnStatus::TReturnObjectOpResult)
|
|
return result.fail(status.get_ReturnObjectOpResult().code());
|
|
if (!ok(cx, status))
|
|
return false;
|
|
return result.succeed();
|
|
}
|
|
|
|
static RemoteObject
|
|
MakeRemoteObject(JSContext *cx, ObjectId id, HandleObject obj)
|
|
{
|
|
nsCString objectTag;
|
|
|
|
nsCOMPtr<nsIRemoteTagService> service =
|
|
do_GetService("@mozilla.org/addons/remote-tag-service;1");
|
|
if (service) {
|
|
RootedValue objVal(cx, ObjectValue(*obj));
|
|
service->GetRemoteObjectTag(objVal, objectTag);
|
|
}
|
|
|
|
return RemoteObject(id.serialize(),
|
|
JS::IsCallable(obj),
|
|
JS::IsConstructor(obj),
|
|
dom::IsDOMObject(obj),
|
|
objectTag);
|
|
}
|
|
|
|
bool
|
|
WrapperOwner::toObjectVariant(JSContext *cx, JSObject *objArg, ObjectVariant *objVarp)
|
|
{
|
|
RootedObject obj(cx, objArg);
|
|
MOZ_ASSERT(obj);
|
|
|
|
// We always save objects unwrapped in the CPOW table. If we stored
|
|
// wrappers, then the wrapper might be GCed while the target remained alive.
|
|
// Whenever operating on an object that comes from the table, we wrap it
|
|
// in findObjectById.
|
|
unsigned wrapperFlags = 0;
|
|
obj = js::UncheckedUnwrap(obj, true, &wrapperFlags);
|
|
if (obj && IsCPOW(obj) && OwnerOf(obj) == this) {
|
|
*objVarp = LocalObject(idOf(obj).serialize());
|
|
return true;
|
|
}
|
|
bool waiveXray = wrapperFlags & xpc::WrapperFactory::WAIVE_XRAY_WRAPPER_FLAG;
|
|
|
|
ObjectId id = objectIdMap(waiveXray).find(obj);
|
|
if (!id.isNull()) {
|
|
MOZ_ASSERT(id.hasXrayWaiver() == waiveXray);
|
|
*objVarp = MakeRemoteObject(cx, id, obj);
|
|
return true;
|
|
}
|
|
|
|
// Need to call PreserveWrapper on |obj| in case it's a reflector.
|
|
// FIXME: What if it's an XPCWrappedNative?
|
|
if (mozilla::dom::IsDOMObject(obj))
|
|
mozilla::dom::TryPreserveWrapper(obj);
|
|
|
|
id = ObjectId(nextSerialNumber_++, waiveXray);
|
|
if (!objects_.add(id, obj))
|
|
return false;
|
|
if (!objectIdMap(waiveXray).add(cx, obj, id))
|
|
return false;
|
|
|
|
*objVarp = MakeRemoteObject(cx, id, obj);
|
|
return true;
|
|
}
|
|
|
|
JSObject *
|
|
WrapperOwner::fromObjectVariant(JSContext *cx, ObjectVariant objVar)
|
|
{
|
|
if (objVar.type() == ObjectVariant::TRemoteObject) {
|
|
return fromRemoteObjectVariant(cx, objVar.get_RemoteObject());
|
|
} else {
|
|
return fromLocalObjectVariant(cx, objVar.get_LocalObject());
|
|
}
|
|
}
|
|
|
|
JSObject *
|
|
WrapperOwner::fromRemoteObjectVariant(JSContext *cx, RemoteObject objVar)
|
|
{
|
|
ObjectId objId = ObjectId::deserialize(objVar.serializedId());
|
|
RootedObject obj(cx, findCPOWById(objId));
|
|
if (!obj) {
|
|
|
|
// All CPOWs live in the privileged junk scope.
|
|
RootedObject junkScope(cx, xpc::PrivilegedJunkScope());
|
|
JSAutoCompartment ac(cx, junkScope);
|
|
RootedValue v(cx, UndefinedValue());
|
|
// We need to setLazyProto for the getPrototype hook.
|
|
ProxyOptions options;
|
|
options.setLazyProto(true);
|
|
obj = NewProxyObject(cx,
|
|
&CPOWProxyHandler::singleton,
|
|
v,
|
|
nullptr,
|
|
options);
|
|
if (!obj)
|
|
return nullptr;
|
|
|
|
if (!cpows_.add(objId, obj))
|
|
return nullptr;
|
|
|
|
// Incref once we know the decref will be called.
|
|
incref();
|
|
|
|
AuxCPOWData *aux = new AuxCPOWData(objId,
|
|
objVar.isCallable(),
|
|
objVar.isConstructor(),
|
|
objVar.isDOMObject(),
|
|
objVar.objectTag());
|
|
|
|
SetProxyExtra(obj, 0, PrivateValue(this));
|
|
SetProxyExtra(obj, 1, PrivateValue(aux));
|
|
}
|
|
|
|
if (!JS_WrapObject(cx, &obj))
|
|
return nullptr;
|
|
return obj;
|
|
}
|
|
|
|
JSObject *
|
|
WrapperOwner::fromLocalObjectVariant(JSContext *cx, LocalObject objVar)
|
|
{
|
|
ObjectId id = ObjectId::deserialize(objVar.serializedId());
|
|
Rooted<JSObject*> obj(cx, findObjectById(cx, id));
|
|
if (!obj)
|
|
return nullptr;
|
|
if (!JS_WrapObject(cx, &obj))
|
|
return nullptr;
|
|
return obj;
|
|
}
|