1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
/* -*- 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/. */
#include "WaiveXrayWrapper.h"
#include "WrapperFactory.h"
#include "jsapi.h"
using namespace JS;
namespace xpc {
static bool
WaiveAccessors(JSContext* cx, MutableHandle<PropertyDescriptor> desc)
{
if (desc.hasGetterObject() && desc.getterObject()) {
RootedValue v(cx, JS::ObjectValue(*desc.getterObject()));
if (!WrapperFactory::WaiveXrayAndWrap(cx, &v))
return false;
desc.setGetterObject(&v.toObject());
}
if (desc.hasSetterObject() && desc.setterObject()) {
RootedValue v(cx, JS::ObjectValue(*desc.setterObject()));
if (!WrapperFactory::WaiveXrayAndWrap(cx, &v))
return false;
desc.setSetterObject(&v.toObject());
}
return true;
}
bool
WaiveXrayWrapper::getPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
MutableHandle<PropertyDescriptor> desc) const
{
return CrossCompartmentWrapper::getPropertyDescriptor(cx, wrapper, id, desc) &&
WrapperFactory::WaiveXrayAndWrap(cx, desc.value()) && WaiveAccessors(cx, desc);
}
bool
WaiveXrayWrapper::getOwnPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
MutableHandle<PropertyDescriptor> desc) const
{
return CrossCompartmentWrapper::getOwnPropertyDescriptor(cx, wrapper, id, desc) &&
WrapperFactory::WaiveXrayAndWrap(cx, desc.value()) && WaiveAccessors(cx, desc);
}
bool
WaiveXrayWrapper::get(JSContext* cx, HandleObject wrapper, HandleValue receiver, HandleId id,
MutableHandleValue vp) const
{
return CrossCompartmentWrapper::get(cx, wrapper, receiver, id, vp) &&
WrapperFactory::WaiveXrayAndWrap(cx, vp);
}
bool
WaiveXrayWrapper::enumerate(JSContext* cx, HandleObject proxy,
MutableHandleObject objp) const
{
return CrossCompartmentWrapper::enumerate(cx, proxy, objp) &&
WrapperFactory::WaiveXrayAndWrap(cx, objp);
}
bool
WaiveXrayWrapper::call(JSContext* cx, HandleObject wrapper, const JS::CallArgs& args) const
{
return CrossCompartmentWrapper::call(cx, wrapper, args) &&
WrapperFactory::WaiveXrayAndWrap(cx, args.rval());
}
bool
WaiveXrayWrapper::construct(JSContext* cx, HandleObject wrapper, const JS::CallArgs& args) const
{
return CrossCompartmentWrapper::construct(cx, wrapper, args) &&
WrapperFactory::WaiveXrayAndWrap(cx, args.rval());
}
// NB: This is important as the other side of a handshake with FieldGetter. See
// nsXBLProtoImplField.cpp.
bool
WaiveXrayWrapper::nativeCall(JSContext* cx, JS::IsAcceptableThis test,
JS::NativeImpl impl, const JS::CallArgs& args) const
{
return CrossCompartmentWrapper::nativeCall(cx, test, impl, args) &&
WrapperFactory::WaiveXrayAndWrap(cx, args.rval());
}
bool
WaiveXrayWrapper::hasInstance(JSContext* cx, HandleObject wrapper,
MutableHandleValue v, bool* bp) const {
if (v.isObject() && WrapperFactory::IsXrayWrapper(&v.toObject())) {
// If |v| is an XrayWrapper and in the same compartment as the value
// wrapped by |wrapper|, then the Xrays of |v| would be waived upon
// calling CrossCompartmentWrapper::hasInstance. This may trigger
// getters and proxy traps of unwrapped |v|. To prevent that from
// happening, we exit early.
// |wrapper| is the right operand of "instanceof", and must either be
// a function or an object with a @@hasInstance method. We are not going
// to call @@hasInstance, so only check whether it is a function.
// This check is here for consistency with usual "instanceof" behavior,
// which throws if the right operand is not a function. Without this
// check, the "instanceof" operator would return false and potentially
// hide errors in the code that uses the "instanceof" operator.
if (!JS::IsCallable(wrapper)) {
RootedValue wrapperv(cx, JS::ObjectValue(*wrapper));
js::ReportIsNotFunction(cx, wrapperv);
return false;
}
*bp = false;
return true;
}
// Both |wrapper| and |v| have no Xrays here.
return CrossCompartmentWrapper::hasInstance(cx, wrapper, v, bp);
}
bool
WaiveXrayWrapper::getPrototype(JSContext* cx, HandleObject wrapper, MutableHandleObject protop) const
{
return CrossCompartmentWrapper::getPrototype(cx, wrapper, protop) &&
(!protop || WrapperFactory::WaiveXrayAndWrap(cx, protop));
}
bool
WaiveXrayWrapper::getPrototypeIfOrdinary(JSContext* cx, HandleObject wrapper, bool* isOrdinary,
MutableHandleObject protop) const
{
return CrossCompartmentWrapper::getPrototypeIfOrdinary(cx, wrapper, isOrdinary, protop) &&
(!protop || WrapperFactory::WaiveXrayAndWrap(cx, protop));
}
} // namespace xpc
|
