| <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN"> |
| <html> |
| <head> |
| <script src="/resources/testharness.js"></script> |
| <script src="/resources/testharnessreport.js"></script> |
| </head> |
| <body> |
| <script> |
| |
| function makeCanvas() { |
| return new Promise(resolve => { |
| let canvas = document.createElement('canvas'); |
| canvas.setAttribute('width', '10'); |
| canvas.setAttribute('height', '10'); |
| resolve(canvas); |
| }); |
| } |
| |
| function makeOffscreenCanvas() { |
| return new Promise(resolve => { |
| let canvas = new OffscreenCanvas(10, 10); |
| resolve(canvas); |
| }); |
| } |
| |
| function makeOversizedCanvas() { |
| |
| return new Promise(resolve => { |
| let canvas = document.createElement('canvas'); |
| canvas.setAttribute('width', '100000000'); |
| canvas.setAttribute('height', '100000000'); |
| resolve(canvas); |
| }); |
| } |
| |
| function makeOversizedOffscreenCanvas() { |
| return new Promise(resolve =>{ |
| let canvas = new OffscreenCanvas(100000000, 100000000); |
| resolve(canvas); |
| }); |
| } |
| |
| function makeVideo() { |
| return new Promise(resolve => { |
| let video = document.createElement('video'); |
| video.addEventListener('canplaythrough', resolve.bind(undefined, video), false); |
| video.src = '/media/A4.ogv'; |
| }); |
| } |
| |
| function makeImage() { |
| return makeCanvas().then(canvas => { |
| let image = new Image(); |
| image.src = canvas.toDataURL(); |
| return new Promise(resolve => { |
| image.onload = resolve.bind(undefined, image); |
| }); |
| }); |
| } |
| |
| function makeImageData() { |
| return makeCanvas().then(canvas => { |
| return new Promise(function(resolve, reject) { |
| resolve(canvas.getContext('2d').getImageData(0, 0, 10, 10)); |
| }); |
| }); |
| } |
| |
| function makeImageBitmap() { |
| return makeCanvas().then(canvas => { |
| return createImageBitmap(canvas); |
| }); |
| } |
| |
| function makeBlob() { |
| return makeCanvas().then(canvas => { |
| return new Promise(resolve => { |
| canvas.toBlob(resolve); |
| }); |
| }); |
| } |
| |
| function makeInvalidBlob() { |
| return new Promise(resolve => { |
| resolve(new Blob()); // Blob with no data cannot be decoded. |
| }); |
| } |
| |
| imageSourceTypes = [ |
| { name: 'HTMLImageElement', factory: makeImage }, |
| { name: 'HTMLVideoElement', factory: makeVideo }, |
| { name: 'HTMLCanvasElement', factory: makeCanvas }, |
| { name: 'OffscreenCanvas', factory: makeOffscreenCanvas }, |
| { name: 'ImageData', factory: makeImageData }, |
| { name: 'ImageBitmap', factory: makeImageBitmap }, |
| { name: 'Blob', factory: makeBlob }, |
| ]; |
| |
| testCases = [ |
| { |
| description: 'createImageBitmap with a <sourceType> source and sw set to ' + |
| '0 rejects with a RangeError.', |
| promiseTestFunction: |
| (source, t) => { |
| return promise_rejects(t, new RangeError(), |
| createImageBitmap(source, 0, 0, 0, 10)); |
| } |
| }, |
| { |
| description: 'createImageBitmap with a <sourceType> source and sh set to ' + |
| '0 rejects with a RangeError.', |
| promiseTestFunction: |
| (source, t) => { |
| return promise_rejects(t, new RangeError(), |
| createImageBitmap(source, 0, 0, 10, 0)); |
| } |
| }, |
| { |
| // This case is not explicitly documented in the specification for |
| // createImageBitmap, but it is expected that internal failures cause |
| // |
| description: 'createImageBitmap with a <sourceType> source and oversized ' + |
| '(unallocatable) crop region rejects with an InvalidStateError ' + |
| 'DOMException.', |
| promiseTestFunction: |
| (source, t) => { |
| return promise_rejects(t, new DOMException('', 'InvalidStateError'), |
| createImageBitmap(source, 0, 0, 100000000, 100000000)); |
| } |
| }, |
| ]; |
| |
| // Generate the test matrix for each sourceType + testCase combo. |
| imageSourceTypes.forEach(imageSourceType => { |
| testCases.forEach(testCase => { |
| let description = testCase.description.replace('<sourceType>', |
| imageSourceType.name); |
| promise_test( t => { |
| return imageSourceType.factory().then(source => { |
| return testCase.promiseTestFunction(source, t); |
| }); |
| }, description); |
| }); |
| }); |
| |
| promise_test( t => { |
| return promise_rejects(t, new TypeError(), createImageBitmap(undefined)); |
| }, "createImageBitmap with undefined image source rejects with a TypeError."); |
| |
| promise_test( t => { |
| return promise_rejects(t, new TypeError(), createImageBitmap(null)); |
| }, "createImageBitmap with null image source rejects with a TypeError."); |
| |
| promise_test( t => { |
| return promise_rejects(t, new DOMException('', 'InvalidStateError'), |
| createImageBitmap(new Image())); |
| }, "createImageBitmap with empty image source rejects with a InvalidStateError."); |
| |
| promise_test( t => { |
| return promise_rejects(t, new DOMException('', 'InvalidStateError'), |
| createImageBitmap(document.createElement('video'))); |
| }, "createImageBitmap with empty video source rejects with a InvalidStateError."); |
| |
| promise_test( t => { |
| return makeOversizedCanvas().then(canvas => { |
| return promise_rejects(t, new DOMException('', 'InvalidStateError'), |
| createImageBitmap(canvas)); |
| }); |
| }, "createImageBitmap with an oversized canvas source rejects with a RangeError."); |
| |
| promise_test( t => { |
| return makeOversizedOffscreenCanvas().then(offscreenCanvas => { |
| return promise_rejects(t, new DOMException('', 'InvalidStateError'), |
| createImageBitmap(offscreenCanvas)); |
| }); |
| }, "createImageBitmap with an invalid OffscreenCanvas source rejects with a RangeError."); |
| |
| promise_test( t => { |
| return makeInvalidBlob().then(blob => { |
| return promise_rejects(t, new DOMException('', 'InvalidStateError'), |
| createImageBitmap(blob)); |
| }); |
| }, "createImageBitmap with an undecodable blob source rejects with an InvalidStateError."); |
| |
| </script> |
| </body> |
| </html> |
