third_party/WebKit/LayoutTests/external/wpt/image-decodes/image-decode.html - Issue 2769823002: Add decode() functionality to image elements.

Side by Side Diff: third_party/WebKit/LayoutTests/external/wpt/image-decodes/image-decode.html

Issue 2769823002: Add decode() functionality to image elements. (Closed)

Patch Set: update Created 3 years, 9 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:

OLD	NEW
(Empty)
	1 <!DOCTYPE html>

	2 <meta charset=utf-8>

	3 <meta name="timeout" content="long">

	4 <title>img.decode()</title>

	5 <link rel="author" title="Vladimir Levin" href="mailto:vmpstr@chromium.org">

	6 <link rel=help href="">

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

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

	9 <div id="log"></div>

	10

	11 <script>

	12 "use strict";

	13

	14 // Basic png decode success test.

	15 promise_test(function() {

	16 var message = "PNG Image must be decoded";

	17 var resolved = false;

	18 var rejected = false;

	19

	20 var img = new Image();

	21 img.src = "/images/green.png";

	22 return img.decode().then(
	domenic 2017/03/23 07:49:20 You should just do `return img.decode()`. promise_ You should just do `return img.decode()`. promise_test tests will succeed if and only if the returned promise fulfills. Actually, even better would be `return img.decode().then(arg => assert_equals(arg, undefined, "The promise must fulfill with undefined"))`
	23 function() { resolved = true; },

	24 function() { rejected = true; }

	25 ).then(

	26 function() {

	27 assert_true(resolved, message);

	28 assert_false(rejected, message);

	29 }

	30 );

	31 });

	32

	33 // Basic svg decode success test.

	34 promise_test(function() {

	35 var message = "SVG Image must be decoded";

	36 var resolved = false;

	37 var rejected = false;

	38

	39 var img = new Image();

	40 img.src = "/images/green.svg";

	41 return img.decode().then(

	42 function() { resolved = true; },

	43 function() { rejected = true; }

	44 ).then(

	45 function() {

	46 assert_true(resolved, message);

	47 assert_false(rejected, message);

	48 }

	49 );

	50 });

	51

	52 // Non existent path failure.

	53 promise_test(function() {

	54 var message = "Non-existent path must be rejected.";

	55 var resolved = false;

	56 var rejected = false;

	57

	58 var img = new Image();

	59 img.src = "/non/existent/path.png";

	60 return img.decode().then(
	domenic 2017/03/23 07:49:20 The way to test promise rejections is with `return The way to test promise rejections is with `return promise_rejects(t, "EncodingError", img.decode())`. Here `t` is passed to your test function, i.e. it becomes `promise_test(function(t) { ...`
	61 function() { resolved = true; },

	62 function(e) {

	63 assert_equals(e.name, "EncodingError");

	64 rejected = true;

	65 }

	66 ).then(

	67 function() {

	68 assert_false(resolved, message);

	69 assert_true(rejected, message);

	70 }

	71 );

	72 });

	73

	74 // src-less image decode failure.

	75 promise_test(function() {

	76 var message = "src-less images must fail decodes.";

	77 var resolved = false;

	78 var rejected = false;

	79

	80 var img = new Image();

	81 return img.decode().then(

	82 function() { resolved = true; },

	83 function(e) {

	84 assert_equals(e.name, "EncodingError");

	85 rejected = true;

	86 }

	87 ).then(

	88 function() {

	89 assert_false(resolved, message);

	90 assert_true(rejected, message);

	91 }

	92 )

	93 });

	94

	95 // src changes causes a decode failure.

	96 promise_test(function() {

	97 var message = "src changes must fail decodes.";

	98 var resolved = false;

	99 var rejected = false;

	100

	101 var img = new Image();

	102 img.src = "/images/green.png";

	103 var promise = img.decode().then(

	104 function() { resolved = true; },

	105 function(e) {

	106 assert_equals(e.name, "EncodingError");

	107 rejected = true;

	108 }

	109 );

	110 img.src = "/images/green.svg";

	111 return promise.then(

	112 function() {

	113 assert_false(resolved, message);

	114 assert_true(rejected, message);

	115 }

	116 )

	117 });

	118

	119 // src changes causes a decode failure, following good decodes succeed.

	120 promise_test(function() {

	121 var message = "src changes must fail decodes, following good decodes must succ eed."

	122 var resolved_count = 0;

	123 var rejected_count = 0;

	124 var decode_request_count = 2;

	125

	126 var do_resolve = function(resolve) {

	127 ++resolved_count;

	128 if (resolved_count + rejected_count == decode_request_count)

	129 resolve();

	130 }

	131 var do_reject = function(resolve) {

	132 ++rejected_count;

	133 if (resolved_count + rejected_count == decode_request_count)

	134 resolve();

	135 }

	136

	137 return new Promise(function(resolve, _) {
	domenic 2017/03/23 07:49:19 This promise thing is best done via ``` const img This promise thing is best done via ``` const img = new Image(); img.src = "/images/green.png"; const promise1 = img.decode(); img.src = "/images/green.svg"; const promise2 = img.decode(); return Promise.all([ promise_rejects(t, promise1, "EncodingError"), promise2 ]); ```
	138 var img = new Image();

	139 img.src = "/images/green.png";

	140 img.decode().then(

	141 function() { do_resolve(resolve); },

	142 function() { do_reject(resolve); }

	143 );

	144 img.src = "/images/green.svg";

	145 img.decode().then(

	146 function() { do_resolve(resolve); },

	147 function() { do_reject(resolve); }

	148 );

	149 }).then(function() {

	150 assert_equals(resolved_count, 1, message);

	151 assert_equals(rejected_count, 1, message);

	152 });

	153 });

	154

	155 // src changes causes a decode failure, following bad decodes also fail.

	156 promise_test(function() {

	157 var message = "src changes must fail decodes, following bad decodes also fail. ";

	158 var resolved_count = 0;

	159 var rejected_count = 0;

	160 var decode_request_count = 2;

	161

	162 var do_resolve = function(resolve) {

	163 ++resolved_count;

	164 if (resolved_count + rejected_count == decode_request_count)

	165 resolve();

	166 }

	167 var do_reject = function(resolve) {

	168 ++rejected_count;

	169 if (resolved_count + rejected_count == decode_request_count)

	170 resolve();

	171 }

	172

	173 return new Promise(function(resolve, _) {

	174 var img = new Image();

	175 img.src = "/images/green.png";

	176 img.decode().then(

	177 function() { do_resolve(resolve); },

	178 function() { do_reject(resolve); }

	179 );

	180 img.src = "/non/existent/path.png";

	181 img.decode().then(

	182 function() { do_resolve(resolve); },

	183 function() { do_reject(resolve); }

	184 );

	185 }).then(function() {

	186 assert_equals(resolved_count, 0, message);

	187 assert_equals(rejected_count, decode_request_count, message);

	188 });

	189 });

	190

	191 // src changes to the same path succeed.

	192 promise_test(function() {

	193 var message = "Same src set must succeed decode.";

	194 var resolved = false;

	195 var rejected = false;

	196

	197 var img = new Image();

	198 img.src = "/images/green.png";

	199 var promise = img.decode().then(

	200 function() { resolved = true; },

	201 function(e) { rejected = true; }

	202 );

	203 img.src = "/images/green.png";

	204 return promise.then(

	205 function() {

	206 assert_true(resolved, message);

	207 assert_false(rejected, message);

	208 }

	209 )

	210 });

	211

	212 // Multiple decodes all succeed.

	213 promise_test(function() {

	214 var message = "Multiple decodes must succeed.";

	215 var resolved_count = 0;

	216 var rejected_count = 0;

	217 var decode_request_count = 2;

	218

	219 var do_resolve = function(resolve) {

	220 ++resolved_count;

	221 if (resolved_count + rejected_count == decode_request_count)

	222 resolve();

	223 }

	224 var do_reject = function(resolve) {

	225 ++rejected_count;

	226 if (resolved_count + rejected_count == decode_request_count)

	227 resolve();

	228 }

	229

	230 var img = new Image();

	231 img.src = "/images/green.png";

	232

	233 return new Promise(function(resolve, _) {

	234 img.decode().then(

	235 function() { do_resolve(resolve); },

	236 function() { do_reject(resolve); }

	237 );

	238 img.decode().then(

	239 function() { do_resolve(resolve); },

	240 function() { do_reject(resolve); }

	241 );

	242 }).then(function() {

	243 assert_equals(resolved_count, decode_request_count, message);

	244 assert_equals(rejected_count, 0, message);

	245 });

	246 });

	247

	248

	249 </script>

OLD	NEW

« no previous file with comments | « content/renderer/gpu/render_widget_compositor.cc ('k') | third_party/WebKit/Source/core/html/HTMLImageElement.h » ('j') | no next file with comments »