LayoutTests/web-animations-api/player-state-changes.html - Issue 555063002: Web Animations: Add tests for player state transitions and fix discovered issues

Side by Side Diff: LayoutTests/web-animations-api/player-state-changes.html

Issue 555063002: Web Animations: Add tests for player state transitions and fix discovered issues (Closed) Base URL: svn://svn.chromium.org/blink/trunk

Patch Set: Created 6 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
(Empty)
	1 <!DOCTYPE html>

	2 <script src="../resources/testharness.js"></script>

	3 <script src="../resources/testharnessreport.js"></script>

	4

	5 <script>

	6 setTimeout(function() { window.location.reload()}, 500);

	7 </script>

	8

	9 <script>

	10 function assert_unresolved(value) {

	11 assert_true(isNaN(value));

	12 }

	13

	14 function idlePlayer() {

	15 var player = document.documentElement.animate([], 100000);

	16 player.cancel();

	17 assert_equals(player.playState, 'idle');

	18 return player;

	19 }

	20

	21 function runningPlayer() {

	22 var player = document.documentElement.animate([], 100000);

	23 player.startTime = document.timeline.currentTime;

	24 return player;

	25 }

	26

	27 function pendingStartTimePlayer() {

	28 var player = document.documentElement.animate([], 100000);

	29 return player;

	30 }

	31

	32 function pendingStartTimeAndCurrentTimePlayer() {

	33 var player = document.documentElement.animate([], 100000);

	34 player.pause();

	35 player.play();

	36 return player;

	37 }

	38

	39 function pausedPlayer() {

	40 var player = document.documentElement.animate([], 100000);

	41 player.pause();

	42 player.currentTime = 0;

	43 return player;

	44 }

	45

	46 function finishedPlayer() {

	47 var player = document.documentElement.animate([], 100000);

	48 player.finish();

	49 return player;

	50 }

	51

	52 test(function() {

	53 var player = idlePlayer();

	54 assert_unresolved(player.startTime);

	55 assert_unresolved(player.currentTime);

	56 assert_equals(player.playState, 'idle');

	57 }, "idle");

	58

	59 test(function() {

	60 var player = pendingStartTimePlayer();

	61 assert_unresolved(player.startTime);

	62 assert_equals(player.currentTime, 0);

	63 assert_equals(player.playState, 'pending');

	64 }, "pending startTime");

	65

	66 test(function() {

	67 var player = pendingStartTimeAndCurrentTimePlayer();

	68 assert_unresolved(player.startTime);

	69 assert_unresolved(player.currentTime);

	70 assert_equals(player.playState, 'pending');

	71 }, "pending startTime and currentTime");

	72

	73 test(function() {

	74 var player = runningPlayer();

	75 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	76 assert_equals(player.currentTime, 0);

	77 assert_equals(player.playState, 'running');

	78 }, "running");
	shans 2014/09/09 09:43:10 This is a bit of a nonsense test - all of the asse This is a bit of a nonsense test - all of the assertions here are either established or tested directly in runningPlayer(). dstockwell 2014/09/09 09:59:49 These are testing that runningPlayer() and friends Show quoted text On 2014/09/09 09:43:10, shans wrote: > This is a bit of a nonsense test - all of the assertions here are either > established or tested directly in runningPlayer(). These are testing that runningPlayer() and friends are establishing players in the expected states. The assertion in idlePlayer() isn't meant to be there.
	79

	80 test(function() {

	81 var player = pausedPlayer();

	82 assert_unresolved(player.startTime);

	83 assert_equals(player.currentTime, 0);

	84 assert_equals(player.playState, 'paused');

	85 }, "paused");

	86

	87 test(function() {

	88 var player = finishedPlayer();

	89 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	90 assert_equals(player.currentTime, 100000);

	91 assert_equals(player.playState, 'finished');

	92 }, "finished");

	93

	94 test(function() {

	95 var player = idlePlayer();

	96 player.play();

	97 assert_unresolved(player.startTime);

	98 assert_equals(player.currentTime, 0);

	99 assert_equals(player.playState, 'pending');

	100 }, "idle -> play()");

	101

	102 test(function() {

	103 var player = idlePlayer();

	104 player.pause();

	105 assert_unresolved(player.startTime);

	106 assert_unresolved(player.currentTime);

	107 assert_equals(player.playState, 'idle');

	108 }, "idle -> pause()");

	109

	110 test(function() {

	111 var player = idlePlayer();

	112 player.cancel();

	113 assert_unresolved(player.startTime);

	114 assert_unresolved(player.currentTime);

	115 assert_equals(player.playState, 'idle');

	116 }, "idle -> cancel()");

	117

	118 test(function() {

	119 var player = idlePlayer();

	120 player.finish();

	121 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	122 assert_equals(player.currentTime, 100000);

	123 assert_equals(player.playState, 'finished');
	shans 2014/09/09 09:43:10 I'm not sure that this makes sense. If paused and I'm not sure that this makes sense. If paused and finished are independent, should idle and finished be independent too? i.e. should there be a ghost currentTime while idle, and calling finish() or setting currentTime updates this, but you're still idle unless play() is called? Or should there be a separate activate() method? dstockwell 2014/09/09 23:20:03 OK, if finish() is just seek, then finish() should Show quoted text On 2014/09/09 at 09:43:10, shans wrote: > I'm not sure that this makes sense. If paused and finished are independent, should idle and finished be independent too? > > i.e. should there be a ghost currentTime while idle, and calling finish() or setting currentTime updates this, but you're still idle unless play() is called? > > Or should there be a separate activate() method? OK, if finish() is just seek, then finish() should not do anything while idle -- the same as setting currentTime/startTime.
	124 }, "idle -> finish()");

	125

	126 test(function() {

	127 var player = idlePlayer();

	128 player.reverse();

	129 assert_unresolved(player.startTime);

	130 assert_equals(player.currentTime, 100000);

	131 assert_equals(player.playState, 'pending');

	132 }, "idle -> reverse()");

	133

	134 test(function() {

	135 var player = idlePlayer();

	136 player.currentTime = 1000;

	137 assert_unresolved(player.startTime);

	138 assert_unresolved(player.currentTime);

	139 assert_equals(player.playState, 'idle');

	140 }, "idle -> set currentTime");
	shans 2014/09/09 09:43:10 why should this act differently to finish()? why should this act differently to finish()?
	141

	142 test(function() {

	143 var player = idlePlayer();

	144 player.startTime = 1000;

	145 assert_unresolved(player.startTime);

	146 assert_unresolved(player.currentTime);

	147 assert_equals(player.playState, 'idle');

	148 }, "idle -> set startTime");

	149

	150 test(function() {

	151 var player = pendingStartTimePlayer();

	152 player.play();

	153 assert_unresolved(player.startTime);

	154 assert_equals(player.currentTime, 0);

	155 assert_equals(player.playState, 'pending');

	156 }, "pending startTime -> play()");

	157

	158 test(function() {

	159 var player = pendingStartTimePlayer();

	160 player.pause();

	161 assert_unresolved(player.startTime);

	162 assert_unresolved(player.currentTime);

	163 assert_equals(player.playState, 'pending');

	164 }, "pending startTime -> pause()");

	165

	166 test(function() {

	167 var player = pendingStartTimePlayer();

	168 player.cancel();

	169 assert_unresolved(player.startTime);

	170 assert_unresolved(player.currentTime);

	171 assert_equals(player.playState, 'idle');

	172 }, "pending startTime -> cancel()");

	173

	174 test(function() {

	175 var player = pendingStartTimePlayer();

	176 player.finish();

	177 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	178 assert_equals(player.currentTime, 100000);

	179 assert_equals(player.playState, 'finished');

	180 }, "pending startTime -> finish()");

	181

	182 test(function() {

	183 var player = pendingStartTimePlayer();

	184 player.reverse();

	185 assert_unresolved(player.startTime);

	186 assert_equals(player.currentTime, 100000);

	187 assert_equals(player.playState, 'pending');

	188 }, "pending startTime -> reverse()");

	189

	190 test(function() {

	191 var player = pendingStartTimePlayer();

	192 player.currentTime = 1000;

	193 assert_unresolved(player.startTime);

	194 assert_equals(player.currentTime, 1000);

	195 assert_equals(player.playState, 'pending');

	196 }, "pending startTime -> set currentTime");
	shans 2014/09/09 09:43:10 This still feels a bit strange. I think setting cu This still feels a bit strange. I think setting current time should force start time, and exit pending state. When you have a pending start time it means you're waiting for the compositor to tell you when it started in order to (effectively) make the currentTime valid. When the currentTime is set though, it's automatically valid, and the startTime is known by computation. Shouldn't this exit pending state? dstockwell 2014/09/09 09:59:49 The time at which we can actually start animating Show quoted text On 2014/09/09 09:43:10, shans wrote: > This still feels a bit strange. I think setting current time should force start > time, and exit pending state. When you have a pending start time it means you're > waiting for the compositor to tell you when it started in order to (effectively) > make the currentTime valid. > > When the currentTime is set though, it's automatically valid, and the startTime > is known by computation. Shouldn't this exit pending state? The time at which we can actually start animating isn't known -- this is how we planned to support soft start, eg: p = animate(); p.currentTime = 1000;
	197

	198 test(function() {

	199 var player = pendingStartTimePlayer();

	200 player.startTime = document.timeline.currentTime;

	201 assert_equals(player.startTime, document.timeline.currentTime);

	202 assert_equals(player.currentTime, 0);

	203 assert_equals(player.playState, 'running');

	204 }, "pending startTime -> set startTime");

	205

	206 test(function() {

	207 var player = pendingStartTimeAndCurrentTimePlayer();

	208 player.play();

	209 assert_unresolved(player.startTime);

	210 assert_unresolved(player.currentTime);

	211 assert_equals(player.playState, 'pending');

	212 }, "pending startTime & currentTime -> play()");

	213

	214 test(function() {

	215 var player = pendingStartTimeAndCurrentTimePlayer();

	216 player.pause();

	217 assert_unresolved(player.startTime);

	218 assert_unresolved(player.currentTime);

	219 assert_equals(player.playState, 'pending');

	220 }, "pending startTime & currentTime -> pause()");

	221

	222 test(function() {

	223 var player = pendingStartTimeAndCurrentTimePlayer();

	224 player.cancel();

	225 assert_unresolved(player.startTime);

	226 assert_unresolved(player.currentTime);

	227 assert_equals(player.playState, 'idle');

	228 }, "pending startTime & currentTime -> cancel()");

	229

	230 test(function() {

	231 var player = pendingStartTimeAndCurrentTimePlayer();

	232 player.finish();

	233 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	234 assert_equals(player.currentTime, 100000);

	235 assert_equals(player.playState, 'finished');

	236 }, "pending startTime & currentTime -> finish()");

	237

	238 test(function() {

	239 var player = pendingStartTimeAndCurrentTimePlayer();

	240 player.reverse();

	241 assert_unresolved(player.startTime);

	242 assert_unresolved(player.currentTime);

	243 assert_equals(player.playState, 'pending');

	244 }, "pending startTime & currentTime -> reverse()");

	245

	246 test(function() {

	247 var player = pendingStartTimeAndCurrentTimePlayer();

	248 player.currentTime = 1000;

	249 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	250 assert_equals(player.currentTime, 1000);

	251 assert_equals(player.playState, 'running');

	252 }, "pending startTime & currentTime -> set currentTime");
	shans 2014/09/09 09:43:10 pending startTime & currentTime should be a weaker pending startTime & currentTime should be a weaker state than pending startTime. So setting currentTime here should not result in 'running' if it results in 'pending' above. dstockwell 2014/09/09 09:59:49 Yep, this one seems wrong. Show quoted text On 2014/09/09 09:43:10, shans wrote: > pending startTime & currentTime should be a weaker state than pending startTime. > So setting currentTime here should not result in 'running' if it results in > 'pending' above. Yep, this one seems wrong. dstockwell 2014/09/09 23:20:03 Fixed. Show quoted text On 2014/09/09 at 09:59:49, dstockwell wrote: > On 2014/09/09 09:43:10, shans wrote: > > pending startTime & currentTime should be a weaker state than pending startTime. > > So setting currentTime here should not result in 'running' if it results in > > 'pending' above. > > Yep, this one seems wrong. Fixed. dstockwell 2014/09/09 23:20:03 Fixed. Show quoted text On 2014/09/09 at 09:59:49, dstockwell wrote: > On 2014/09/09 09:43:10, shans wrote: > > pending startTime & currentTime should be a weaker state than pending startTime. > > So setting currentTime here should not result in 'running' if it results in > > 'pending' above. > > Yep, this one seems wrong. Fixed.
	253

	254 test(function() {

	255 var player = pendingStartTimeAndCurrentTimePlayer();

	256 player.startTime = document.timeline.currentTime;

	257 assert_equals(player.startTime, document.timeline.currentTime);

	258 assert_equals(player.currentTime, 0);

	259 assert_equals(player.playState, 'running');

	260 }, "pending startTime & currentTime -> set startTime");

	261

	262 test(function() {

	263 var player = runningPlayer();

	264 var startTime = player.startTime;

	265 var currentTime = player.currentTime;

	266 player.play();

	267 assert_equals(player.startTime, startTime);

	268 assert_equals(player.currentTime, currentTime);

	269 assert_equals(player.playState, 'running');

	270 }, "running -> play()");

	271

	272 test(function() {

	273 var player = runningPlayer();

	274 player.pause();

	275 assert_unresolved(player.startTime);

	276 assert_unresolved(player.currentTime);

	277 assert_equals(player.playState, 'pending');

	278 }, "running -> pause()");

	279

	280 test(function() {

	281 var player = runningPlayer();

	282 player.cancel();

	283 assert_unresolved(player.startTime);

	284 assert_unresolved(player.currentTime);

	285 assert_equals(player.playState, 'idle');

	286 }, "running -> cancel()");

	287

	288 test(function() {

	289 var player = runningPlayer();

	290 player.finish();

	291 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	292 assert_equals(player.currentTime, 100000);

	293 assert_equals(player.playState, 'finished');

	294 }, "running -> finish()");

	295

	296 test(function() {

	297 var player = runningPlayer();

	298 player.reverse();

	299 assert_unresolved(player.startTime);

	300 assert_unresolved(player.currentTime);

	301 assert_equals(player.playState, 'pending');

	302 }, "running -> reverse()");

	303

	304 test(function() {

	305 var player = runningPlayer();

	306 player.currentTime = 1000;

	307 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	308 assert_equals(player.currentTime, 1000);

	309 assert_equals(player.playState, 'running');

	310 }, "running -> set currentTime");

	311

	312 test(function() {

	313 var player = runningPlayer();

	314 player.startTime = document.timeline.currentTime - 1000;

	315 assert_equals(player.startTime, document.timeline.currentTime - 1000);

	316 assert_equals(player.currentTime, 1000);

	317 assert_equals(player.playState, 'running');

	318 }, "running -> set startTime");

	319

	320 test(function() {

	321 var player = pausedPlayer();

	322 player.play();

	323 assert_unresolved(player.startTime);

	324 assert_equals(player.currentTime, 0);

	325 assert_equals(player.playState, 'pending');

	326 }, "paused -> play()");

	327

	328 test(function() {

	329 var player = pausedPlayer();

	330 player.pause();

	331 assert_unresolved(player.startTime);

	332 assert_equals(player.currentTime, 0);

	333 assert_equals(player.playState, 'paused');

	334 }, "paused -> pause()");

	335

	336 test(function() {

	337 var player = pausedPlayer();

	338 player.cancel();

	339 assert_unresolved(player.startTime);

	340 assert_unresolved(player.currentTime);

	341 assert_equals(player.playState, 'idle');

	342 }, "paused -> cancel()");

	343

	344 test(function() {

	345 var player = pausedPlayer();

	346 player.finish();

	347 assert_unresolved(player.startTime);

	348 assert_equals(player.currentTime, 100000);

	349 assert_equals(player.playState, 'paused');

	350 }, "paused -> finish()");

	351

	352 test(function() {

	353 var player = pausedPlayer();

	354 player.reverse();

	355 assert_unresolved(player.startTime);

	356 assert_equals(player.currentTime, 100000);

	357 assert_equals(player.playState, 'pending');

	358 }, "paused -> reverse()");

	359

	360 test(function() {

	361 var player = pausedPlayer();

	362 player.currentTime = 1000;

	363 assert_unresolved(player.startTime);

	364 assert_equals(player.currentTime, 1000);

	365 assert_equals(player.playState, 'paused');

	366 }, "paused -> set currentTime");

	367

	368 test(function() {

	369 var player = pausedPlayer();

	370 player.startTime = 1000;

	371 assert_unresolved(player.startTime);

	372 assert_equals(player.currentTime, 0);

	373 assert_equals(player.playState, 'paused');

	374 }, "paused -> set startTime");

	375

	376 test(function() {

	377 var player = finishedPlayer();

	378 player.play();

	379 assert_unresolved(player.startTime);

	380 assert_equals(player.currentTime, 0);

	381 assert_equals(player.playState, 'pending');

	382 }, "finished -> play()");

	383

	384 test(function() {

	385 var player = finishedPlayer();

	386 player.pause();

	387 assert_unresolved(player.startTime);

	388 assert_equals(player.currentTime, 100000);

	389 assert_equals(player.playState, 'paused');

	390 }, "finished -> pause()");

	391

	392 test(function() {

	393 var player = finishedPlayer();

	394 player.cancel();

	395 assert_unresolved(player.startTime);

	396 assert_unresolved(player.currentTime);

	397 assert_equals(player.playState, 'idle');

	398 }, "finished -> cancel()");

	399

	400 test(function() {

	401 var player = finishedPlayer();

	402 player.finish();

	403 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	404 assert_equals(player.currentTime, 100000);

	405 assert_equals(player.playState, 'finished');

	406 }, "finished -> finish()");

	407

	408 test(function() {

	409 var player = finishedPlayer();

	410 player.reverse();

	411 assert_unresolved(player.startTime);

	412 assert_equals(player.currentTime, 100000);

	413 assert_equals(player.playState, 'pending');

	414 }, "finished -> reverse()");

	415

	416 test(function() {

	417 var player = finishedPlayer();

	418 player.currentTime = 1000;

	419 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	420 assert_equals(player.currentTime, 1000);

	421 assert_equals(player.playState, 'running');

	422 }, "finished -> set currentTime");

	423 </script>

OLD	NEW

« no previous file with comments | « no previous file | Source/core/animation/AnimationPlayer.cpp » ('j') | no next file with comments »