editing/execCommand/insert-image-in-composed-list.html is crashing
[WebKit-https.git] / LayoutTests / imported / w3c / web-platform-tests / html / browsers / origin / relaxing-the-same-origin-restriction / document_domain_access_details.sub.html
1 <!DOCTYPE html>
2 <script src="/resources/testharness.js"></script>
3 <script src="/resources/testharnessreport.js"></script>
4 <script src="support/document_domain_frame.sub.js"></script>
5 <body>
6 <script>
7 promise_test(async (t) => {
8   let frame1 = await createFrame(t, "control1-1", "{{domains[www1]}}");
9   let frame2 = await createFrame(t, "control1-2", "{{domains[www1]}}");
10   let result = await postMessageToFrame(frame1, { 'poke-at-sibling': "control1-2" });
11   assert_equals(result.data, "omg!");
12 }, "Access allowed if same-origin with no 'document.domain' modification. (Sanity check)");
13
14 promise_test(async (t) => {
15   let frame1 = await createFrame(t, "control2-1", "{{domains[www1]}}");
16   let frame2 = await createFrame(t, "control2-2", "{{domains[www2]}}");
17   let result = await postMessageToFrame(frame1, { 'poke-at-sibling': "control2-2" });
18   assert_equals(result.data, "SecurityError");
19 }, "Access not allowed if different-origin with no 'document.domain' modification. (Sanity check)");
20
21 promise_test(async (t) => {
22   let frame1 = await createFrame(t, "one-set-one-not-1", "{{domains[www1]}}");
23   let frame2 = await createFrame(t, "one-set-one-not-2", "{{domains[www1]}}");
24   await postMessageToFrame(frame1, { domain: "{{domains[www1]}}" });
25
26   let result = await postMessageToFrame(frame1, { 'poke-at-sibling': "one-set-one-not-2" });
27   assert_equals(result.data, "SecurityError");
28
29   result = await postMessageToFrame(frame2, { 'poke-at-sibling': "one-set-one-not-1" });
30   assert_equals(result.data, "SecurityError");
31 }, "Access disallowed if same-origin but only one sets document.domain.");
32
33 promise_test(async (t) => {
34   var frame1 = await createFrame(t, "both-set-to-existing-1", "{{domains[www1]}}");
35   var frame2 = await createFrame(t, "both-set-to-existing-2", "{{domains[www1]}}");
36   let result = await postMessageToFrame(frame1, { domain: "{{domains[www1]}}" });
37   assert_equals(result.data, "Done");
38
39   result = await postMessageToFrame(frame2, { domain: "{{domains[www1]}}" });
40   assert_equals(result.data, "Done");
41
42   result = await postMessageToFrame(frame1, { 'poke-at-sibling': "both-set-to-existing-2" });
43   assert_equals(result.data, "omg!");
44
45   result = await postMessageToFrame(frame2, { 'poke-at-sibling': "both-set-to-existing-1" });
46   assert_equals(result.data, "omg!");
47 }, "Access allowed if same-origin and both set document.domain to existing value.");
48
49 promise_test(async (t) => {
50   var frame1 = await createFrame(t, "both-set-to-parent-1", "{{domains[www1]}}");
51   var frame2 = await createFrame(t, "both-set-to-parent-2", "{{domains[www2]}}");
52   let result = await postMessageToFrame(frame1, { domain: "{{domains[]}}" });
53   assert_equals(result.data, "Done");
54
55   result = await postMessageToFrame(frame2, { domain: "{{domains[]}}" });
56   assert_equals(result.data, "Done");
57
58   result = await postMessageToFrame(frame1, { 'poke-at-sibling': "both-set-to-parent-2" });
59   assert_equals(result.data, "omg!");
60
61   result = await postMessageToFrame(frame2, { 'poke-at-sibling': "both-set-to-parent-1" });
62   assert_equals(result.data, "omg!");
63 }, "Access allowed if different-origin but both set document.domain to parent domain.");
64
65 promise_test(async (t) => {
66   var frame1 = await createFrame(t, "allow-then-revoke-1", "{{domains[www1]}}");
67   var frame2 = await createFrame(t, "allow-then-revoke-2", "{{domains[www1]}}");
68   let result = await postMessageToFrame(frame1, { domain: "{{domains[www1]}}" });
69   assert_equals(result.data, "Done");
70
71   result = await postMessageToFrame(frame2, { domain: "{{domains[www1]}}" });
72   assert_equals(result.data, "Done");
73
74   result = await postMessageToFrame(frame1, { 'poke-at-sibling': "allow-then-revoke-2" });
75   assert_equals(result.data, "omg!");
76
77   result = await postMessageToFrame(frame2, { 'poke-at-sibling': "allow-then-revoke-1" });
78   assert_equals(result.data, "omg!");
79
80   result = await postMessageToFrame(frame1, { domain: "{{domains[]}}" });
81   assert_equals(result.data, "Done");
82
83   result = await postMessageToFrame(frame1, { 'poke-at-sibling': "allow-then-revoke-2" });
84   assert_equals(result.data, "SecurityError");
85
86   result = await postMessageToFrame(frame2, { 'poke-at-sibling': "allow-then-revoke-1" });
87   assert_equals(result.data, "SecurityError");
88 }, "Access disallowed again if same-origin, both set document-domain to existing value, then one sets to parent.");
89
90 promise_test(async (t) => {
91   let frame1 = await createFrame(t, "revoke-Window-1", "{{domains[www1]}}");
92   let frame2 = await createFrame(t, "revoke-Window-2", "{{domains[www1]}}");
93
94   let result = await postMessageToFrame(frame1, { cache: ["parent", "revoke-Window-2"] });
95   assert_equals(result.data, "cached");
96
97   result = await postMessageToFrame(frame1, 'touch-cached');
98   assert_equals(result.data, "Reachable 1");
99
100   result = await postMessageToFrame(frame2, { cache: ["parent", "revoke-Window-1"] });
101   assert_equals(result.data, "cached");
102
103   result = await postMessageToFrame(frame1, 'touch-cached');
104   assert_equals(result.data, "Reachable 1");
105
106   result = await postMessageToFrame(frame1, { domain: "{{domains[www1]}}" });
107   assert_equals(result.data, "Done");
108
109   result = await postMessageToFrame(frame1, 'touch-cached');
110   assert_equals(result.data, "SecurityError");
111
112   result = await postMessageToFrame(frame2, 'touch-cached');
113   assert_equals(result.data, "SecurityError");
114 }, "Access is revoked to Window object when we stop being same effective script origin due to document.domain.");
115
116 promise_test(async (t) => {
117   let frame1 = await createFrame(t, "revoke-Location-1", "{{domains[www1]}}");
118   let frame2 = await createFrame(t, "revoke-Location-2", "{{domains[www1]}}");
119
120   let result = await postMessageToFrame(frame1, { cache: ["parent", "revoke-Location-2", "location"] });
121   assert_equals(result.data, "cached");
122
123   result = await postMessageToFrame(frame1, 'touch-cached');
124   assert_equals(result.data, "Reachable 3");
125
126   result = await postMessageToFrame(frame2, { cache: ["parent", "revoke-Location-1", "location"] });
127   assert_equals(result.data, "cached");
128
129   result = await postMessageToFrame(frame1, 'touch-cached');
130   assert_equals(result.data, "Reachable 3");
131
132   result = await postMessageToFrame(frame1, { domain: "{{domains[www1]}}" });
133   assert_equals(result.data, "Done");
134
135   result = await postMessageToFrame(frame1, 'touch-cached');
136   assert_equals(result.data, "SecurityError");
137
138   result = await postMessageToFrame(frame2, 'touch-cached');
139   assert_equals(result.data, "SecurityError");
140 }, "Access is revoked to Location object when we stop being same effective script origin due to document.domain.");
141
142 promise_test(async (t) => {
143   let frame1 = await createFrame(t, "no-revoke-Document-1", "{{domains[www1]}}");
144   let frame2 = await createFrame(t, "no-revoke-Document-2", "{{domains[www1]}}");
145
146   let result = await postMessageToFrame(frame1, { cache: ["parent", "no-revoke-Document-2", "document"] });
147   assert_equals(result.data, "cached");
148
149   result = await postMessageToFrame(frame1, 'touch-cached');
150   assert_equals(result.data, "Reachable 4");
151
152   result = await postMessageToFrame(frame2, { cache: ["parent", "no-revoke-Document-1", "document"] });
153   assert_equals(result.data, "cached");
154
155   result = await postMessageToFrame(frame2, 'touch-cached');
156   assert_equals(result.data, "Reachable 4");
157
158   result = await postMessageToFrame(frame1, { domain: "{{domains[www1]}}" });
159   assert_equals(result.data, "Done");
160
161   result = await postMessageToFrame(frame1, 'touch-cached');
162   assert_equals(result.data, "Reachable 4");
163
164   result = await postMessageToFrame(frame2, 'touch-cached');
165   assert_equals(result.data, "Reachable 4");
166 }, "Access is not revoked to Document object when we stop being same effective script origin due to document.domain.");
167
168 promise_test(async (t) => {
169   let frame1 = await createFrame(t, "no-revoke-object-1", "{{domains[www1]}}");
170   let frame2 = await createFrame(t, "no-revoke-object-2", "{{domains[www1]}}");
171
172   let result = await postMessageToFrame(frame1, { cache: ["parent", "no-revoke-object-2", "bar"] });
173   assert_equals(result.data, "cached");
174
175   result = await postMessageToFrame(frame1, 'touch-cached');
176   assert_equals(result.data, "Reachable 2");
177
178   result = await postMessageToFrame(frame2, { cache: ["parent", "no-revoke-object-1", "bar"] });
179   assert_equals(result.data, "cached");
180
181   result = await postMessageToFrame(frame1, 'touch-cached');
182   assert_equals(result.data, "Reachable 2");
183
184   result = await postMessageToFrame(frame1, { domain: "{{domains[www1]}}" });
185   assert_equals(result.data, "Done");
186
187   result = await postMessageToFrame(frame1, 'touch-cached');
188   assert_equals(result.data, "Reachable 2");
189
190   result = await postMessageToFrame(frame2, 'touch-cached');
191   assert_equals(result.data, "Reachable 2");
192 }, "Access is not revoked to random object when we stop being same effective script origin due to document.domain.");
193
194 promise_test(async (t) => {
195   let frame1 = await createFrame(t, "join-and-diverge-1", "{{domains[www2.www1]}}");
196   let frame2 = await createFrame(t, "join-and-diverge-2", "{{domains[www1.www1]}}");
197
198   // Make sure we can't touch each other.
199   let result = await postMessageToFrame(frame1, { 'poke-at-sibling': "join-and-diverge-2" });
200   assert_equals(result.data, "SecurityError");
201
202   result = await postMessageToFrame(frame2, { 'poke-at-sibling': "join-and-diverge-1" });
203   assert_equals(result.data, "SecurityError");
204
205   result = await postMessageToFrame(frame1, { cache: ["parent", "join-and-diverge-2", "bar"] });
206   assert_equals(result.data, "SecurityError");
207
208   result = await postMessageToFrame(frame2, { cache: ["parent", "join-and-diverge-1", "document"] });
209   assert_equals(result.data, "SecurityError");
210
211   // Let's join up now.
212   result = await postMessageToFrame(frame1, { domain: "{{domains[www1]}}" });
213   assert_equals(result.data, "Done");
214
215   result = await postMessageToFrame(frame2, { domain: "{{domains[www1]}}" });
216   assert_equals(result.data, "Done");
217
218   // Now we should be able to touch each other.
219   result = await postMessageToFrame(frame1, { 'poke-at-sibling': "join-and-diverge-2" });
220   assert_equals(result.data, "omg!");
221
222   result = await postMessageToFrame(frame2, { 'poke-at-sibling': "join-and-diverge-1" });
223   assert_equals(result.data, "omg!");
224
225   // Cache a random object and a document.
226   result = await postMessageToFrame(frame1, { cache: ["parent", "join-and-diverge-2", "bar"] });
227   assert_equals(result.data, "cached");
228
229   result = await postMessageToFrame(frame1, 'touch-cached');
230   assert_equals(result.data, "Reachable 2");
231
232   result = await postMessageToFrame(frame2, { cache: ["parent", "join-and-diverge-1", "document"] });
233   assert_equals(result.data, "cached");
234
235   result = await postMessageToFrame(frame2, 'touch-cached');
236   assert_equals(result.data, "Reachable 4");
237
238   // OK, now let's diverge
239   result = await postMessageToFrame(frame1, { domain: "{{domains[]}}" });
240   assert_equals(result.data, "Done");
241
242   // We should still be able to touch our cached things.
243   result = await postMessageToFrame(frame1, 'touch-cached');
244   assert_equals(result.data, "Reachable 2");
245
246   result = await postMessageToFrame(frame2, 'touch-cached');
247   assert_equals(result.data, "Reachable 4");
248 }, "Access evolves correctly for non-cross-origin objects when we join up via document.domain and then diverge again.");
249
250 promise_test(async (t) => {
251   let frame1 = await createFrame(t, "join-and-diverge-cross-origin-1", "{{domains[www2.www1]}}");
252   let frame2 = await createFrame(t, "join-and-diverge-cross-origin-2", "{{domains[www1.www1]}}");
253
254   // Make sure we can't touch each other.
255   let result = await postMessageToFrame(frame1, { 'poke-at-sibling': "join-and-diverge-cross-origin-2" });
256   assert_equals(result.data, "SecurityError");
257
258   result = await postMessageToFrame(frame2, { 'poke-at-sibling': "join-and-diverge-cross-origin-1" });
259   assert_equals(result.data, "SecurityError");
260
261   result = await postMessageToFrame(frame1, { cache: ["parent", "join-and-diverge-2", "bar"] });
262   assert_equals(result.data, "SecurityError");
263
264   result = await postMessageToFrame(frame2, { cache: ["parent", "join-and-diverge-1", "document"] });
265   assert_equals(result.data, "SecurityError");
266
267   // Let's join up now.
268   result = await postMessageToFrame(frame1, { domain: "{{domains[www1]}}" });
269   assert_equals(result.data, "Done");
270
271   result = await postMessageToFrame(frame2, { domain: "{{domains[www1]}}" });
272   assert_equals(result.data, "Done");
273
274   // Now we should be able to touch each other.
275   result = await postMessageToFrame(frame1, { 'poke-at-sibling': "join-and-diverge-cross-origin-2" });
276   assert_equals(result.data, "omg!");
277
278   result = await postMessageToFrame(frame2, { 'poke-at-sibling': "join-and-diverge-cross-origin-1" });
279   assert_equals(result.data, "omg!");
280
281   // Cache a window and a location
282   result = await postMessageToFrame(frame1, { cache: ["parent", "join-and-diverge-cross-origin-2"] });
283   assert_equals(result.data, "cached");
284
285   result = await postMessageToFrame(frame1, 'touch-cached');
286   assert_equals(result.data, "Reachable 1");
287
288   result = await postMessageToFrame(frame2, { cache: ["parent", "join-and-diverge-cross-origin-1", "location"] });
289   assert_equals(result.data, "cached");
290
291   result = await postMessageToFrame(frame2, 'touch-cached');
292   assert_equals(result.data, "Reachable 3");
293
294   // OK, now let's diverge
295   result = await postMessageToFrame(frame1, { domain: "{{domains[]}}" });
296   assert_equals(result.data, "Done");
297
298   // Now our cross-origin objects should start denying access.
299   result = await postMessageToFrame(frame1, 'touch-cached');
300   assert_equals(result.data, "SecurityError");
301
302   result = await postMessageToFrame(frame2, 'touch-cached');
303   assert_equals(result.data, "SecurityError");
304 }, "Access evolves correctly for cross-origin objects when we join up via document.domain and then diverge again.");
305 </script>