| OLD | NEW |
|---|
| 1 <!DOCTYPE html> | 1 <!DOCTYPE html> |
| 2 <title>ServiceWorkerGlobalScope: ExtendableMessageEvent</title> | 2 <title>ServiceWorkerGlobalScope: ExtendableMessageEvent</title> |
| 3 <script src='../../resources/testharness.js'></script> | 3 <script src='/resources/testharness.js'></script> |
| 4 <script src='../../resources/testharnessreport.js'></script> | 4 <script src='/resources/testharnessreport.js'></script> |
| 5 <script src='../resources/test-helpers.js'></script> | 5 <script src='../resources/test-helpers.sub.js'></script> |
| 6 <script src='./resources/extendable-message-event-utils.js'></script> |
| 6 <script> | 7 <script> |
| 7 | |
| 8 promise_test(function(t) { | |
| 9 var script = 'resources/extendable-message-event-constructor-worker.js'; | |
| 10 var scope = 'resources/scope/extendable-message-event-constructor'; | |
| 11 var registration; | |
| 12 | |
| 13 return service_worker_unregister_and_register(t, script, scope) | |
| 14 .then(function(r) { | |
| 15 registration = r; | |
| 16 add_completion_callback(function() { registration.unregister(); }); | |
| 17 return wait_for_state(t, registration.installing, 'activated'); | |
| 18 }) | |
| 19 .then(function() { | |
| 20 var saw_message = new Promise(function(resolve) { | |
| 21 navigator.serviceWorker.onmessage = | |
| 22 function(event) { resolve(event.data); }; | |
| 23 }); | |
| 24 registration.active.postMessage(''); | |
| 25 return saw_message; | |
| 26 }) | |
| 27 .then(function(result) { | |
| 28 assert_equals(result, 'success'); | |
| 29 }); | |
| 30 }, 'Test the constructor for ExtendableMessageEvent'); | |
| 31 | |
| 32 promise_test(function(t) { | 8 promise_test(function(t) { |
| 33 var script = 'resources/extendable-message-event-worker.js'; | 9 var script = 'resources/extendable-message-event-worker.js'; |
| 34 var scope = 'resources/scope/extendable-message-event-from-toplevel'; | 10 var scope = 'resources/scope/extendable-message-event-from-toplevel'; |
| 35 var registration; | 11 var registration; |
| 36 | 12 |
| 37 return service_worker_unregister_and_register(t, script, scope) | 13 return service_worker_unregister_and_register(t, script, scope) |
| 38 .then(function(r) { | 14 .then(function(r) { |
| 39 registration = r; | 15 registration = r; |
| 40 add_completion_callback(function() { registration.unregister(); }); | 16 add_completion_callback(function() { registration.unregister(); }); |
| 41 return wait_for_state(t, registration.installing, 'activated'); | 17 return wait_for_state(t, registration.installing, 'activated'); |
| 42 }) | 18 }) |
| 43 .then(function() { | 19 .then(function() { |
| 44 var saw_message = new Promise(function(resolve) { | 20 var saw_message = new Promise(function(resolve) { |
| 45 navigator.serviceWorker.onmessage = | 21 navigator.serviceWorker.onmessage = |
| 46 function(event) { resolve(event.data); } | 22 function(event) { resolve(event.data); } |
| 47 }); | 23 }); |
| 48 var channel = new MessageChannel; | 24 var channel = new MessageChannel; |
| 49 registration.active.postMessage('', [channel.port1]); | 25 registration.active.postMessage('', [channel.port1]); |
| 50 return saw_message; | 26 return saw_message; |
| 51 }) | 27 }) |
| 52 .then(function(results) { | 28 .then(function(results) { |
| 53 var expected_results = [ | 29 var expected = { |
| 54 'Client message: [object ExtendableMessageEvent]', | 30 constructor: { name: 'ExtendableMessageEvent' }, |
| 55 ' event.origin: ' + location.origin, | 31 origin: location.origin, |
| 56 ' event.lastEventId: ', | 32 lastEventId: '', |
| 57 ' event.source: [object WindowClient]', | 33 source: { |
| 58 ' event.source.url: ' + location.href, | 34 constructor: { name: 'WindowClient' }, |
| 59 ' event.source.frameType: top-level', | 35 frameType: 'top-level', |
| 60 ' event.source.visibilityState: visible', | 36 url: location.href, |
| 61 ' event.source.focused: true', | 37 visibilityState: 'visible', |
| 62 ' event.ports: [object MessagePort]', | 38 focused: true |
| 63 ]; | 39 }, |
| 64 assert_array_equals(results, expected_results); | 40 ports: [ { constructor: { name: 'MessagePort' } } ] |
| 41 }; |
| 42 ExtendableMessageEventUtils.assert_equals(results, expected); |
| 65 }); | 43 }); |
| 66 }, 'Post an extendable message from a top-level client'); | 44 }, 'Post an extendable message from a top-level client'); |
| 67 | 45 |
| 68 promise_test(function(t) { | 46 promise_test(function(t) { |
| 69 var script = 'resources/extendable-message-event-worker.js'; | 47 var script = 'resources/extendable-message-event-worker.js'; |
| 70 var scope = 'resources/scope/extendable-message-event-from-nested'; | 48 var scope = 'resources/scope/extendable-message-event-from-nested'; |
| 71 var frame; | 49 var frame; |
| 72 | 50 |
| 73 return service_worker_unregister_and_register(t, script, scope) | 51 return service_worker_unregister_and_register(t, script, scope) |
| 74 .then(function(registration) { | 52 .then(function(registration) { |
| 75 add_completion_callback(function() { registration.unregister(); }); | 53 add_completion_callback(function() { registration.unregister(); }); |
| 76 return wait_for_state(t, registration.installing, 'activated'); | 54 return wait_for_state(t, registration.installing, 'activated'); |
| 77 }) | 55 }) |
| 78 .then(function() { return with_iframe(scope); }) | 56 .then(function() { return with_iframe(scope); }) |
| 79 .then(function(f) { | 57 .then(function(f) { |
| 80 frame = f; | 58 frame = f; |
| 81 add_completion_callback(function() { frame.remove(); }); | 59 add_completion_callback(function() { frame.remove(); }); |
| 82 var saw_message = new Promise(function(resolve) { | 60 var saw_message = new Promise(function(resolve) { |
| 83 frame.contentWindow.navigator.serviceWorker.onmessage = | 61 frame.contentWindow.navigator.serviceWorker.onmessage = |
| 84 function(event) { resolve(event.data); } | 62 function(event) { resolve(event.data); } |
| 85 }); | 63 }); |
| 86 f.contentWindow.navigator.serviceWorker.controller.postMessage(''); | 64 f.contentWindow.navigator.serviceWorker.controller.postMessage(''); |
| 87 return saw_message; | 65 return saw_message; |
| 88 }) | 66 }) |
| 89 .then(function(results) { | 67 .then(function(results) { |
| 90 var expected_results = [ | 68 var expected = { |
| 91 'Client message: [object ExtendableMessageEvent]', | 69 constructor: { name: 'ExtendableMessageEvent' }, |
| 92 ' event.origin: ' + frame.contentWindow.location.origin, | 70 origin: location.origin, |
| 93 ' event.lastEventId: ', | 71 lastEventId: '', |
| 94 ' event.source: [object WindowClient]', | 72 source: { |
| 95 ' event.source.url: ' + frame.contentWindow.location.href, | 73 constructor: { name: 'WindowClient' }, |
| 96 ' event.source.frameType: nested', | 74 url: frame.contentWindow.location.href, |
| 97 ' event.source.visibilityState: visible', | 75 frameType: 'nested', |
| 98 ' event.source.focused: false', | 76 visibilityState: 'visible', |
| 99 ' event.ports: ', | 77 focused: false |
| 100 ]; | 78 }, |
| 101 assert_array_equals(results, expected_results); | 79 ports: [] |
| 80 }; |
| 81 ExtendableMessageEventUtils.assert_equals(results, expected); |
| 102 }); | 82 }); |
| 103 }, 'Post an extendable message from a nested client'); | 83 }, 'Post an extendable message from a nested client'); |
| 104 | 84 |
| 105 promise_test(function(t) { | 85 promise_test(function(t) { |
| 106 var script = 'resources/extendable-message-event-loopback-worker.js'; | 86 var script = 'resources/extendable-message-event-loopback-worker.js'; |
| 107 var scope = 'resources/scope/extendable-message-event-loopback'; | 87 var scope = 'resources/scope/extendable-message-event-loopback'; |
| 108 var registration; | 88 var registration; |
| 109 | 89 |
| 110 return service_worker_unregister_and_register(t, script, scope) | 90 return service_worker_unregister_and_register(t, script, scope) |
| 111 .then(function(r) { | 91 .then(function(r) { |
| 112 registration = r; | 92 registration = r; |
| 113 add_completion_callback(function() { registration.unregister(); }); | 93 add_completion_callback(function() { registration.unregister(); }); |
| 114 return wait_for_state(t, registration.installing, 'activated'); | 94 return wait_for_state(t, registration.installing, 'activated'); |
| 115 }) | 95 }) |
| 116 .then(function() { | 96 .then(function() { |
| 117 var results = []; | 97 var results = []; |
| 118 var saw_message = new Promise(function(resolve) { | 98 var saw_message = new Promise(function(resolve) { |
| 119 navigator.serviceWorker.onmessage = function(event) { | 99 navigator.serviceWorker.onmessage = function(event) { |
| 120 switch (event.data.type) { | 100 switch (event.data.type) { |
| 121 case 'record': | 101 case 'record': |
| 122 Array.prototype.push.apply(results, event.data.results); | 102 results.push(event.data.results); |
| 123 break; | 103 break; |
| 124 case 'finish': | 104 case 'finish': |
| 125 resolve(results); | 105 resolve(results); |
| 126 break; | 106 break; |
| 127 } | 107 } |
| 128 }; | 108 }; |
| 129 }); | 109 }); |
| 130 registration.active.postMessage({type: 'start'}); | 110 registration.active.postMessage({type: 'start'}); |
| 131 return saw_message; | 111 return saw_message; |
| 132 }) | 112 }) |
| 133 .then(function(results) { | 113 .then(function(results) { |
| 134 var expected_results = [ | 114 assert_equals(results.length, 2); |
| 135 '1st loopback: [object ExtendableMessageEvent]', | 115 |
| 136 ' event.origin: ' + location.origin, | 116 var expected_trial_1 = { |
| 137 ' event.lastEventId: ', | 117 constructor: { name: 'ExtendableMessageEvent' }, |
| 138 ' event.source: [object ServiceWorker]', | 118 origin: location.origin, |
| 139 ' event.source.scriptURL: ' + normalizeURL(script), | 119 lastEventId: '', |
| 140 ' event.source.state: activated', | 120 source: { |
| 141 ' event.ports: ', | 121 constructor: { name: 'ServiceWorker' }, |
| 142 '2nd loopback: [object ExtendableMessageEvent]', | 122 scriptURL: normalizeURL(script), |
| 143 ' event.origin: ' + location.origin, | 123 state: 'activated' |
| 144 ' event.lastEventId: ', | 124 }, |
| 145 ' event.source: [object ServiceWorker]', | 125 ports: [] |
| 146 ' event.source.scriptURL: ' + normalizeURL(script), | 126 }; |
| 147 ' event.source.state: activated', | 127 assert_equals(results[0].trial, 1); |
| 148 ' event.ports: ', | 128 ExtendableMessageEventUtils.assert_equals( |
| 149 ]; | 129 results[0].event, expected_trial_1 |
| 150 assert_array_equals(results, expected_results); | 130 ); |
| 131 |
| 132 var expected_trial_2 = { |
| 133 constructor: { name: 'ExtendableMessageEvent' }, |
| 134 origin: location.origin, |
| 135 lastEventId: '', |
| 136 source: { |
| 137 constructor: { name: 'ServiceWorker' }, |
| 138 scriptURL: normalizeURL(script), |
| 139 state: 'activated' |
| 140 }, |
| 141 ports: [], |
| 142 }; |
| 143 assert_equals(results[1].trial, 2); |
| 144 ExtendableMessageEventUtils.assert_equals( |
| 145 results[1].event, expected_trial_2 |
| 146 ); |
| 151 }); | 147 }); |
| 152 }, 'Post loopback extendable messages'); | 148 }, 'Post loopback extendable messages'); |
| 153 | 149 |
| 154 promise_test(function(t) { | 150 promise_test(function(t) { |
| 155 var script1 = 'resources/extendable-message-event-ping-worker.js'; | 151 var script1 = 'resources/extendable-message-event-ping-worker.js'; |
| 156 var script2 = 'resources/extendable-message-event-pong-worker.js'; | 152 var script2 = 'resources/extendable-message-event-pong-worker.js'; |
| 157 var scope = 'resources/scope/extendable-message-event-pingpong'; | 153 var scope = 'resources/scope/extendable-message-event-pingpong'; |
| 158 var registration; | 154 var registration; |
| 159 | 155 |
| 160 return service_worker_unregister_and_register(t, script1, scope) | 156 return service_worker_unregister_and_register(t, script1, scope) |
| (...skipping 12 matching lines...) Expand all Loading... |
| 173 }) | 169 }) |
| 174 .then(function(r) { | 170 .then(function(r) { |
| 175 return wait_for_state(t, r.installing, 'installed'); | 171 return wait_for_state(t, r.installing, 'installed'); |
| 176 }) | 172 }) |
| 177 .then(function() { | 173 .then(function() { |
| 178 var results = []; | 174 var results = []; |
| 179 var saw_message = new Promise(function(resolve) { | 175 var saw_message = new Promise(function(resolve) { |
| 180 navigator.serviceWorker.onmessage = function(event) { | 176 navigator.serviceWorker.onmessage = function(event) { |
| 181 switch (event.data.type) { | 177 switch (event.data.type) { |
| 182 case 'record': | 178 case 'record': |
| 183 Array.prototype.push.apply(results, event.data.results); | 179 results.push(event.data.results); |
| 184 break; | 180 break; |
| 185 case 'finish': | 181 case 'finish': |
| 186 resolve(results); | 182 resolve(results); |
| 187 break; | 183 break; |
| 188 } | 184 } |
| 189 }; | 185 }; |
| 190 }); | 186 }); |
| 191 registration.active.postMessage({type: 'start'}); | 187 registration.active.postMessage({type: 'start'}); |
| 192 return saw_message; | 188 return saw_message; |
| 193 }) | 189 }) |
| 194 .then(function(results) { | 190 .then(function(results) { |
| 195 var expected_results = [ | 191 assert_equals(results.length, 2); |
| 196 'Ping message: [object ExtendableMessageEvent]', | 192 |
| 197 ' event.origin: ' + location.origin, | 193 var expected_ping = { |
| 198 ' event.lastEventId: ', | 194 constructor: { name: 'ExtendableMessageEvent' }, |
| 199 ' event.source: [object ServiceWorker]', | 195 origin: location.origin, |
| 200 ' event.source.scriptURL: ' + normalizeURL(script1), | 196 lastEventId: '', |
| 201 ' event.source.state: activated', | 197 source: { |
| 202 ' event.ports: ', | 198 constructor: { name: 'ServiceWorker' }, |
| 203 'Pong message: [object ExtendableMessageEvent]', | 199 scriptURL: normalizeURL(script1), |
| 204 ' event.origin: ' + location.origin, | 200 state: 'activated' |
| 205 ' event.lastEventId: ', | 201 }, |
| 206 ' event.source: [object ServiceWorker]', | 202 ports: [] |
| 207 ' event.source.scriptURL: ' + normalizeURL(script2), | 203 }; |
| 208 ' event.source.state: installed', | 204 assert_equals(results[0].pingOrPong, 'ping'); |
| 209 ' event.ports: ', | 205 ExtendableMessageEventUtils.assert_equals( |
| 210 ]; | 206 results[0].event, expected_ping |
| 211 assert_array_equals(results, expected_results); | 207 ); |
| 208 |
| 209 var expected_pong = { |
| 210 constructor: { name: 'ExtendableMessageEvent' }, |
| 211 origin: location.origin, |
| 212 lastEventId: '', |
| 213 source: { |
| 214 constructor: { name: 'ServiceWorker' }, |
| 215 scriptURL: normalizeURL(script2), |
| 216 state: 'installed' |
| 217 }, |
| 218 ports: [] |
| 219 }; |
| 220 assert_equals(results[1].pingOrPong, 'pong'); |
| 221 ExtendableMessageEventUtils.assert_equals( |
| 222 results[1].event, expected_pong |
| 223 ); |
| 212 }); | 224 }); |
| 213 }, 'Post extendable messages among service workers'); | 225 }, 'Post extendable messages among service workers'); |
| 214 | |
| 215 </script> | 226 </script> |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2751113005:
Upstream service worker message event tests to WPT (Closed)
