1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/content/media/test/test_preload_actions.html Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,625 @@
1.4 +<!DOCTYPE HTML>
1.5 +<html>
1.6 +<!--
1.7 +https://bugzilla.mozilla.org/show_bug.cgi?id=548523
1.8 +-->
1.9 +<head>
1.10 + <title>Test for Bug 548523</title>
1.11 + <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
1.12 + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
1.13 + <script type="text/javascript" src="manifest.js"></script>
1.14 +</head>
1.15 +<body>
1.16 +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=548523">Mozilla Bug 548523</a>
1.17 +<p id="display"></p>
1.18 +<div id="content" style="display: none">
1.19 +
1.20 +</div>
1.21 +<!-- <button onClick="SimpleTest.finish();">Finish</button> -->
1.22 +<div>Tests complete: <span id="log" style="font-size: small;"></span></div>
1.23 +<pre id="test">
1.24 +<script type="application/javascript">
1.25 +
1.26 +/** Test for Bug 548523 **/
1.27 +
1.28 +var manager = new MediaTestManager;
1.29 +
1.30 +manager.onFinished = function() {
1.31 + is(gotLoadEvent, true, "Should not have delayed the load event indefinitely");
1.32 +};
1.33 +
1.34 +var test = getPlayableVideo(gSeekTests);
1.35 +var baseName = test.name;
1.36 +var gTest = test;
1.37 +var bogusSrc = "bogus.duh";
1.38 +var bogusType = "video/bogus";
1.39 +var gotLoadEvent = false;
1.40 +var finished = false;
1.41 +
1.42 +addLoadEvent(function() {gotLoadEvent=true;});
1.43 +
1.44 +function log(m) {
1.45 + var l = document.getElementById("log");
1.46 + l.innerHTML += m;
1.47 +}
1.48 +
1.49 +function maybeFinish(v, n) {
1.50 + if (v._finished) {
1.51 + return;
1.52 + }
1.53 + v._finished = true;
1.54 + log(n + ",");
1.55 + removeNodeAndSource(v);
1.56 + manager.finished(v.token);
1.57 +}
1.58 +
1.59 +function filename(uri) {
1.60 + return uri.substr(uri.lastIndexOf("/")+1);
1.61 +}
1.62 +
1.63 +// Every test must have a setup(v) function, and must call maybeFinish() when test is complete.
1.64 +var tests = [
1.65 + {
1.66 + // 1. Add preload:none video with src to document. Load should halt at NETWORK_IDLE and HAVE_NOTHING,
1.67 + // after receiving a suspend event. Should not receive loaded events until after we call load().
1.68 + // Note the suspend event is explictly sent by our "stop the load" code, but other tests can't rely
1.69 + // on it for the preload:metadata case, as there can be multiple suspend events when loading metadata.
1.70 + suspend:
1.71 + function(e) {
1.72 + var v = e.target;
1.73 + is(v._gotLoadStart, true, "(1) Must get loadstart.");
1.74 + is(v._gotLoadedMetaData, false, "(1) Must not get loadedmetadata.");
1.75 + is(v.readyState, v.HAVE_NOTHING, "(1) ReadyState must be HAVE_NOTHING");
1.76 + // bug 962949
1.77 + // is(v.networkState, v.NETWORK_IDLE, "(1) NetworkState must be NETWORK_IDLE");
1.78 + maybeFinish(v, 1);
1.79 + },
1.80 +
1.81 + setup:
1.82 + function(v) {
1.83 + v._gotLoadStart = false;
1.84 + v._gotLoadedMetaData = false;
1.85 + v.preload = "none";
1.86 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.87 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.88 + v.addEventListener("suspend", this.suspend, false);
1.89 + v.src = test.name;
1.90 + document.body.appendChild(v); // Causes implicit load, which will be halted due to preload:none.
1.91 + },
1.92 +
1.93 + name: "test1",
1.94 + },
1.95 + {
1.96 + // 2. Add preload:metadata video with src to document. Should halt with NETWORK_IDLE, HAVE_CURRENT_DATA
1.97 + // after suspend event and after loadedmetadata.
1.98 + loadeddata:
1.99 + function(e) {
1.100 + var v = e.target;
1.101 + is(v._gotLoadStart, true, "(2) Must get loadstart.");
1.102 + is(v._gotLoadedMetaData, true, "(2) Must get loadedmetadata.");
1.103 + ok(v.readyState >= v.HAVE_CURRENT_DATA, "(2) ReadyState must be >= HAVE_CURRENT_DATA");
1.104 + // bug 962949
1.105 + // is(v.networkState, v.NETWORK_IDLE, "(2) NetworkState must be NETWORK_IDLE");
1.106 + maybeFinish(v, 2);
1.107 + },
1.108 +
1.109 + setup:
1.110 + function(v) {
1.111 + v._gotLoadStart = false;
1.112 + v._gotLoadedMetaData = false;
1.113 + v.preload = "metadata";
1.114 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.115 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.116 + v.addEventListener("loadeddata", this.loadeddata, false);
1.117 + v.src = test.name;
1.118 + document.body.appendChild(v); // Causes implicit load, which will be halted after
1.119 + // metadata due to preload:metadata.
1.120 + },
1.121 +
1.122 + name: "test2",
1.123 + },
1.124 + {
1.125 + // 3. Add preload:auto to document. Should receive canplaythrough eventually.
1.126 + canplaythrough:
1.127 + function(e) {
1.128 + var v = e.target;
1.129 + is(v._gotLoadStart, true, "(3) Must get loadstart.");
1.130 + is(v._gotLoadedMetaData, true, "(3) Must get loadedmetadata.");
1.131 + maybeFinish(v, 3);
1.132 + },
1.133 +
1.134 + setup:
1.135 + function(v) {
1.136 + v._gotLoadStart = false;
1.137 + v._gotLoadedMetaData = false;
1.138 + v.preload = "auto";
1.139 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.140 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.141 + v.addEventListener("canplaythrough", this.canplaythrough, false);
1.142 + v.src = test.name; // Causes implicit load.
1.143 + document.body.appendChild(v);
1.144 + },
1.145 +
1.146 + name: "test3",
1.147 + },
1.148 + {
1.149 + // 4. Add preload:none video to document. Call play(), should load then play through.
1.150 + suspend:
1.151 + function(e) {
1.152 + var v = e.target;
1.153 + if (v._gotSuspend) {
1.154 + return; // We can receive multiple suspend events, like the one after download completes.
1.155 + }
1.156 + v._gotSuspend = true;
1.157 + is(v._gotLoadStart, true, "(4) Must get loadstart.");
1.158 + is(v._gotLoadedMetaData, false, "(4) Must not get loadedmetadata.");
1.159 + is(v.readyState, v.HAVE_NOTHING, "(4) ReadyState must be HAVE_NOTHING");
1.160 + // bug 962949
1.161 + // is(v.networkState, v.NETWORK_IDLE, "(4) NetworkState must be NETWORK_IDLE");
1.162 + v.play(); // Should load and play through.
1.163 + },
1.164 +
1.165 + ended:
1.166 + function(e) {
1.167 + ok(true, "(4) Got playback ended");
1.168 + maybeFinish(e.target, 4);
1.169 + },
1.170 +
1.171 + setup:
1.172 + function(v) {
1.173 + v._gotLoadStart = false;
1.174 + v._gotLoadedMetaData = false;
1.175 + v._gotSuspend = false;
1.176 + v.preload = "none";
1.177 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.178 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.179 + v.addEventListener("suspend", this.suspend, false);
1.180 + v.addEventListener("ended", this.ended, false);
1.181 + v.src = test.name;
1.182 + document.body.appendChild(v);
1.183 + },
1.184 +
1.185 + name: "test4",
1.186 + },
1.187 + {
1.188 + // 5. preload:none video without resource, add to document, will implicitly start a
1.189 + // preload:none load. Add a src, it shouldn't load.
1.190 + suspend:
1.191 + function(e) {
1.192 + var v = e.target;
1.193 + is(v._gotLoadStart, true, "(5) Must get loadstart.");
1.194 + is(v._gotLoadedMetaData, false, "(5) Must not get loadedmetadata.");
1.195 + is(v.readyState, v.HAVE_NOTHING, "(5) ReadyState must be HAVE_NOTHING");
1.196 + // bug 962949
1.197 + // is(v.networkState, v.NETWORK_IDLE, "(5) NetworkState must be NETWORK_IDLE");
1.198 + maybeFinish(v, 5);
1.199 + },
1.200 +
1.201 + setup:
1.202 + function(v) {
1.203 + v._gotLoadStart = false;
1.204 + v._gotLoadedMetaData = false;
1.205 + v.preload = "none";
1.206 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.207 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.208 + v.addEventListener("suspend", this.suspend, false);
1.209 + document.body.appendChild(v); // Causes implicit load, which will be halted due to no resource.
1.210 + v.src = test.name; // Load should start, and halt at preload:none.
1.211 + },
1.212 +
1.213 + name: "test5",
1.214 + },
1.215 + {
1.216 + // 6. preload:none video without resource, add to document, will implicitly start a
1.217 + // preload:none load. Add a source, it shouldn't load.
1.218 + suspend:
1.219 + function(e) {
1.220 + var v = e.target;
1.221 + is(v._gotLoadStart, true, "(6) Must get loadstart.");
1.222 + is(v._gotLoadedMetaData, false, "(6) Must not get loadedmetadata.");
1.223 + is(v.readyState, v.HAVE_NOTHING, "(6) ReadyState must be HAVE_NOTHING");
1.224 + // bug 962949
1.225 + // is(v.networkState, v.NETWORK_IDLE, "(6) NetworkState must be NETWORK_IDLE");
1.226 + maybeFinish(v, 6);
1.227 + },
1.228 +
1.229 + setup:
1.230 + function(v) {
1.231 + v._gotLoadStart = false;
1.232 + v._gotLoadedMetaData = false;
1.233 + v.preload = "none";
1.234 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.235 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.236 + v.addEventListener("suspend", this.suspend, false);
1.237 + document.body.appendChild(v); // Causes implicit load, which will be halted due to no resource.
1.238 + var s = document.createElement("source");
1.239 + s.src = test.name;
1.240 + s.type = test.type;
1.241 + v.appendChild(s); // Load should start, and halt at preload:none.
1.242 + },
1.243 +
1.244 + name: "test6",
1.245 + },
1.246 + {
1.247 + // 7. create a preload:none document with multiple sources, the first of which is invalid.
1.248 + // Add to document, then play. It should load and play through the second source.
1.249 + suspend:
1.250 + function(e) {
1.251 + var v = e.target;
1.252 + if (v._gotSuspend)
1.253 + return; // We can receive multiple suspend events, like the one after download completes.
1.254 + v._gotSuspend = true;
1.255 + is(v._gotLoadStart, true, "(7) Must get loadstart.");
1.256 + is(v._gotLoadedMetaData, false, "(7) Must not get loadedmetadata.");
1.257 + is(v.readyState, v.HAVE_NOTHING, "(7) ReadyState must be HAVE_NOTHING");
1.258 + // bug 962949
1.259 + // is(v.networkState, v.NETWORK_IDLE, "(7) NetworkState must be NETWORK_IDLE");
1.260 + v.play(); // Should load and play through.
1.261 + },
1.262 +
1.263 + ended:
1.264 + function(e) {
1.265 + ok(true, "(7) Got playback ended");
1.266 + var v = e.target;
1.267 + is(v._gotErrorEvent, true, "(7) Should get error event from first source load failure");
1.268 + maybeFinish(v, 7);
1.269 + },
1.270 +
1.271 + setup:
1.272 + function(v) {
1.273 + v._gotLoadStart = false;
1.274 + v._gotLoadedMetaData = false;
1.275 + v.preload = "none";
1.276 + v._gotErrorEvent = false;
1.277 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.278 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.279 + v.addEventListener("suspend", this.suspend, false);
1.280 + v.addEventListener("ended", this.ended, false);
1.281 + var s1 = document.createElement("source");
1.282 + s1.src = "not-a-real-file.404"
1.283 + s1.type = test.type;
1.284 + s1.addEventListener("error", function(e){v._gotErrorEvent = true;}, false);
1.285 + v.appendChild(s1);
1.286 + var s2 = document.createElement("source");
1.287 + s2.src = test.name;
1.288 + s2.type = test.type;
1.289 + v.appendChild(s2);
1.290 + document.body.appendChild(v); // Causes implicit load, which will be halt at preload:none on the second resource.
1.291 + },
1.292 +
1.293 + name: "test7",
1.294 + },
1.295 + {
1.296 + // 8. Change preload value from none to metadata should cause metadata to be loaded.
1.297 + loadeddata:
1.298 + function(e) {
1.299 + var v = e.target;
1.300 + is(v._gotLoadedMetaData, true, "(8) Must get loadedmetadata.");
1.301 + ok(v.readyState >= v.HAVE_CURRENT_DATA, "(8) ReadyState must be >= HAVE_CURRENT_DATA on suspend.");
1.302 + // bug 962949
1.303 + // is(v.networkState, v.NETWORK_IDLE, "(8) NetworkState must be NETWORK_IDLE when load is halted");
1.304 + maybeFinish(v, 8);
1.305 + },
1.306 +
1.307 + setup:
1.308 + function(v) {
1.309 + v._gotLoadedMetaData = false;
1.310 + v.preload = "none";
1.311 + v.addEventListener("loadstart", function(e){v.preload = "metadata";}, false);
1.312 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.313 + v.addEventListener("loadeddata", this.loadeddata, false);
1.314 + v.src = test.name; // Causes implicit load.
1.315 + document.body.appendChild(v);
1.316 + },
1.317 +
1.318 + name: "test8",
1.319 + },
1.320 + /*{
1.321 + // 9. Change preload value from metadata to auto should cause entire media to be loaded.
1.322 + // For some reason we don't always receive the canplaythrough event, particuarly on this test.
1.323 + // We've disabled this test until bug 568402 is fixed.
1.324 + canplaythrough:
1.325 + function(e) {
1.326 + var v = e.target;
1.327 + is(v._gotLoadStart, true, "(9) Must get loadstart.");
1.328 + is(v._gotLoadedMetaData, true, "(9) Must get loadedmetadata.");
1.329 + maybeFinish(v, 9);
1.330 + },
1.331 +
1.332 + setup:
1.333 + function(v) {
1.334 + v._gotLoadStart = false;
1.335 + v._gotLoadedMetaData = false;
1.336 + v.preload = "metadata";
1.337 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.338 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.339 + v.addEventListener("loadeddata", function(){v.preload = "auto"}, false);
1.340 + v.addEventListener("canplaythrough", this.canplaythrough, false);
1.341 + v.src = test.name; // Causes implicit load.
1.342 + document.body.appendChild(v);
1.343 + },
1.344 + },*/
1.345 + {
1.346 + // 10. Change preload value from none to auto should cause entire media to be loaded.
1.347 + canplaythrough:
1.348 + function(e) {
1.349 + var v = e.target;
1.350 + is(v._gotLoadedMetaData, true, "(10) Must get loadedmetadata.");
1.351 + maybeFinish(v, 10);
1.352 + },
1.353 +
1.354 + setup:
1.355 + function(v) {
1.356 + v._gotLoadedMetaData = false;
1.357 + v.preload = "none";
1.358 + v.addEventListener("loadstart", function(e){v.preload = "auto";}, false);
1.359 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.360 + v.addEventListener("canplaythrough", this.canplaythrough, false);
1.361 + v.src = test.name; // Causes implicit load.
1.362 + document.body.appendChild(v);
1.363 + },
1.364 +
1.365 + name: "test10",
1.366 + },
1.367 + {
1.368 + // 11. Change preload value from none to metadata should cause metadata to load.
1.369 + loadeddata:
1.370 + function(e) {
1.371 + var v = e.target;
1.372 + is(v._gotLoadedMetaData, true, "(11) Must get loadedmetadata.");
1.373 + ok(v.readyState >= v.HAVE_CURRENT_DATA, "(11) ReadyState must be >= HAVE_CURRENT_DATA.");
1.374 + // bug 962949
1.375 + // is(v.networkState, v.NETWORK_IDLE, "(11) NetworkState must be NETWORK_IDLE.");
1.376 + maybeFinish(v, 11);
1.377 + },
1.378 +
1.379 + setup:
1.380 + function(v) {
1.381 + v._gotLoadedMetaData = false;
1.382 + v.preload = "none";
1.383 + v.addEventListener("loadstart", function(e){v.preload = "metadata";}, false);
1.384 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.385 + v.addEventListener("loadeddata", this.loadeddata, false);
1.386 + v.src = test.name; // Causes implicit load.
1.387 + document.body.appendChild(v);
1.388 + },
1.389 +
1.390 + name: "test11",
1.391 + },
1.392 + /*{
1.393 + // 12. Change preload value from auto to metadata after load started,
1.394 + // should still do full load, should not halt after metadata only.
1.395 + // disable this test since the spec is no longer found in the document
1.396 + // http://dev.w3.org/html5/spec-preview/media-elements.html
1.397 + canplaythrough:
1.398 + function(e) {
1.399 + var v = e.target;
1.400 + is(v._gotLoadedMetaData, true, "(12) Must get loadedmetadata.");
1.401 + is(v._gotLoadStart, true, "(12) Must get loadstart.");
1.402 + maybeFinish(v, 12);
1.403 + },
1.404 +
1.405 + setup:
1.406 + function(v) {
1.407 + v._gotLoadStart = false;
1.408 + v._gotLoadedMetaData = false;
1.409 + v.preload = "auto";
1.410 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.411 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.412 + v.addEventListener("canplaythrough", this.canplaythrough, false);
1.413 + v.src = test.name; // Causes implicit load.
1.414 + document.body.appendChild(v);
1.415 + v.preload = "metadata";
1.416 + },
1.417 +
1.418 + name: "test12",
1.419 + },*/
1.420 + {
1.421 + // 13. Change preload value from auto to none after specifying a src
1.422 + // should load according to preload none, no buffering should have taken place
1.423 + suspend:
1.424 + function(e) {
1.425 + var v = e.target;
1.426 + is(v._gotLoadStart, true, "(13) Must get loadstart.");
1.427 + is(v._gotLoadedMetaData, false, "(13) Must not get loadedmetadata.");
1.428 + is(v.readyState, v.HAVE_NOTHING, "(13) ReadyState must be HAVE_NOTHING");
1.429 + // bug 962949
1.430 + // is(v.networkState, v.NETWORK_IDLE, "(13) NetworkState must be NETWORK_IDLE");
1.431 + maybeFinish(v, 13);
1.432 + },
1.433 +
1.434 + setup:
1.435 + function(v) {
1.436 + v._gotLoadStart = false;
1.437 + v._gotLoadedMetaData = false;
1.438 + v.preload = "auto";
1.439 + v.src = test.name;
1.440 + v.preload = "none";
1.441 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.442 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.443 + v.addEventListener("suspend", this.suspend, false);
1.444 + document.body.appendChild(v); // Causes implicit load, should load according to preload none
1.445 + var s = document.createElement("source");
1.446 + },
1.447 +
1.448 + name: "test13",
1.449 + },
1.450 + {
1.451 + // 14. Add preload:metadata video with src to document. Play(), should play through.
1.452 + loadeddata:
1.453 + function(e) {
1.454 + var v = e.target;
1.455 + is(v._gotLoadStart, true, "(14) Must get loadstart.");
1.456 + is(v._gotLoadedMetaData, true, "(14) Must get loadedmetadata.");
1.457 + ok(v.readyState >= v.HAVE_CURRENT_DATA, "(14) ReadyState must be >= HAVE_CURRENT_DATA");
1.458 + // bug 962949
1.459 + // is(v.networkState, v.NETWORK_IDLE, "(14) NetworkState must be NETWORK_IDLE");
1.460 + v.play();
1.461 + },
1.462 +
1.463 + ended:
1.464 + function(e) {
1.465 + ok(true, "(14) Got playback ended");
1.466 + var v = e.target;
1.467 + maybeFinish(v, 14);
1.468 + },
1.469 +
1.470 + setup:
1.471 + function(v) {
1.472 + v._gotLoadStart = false;
1.473 + v._gotLoadedMetaData = false;
1.474 + v.preload = "metadata";
1.475 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.476 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.477 + v.addEventListener("ended", this.ended, false);
1.478 + v.addEventListener("loadeddata", this.loadeddata, false);
1.479 + v.src = test.name;
1.480 + document.body.appendChild(v); // Causes implicit load, which will be halted after
1.481 + // metadata due to preload:metadata.
1.482 + },
1.483 +
1.484 + name: "test14",
1.485 + },
1.486 + {
1.487 + // 15. Autoplay should override preload:none.
1.488 + ended:
1.489 + function(e) {
1.490 + ok(true, "(15) Got playback ended.");
1.491 + var v = e.target;
1.492 + maybeFinish(v, 15);
1.493 + },
1.494 +
1.495 + setup:
1.496 + function(v) {
1.497 + v._gotLoadStart = false;
1.498 + v._gotLoadedMetaData = false;
1.499 + v.preload = "none";
1.500 + v.autoplay = true;
1.501 + v.addEventListener("loadstart", function(e){v._gotLoadStart = true;}, false);
1.502 + v.addEventListener("loadedmetadata", function(e){v._gotLoadedMetaData = true;}, false);
1.503 + v.addEventListener("ended", this.ended, false);
1.504 + v.src = test.name; // Causes implicit load.
1.505 + document.body.appendChild(v);
1.506 + },
1.507 +
1.508 + name: "test15",
1.509 + },
1.510 + {
1.511 + // 16. Autoplay should override preload:metadata.
1.512 + ended:
1.513 + function(e) {
1.514 + ok(true, "(16) Got playback ended.");
1.515 + var v = e.target;
1.516 + maybeFinish(v, 16);
1.517 + },
1.518 +
1.519 + setup:
1.520 + function(v) {
1.521 + v.preload = "metadata";
1.522 + v.autoplay = true;
1.523 + v.addEventListener("ended", this.ended, false);
1.524 + v.src = test.name; // Causes implicit load.
1.525 + document.body.appendChild(v);
1.526 + },
1.527 +
1.528 + name: "test16",
1.529 + },
1.530 + {
1.531 + // 17. On a preload:none video, adding autoplay should disable preload none, i.e. don't break autoplay!
1.532 + ended:
1.533 + function(e) {
1.534 + ok(true, "(17) Got playback ended.");
1.535 + var v = e.target;
1.536 + maybeFinish(v, 17);
1.537 + },
1.538 +
1.539 + setup:
1.540 + function(v) {
1.541 + v.addEventListener("ended", this.ended, false);
1.542 + v.preload = "none";
1.543 + document.body.appendChild(v); // Causes implicit load, which will be halted due to preload:none.
1.544 + v.autoplay = true;
1.545 + v.src = test.name;
1.546 + },
1.547 +
1.548 + name: "test17",
1.549 + },
1.550 + {
1.551 + // 18. On a preload='none' video, call play() before load algorithms's sync
1.552 + // has run, the play() call should override preload='none'.
1.553 + ended:
1.554 + function(e) {
1.555 + ok(true, "(18) Got playback ended.");
1.556 + var v = e.target;
1.557 + maybeFinish(v, 18);
1.558 + },
1.559 +
1.560 + setup:
1.561 + function(v) {
1.562 + v.addEventListener("ended", this.ended, false);
1.563 + v.preload = "none";
1.564 + v.src = test.name; // Schedules async section to continue load algorithm.
1.565 + document.body.appendChild(v);
1.566 + v.play(); // Should cause preload:none to be overridden.
1.567 + },
1.568 +
1.569 + name: "test18",
1.570 + },
1.571 + {
1.572 + // 19. Set preload='auto' on first video source then switching preload='none' and swapping the video source to another.
1.573 + // The second video should not start playing as it's preload state has been changed to 'none' from 'auto'
1.574 + loadedmetadata: function(e) {
1.575 + var v = e.target;
1.576 + is(v.preload === "auto", true, "(19) preload is initially auto");
1.577 + setTimeout(function() {
1.578 + // set preload state to none and switch video sources
1.579 + v.preload="none";
1.580 + v.src = test.name + "?asdf";
1.581 + setTimeout(function() {
1.582 + is(v.readyState === 0, true, "(19) no buffering has taken place");
1.583 + maybeFinish(v, 19);
1.584 + }, 2000);
1.585 + }, 2000);
1.586 +
1.587 + },
1.588 +
1.589 + setup:
1.590 + function(v) {
1.591 + var that = this;
1.592 + v.preload = "auto";
1.593 + v.src = test.name;
1.594 + // add a listener for when the video has loaded, so we know preload auto has worked
1.595 + v.addEventListener( "loadedmetadata", this.loadedmetadata, false);
1.596 + document.body.appendChild(v);
1.597 + },
1.598 +
1.599 + name: "test19",
1.600 + }
1.601 +];
1.602 +
1.603 +var iterationCount = 0;
1.604 +function startTest(test, token) {
1.605 + if (test == tests[0]) {
1.606 + ++iterationCount;
1.607 + info("iterationCount=" + iterationCount);
1.608 + }
1.609 + if (iterationCount == 2) {
1.610 + // Do this series of tests on logically different resources
1.611 + test.name = baseName + "?" + Math.floor(Math.random()*100000);
1.612 + }
1.613 + var v = document.createElement("video");
1.614 + v.token = token;
1.615 + test.setup(v);
1.616 + manager.started(token);
1.617 +}
1.618 +
1.619 +var twiceTests = tests.concat(tests);
1.620 +SimpleTest.waitForExplicitFinish();
1.621 +SpecialPowers.pushPrefEnv({"set": [["media.cache_size", 40000]]}, beginTest);
1.622 +function beginTest() {
1.623 + manager.runTests(twiceTests, startTest);
1.624 +}
1.625 +</script>
1.626 +</pre>
1.627 +</body>
1.628 +</html>
