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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 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_dom_RemoteObjectProxy_h
#define mozilla_dom_RemoteObjectProxy_h
#include "js/Proxy.h"
#include "mozilla/Maybe.h"
#include "mozilla/dom/MaybeCrossOriginObject.h"
#include "mozilla/dom/PrototypeList.h"
#include "xpcpublic.h"
namespace mozilla::dom {
class BrowsingContext;
/**
* Base class for RemoteObjectProxy. Implements the pieces of the handler that
* don't depend on properties/methods of the specific WebIDL interface that this
* proxy implements.
*/
class RemoteObjectProxyBase : public js::BaseProxyHandler,
public MaybeCrossOriginObjectMixins {
protected:
explicit constexpr RemoteObjectProxyBase(prototypes::ID aPrototypeID)
: BaseProxyHandler(&sCrossOriginProxyFamily, false),
mPrototypeID(aPrototypeID) {}
public:
bool finalizeInBackground(const JS::Value& priv) const final { return false; }
// Standard internal methods
bool getOwnPropertyDescriptor(
JSContext* aCx, JS::Handle<JSObject*> aProxy, JS::Handle<jsid> aId,
JS::MutableHandle<Maybe<JS::PropertyDescriptor>> aDesc) const override;
bool ownPropertyKeys(JSContext* aCx, JS::Handle<JSObject*> aProxy,
JS::MutableHandleVector<jsid> aProps) const override;
bool defineProperty(JSContext* aCx, JS::Handle<JSObject*> aProxy,
JS::Handle<jsid> aId,
JS::Handle<JS::PropertyDescriptor> aDesc,
JS::ObjectOpResult& result) const final;
bool delete_(JSContext* aCx, JS::Handle<JSObject*> aProxy,
JS::Handle<jsid> aId, JS::ObjectOpResult& aResult) const final;
bool getPrototypeIfOrdinary(JSContext* aCx, JS::Handle<JSObject*> aProxy,
bool* aIsOrdinary,
JS::MutableHandle<JSObject*> aProtop) const final;
bool preventExtensions(JSContext* aCx, JS::Handle<JSObject*> aProxy,
JS::ObjectOpResult& aResult) const final;
bool isExtensible(JSContext* aCx, JS::Handle<JSObject*> aProxy,
bool* aExtensible) const final;
bool get(JSContext* cx, JS::Handle<JSObject*> aProxy,
JS::Handle<JS::Value> aReceiver, JS::Handle<jsid> aId,
JS::MutableHandle<JS::Value> aVp) const final;
bool set(JSContext* cx, JS::Handle<JSObject*> aProxy, JS::Handle<jsid> aId,
JS::Handle<JS::Value> aValue, JS::Handle<JS::Value> aReceiver,
JS::ObjectOpResult& aResult) const final;
// SpiderMonkey extensions
bool getOwnEnumerablePropertyKeys(
JSContext* aCx, JS::Handle<JSObject*> aProxy,
JS::MutableHandleVector<jsid> aProps) const override;
const char* className(JSContext* aCx,
JS::Handle<JSObject*> aProxy) const final;
// Cross origin objects like RemoteWindowProxy should not participate in
// private fields.
virtual bool throwOnPrivateField() const override { return true; }
bool isCallable(JSObject* aObj) const final { return false; }
bool isConstructor(JSObject* aObj) const final { return false; }
virtual void NoteChildren(JSObject* aProxy,
nsCycleCollectionTraversalCallback& aCb) const = 0;
static void* GetNative(JSObject* aProxy) {
return js::GetProxyPrivate(aProxy).toPrivate();
}
/**
* Returns true if aProxy is a cross-process proxy that represents
* an object implementing the WebIDL interface for aProtoID. aProxy
* should be a proxy object.
*/
static inline bool IsRemoteObjectProxy(JSObject* aProxy,
prototypes::ID aProtoID) {
const js::BaseProxyHandler* handler = js::GetProxyHandler(aProxy);
return handler->family() == &sCrossOriginProxyFamily &&
static_cast<const RemoteObjectProxyBase*>(handler)->mPrototypeID ==
aProtoID;
}
/**
* Returns true if aProxy is a cross-process proxy, no matter which
* interface it represents. aProxy should be a proxy object.
*/
static inline bool IsRemoteObjectProxy(JSObject* aProxy) {
const js::BaseProxyHandler* handler = js::GetProxyHandler(aProxy);
return handler->family() == &sCrossOriginProxyFamily;
}
protected:
/**
* Gets an existing cached proxy object, or creates a new one and caches it.
* aProxy will be null on failure. aNewObjectCreated is set to true if a new
* object was created, callers probably need to addref the native in that
* case. aNewObjectCreated can be true even if aProxy is null, if something
* failed after creating the object.
*
* If aTransplantTo is non-null, failure is assumed to be unrecoverable, so
* this will crash.
*/
void GetOrCreateProxyObject(JSContext* aCx, void* aNative,
const JSClass* aClasp,
JS::Handle<JSObject*> aTransplantTo,
JS::MutableHandle<JSObject*> aProxy,
bool& aNewObjectCreated) const;
const prototypes::ID mPrototypeID;
friend struct SetDOMProxyInformation;
static const char sCrossOriginProxyFamily;
};
/**
* Proxy handler for proxy objects that represent an object implementing a
* WebIDL interface that has cross-origin accessible properties/methods, and
* which lives in a different process. The WebIDL code generator will create
* arrays of cross-origin accessible properties/methods that can be used as
* arguments to this template.
*
* The properties and methods can be cached on a holder JSObject, stored in a
* reserved slot on the proxy object.
*
* The proxy objects that use a handler derived from this one are stored in a
* hash map in the JS compartment's private (@see
* xpc::CompartmentPrivate::GetRemoteProxyMap).
*/
template <class Native, const CrossOriginProperties& P>
class RemoteObjectProxy : public RemoteObjectProxyBase {
public:
void finalize(JS::GCContext* aGcx, JSObject* aProxy) const final {
auto native = static_cast<Native*>(GetNative(aProxy));
RefPtr<Native> self(dont_AddRef(native));
}
void GetProxyObject(JSContext* aCx, Native* aNative,
JS::Handle<JSObject*> aTransplantTo,
JS::MutableHandle<JSObject*> aProxy) const {
bool objectCreated = false;
GetOrCreateProxyObject(aCx, aNative, &sClass, aTransplantTo, aProxy,
objectCreated);
if (objectCreated) {
NS_ADDREF(aNative);
}
}
protected:
using RemoteObjectProxyBase::RemoteObjectProxyBase;
private:
bool EnsureHolder(JSContext* aCx, JS::Handle<JSObject*> aProxy,
JS::MutableHandle<JSObject*> aHolder) const final {
return MaybeCrossOriginObjectMixins::EnsureHolder(
aCx, aProxy, /* slot = */ 0, P, aHolder);
}
static const JSClass sClass;
};
/**
* Returns true if aObj is a cross-process proxy object that
* represents an object implementing the WebIDL interface for
* aProtoID.
*/
inline bool IsRemoteObjectProxy(JSObject* aObj, prototypes::ID aProtoID) {
if (!js::IsProxy(aObj)) {
return false;
}
return RemoteObjectProxyBase::IsRemoteObjectProxy(aObj, aProtoID);
}
/**
* Returns true if aObj is a cross-process proxy object, no matter
* which WebIDL interface it corresponds to.
*/
inline bool IsRemoteObjectProxy(JSObject* aObj) {
if (!js::IsProxy(aObj)) {
return false;
}
return RemoteObjectProxyBase::IsRemoteObjectProxy(aObj);
}
/**
* Return the browsing context for this remote outer window proxy.
* Only call this function on remote outer window proxies.
*/
BrowsingContext* GetBrowsingContext(JSObject* aProxy);
} // namespace mozilla::dom
#endif /* mozilla_dom_RemoteObjectProxy_h */
|
