mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
696 lines
28 KiB
C++
696 lines
28 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
* 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 js_Proxy_h
|
|
#define js_Proxy_h
|
|
|
|
#include "mozilla/Maybe.h"
|
|
|
|
#include "jsfriendapi.h"
|
|
|
|
#include "js/CallNonGenericMethod.h"
|
|
#include "js/Class.h"
|
|
|
|
namespace js {
|
|
|
|
using JS::AutoIdVector;
|
|
using JS::CallArgs;
|
|
using JS::Handle;
|
|
using JS::HandleId;
|
|
using JS::HandleObject;
|
|
using JS::HandleValue;
|
|
using JS::IsAcceptableThis;
|
|
using JS::MutableHandle;
|
|
using JS::MutableHandleObject;
|
|
using JS::MutableHandleValue;
|
|
using JS::NativeImpl;
|
|
using JS::ObjectOpResult;
|
|
using JS::PrivateValue;
|
|
using JS::Value;
|
|
|
|
class RegExpGuard;
|
|
class JS_FRIEND_API(Wrapper);
|
|
|
|
/*
|
|
* A proxy is a JSObject with highly customizable behavior. ES6 specifies a
|
|
* single kind of proxy, but the customization mechanisms we use to implement
|
|
* ES6 Proxy objects are also useful wherever an object with weird behavior is
|
|
* wanted. Proxies are used to implement:
|
|
*
|
|
* - the scope objects used by the Debugger's frame.eval() method
|
|
* (see js::GetDebugScopeForFunction)
|
|
*
|
|
* - the khuey hack, whereby a whole compartment can be blown away
|
|
* even if other compartments hold references to objects in it
|
|
* (see js::NukeCrossCompartmentWrappers)
|
|
*
|
|
* - XPConnect security wrappers, which protect chrome from malicious content
|
|
* (js/xpconnect/wrappers)
|
|
*
|
|
* - DOM objects with special property behavior, like named getters
|
|
* (dom/bindings/Codegen.py generates these proxies from WebIDL)
|
|
*
|
|
* - semi-transparent use of objects that live in other processes
|
|
* (CPOWs, implemented in js/ipc)
|
|
*
|
|
* ### Proxies and internal methods
|
|
*
|
|
* ES6 draft rev 27 (24 August 2014) specifies 14 internal methods. The runtime
|
|
* semantics of just about everything a script can do to an object is specified
|
|
* in terms of these internal methods. For example:
|
|
*
|
|
* JS code ES6 internal method that gets called
|
|
* --------------------------- --------------------------------
|
|
* obj.prop obj.[[Get]](obj, "prop")
|
|
* "prop" in obj obj.[[HasProperty]]("prop")
|
|
* new obj() obj.[[Construct]](<empty argument List>)
|
|
* for (k in obj) {} obj.[[Enumerate]]()
|
|
*
|
|
* With regard to the implementation of these internal methods, there are three
|
|
* very different kinds of object in SpiderMonkey.
|
|
*
|
|
* 1. Native objects' internal methods are implemented in vm/NativeObject.cpp,
|
|
* with duplicate (but functionally identical) implementations scattered
|
|
* through the ICs and JITs.
|
|
*
|
|
* 2. Certain non-native objects have internal methods that are implemented as
|
|
* magical js::ObjectOps hooks. We're trying to get rid of these.
|
|
*
|
|
* 3. All other objects are proxies. A proxy's internal methods are
|
|
* implemented in C++, as the virtual methods of a C++ object stored on the
|
|
* proxy, known as its handler.
|
|
*
|
|
* This means that just about anything you do to a proxy will end up going
|
|
* through a C++ virtual method call. Possibly several. There's no reason the
|
|
* JITs and ICs can't specialize for particular proxies, based on the handler;
|
|
* but currently we don't do much of this, so the virtual method overhead
|
|
* typically is actually incurred.
|
|
*
|
|
* ### The proxy handler hierarchy
|
|
*
|
|
* A major use case for proxies is to forward each internal method call to
|
|
* another object, known as its target. The target can be an arbitrary JS
|
|
* object. Not every proxy has the notion of a target, however.
|
|
*
|
|
* To minimize code duplication, a set of abstract proxy handler classes is
|
|
* provided, from which other handlers may inherit. These abstract classes are
|
|
* organized in the following hierarchy:
|
|
*
|
|
* BaseProxyHandler
|
|
* |
|
|
* DirectProxyHandler // has a target
|
|
* |
|
|
* Wrapper // can be unwrapped, revealing target
|
|
* | // (see js::CheckedUnwrap)
|
|
* |
|
|
* CrossCompartmentWrapper // target is in another compartment;
|
|
* // implements membrane between compartments
|
|
*
|
|
* Example: Some DOM objects (including all the arraylike DOM objects) are
|
|
* implemented as proxies. Since these objects don't need to forward operations
|
|
* to any underlying JS object, DOMJSProxyHandler directly subclasses
|
|
* BaseProxyHandler.
|
|
*
|
|
* Gecko's security wrappers are examples of cross-compartment wrappers.
|
|
*
|
|
* ### Proxy prototype chains
|
|
*
|
|
* In addition to the normal methods, there are two models for proxy prototype
|
|
* chains.
|
|
*
|
|
* 1. Proxies can use the standard prototype mechanism used throughout the
|
|
* engine. To do so, simply pass a prototype to NewProxyObject() at
|
|
* creation time. All prototype accesses will then "just work" to treat the
|
|
* proxy as a "normal" object.
|
|
*
|
|
* 2. A proxy can implement more complicated prototype semantics (if, for
|
|
* example, it wants to delegate the prototype lookup to a wrapped object)
|
|
* by passing Proxy::LazyProto as the prototype at create time. This
|
|
* guarantees that the getPrototype() handler method will be called every
|
|
* time the object's prototype chain is accessed.
|
|
*
|
|
* This system is implemented with two methods: {get,set}Prototype. The
|
|
* default implementation of setPrototype throws a TypeError. Since it is
|
|
* not possible to create an object without a sense of prototype chain,
|
|
* handlers must implement getPrototype if opting in to the dynamic
|
|
* prototype system.
|
|
*/
|
|
|
|
/*
|
|
* BaseProxyHandler is the most generic kind of proxy handler. It does not make
|
|
* any assumptions about the target. Consequently, it does not provide any
|
|
* default implementation for most methods. As a convenience, a few high-level
|
|
* methods, like get() and set(), are given default implementations that work by
|
|
* calling the low-level methods, like getOwnPropertyDescriptor().
|
|
*
|
|
* Important: If you add a method here, you should probably also add a
|
|
* Proxy::foo entry point with an AutoEnterPolicy. If you don't, you need an
|
|
* explicit override for the method in SecurityWrapper. See bug 945826 comment 0.
|
|
*/
|
|
class JS_FRIEND_API(BaseProxyHandler)
|
|
{
|
|
/*
|
|
* Sometimes it's desirable to designate groups of proxy handlers as "similar".
|
|
* For this, we use the notion of a "family": A consumer-provided opaque pointer
|
|
* that designates the larger group to which this proxy belongs.
|
|
*
|
|
* If it will never be important to differentiate this proxy from others as
|
|
* part of a distinct group, nullptr may be used instead.
|
|
*/
|
|
const void* mFamily;
|
|
|
|
/*
|
|
* Proxy handlers can use mHasPrototype to request the following special
|
|
* treatment from the JS engine:
|
|
*
|
|
* - When mHasPrototype is true, the engine never calls these methods:
|
|
* getPropertyDescriptor, has, set, enumerate, iterate. Instead, for
|
|
* these operations, it calls the "own" methods like
|
|
* getOwnPropertyDescriptor, hasOwn, defineProperty,
|
|
* getOwnEnumerablePropertyKeys, etc., and consults the prototype chain
|
|
* if needed.
|
|
*
|
|
* - When mHasPrototype is true, the engine calls handler->get() only if
|
|
* handler->hasOwn() says an own property exists on the proxy. If not,
|
|
* it consults the prototype chain.
|
|
*
|
|
* This is useful because it frees the ProxyHandler from having to implement
|
|
* any behavior having to do with the prototype chain.
|
|
*/
|
|
bool mHasPrototype;
|
|
|
|
/*
|
|
* All proxies indicate whether they have any sort of interesting security
|
|
* policy that might prevent the caller from doing something it wants to
|
|
* the object. In the case of wrappers, this distinction is used to
|
|
* determine whether the caller may strip off the wrapper if it so desires.
|
|
*/
|
|
bool mHasSecurityPolicy;
|
|
|
|
public:
|
|
explicit MOZ_CONSTEXPR BaseProxyHandler(const void* aFamily, bool aHasPrototype = false,
|
|
bool aHasSecurityPolicy = false)
|
|
: mFamily(aFamily),
|
|
mHasPrototype(aHasPrototype),
|
|
mHasSecurityPolicy(aHasSecurityPolicy)
|
|
{ }
|
|
|
|
bool hasPrototype() const {
|
|
return mHasPrototype;
|
|
}
|
|
|
|
bool hasSecurityPolicy() const {
|
|
return mHasSecurityPolicy;
|
|
}
|
|
|
|
inline const void* family() const {
|
|
return mFamily;
|
|
}
|
|
static size_t offsetOfFamily() {
|
|
return offsetof(BaseProxyHandler, mFamily);
|
|
}
|
|
|
|
virtual bool finalizeInBackground(Value priv) const {
|
|
/*
|
|
* Called on creation of a proxy to determine whether its finalize
|
|
* method can be finalized on the background thread.
|
|
*/
|
|
return true;
|
|
}
|
|
|
|
/* Policy enforcement methods.
|
|
*
|
|
* enter() allows the policy to specify whether the caller may perform |act|
|
|
* on the proxy's |id| property. In the case when |act| is CALL, |id| is
|
|
* generally JSID_VOID.
|
|
*
|
|
* The |act| parameter to enter() specifies the action being performed.
|
|
* If |bp| is false, the method suggests that the caller throw (though it
|
|
* may still decide to squelch the error).
|
|
*
|
|
* We make these OR-able so that assertEnteredPolicy can pass a union of them.
|
|
* For example, get{,Own}PropertyDescriptor is invoked by calls to ::get()
|
|
* ::set(), in addition to being invoked on its own, so there are several
|
|
* valid Actions that could have been entered.
|
|
*/
|
|
typedef uint32_t Action;
|
|
enum {
|
|
NONE = 0x00,
|
|
GET = 0x01,
|
|
SET = 0x02,
|
|
CALL = 0x04,
|
|
ENUMERATE = 0x08,
|
|
GET_PROPERTY_DESCRIPTOR = 0x10
|
|
};
|
|
|
|
virtual bool enter(JSContext* cx, HandleObject wrapper, HandleId id, Action act,
|
|
bool* bp) const;
|
|
|
|
/* Standard internal methods. */
|
|
virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc) const = 0;
|
|
virtual bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
|
|
Handle<JSPropertyDescriptor> desc,
|
|
ObjectOpResult& result) const = 0;
|
|
virtual bool ownPropertyKeys(JSContext* cx, HandleObject proxy,
|
|
AutoIdVector& props) const = 0;
|
|
virtual bool delete_(JSContext* cx, HandleObject proxy, HandleId id,
|
|
ObjectOpResult& result) const = 0;
|
|
|
|
/*
|
|
* Because [[Enumerate]] is one of the standard traps it should be overridden.
|
|
* However for convenience BaseProxyHandler includes a pure virtual implementation,
|
|
* that turns the properties returned by getOwnEnumerablePropertyKeys (and proto walking)
|
|
* into an Iterator object.
|
|
*/
|
|
virtual bool enumerate(JSContext* cx, HandleObject proxy, MutableHandleObject objp) const = 0;
|
|
|
|
/*
|
|
* These methods are standard, but the engine does not normally call them.
|
|
* They're opt-in. See "Proxy prototype chains" above.
|
|
*
|
|
* getPrototype() crashes if called. setPrototype() throws a TypeError.
|
|
*/
|
|
virtual bool getPrototype(JSContext* cx, HandleObject proxy, MutableHandleObject protop) const;
|
|
virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
|
|
ObjectOpResult& result) const;
|
|
|
|
/* Non-standard but conceptual kin to {g,s}etPrototype, so lives here. */
|
|
virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy, bool* succeeded) const;
|
|
|
|
virtual bool preventExtensions(JSContext* cx, HandleObject proxy,
|
|
ObjectOpResult& result) const = 0;
|
|
virtual bool isExtensible(JSContext* cx, HandleObject proxy, bool* extensible) const = 0;
|
|
|
|
/*
|
|
* These standard internal methods are implemented, as a convenience, so
|
|
* that ProxyHandler subclasses don't have to provide every single method.
|
|
*
|
|
* The base-class implementations work by calling getPropertyDescriptor().
|
|
* They do not follow any standard. When in doubt, override them.
|
|
*/
|
|
virtual bool has(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const;
|
|
virtual bool get(JSContext* cx, HandleObject proxy, HandleValue receiver,
|
|
HandleId id, MutableHandleValue vp) const;
|
|
virtual bool set(JSContext* cx, HandleObject proxy, HandleId id, HandleValue v,
|
|
HandleValue receiver, ObjectOpResult& result) const;
|
|
|
|
/*
|
|
* [[Call]] and [[Construct]] are standard internal methods but according
|
|
* to the spec, they are not present on every object.
|
|
*
|
|
* SpiderMonkey never calls a proxy's call()/construct() internal method
|
|
* unless isCallable()/isConstructor() returns true for that proxy.
|
|
*
|
|
* BaseProxyHandler::isCallable()/isConstructor() always return false, and
|
|
* BaseProxyHandler::call()/construct() crash if called. So if you're
|
|
* creating a kind of that is never callable, you don't have to override
|
|
* anything, but otherwise you probably want to override all four.
|
|
*/
|
|
virtual bool call(JSContext* cx, HandleObject proxy, const CallArgs& args) const;
|
|
virtual bool construct(JSContext* cx, HandleObject proxy, const CallArgs& args) const;
|
|
|
|
/* SpiderMonkey extensions. */
|
|
virtual bool getPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc) const;
|
|
virtual bool hasOwn(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const;
|
|
virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy,
|
|
AutoIdVector& props) const;
|
|
virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
|
|
const CallArgs& args) const;
|
|
virtual bool hasInstance(JSContext* cx, HandleObject proxy, MutableHandleValue v, bool* bp) const;
|
|
virtual bool getBuiltinClass(JSContext* cx, HandleObject proxy,
|
|
ESClassValue* classValue) const;
|
|
virtual bool isArray(JSContext* cx, HandleObject proxy, JS::IsArrayAnswer* answer) const;
|
|
virtual const char* className(JSContext* cx, HandleObject proxy) const;
|
|
virtual JSString* fun_toString(JSContext* cx, HandleObject proxy, unsigned indent) const;
|
|
virtual bool regexp_toShared(JSContext* cx, HandleObject proxy, RegExpGuard* g) const;
|
|
virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy, MutableHandleValue vp) const;
|
|
virtual void trace(JSTracer* trc, JSObject* proxy) const;
|
|
virtual void finalize(JSFreeOp* fop, JSObject* proxy) const;
|
|
virtual void objectMoved(JSObject* proxy, const JSObject* old) const;
|
|
|
|
// Allow proxies, wrappers in particular, to specify callability at runtime.
|
|
// Note: These do not take const JSObject*, but they do in spirit.
|
|
// We are not prepared to do this, as there's little const correctness
|
|
// in the external APIs that handle proxies.
|
|
virtual bool isCallable(JSObject* obj) const;
|
|
virtual bool isConstructor(JSObject* obj) const;
|
|
|
|
// These two hooks must be overridden, or not overridden, in tandem -- no
|
|
// overriding just one!
|
|
virtual bool watch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
|
|
JS::HandleObject callable) const;
|
|
virtual bool unwatch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id) const;
|
|
|
|
virtual bool getElements(JSContext* cx, HandleObject proxy, uint32_t begin, uint32_t end,
|
|
ElementAdder* adder) const;
|
|
|
|
/* See comment for weakmapKeyDelegateOp in js/Class.h. */
|
|
virtual JSObject* weakmapKeyDelegate(JSObject* proxy) const;
|
|
virtual bool isScripted() const { return false; }
|
|
};
|
|
|
|
/*
|
|
* DirectProxyHandler includes a notion of a target object. All methods are
|
|
* reimplemented such that they forward their behavior to the target. This
|
|
* allows consumers of this class to forward to another object as transparently
|
|
* and efficiently as possible.
|
|
*
|
|
* Important: If you add a method implementation here, you probably also need
|
|
* to add an override in CrossCompartmentWrapper. If you don't, you risk
|
|
* compartment mismatches. See bug 945826 comment 0.
|
|
*/
|
|
class JS_FRIEND_API(DirectProxyHandler) : public BaseProxyHandler
|
|
{
|
|
public:
|
|
explicit MOZ_CONSTEXPR DirectProxyHandler(const void* aFamily, bool aHasPrototype = false,
|
|
bool aHasSecurityPolicy = false)
|
|
: BaseProxyHandler(aFamily, aHasPrototype, aHasSecurityPolicy)
|
|
{ }
|
|
|
|
/* Standard internal methods. */
|
|
virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<JSPropertyDescriptor> desc) const override;
|
|
virtual bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
|
|
Handle<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 getPrototype(JSContext* cx, HandleObject proxy,
|
|
MutableHandleObject protop) const override;
|
|
virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
|
|
ObjectOpResult& result) const override;
|
|
virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy,
|
|
bool* succeeded) 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, HandleValue receiver,
|
|
HandleId id, MutableHandleValue vp) const override;
|
|
virtual bool set(JSContext* cx, HandleObject proxy, HandleId id, HandleValue v,
|
|
HandleValue receiver, 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;
|
|
|
|
/* SpiderMonkey extensions. */
|
|
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 nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
|
|
const CallArgs& args) const override;
|
|
virtual bool hasInstance(JSContext* cx, HandleObject proxy, MutableHandleValue v,
|
|
bool* bp) const override;
|
|
virtual bool getBuiltinClass(JSContext* cx, HandleObject proxy,
|
|
ESClassValue* classValue) const override;
|
|
virtual bool isArray(JSContext* cx, HandleObject proxy,
|
|
JS::IsArrayAnswer* answer) const override;
|
|
virtual const char* className(JSContext* cx, HandleObject proxy) const override;
|
|
virtual JSString* fun_toString(JSContext* cx, HandleObject proxy,
|
|
unsigned indent) const override;
|
|
virtual bool regexp_toShared(JSContext* cx, HandleObject proxy,
|
|
RegExpGuard* g) const override;
|
|
virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy, MutableHandleValue vp) const override;
|
|
virtual bool isCallable(JSObject* obj) const override;
|
|
virtual JSObject* weakmapKeyDelegate(JSObject* proxy) const override;
|
|
};
|
|
|
|
extern JS_FRIEND_DATA(const js::Class* const) ProxyClassPtr;
|
|
|
|
inline bool IsProxy(const JSObject* obj)
|
|
{
|
|
return GetObjectClass(obj)->isProxy();
|
|
}
|
|
|
|
const uint32_t PROXY_EXTRA_SLOTS = 2;
|
|
|
|
// Layout of the values stored by a proxy. Note that API clients require the
|
|
// private slot to be the first slot in the proxy's values, so that the private
|
|
// slot can be accessed in the same fashion as the first reserved slot, via
|
|
// {Get,Set}ReservedOrProxyPrivateSlot.
|
|
|
|
struct ProxyValueArray
|
|
{
|
|
Value privateSlot;
|
|
Value extraSlots[PROXY_EXTRA_SLOTS];
|
|
|
|
ProxyValueArray()
|
|
: privateSlot(JS::UndefinedValue())
|
|
{
|
|
for (size_t i = 0; i < PROXY_EXTRA_SLOTS; i++)
|
|
extraSlots[i] = JS::UndefinedValue();
|
|
}
|
|
};
|
|
|
|
// All proxies share the same data layout. Following the object's shape and
|
|
// type, the proxy has a ProxyDataLayout structure with a pointer to an array
|
|
// of values and the proxy's handler. This is designed both so that proxies can
|
|
// be easily swapped with other objects (via RemapWrapper) and to mimic the
|
|
// layout of other objects (proxies and other objects have the same size) so
|
|
// that common code can access either type of object.
|
|
//
|
|
// See GetReservedOrProxyPrivateSlot below.
|
|
struct ProxyDataLayout
|
|
{
|
|
ProxyValueArray* values;
|
|
const BaseProxyHandler* handler;
|
|
};
|
|
|
|
const uint32_t ProxyDataOffset = 2 * sizeof(void*);
|
|
|
|
// This method should only be used internally and by the accessors below.
|
|
inline ProxyDataLayout*
|
|
GetProxyDataLayout(JSObject* obj)
|
|
{
|
|
MOZ_ASSERT(IsProxy(obj));
|
|
return reinterpret_cast<ProxyDataLayout*>(reinterpret_cast<uint8_t*>(obj) + ProxyDataOffset);
|
|
}
|
|
|
|
inline const BaseProxyHandler*
|
|
GetProxyHandler(JSObject* obj)
|
|
{
|
|
return GetProxyDataLayout(obj)->handler;
|
|
}
|
|
|
|
inline const Value&
|
|
GetProxyPrivate(JSObject* obj)
|
|
{
|
|
return GetProxyDataLayout(obj)->values->privateSlot;
|
|
}
|
|
|
|
inline JSObject*
|
|
GetProxyTargetObject(JSObject* obj)
|
|
{
|
|
return GetProxyPrivate(obj).toObjectOrNull();
|
|
}
|
|
|
|
inline const Value&
|
|
GetProxyExtra(JSObject* obj, size_t n)
|
|
{
|
|
MOZ_ASSERT(n < PROXY_EXTRA_SLOTS);
|
|
return GetProxyDataLayout(obj)->values->extraSlots[n];
|
|
}
|
|
|
|
inline void
|
|
SetProxyHandler(JSObject* obj, const BaseProxyHandler* handler)
|
|
{
|
|
GetProxyDataLayout(obj)->handler = handler;
|
|
}
|
|
|
|
JS_FRIEND_API(void)
|
|
SetValueInProxy(Value* slot, const Value& value);
|
|
|
|
inline void
|
|
SetProxyExtra(JSObject* obj, size_t n, const Value& extra)
|
|
{
|
|
MOZ_ASSERT(n < PROXY_EXTRA_SLOTS);
|
|
Value* vp = &GetProxyDataLayout(obj)->values->extraSlots[n];
|
|
|
|
// Trigger a barrier before writing the slot.
|
|
if (vp->isMarkable() || extra.isMarkable())
|
|
SetValueInProxy(vp, extra);
|
|
else
|
|
*vp = extra;
|
|
}
|
|
|
|
inline bool
|
|
IsScriptedProxy(JSObject* obj)
|
|
{
|
|
return IsProxy(obj) && GetProxyHandler(obj)->isScripted();
|
|
}
|
|
|
|
inline const Value&
|
|
GetReservedOrProxyPrivateSlot(JSObject* obj, size_t slot)
|
|
{
|
|
MOZ_ASSERT(slot == 0);
|
|
MOZ_ASSERT(slot < JSCLASS_RESERVED_SLOTS(GetObjectClass(obj)) || IsProxy(obj));
|
|
return reinterpret_cast<const shadow::Object*>(obj)->slotRef(slot);
|
|
}
|
|
|
|
inline void
|
|
SetReservedOrProxyPrivateSlot(JSObject* obj, size_t slot, const Value& value)
|
|
{
|
|
MOZ_ASSERT(slot == 0);
|
|
MOZ_ASSERT(slot < JSCLASS_RESERVED_SLOTS(GetObjectClass(obj)) || IsProxy(obj));
|
|
shadow::Object* sobj = reinterpret_cast<shadow::Object*>(obj);
|
|
if (sobj->slotRef(slot).isMarkable() || value.isMarkable())
|
|
SetReservedOrProxyPrivateSlotWithBarrier(obj, slot, value);
|
|
else
|
|
sobj->slotRef(slot) = value;
|
|
}
|
|
|
|
class MOZ_STACK_CLASS ProxyOptions {
|
|
protected:
|
|
/* protected constructor for subclass */
|
|
explicit ProxyOptions(bool singletonArg, bool lazyProtoArg = false)
|
|
: singleton_(singletonArg),
|
|
lazyProto_(lazyProtoArg),
|
|
clasp_(ProxyClassPtr)
|
|
{}
|
|
|
|
public:
|
|
ProxyOptions() : singleton_(false),
|
|
lazyProto_(false),
|
|
clasp_(ProxyClassPtr)
|
|
{}
|
|
|
|
bool singleton() const { return singleton_; }
|
|
ProxyOptions& setSingleton(bool flag) {
|
|
singleton_ = flag;
|
|
return *this;
|
|
}
|
|
|
|
bool lazyProto() const { return lazyProto_; }
|
|
ProxyOptions& setLazyProto(bool flag) {
|
|
lazyProto_ = flag;
|
|
return *this;
|
|
}
|
|
|
|
const Class* clasp() const {
|
|
return clasp_;
|
|
}
|
|
ProxyOptions& setClass(const Class* claspArg) {
|
|
clasp_ = claspArg;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
bool singleton_;
|
|
bool lazyProto_;
|
|
const Class* clasp_;
|
|
};
|
|
|
|
JS_FRIEND_API(JSObject*)
|
|
NewProxyObject(JSContext* cx, const BaseProxyHandler* handler, HandleValue priv,
|
|
JSObject* proto, const ProxyOptions& options = ProxyOptions());
|
|
|
|
JSObject*
|
|
RenewProxyObject(JSContext* cx, JSObject* obj, BaseProxyHandler* handler, Value priv);
|
|
|
|
class JS_FRIEND_API(AutoEnterPolicy)
|
|
{
|
|
public:
|
|
typedef BaseProxyHandler::Action Action;
|
|
AutoEnterPolicy(JSContext* cx, const BaseProxyHandler* handler,
|
|
HandleObject wrapper, HandleId id, Action act, bool mayThrow)
|
|
#ifdef JS_DEBUG
|
|
: context(nullptr)
|
|
#endif
|
|
{
|
|
allow = handler->hasSecurityPolicy() ? handler->enter(cx, wrapper, id, act, &rv)
|
|
: true;
|
|
recordEnter(cx, wrapper, id, act);
|
|
// We want to throw an exception if all of the following are true:
|
|
// * The policy disallowed access.
|
|
// * The policy set rv to false, indicating that we should throw.
|
|
// * The caller did not instruct us to ignore exceptions.
|
|
// * The policy did not throw itself.
|
|
if (!allow && !rv && mayThrow)
|
|
reportErrorIfExceptionIsNotPending(cx, id);
|
|
}
|
|
|
|
virtual ~AutoEnterPolicy() { recordLeave(); }
|
|
inline bool allowed() { return allow; }
|
|
inline bool returnValue() { MOZ_ASSERT(!allowed()); return rv; }
|
|
|
|
protected:
|
|
// no-op constructor for subclass
|
|
AutoEnterPolicy()
|
|
#ifdef JS_DEBUG
|
|
: context(nullptr)
|
|
, enteredAction(BaseProxyHandler::NONE)
|
|
#endif
|
|
{}
|
|
void reportErrorIfExceptionIsNotPending(JSContext* cx, jsid id);
|
|
bool allow;
|
|
bool rv;
|
|
|
|
#ifdef JS_DEBUG
|
|
JSContext* context;
|
|
mozilla::Maybe<HandleObject> enteredProxy;
|
|
mozilla::Maybe<HandleId> enteredId;
|
|
Action enteredAction;
|
|
|
|
// NB: We explicitly don't track the entered action here, because sometimes
|
|
// set() methods do an implicit get() during their implementation, leading
|
|
// to spurious assertions.
|
|
AutoEnterPolicy* prev;
|
|
void recordEnter(JSContext* cx, HandleObject proxy, HandleId id, Action act);
|
|
void recordLeave();
|
|
|
|
friend JS_FRIEND_API(void) assertEnteredPolicy(JSContext* cx, JSObject* proxy, jsid id, Action act);
|
|
#else
|
|
inline void recordEnter(JSContext* cx, JSObject* proxy, jsid id, Action act) {}
|
|
inline void recordLeave() {}
|
|
#endif
|
|
|
|
};
|
|
|
|
#ifdef JS_DEBUG
|
|
class JS_FRIEND_API(AutoWaivePolicy) : public AutoEnterPolicy {
|
|
public:
|
|
AutoWaivePolicy(JSContext* cx, HandleObject proxy, HandleId id,
|
|
BaseProxyHandler::Action act)
|
|
{
|
|
allow = true;
|
|
recordEnter(cx, proxy, id, act);
|
|
}
|
|
};
|
|
#else
|
|
class JS_FRIEND_API(AutoWaivePolicy) {
|
|
public:
|
|
AutoWaivePolicy(JSContext* cx, HandleObject proxy, HandleId id,
|
|
BaseProxyHandler::Action act)
|
|
{}
|
|
};
|
|
#endif
|
|
|
|
#ifdef JS_DEBUG
|
|
extern JS_FRIEND_API(void)
|
|
assertEnteredPolicy(JSContext* cx, JSObject* obj, jsid id,
|
|
BaseProxyHandler::Action act);
|
|
#else
|
|
inline void assertEnteredPolicy(JSContext* cx, JSObject* obj, jsid id,
|
|
BaseProxyHandler::Action act)
|
|
{}
|
|
#endif
|
|
|
|
extern JS_FRIEND_API(JSObject*)
|
|
InitProxyClass(JSContext* cx, JS::HandleObject obj);
|
|
|
|
} /* namespace js */
|
|
|
|
#endif /* js_Proxy_h */
|