2013-04-16 20:47:10 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
2012-05-21 11:12:37 +00:00
|
|
|
* 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/. */
|
2010-05-19 02:21:43 +00:00
|
|
|
|
2014-09-09 21:31:20 +00:00
|
|
|
#ifndef jsproxy_h
|
|
|
|
#define jsproxy_h
|
2010-05-19 02:21:43 +00:00
|
|
|
|
2013-08-27 22:10:28 +00:00
|
|
|
#include "mozilla/Maybe.h"
|
|
|
|
|
2011-10-04 14:06:54 +00:00
|
|
|
#include "jsfriendapi.h"
|
2010-05-19 02:21:43 +00:00
|
|
|
|
2013-08-27 04:39:38 +00:00
|
|
|
#include "js/CallNonGenericMethod.h"
|
2013-08-29 00:20:24 +00:00
|
|
|
#include "js/Class.h"
|
2013-08-27 04:39:38 +00:00
|
|
|
|
2010-05-24 21:33:03 +00:00
|
|
|
namespace js {
|
|
|
|
|
2013-08-29 00:20:24 +00:00
|
|
|
using JS::AutoIdVector;
|
|
|
|
using JS::CallArgs;
|
|
|
|
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::PrivateValue;
|
|
|
|
using JS::Value;
|
|
|
|
|
2013-07-26 04:23:14 +00:00
|
|
|
class RegExpGuard;
|
2012-07-17 16:54:41 +00:00
|
|
|
class JS_FRIEND_API(Wrapper);
|
2012-06-28 02:10:37 +00:00
|
|
|
|
2012-07-08 17:04:14 +00:00
|
|
|
/*
|
|
|
|
* A proxy is a JSObject that implements generic behavior by providing custom
|
|
|
|
* implementations for each object trap. The implementation for each trap is
|
|
|
|
* provided by a C++ object stored on the proxy, known as its handler.
|
|
|
|
*
|
|
|
|
* A major use case for proxies is to forward each trap to another object,
|
|
|
|
* known as its target. The target can be an arbitrary C++ object. Not every
|
|
|
|
* proxy has the notion of a target, however.
|
|
|
|
*
|
|
|
|
* Proxy traps are grouped into fundamental and derived traps. Every proxy has
|
|
|
|
* to at least provide implementations for the fundamental traps, but the
|
2012-10-29 15:52:53 +00:00
|
|
|
* derived traps can be implemented in terms of the fundamental ones
|
|
|
|
* BaseProxyHandler provides implementations of the derived traps in terms of
|
|
|
|
* the (pure virtual) fundamental traps.
|
2012-07-08 17:04:14 +00:00
|
|
|
*
|
2013-12-13 20:01:30 +00:00
|
|
|
* In addition to the normal traps, there are two models for proxy prototype
|
|
|
|
* chains. First, proxies may opt to 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. Alternatively, if instead the proxy wishes to
|
|
|
|
* implement more complicated prototype semantics (if, for example, it wants to
|
|
|
|
* delegate the prototype lookup to a wrapped object), it may pass Proxy::LazyProto
|
|
|
|
* as the prototype at create time and opt in to the trapped prototype system,
|
|
|
|
* which guarantees that their trap will be called on any and every prototype
|
|
|
|
* chain access of the object.
|
|
|
|
*
|
|
|
|
* This system is implemented with two traps: {get,set}PrototypeOf. The default
|
|
|
|
* implementation of setPrototypeOf throws a TypeError. Since it is not possible
|
|
|
|
* to create an object without a sense of prototype chain, handler implementors
|
|
|
|
* must provide a getPrototypeOf trap if opting in to the dynamic prototype system.
|
|
|
|
*
|
2012-07-08 17:04:14 +00:00
|
|
|
* 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
|
2012-10-29 15:52:53 +00:00
|
|
|
* |
|
|
|
|
* Wrapper
|
2012-07-08 17:04:14 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 the fundamental traps. It does, however, implement
|
|
|
|
* the derived traps in terms of the fundamental ones. This allows consumers of
|
|
|
|
* this class to define any custom behavior they want.
|
2013-12-05 20:58:20 +00:00
|
|
|
*
|
|
|
|
* Important: If you add a trap 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 trap in SecurityWrapper. See bug 945826 comment 0.
|
2012-07-08 17:04:14 +00:00
|
|
|
*/
|
2013-03-23 02:43:03 +00:00
|
|
|
class JS_FRIEND_API(BaseProxyHandler)
|
|
|
|
{
|
2014-08-28 00:09:06 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2013-09-24 15:21:22 +00:00
|
|
|
const void *mFamily;
|
2014-04-25 20:07:18 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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" traps like
|
|
|
|
* getOwnPropertyDescriptor, hasOwn, defineProperty, keys, 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.
|
|
|
|
*/
|
2012-08-10 11:55:55 +00:00
|
|
|
bool mHasPrototype;
|
2014-01-29 21:07:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2010-05-19 02:21:43 +00:00
|
|
|
public:
|
2014-08-28 20:47:16 +00:00
|
|
|
explicit MOZ_CONSTEXPR BaseProxyHandler(const void *aFamily, bool aHasPrototype = false,
|
|
|
|
bool aHasSecurityPolicy = false)
|
|
|
|
: mFamily(aFamily),
|
|
|
|
mHasPrototype(aHasPrototype),
|
|
|
|
mHasSecurityPolicy(aHasSecurityPolicy)
|
|
|
|
{ }
|
2010-05-19 02:21:43 +00:00
|
|
|
|
2014-06-27 11:44:04 +00:00
|
|
|
bool hasPrototype() const {
|
2012-08-10 11:55:55 +00:00
|
|
|
return mHasPrototype;
|
|
|
|
}
|
|
|
|
|
2014-06-27 11:44:04 +00:00
|
|
|
bool hasSecurityPolicy() const {
|
2014-01-29 21:07:13 +00:00
|
|
|
return mHasSecurityPolicy;
|
2013-02-25 21:54:18 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 11:44:04 +00:00
|
|
|
inline const void *family() const {
|
2012-06-28 02:10:37 +00:00
|
|
|
return mFamily;
|
2012-06-29 22:59:42 +00:00
|
|
|
}
|
2013-08-11 05:20:36 +00:00
|
|
|
static size_t offsetOfFamily() {
|
|
|
|
return offsetof(BaseProxyHandler, mFamily);
|
|
|
|
}
|
2012-06-28 02:10:37 +00:00
|
|
|
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual bool finalizeInBackground(Value priv) const {
|
2013-02-21 10:19:17 +00:00
|
|
|
/*
|
|
|
|
* Called on creation of a proxy to determine whether its finalize
|
|
|
|
* method can be finalized on the background thread.
|
|
|
|
*/
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-02-25 21:54:18 +00:00
|
|
|
/* Policy enforcement traps.
|
|
|
|
*
|
|
|
|
* 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
|
2013-12-17 02:27:43 +00:00
|
|
|
* generally JSID_VOID.
|
2013-02-25 21:54:18 +00:00
|
|
|
*
|
|
|
|
* The |act| parameter to enter() specifies the action being performed.
|
2013-02-25 21:54:18 +00:00
|
|
|
* If |bp| is false, the trap suggests that the caller throw (though it
|
|
|
|
* may still decide to squelch the error).
|
2014-02-13 18:54:07 +00:00
|
|
|
*
|
|
|
|
* We make these OR-able so that assertEnteredPolicy can pass a union of them.
|
2014-07-30 19:23:03 +00:00
|
|
|
* 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.
|
2013-02-25 21:54:18 +00:00
|
|
|
*/
|
2014-02-13 18:54:07 +00:00
|
|
|
typedef uint32_t Action;
|
2014-02-17 20:59:03 +00:00
|
|
|
enum {
|
|
|
|
NONE = 0x00,
|
|
|
|
GET = 0x01,
|
|
|
|
SET = 0x02,
|
|
|
|
CALL = 0x04,
|
2014-07-30 19:23:03 +00:00
|
|
|
ENUMERATE = 0x08,
|
|
|
|
GET_PROPERTY_DESCRIPTOR = 0x10
|
2014-02-17 20:59:03 +00:00
|
|
|
};
|
2014-02-13 18:54:07 +00:00
|
|
|
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool enter(JSContext *cx, HandleObject wrapper, HandleId id, Action act,
|
2014-06-27 11:44:06 +00:00
|
|
|
bool *bp) const;
|
2013-02-25 21:54:18 +00:00
|
|
|
|
2010-05-19 02:21:43 +00:00
|
|
|
/* ES5 Harmony fundamental proxy traps. */
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual bool preventExtensions(JSContext *cx, HandleObject proxy) const = 0;
|
2013-03-21 22:23:47 +00:00
|
|
|
virtual bool getPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
|
2014-06-27 11:44:06 +00:00
|
|
|
MutableHandle<JSPropertyDescriptor> desc) const = 0;
|
2013-03-21 22:23:47 +00:00
|
|
|
virtual bool getOwnPropertyDescriptor(JSContext *cx, HandleObject proxy,
|
2014-06-27 11:44:06 +00:00
|
|
|
HandleId id, MutableHandle<JSPropertyDescriptor> desc) const = 0;
|
2013-03-21 22:23:47 +00:00
|
|
|
virtual bool defineProperty(JSContext *cx, HandleObject proxy, HandleId id,
|
2014-06-27 11:44:06 +00:00
|
|
|
MutableHandle<JSPropertyDescriptor> desc) const = 0;
|
2013-03-21 22:23:47 +00:00
|
|
|
virtual bool getOwnPropertyNames(JSContext *cx, HandleObject proxy,
|
2014-06-27 11:44:06 +00:00
|
|
|
AutoIdVector &props) const = 0;
|
|
|
|
virtual bool delete_(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const = 0;
|
|
|
|
virtual bool enumerate(JSContext *cx, HandleObject proxy, AutoIdVector &props) const = 0;
|
2010-05-19 02:21:43 +00:00
|
|
|
|
|
|
|
/* ES5 Harmony derived proxy traps. */
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual bool has(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const;
|
|
|
|
virtual bool hasOwn(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool get(JSContext *cx, HandleObject proxy, HandleObject receiver,
|
2014-06-27 11:44:06 +00:00
|
|
|
HandleId id, MutableHandleValue vp) const;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool set(JSContext *cx, HandleObject proxy, HandleObject receiver,
|
2014-06-27 11:44:06 +00:00
|
|
|
HandleId id, bool strict, MutableHandleValue vp) const;
|
|
|
|
virtual bool keys(JSContext *cx, HandleObject proxy, AutoIdVector &props) const;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool iterate(JSContext *cx, HandleObject proxy, unsigned flags,
|
2014-06-27 11:44:06 +00:00
|
|
|
MutableHandleValue vp) const;
|
2010-05-19 02:21:43 +00:00
|
|
|
|
|
|
|
/* Spidermonkey extensions. */
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual bool isExtensible(JSContext *cx, HandleObject proxy, bool *extensible) const = 0;
|
|
|
|
virtual bool call(JSContext *cx, HandleObject proxy, const CallArgs &args) const;
|
|
|
|
virtual bool construct(JSContext *cx, HandleObject proxy, const CallArgs &args) const;
|
|
|
|
virtual bool nativeCall(JSContext *cx, IsAcceptableThis test, NativeImpl impl, CallArgs args) const;
|
|
|
|
virtual bool hasInstance(JSContext *cx, HandleObject proxy, MutableHandleValue v, bool *bp) const;
|
|
|
|
virtual bool objectClassIs(HandleObject obj, ESClassValue classValue, JSContext *cx) 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;
|
2014-08-18 21:18:39 +00:00
|
|
|
virtual bool boxedValue_unbox(JSContext *cx, HandleObject proxy, MutableHandleValue vp) const;
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual bool defaultValue(JSContext *cx, HandleObject obj, JSType hint, MutableHandleValue vp) const;
|
|
|
|
virtual void finalize(JSFreeOp *fop, JSObject *proxy) const;
|
2014-09-02 09:07:22 +00:00
|
|
|
virtual void objectMoved(JSObject *proxy, const JSObject *old) const;
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual bool getPrototypeOf(JSContext *cx, HandleObject proxy, MutableHandleObject protop) const;
|
|
|
|
virtual bool setPrototypeOf(JSContext *cx, HandleObject proxy, HandleObject proto, bool *bp) const;
|
2012-10-09 01:22:47 +00:00
|
|
|
|
2014-09-10 22:52:36 +00:00
|
|
|
// 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;
|
|
|
|
|
2013-10-29 23:39:09 +00:00
|
|
|
// 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,
|
2014-06-27 11:44:06 +00:00
|
|
|
JS::HandleObject callable) const;
|
|
|
|
virtual bool unwatch(JSContext *cx, JS::HandleObject proxy, JS::HandleId id) const;
|
2013-10-29 23:39:09 +00:00
|
|
|
|
2013-12-05 19:07:24 +00:00
|
|
|
virtual bool slice(JSContext *cx, HandleObject proxy, uint32_t begin, uint32_t end,
|
2014-06-27 11:44:06 +00:00
|
|
|
HandleObject result) const;
|
2013-12-05 19:07:24 +00:00
|
|
|
|
2013-08-22 05:26:57 +00:00
|
|
|
/* See comment for weakmapKeyDelegateOp in js/Class.h. */
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual JSObject *weakmapKeyDelegate(JSObject *proxy) const;
|
|
|
|
virtual bool isScripted() const { return false; }
|
2010-05-19 02:21:43 +00:00
|
|
|
};
|
|
|
|
|
2012-07-08 17:04:14 +00:00
|
|
|
/*
|
2012-10-29 15:52:53 +00:00
|
|
|
* DirectProxyHandler includes a notion of a target object. All traps 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.
|
2013-12-05 20:58:20 +00:00
|
|
|
*
|
|
|
|
* Important: If you add a trap 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.
|
2012-07-08 17:04:14 +00:00
|
|
|
*/
|
2013-03-23 02:43:03 +00:00
|
|
|
class JS_PUBLIC_API(DirectProxyHandler) : public BaseProxyHandler
|
|
|
|
{
|
|
|
|
public:
|
2014-08-28 20:47:16 +00:00
|
|
|
explicit MOZ_CONSTEXPR DirectProxyHandler(const void *aFamily, bool aHasPrototype = false,
|
|
|
|
bool aHasSecurityPolicy = false)
|
|
|
|
: BaseProxyHandler(aFamily, aHasPrototype, aHasSecurityPolicy)
|
|
|
|
{ }
|
2012-05-17 11:19:37 +00:00
|
|
|
|
|
|
|
/* ES5 Harmony fundamental proxy traps. */
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual bool preventExtensions(JSContext *cx, HandleObject proxy) const MOZ_OVERRIDE;
|
2013-03-21 22:23:47 +00:00
|
|
|
virtual bool getPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
|
2014-06-27 11:44:06 +00:00
|
|
|
MutableHandle<JSPropertyDescriptor> desc) const MOZ_OVERRIDE;
|
2014-04-25 21:11:01 +00:00
|
|
|
virtual bool getOwnPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
|
2014-06-27 11:44:06 +00:00
|
|
|
MutableHandle<JSPropertyDescriptor> desc) const MOZ_OVERRIDE;
|
2013-03-21 22:23:47 +00:00
|
|
|
virtual bool defineProperty(JSContext *cx, HandleObject proxy, HandleId id,
|
2014-06-27 11:44:06 +00:00
|
|
|
MutableHandle<JSPropertyDescriptor> desc) const MOZ_OVERRIDE;
|
2013-03-21 22:23:47 +00:00
|
|
|
virtual bool getOwnPropertyNames(JSContext *cx, HandleObject proxy,
|
2014-06-27 11:44:06 +00:00
|
|
|
AutoIdVector &props) const MOZ_OVERRIDE;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool delete_(JSContext *cx, HandleObject proxy, HandleId id,
|
2014-06-27 11:44:06 +00:00
|
|
|
bool *bp) const MOZ_OVERRIDE;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool enumerate(JSContext *cx, HandleObject proxy,
|
2014-06-27 11:44:06 +00:00
|
|
|
AutoIdVector &props) const MOZ_OVERRIDE;
|
2012-05-17 11:19:37 +00:00
|
|
|
|
2012-10-29 15:52:53 +00:00
|
|
|
/* ES5 Harmony derived proxy traps. */
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool has(JSContext *cx, HandleObject proxy, HandleId id,
|
2014-06-27 11:44:06 +00:00
|
|
|
bool *bp) const MOZ_OVERRIDE;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool hasOwn(JSContext *cx, HandleObject proxy, HandleId id,
|
2014-06-27 11:44:06 +00:00
|
|
|
bool *bp) const MOZ_OVERRIDE;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool get(JSContext *cx, HandleObject proxy, HandleObject receiver,
|
2014-06-27 11:44:06 +00:00
|
|
|
HandleId id, MutableHandleValue vp) const MOZ_OVERRIDE;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool set(JSContext *cx, HandleObject proxy, HandleObject receiver,
|
2014-06-27 11:44:06 +00:00
|
|
|
HandleId id, bool strict, MutableHandleValue vp) const MOZ_OVERRIDE;
|
2013-03-21 22:23:47 +00:00
|
|
|
virtual bool keys(JSContext *cx, HandleObject proxy,
|
2014-06-27 11:44:06 +00:00
|
|
|
AutoIdVector &props) const MOZ_OVERRIDE;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool iterate(JSContext *cx, HandleObject proxy, unsigned flags,
|
2014-06-27 11:44:06 +00:00
|
|
|
MutableHandleValue vp) const MOZ_OVERRIDE;
|
2012-10-29 15:52:53 +00:00
|
|
|
|
2012-05-17 11:19:37 +00:00
|
|
|
/* Spidermonkey extensions. */
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual bool isExtensible(JSContext *cx, HandleObject proxy, bool *extensible) const MOZ_OVERRIDE;
|
|
|
|
virtual bool call(JSContext *cx, HandleObject proxy, const CallArgs &args) const MOZ_OVERRIDE;
|
|
|
|
virtual bool construct(JSContext *cx, HandleObject proxy, const CallArgs &args) const MOZ_OVERRIDE;
|
2012-07-04 00:44:22 +00:00
|
|
|
virtual bool nativeCall(JSContext *cx, IsAcceptableThis test, NativeImpl impl,
|
2014-06-27 11:44:06 +00:00
|
|
|
CallArgs args) const MOZ_OVERRIDE;
|
2012-09-04 23:40:12 +00:00
|
|
|
virtual bool hasInstance(JSContext *cx, HandleObject proxy, MutableHandleValue v,
|
2014-06-27 11:44:06 +00:00
|
|
|
bool *bp) const MOZ_OVERRIDE;
|
|
|
|
virtual bool getPrototypeOf(JSContext *cx, HandleObject proxy,
|
|
|
|
MutableHandleObject protop) const MOZ_OVERRIDE;
|
|
|
|
virtual bool setPrototypeOf(JSContext *cx, HandleObject proxy, HandleObject proto,
|
|
|
|
bool *bp) const MOZ_OVERRIDE;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool objectClassIs(HandleObject obj, ESClassValue classValue,
|
2014-06-27 11:44:06 +00:00
|
|
|
JSContext *cx) const MOZ_OVERRIDE;
|
|
|
|
virtual const char *className(JSContext *cx, HandleObject proxy) const MOZ_OVERRIDE;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual JSString *fun_toString(JSContext *cx, HandleObject proxy,
|
2014-06-27 11:44:06 +00:00
|
|
|
unsigned indent) const MOZ_OVERRIDE;
|
2013-03-21 22:23:48 +00:00
|
|
|
virtual bool regexp_toShared(JSContext *cx, HandleObject proxy,
|
2014-06-27 11:44:06 +00:00
|
|
|
RegExpGuard *g) const MOZ_OVERRIDE;
|
2014-08-18 21:18:39 +00:00
|
|
|
virtual bool boxedValue_unbox(JSContext *cx, HandleObject proxy, MutableHandleValue vp) const;
|
2014-06-27 11:44:06 +00:00
|
|
|
virtual JSObject *weakmapKeyDelegate(JSObject *proxy) const MOZ_OVERRIDE;
|
2014-09-10 22:52:36 +00:00
|
|
|
virtual bool isCallable(JSObject *obj) const MOZ_OVERRIDE;
|
2012-05-17 11:19:37 +00:00
|
|
|
};
|
|
|
|
|
2014-09-10 22:52:36 +00:00
|
|
|
extern JS_FRIEND_DATA(const js::Class* const) ProxyClassPtr;
|
2013-08-27 04:39:37 +00:00
|
|
|
|
2013-04-30 22:41:12 +00:00
|
|
|
inline bool IsProxy(JSObject *obj)
|
2011-10-04 14:06:54 +00:00
|
|
|
{
|
2014-02-01 08:30:44 +00:00
|
|
|
return GetObjectClass(obj)->isProxy();
|
2011-10-04 14:06:54 +00:00
|
|
|
}
|
|
|
|
|
2012-12-06 20:21:19 +00:00
|
|
|
/*
|
2013-06-21 05:39:22 +00:00
|
|
|
* These are part of the API.
|
|
|
|
*
|
|
|
|
* NOTE: PROXY_PRIVATE_SLOT is 0 because that way slot 0 is usable by API
|
2012-12-06 20:21:19 +00:00
|
|
|
* clients for both proxy and non-proxy objects. So an API client that only
|
|
|
|
* needs to store one slot's worth of data doesn't need to branch on what sort
|
|
|
|
* of object it has.
|
|
|
|
*/
|
2014-01-30 01:20:16 +00:00
|
|
|
const uint32_t PROXY_PRIVATE_SLOT = 0;
|
|
|
|
const uint32_t PROXY_HANDLER_SLOT = 1;
|
|
|
|
const uint32_t PROXY_EXTRA_SLOT = 2;
|
|
|
|
const uint32_t PROXY_MINIMUM_SLOTS = 4;
|
2010-05-19 02:21:43 +00:00
|
|
|
|
2014-06-27 11:44:08 +00:00
|
|
|
inline const BaseProxyHandler *
|
2013-04-30 22:41:12 +00:00
|
|
|
GetProxyHandler(JSObject *obj)
|
2010-05-19 02:21:43 +00:00
|
|
|
{
|
2011-10-04 14:06:54 +00:00
|
|
|
JS_ASSERT(IsProxy(obj));
|
2014-06-27 11:44:08 +00:00
|
|
|
return (const BaseProxyHandler *) GetReservedSlot(obj, PROXY_HANDLER_SLOT).toPrivate();
|
2010-05-19 02:21:43 +00:00
|
|
|
}
|
|
|
|
|
2011-10-04 14:06:54 +00:00
|
|
|
inline const Value &
|
2013-04-30 22:41:12 +00:00
|
|
|
GetProxyPrivate(JSObject *obj)
|
2010-05-19 02:21:43 +00:00
|
|
|
{
|
2011-10-04 14:06:54 +00:00
|
|
|
JS_ASSERT(IsProxy(obj));
|
2013-06-21 05:39:22 +00:00
|
|
|
return GetReservedSlot(obj, PROXY_PRIVATE_SLOT);
|
2010-05-19 02:21:43 +00:00
|
|
|
}
|
|
|
|
|
2012-05-17 11:19:37 +00:00
|
|
|
inline JSObject *
|
2013-04-30 22:41:12 +00:00
|
|
|
GetProxyTargetObject(JSObject *obj)
|
2012-05-17 11:19:37 +00:00
|
|
|
{
|
|
|
|
JS_ASSERT(IsProxy(obj));
|
|
|
|
return GetProxyPrivate(obj).toObjectOrNull();
|
|
|
|
}
|
|
|
|
|
2012-05-23 23:31:26 +00:00
|
|
|
inline const Value &
|
2013-04-30 22:41:12 +00:00
|
|
|
GetProxyExtra(JSObject *obj, size_t n)
|
2010-09-20 21:48:01 +00:00
|
|
|
{
|
2011-10-04 14:06:54 +00:00
|
|
|
JS_ASSERT(IsProxy(obj));
|
2013-06-21 05:39:22 +00:00
|
|
|
return GetReservedSlot(obj, PROXY_EXTRA_SLOT + n);
|
2010-09-20 21:48:01 +00:00
|
|
|
}
|
|
|
|
|
2012-04-26 04:03:53 +00:00
|
|
|
inline void
|
2013-04-30 22:41:12 +00:00
|
|
|
SetProxyHandler(JSObject *obj, BaseProxyHandler *handler)
|
2012-04-26 04:03:53 +00:00
|
|
|
{
|
|
|
|
JS_ASSERT(IsProxy(obj));
|
2013-06-21 05:39:22 +00:00
|
|
|
SetReservedSlot(obj, PROXY_HANDLER_SLOT, PrivateValue(handler));
|
2012-04-26 04:03:53 +00:00
|
|
|
}
|
|
|
|
|
2010-09-20 21:48:01 +00:00
|
|
|
inline void
|
2013-04-30 22:41:12 +00:00
|
|
|
SetProxyExtra(JSObject *obj, size_t n, const Value &extra)
|
2010-09-20 21:48:01 +00:00
|
|
|
{
|
2011-10-04 14:06:54 +00:00
|
|
|
JS_ASSERT(IsProxy(obj));
|
2011-05-23 15:39:25 +00:00
|
|
|
JS_ASSERT(n <= 1);
|
2013-06-21 05:39:22 +00:00
|
|
|
SetReservedSlot(obj, PROXY_EXTRA_SLOT + n, extra);
|
2010-09-20 21:48:01 +00:00
|
|
|
}
|
|
|
|
|
2014-04-25 20:07:18 +00:00
|
|
|
inline bool
|
|
|
|
IsScriptedProxy(JSObject *obj)
|
|
|
|
{
|
|
|
|
return IsProxy(obj) && GetProxyHandler(obj)->isScripted();
|
|
|
|
}
|
|
|
|
|
2013-10-04 11:29:35 +00:00
|
|
|
class MOZ_STACK_CLASS ProxyOptions {
|
2014-01-30 01:20:16 +00:00
|
|
|
protected:
|
|
|
|
/* protected constructor for subclass */
|
2014-09-24 02:04:52 +00:00
|
|
|
explicit ProxyOptions(bool singletonArg)
|
2014-01-30 01:20:16 +00:00
|
|
|
: singleton_(singletonArg),
|
2014-09-10 22:52:36 +00:00
|
|
|
clasp_(ProxyClassPtr)
|
2014-01-30 01:20:16 +00:00
|
|
|
{}
|
|
|
|
|
2013-10-04 11:29:35 +00:00
|
|
|
public:
|
2014-01-30 01:20:16 +00:00
|
|
|
ProxyOptions() : singleton_(false),
|
2014-09-10 22:52:36 +00:00
|
|
|
clasp_(ProxyClassPtr)
|
2013-10-04 11:29:35 +00:00
|
|
|
{}
|
|
|
|
|
|
|
|
bool singleton() const { return singleton_; }
|
|
|
|
ProxyOptions &setSingleton(bool flag) {
|
|
|
|
singleton_ = flag;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2014-01-30 01:20:16 +00:00
|
|
|
const Class *clasp() const {
|
|
|
|
return clasp_;
|
|
|
|
}
|
|
|
|
ProxyOptions &setClass(const Class *claspArg) {
|
|
|
|
clasp_ = claspArg;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2013-10-04 11:29:35 +00:00
|
|
|
private:
|
|
|
|
bool singleton_;
|
2014-01-30 01:20:16 +00:00
|
|
|
const Class *clasp_;
|
2013-03-27 00:51:55 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
JS_FRIEND_API(JSObject *)
|
2014-06-27 11:44:04 +00:00
|
|
|
NewProxyObject(JSContext *cx, const BaseProxyHandler *handler, HandleValue priv,
|
2013-10-04 11:29:35 +00:00
|
|
|
JSObject *proto, JSObject *parent, const ProxyOptions &options = ProxyOptions());
|
2013-03-27 00:51:55 +00:00
|
|
|
|
2012-09-12 00:14:24 +00:00
|
|
|
JSObject *
|
|
|
|
RenewProxyObject(JSContext *cx, JSObject *obj, BaseProxyHandler *handler, Value priv);
|
|
|
|
|
2013-02-25 21:54:18 +00:00
|
|
|
class JS_FRIEND_API(AutoEnterPolicy)
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
typedef BaseProxyHandler::Action Action;
|
2014-06-27 11:44:08 +00:00
|
|
|
AutoEnterPolicy(JSContext *cx, const BaseProxyHandler *handler,
|
2013-03-21 12:56:58 +00:00
|
|
|
HandleObject wrapper, HandleId id, Action act, bool mayThrow)
|
2013-12-06 23:03:08 +00:00
|
|
|
#ifdef JS_DEBUG
|
2013-10-07 16:44:15 +00:00
|
|
|
: context(nullptr)
|
2013-02-25 21:54:18 +00:00
|
|
|
#endif
|
2013-02-25 21:54:18 +00:00
|
|
|
{
|
2014-01-29 21:07:13 +00:00
|
|
|
allow = handler->hasSecurityPolicy() ? handler->enter(cx, wrapper, id, act, &rv)
|
|
|
|
: true;
|
2014-02-13 18:54:07 +00:00
|
|
|
recordEnter(cx, wrapper, id, act);
|
2013-03-18 04:44:41 +00:00
|
|
|
// 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.
|
2013-08-29 00:20:24 +00:00
|
|
|
if (!allow && !rv && mayThrow)
|
|
|
|
reportErrorIfExceptionIsNotPending(cx, id);
|
2013-02-25 21:54:18 +00:00
|
|
|
}
|
|
|
|
|
2013-02-25 21:54:18 +00:00
|
|
|
virtual ~AutoEnterPolicy() { recordLeave(); }
|
2013-02-25 21:54:18 +00:00
|
|
|
inline bool allowed() { return allow; }
|
|
|
|
inline bool returnValue() { JS_ASSERT(!allowed()); return rv; }
|
|
|
|
|
|
|
|
protected:
|
2013-02-25 21:54:18 +00:00
|
|
|
// no-op constructor for subclass
|
|
|
|
AutoEnterPolicy()
|
2013-12-06 23:03:08 +00:00
|
|
|
#ifdef JS_DEBUG
|
2013-10-07 16:44:15 +00:00
|
|
|
: context(nullptr)
|
2014-02-13 19:55:11 +00:00
|
|
|
, enteredAction(BaseProxyHandler::NONE)
|
2013-02-25 21:54:18 +00:00
|
|
|
#endif
|
2014-08-18 19:20:39 +00:00
|
|
|
{}
|
2013-08-29 00:20:24 +00:00
|
|
|
void reportErrorIfExceptionIsNotPending(JSContext *cx, jsid id);
|
2013-02-25 21:54:18 +00:00
|
|
|
bool allow;
|
|
|
|
bool rv;
|
2013-02-25 21:54:18 +00:00
|
|
|
|
2013-12-06 23:03:08 +00:00
|
|
|
#ifdef JS_DEBUG
|
2013-02-25 21:54:18 +00:00
|
|
|
JSContext *context;
|
2013-03-21 12:56:58 +00:00
|
|
|
mozilla::Maybe<HandleObject> enteredProxy;
|
|
|
|
mozilla::Maybe<HandleId> enteredId;
|
2014-02-13 18:54:07 +00:00
|
|
|
Action enteredAction;
|
|
|
|
|
2013-02-25 21:54:18 +00:00
|
|
|
// NB: We explicitly don't track the entered action here, because sometimes
|
|
|
|
// SET traps do an implicit GET during their implementation, leading to
|
|
|
|
// spurious assertions.
|
|
|
|
AutoEnterPolicy *prev;
|
2014-02-13 18:54:07 +00:00
|
|
|
void recordEnter(JSContext *cx, HandleObject proxy, HandleId id, Action act);
|
2013-02-25 21:54:18 +00:00
|
|
|
void recordLeave();
|
|
|
|
|
2014-02-13 18:54:07 +00:00
|
|
|
friend JS_FRIEND_API(void) assertEnteredPolicy(JSContext *cx, JSObject *proxy, jsid id, Action act);
|
2013-02-25 21:54:18 +00:00
|
|
|
#else
|
2014-02-13 18:54:07 +00:00
|
|
|
inline void recordEnter(JSContext *cx, JSObject *proxy, jsid id, Action act) {}
|
2013-02-25 21:54:18 +00:00
|
|
|
inline void recordLeave() {}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2013-12-06 23:03:08 +00:00
|
|
|
#ifdef JS_DEBUG
|
2013-02-25 21:54:18 +00:00
|
|
|
class JS_FRIEND_API(AutoWaivePolicy) : public AutoEnterPolicy {
|
|
|
|
public:
|
2014-02-13 18:54:07 +00:00
|
|
|
AutoWaivePolicy(JSContext *cx, HandleObject proxy, HandleId id,
|
|
|
|
BaseProxyHandler::Action act)
|
2013-02-25 21:54:18 +00:00
|
|
|
{
|
|
|
|
allow = true;
|
2014-02-13 18:54:07 +00:00
|
|
|
recordEnter(cx, proxy, id, act);
|
2013-02-25 21:54:18 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
#else
|
|
|
|
class JS_FRIEND_API(AutoWaivePolicy) {
|
2014-02-13 18:54:07 +00:00
|
|
|
public:
|
|
|
|
AutoWaivePolicy(JSContext *cx, HandleObject proxy, HandleId id,
|
|
|
|
BaseProxyHandler::Action act)
|
|
|
|
{}
|
2013-02-25 21:54:18 +00:00
|
|
|
};
|
2013-02-25 21:54:18 +00:00
|
|
|
#endif
|
2013-02-25 21:54:18 +00:00
|
|
|
|
2014-02-13 18:54:07 +00:00
|
|
|
#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)
|
2014-08-18 19:20:39 +00:00
|
|
|
{}
|
2014-02-13 18:54:07 +00:00
|
|
|
#endif
|
|
|
|
|
2011-10-04 14:06:54 +00:00
|
|
|
} /* namespace js */
|
2010-05-24 21:33:03 +00:00
|
|
|
|
2010-05-19 02:21:43 +00:00
|
|
|
extern JS_FRIEND_API(JSObject *)
|
2013-06-21 13:12:46 +00:00
|
|
|
js_InitProxyClass(JSContext *cx, JS::HandleObject obj);
|
2010-05-19 02:21:43 +00:00
|
|
|
|
2013-06-20 00:59:46 +00:00
|
|
|
#endif /* jsproxy_h */
|