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
|
"use strict";
const global = this;
add_task(async function test_structuredCloneHolder() {
let principal = Services.scriptSecurityManager.createContentPrincipal(
Services.io.newURI("http://example.com/"),
{}
);
let sandbox = Cu.Sandbox(principal);
const obj = { foo: [{ bar: "baz" }] };
let holder = new StructuredCloneHolder("", "", obj);
// Test same-compartment deserialization
let res = holder.deserialize(global, true);
notEqual(
res,
obj,
"Deserialized result is a different object from the original"
);
deepEqual(
res,
obj,
"Deserialized result is deeply equivalent to the original"
);
equal(
Cu.getObjectPrincipal(res),
Cu.getObjectPrincipal(global),
"Deserialized result has the correct principal"
);
// Test non-object-value round-trip.
equal(
new StructuredCloneHolder("", "", "foo").deserialize(global),
"foo",
"Round-tripping non-object values works as expected"
);
// Test cross-compartment deserialization
res = holder.deserialize(sandbox, true);
notEqual(
res,
obj,
"Cross-compartment-deserialized result is a different object from the original"
);
deepEqual(
res,
obj,
"Cross-compartment-deserialized result is deeply equivalent to the original"
);
equal(
Cu.getObjectPrincipal(res),
principal,
"Cross-compartment-deserialized result has the correct principal"
);
// Test message manager transportability
const MSG = "StructuredCloneHolder";
let resultPromise = new Promise(resolve => {
Services.ppmm.addMessageListener(MSG, resolve);
});
Services.cpmm.sendAsyncMessage(MSG, holder);
res = await resultPromise;
ok(
StructuredCloneHolder.isInstance(res.data),
"Sending structured clone holders through message managers works as expected"
);
deepEqual(
res.data.deserialize(global, true),
obj,
"Sending structured clone holders through message managers works as expected"
);
// Test that attempting to deserialize a neutered holder throws.
deepEqual(
holder.deserialize(global),
obj,
"Deserialized result is correct when discarding data"
);
Assert.throws(
() => holder.deserialize(global),
err => err.result == Cr.NS_ERROR_NOT_INITIALIZED,
"Attempting to deserialize neutered holder throws"
);
Assert.throws(
() => holder.deserialize(global, true),
err => err.result == Cr.NS_ERROR_NOT_INITIALIZED,
"Attempting to deserialize neutered holder throws"
);
});
// Test that X-rays passed to an exported function are serialized
// through their exported wrappers.
add_task(async function test_structuredCloneHolder_xray() {
let principal = Services.scriptSecurityManager.createContentPrincipal(
Services.io.newURI("http://example.com/"),
{}
);
let sandbox1 = Cu.Sandbox(principal, { wantXrays: true });
let sandbox2 = Cu.Sandbox(principal, { wantXrays: true });
Cu.evalInSandbox(`this.x = {y: "z", get z() { return "q" }}`, sandbox2);
sandbox1.x = sandbox2.x;
let holder;
Cu.exportFunction(
function serialize(val) {
holder = new StructuredCloneHolder("", "", val, sandbox1);
},
sandbox1,
{ defineAs: "serialize" }
);
Cu.evalInSandbox(`serialize(x)`, sandbox1);
const obj = { y: "z" };
let res = holder.deserialize(global);
deepEqual(
res,
obj,
"Deserialized result is deeply equivalent to the expected object"
);
deepEqual(
res,
sandbox2.x,
"Deserialized result is deeply equivalent to the X-ray-wrapped object"
);
equal(
Cu.getObjectPrincipal(res),
Cu.getObjectPrincipal(global),
"Deserialized result has the correct principal"
);
});
|
