mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
ba1d6a9c71
While adding the CPOW flag for xray waivers, I discovered a bunch of inconsistency and sloppiness with respect to our handling of object ids, and a general lack of clarity about when the id included flags or not. Given the fact that I'm removing static callability for CPOWs, we _could_ just get rid of the flags, and store the xray waiver state on the answer-side only. But I eventually decided that these kinds of flags (which are accessible to both the Answer _and_ the Owner) had enough potential utility that they were worth cleaning up. It's worth noting that that utility comes with the large caveat that the flags can't be trusted for security-sensitive decisions (at least in the parent->child case), since they could be forged by a compromised child.
229 lines
10 KiB
C++
229 lines
10 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 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/. */
|
|
|
|
#ifndef mozilla_jsipc_JavaScriptBase_h__
|
|
#define mozilla_jsipc_JavaScriptBase_h__
|
|
|
|
#include "WrapperAnswer.h"
|
|
#include "WrapperOwner.h"
|
|
#include "mozilla/dom/DOMTypes.h"
|
|
#include "mozilla/jsipc/PJavaScript.h"
|
|
|
|
namespace mozilla {
|
|
namespace jsipc {
|
|
|
|
template<class Base>
|
|
class JavaScriptBase : public WrapperOwner, public WrapperAnswer, public Base
|
|
{
|
|
typedef WrapperAnswer Answer;
|
|
|
|
public:
|
|
explicit JavaScriptBase(JSRuntime *rt)
|
|
: JavaScriptShared(rt),
|
|
WrapperOwner(rt),
|
|
WrapperAnswer(rt)
|
|
{}
|
|
virtual ~JavaScriptBase() {}
|
|
|
|
virtual void ActorDestroy(WrapperOwner::ActorDestroyReason why) {
|
|
WrapperOwner::ActorDestroy(why);
|
|
}
|
|
|
|
/*** IPC handlers ***/
|
|
|
|
bool AnswerPreventExtensions(const uint64_t &objId, ReturnStatus *rs) {
|
|
return Answer::AnswerPreventExtensions(ObjectId::deserialize(objId), rs);
|
|
}
|
|
bool AnswerGetPropertyDescriptor(const uint64_t &objId, const nsString &id,
|
|
ReturnStatus *rs,
|
|
PPropertyDescriptor *out) {
|
|
return Answer::AnswerGetPropertyDescriptor(ObjectId::deserialize(objId), id, rs, out);
|
|
}
|
|
bool AnswerGetOwnPropertyDescriptor(const uint64_t &objId,
|
|
const nsString &id,
|
|
ReturnStatus *rs,
|
|
PPropertyDescriptor *out) {
|
|
return Answer::AnswerGetOwnPropertyDescriptor(ObjectId::deserialize(objId), id, rs, out);
|
|
}
|
|
bool AnswerDefineProperty(const uint64_t &objId, const nsString &id,
|
|
const PPropertyDescriptor &flags,
|
|
ReturnStatus *rs) {
|
|
return Answer::AnswerDefineProperty(ObjectId::deserialize(objId), id, flags, rs);
|
|
}
|
|
bool AnswerDelete(const uint64_t &objId, const nsString &id,
|
|
ReturnStatus *rs, bool *success) {
|
|
return Answer::AnswerDelete(ObjectId::deserialize(objId), id, rs, success);
|
|
}
|
|
|
|
bool AnswerHas(const uint64_t &objId, const nsString &id,
|
|
ReturnStatus *rs, bool *bp) {
|
|
return Answer::AnswerHas(ObjectId::deserialize(objId), id, rs, bp);
|
|
}
|
|
bool AnswerHasOwn(const uint64_t &objId, const nsString &id,
|
|
ReturnStatus *rs, bool *bp) {
|
|
return Answer::AnswerHasOwn(ObjectId::deserialize(objId), id, rs, bp);
|
|
}
|
|
bool AnswerGet(const uint64_t &objId, const ObjectVariant &receiverVar,
|
|
const nsString &id,
|
|
ReturnStatus *rs, JSVariant *result) {
|
|
return Answer::AnswerGet(ObjectId::deserialize(objId), receiverVar, id, rs, result);
|
|
}
|
|
bool AnswerSet(const uint64_t &objId, const ObjectVariant &receiverVar,
|
|
const nsString &id, const bool &strict,
|
|
const JSVariant &value, ReturnStatus *rs, JSVariant *result) {
|
|
return Answer::AnswerSet(ObjectId::deserialize(objId), receiverVar, id, strict, value, rs, result);
|
|
}
|
|
|
|
bool AnswerIsExtensible(const uint64_t &objId, ReturnStatus *rs,
|
|
bool *result) {
|
|
return Answer::AnswerIsExtensible(ObjectId::deserialize(objId), rs, result);
|
|
}
|
|
bool AnswerCallOrConstruct(const uint64_t &objId, const nsTArray<JSParam> &argv,
|
|
const bool &construct, ReturnStatus *rs, JSVariant *result,
|
|
nsTArray<JSParam> *outparams) {
|
|
return Answer::AnswerCallOrConstruct(ObjectId::deserialize(objId), argv, construct, rs, result, outparams);
|
|
}
|
|
bool AnswerHasInstance(const uint64_t &objId, const JSVariant &v, ReturnStatus *rs, bool *bp) {
|
|
return Answer::AnswerHasInstance(ObjectId::deserialize(objId), v, rs, bp);
|
|
}
|
|
bool AnswerObjectClassIs(const uint64_t &objId, const uint32_t &classValue,
|
|
bool *result) {
|
|
return Answer::AnswerObjectClassIs(ObjectId::deserialize(objId), classValue, result);
|
|
}
|
|
bool AnswerClassName(const uint64_t &objId, nsString *result) {
|
|
return Answer::AnswerClassName(ObjectId::deserialize(objId), result);
|
|
}
|
|
|
|
bool AnswerGetPropertyNames(const uint64_t &objId, const uint32_t &flags,
|
|
ReturnStatus *rs, nsTArray<nsString> *names) {
|
|
return Answer::AnswerGetPropertyNames(ObjectId::deserialize(objId), flags, rs, names);
|
|
}
|
|
bool AnswerInstanceOf(const uint64_t &objId, const JSIID &iid,
|
|
ReturnStatus *rs, bool *instanceof) {
|
|
return Answer::AnswerInstanceOf(ObjectId::deserialize(objId), iid, rs, instanceof);
|
|
}
|
|
bool AnswerDOMInstanceOf(const uint64_t &objId, const int &prototypeID, const int &depth,
|
|
ReturnStatus *rs, bool *instanceof) {
|
|
return Answer::AnswerDOMInstanceOf(ObjectId::deserialize(objId), prototypeID, depth, rs, instanceof);
|
|
}
|
|
|
|
bool AnswerIsCallable(const uint64_t &objId, bool *result) {
|
|
return Answer::AnswerIsCallable(ObjectId::deserialize(objId), result);
|
|
}
|
|
|
|
bool AnswerIsConstructor(const uint64_t &objId, bool *result) {
|
|
return Answer::AnswerIsConstructor(ObjectId::deserialize(objId), result);
|
|
}
|
|
|
|
bool RecvDropObject(const uint64_t &objId) {
|
|
return Answer::RecvDropObject(ObjectId::deserialize(objId));
|
|
}
|
|
|
|
/*** Dummy call handlers ***/
|
|
|
|
bool SendDropObject(const ObjectId &objId) {
|
|
return Base::SendDropObject(objId.serialize());
|
|
}
|
|
bool CallPreventExtensions(const ObjectId &objId, ReturnStatus *rs) {
|
|
return Base::CallPreventExtensions(objId.serialize(), rs);
|
|
}
|
|
bool CallGetPropertyDescriptor(const ObjectId &objId, const nsString &id,
|
|
ReturnStatus *rs,
|
|
PPropertyDescriptor *out) {
|
|
return Base::CallGetPropertyDescriptor(objId.serialize(), id, rs, out);
|
|
}
|
|
bool CallGetOwnPropertyDescriptor(const ObjectId &objId,
|
|
const nsString &id,
|
|
ReturnStatus *rs,
|
|
PPropertyDescriptor *out) {
|
|
return Base::CallGetOwnPropertyDescriptor(objId.serialize(), id, rs, out);
|
|
}
|
|
bool CallDefineProperty(const ObjectId &objId, const nsString &id,
|
|
const PPropertyDescriptor &flags,
|
|
ReturnStatus *rs) {
|
|
return Base::CallDefineProperty(objId.serialize(), id, flags, rs);
|
|
}
|
|
bool CallDelete(const ObjectId &objId, const nsString &id,
|
|
ReturnStatus *rs, bool *success) {
|
|
return Base::CallDelete(objId.serialize(), id, rs, success);
|
|
}
|
|
|
|
bool CallHas(const ObjectId &objId, const nsString &id,
|
|
ReturnStatus *rs, bool *bp) {
|
|
return Base::CallHas(objId.serialize(), id, rs, bp);
|
|
}
|
|
bool CallHasOwn(const ObjectId &objId, const nsString &id,
|
|
ReturnStatus *rs, bool *bp) {
|
|
return Base::CallHasOwn(objId.serialize(), id, rs, bp);
|
|
}
|
|
bool CallGet(const ObjectId &objId, const ObjectVariant &receiverVar,
|
|
const nsString &id,
|
|
ReturnStatus *rs, JSVariant *result) {
|
|
return Base::CallGet(objId.serialize(), receiverVar, id, rs, result);
|
|
}
|
|
bool CallSet(const ObjectId &objId, const ObjectVariant &receiverVar,
|
|
const nsString &id, const bool &strict,
|
|
const JSVariant &value, ReturnStatus *rs, JSVariant *result) {
|
|
return Base::CallSet(objId.serialize(), receiverVar, id, strict, value, rs, result);
|
|
}
|
|
|
|
bool CallIsExtensible(const ObjectId &objId, ReturnStatus *rs,
|
|
bool *result) {
|
|
return Base::CallIsExtensible(objId.serialize(), rs, result);
|
|
}
|
|
bool CallCallOrConstruct(const ObjectId &objId, const nsTArray<JSParam> &argv,
|
|
const bool &construct, ReturnStatus *rs, JSVariant *result,
|
|
nsTArray<JSParam> *outparams) {
|
|
return Base::CallCallOrConstruct(objId.serialize(), argv, construct, rs, result, outparams);
|
|
}
|
|
bool CallHasInstance(const ObjectId &objId, const JSVariant &v, ReturnStatus *rs, bool *bp) {
|
|
return Base::CallHasInstance(objId.serialize(), v, rs, bp);
|
|
}
|
|
bool CallObjectClassIs(const ObjectId &objId, const uint32_t &classValue,
|
|
bool *result) {
|
|
return Base::CallObjectClassIs(objId.serialize(), classValue, result);
|
|
}
|
|
bool CallClassName(const ObjectId &objId, nsString *result) {
|
|
return Base::CallClassName(objId.serialize(), result);
|
|
}
|
|
|
|
bool CallGetPropertyNames(const ObjectId &objId, const uint32_t &flags,
|
|
ReturnStatus *rs, nsTArray<nsString> *names) {
|
|
return Base::CallGetPropertyNames(objId.serialize(), flags, rs, names);
|
|
}
|
|
bool CallInstanceOf(const ObjectId &objId, const JSIID &iid,
|
|
ReturnStatus *rs, bool *instanceof) {
|
|
return Base::CallInstanceOf(objId.serialize(), iid, rs, instanceof);
|
|
}
|
|
bool CallDOMInstanceOf(const ObjectId &objId, const int &prototypeID, const int &depth,
|
|
ReturnStatus *rs, bool *instanceof) {
|
|
return Base::CallDOMInstanceOf(objId.serialize(), prototypeID, depth, rs, instanceof);
|
|
}
|
|
|
|
bool CallIsCallable(const ObjectId &objId, bool *result) {
|
|
return Base::CallIsCallable(objId.serialize(), result);
|
|
}
|
|
|
|
bool CallIsConstructor(const ObjectId &objId, bool *result) {
|
|
return Base::CallIsConstructor(objId.serialize(), result);
|
|
}
|
|
|
|
/* The following code is needed to suppress a bogus MSVC warning (C4250). */
|
|
|
|
virtual bool toObjectVariant(JSContext *cx, JSObject *obj, ObjectVariant *objVarp) {
|
|
return WrapperOwner::toObjectVariant(cx, obj, objVarp);
|
|
}
|
|
virtual JSObject *fromObjectVariant(JSContext *cx, ObjectVariant objVar) {
|
|
return WrapperOwner::fromObjectVariant(cx, objVar);
|
|
}
|
|
};
|
|
|
|
} // namespace jsipc
|
|
} // namespace mozilla
|
|
|
|
#endif
|