<!DOCTYPE HTML>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script>

var transparentBlack = [0, 0, 0, 0];

var e_sRGB_Red =   [1, 0, 0, 1]; // sRGB(255,0,0,255)
var e_sRGB_Green = [0, 1, 0, 1]; // sRGB(0,255,0,255)
var e_sRGB_Blue =  [0, 0, 1, 1]; // sRGB(0,0,255,255)
var e_sRGB_Black = [0, 0, 0, 1]; // sRGB(0,0,0,255)

// sRGB(155,27,27,255)
var e_sRGB_OpaqueRed = [0.607422, 0.105835, 0.105835, 1];
// sRGB(27,155,27,255)
var e_sRGB_OpaqueGreen = [0.105835, 0.607422, 0.105835, 1];
// sRGB(27,27,155,255)
var e_sRGB_OpaqueBlue = [0.105835, 0.105835, 0.607422, 1];
// sRGB(27,27,27,255)
var e_sRGB_OpaqueBlack = [0.105835, 0.105835, 0.105835, 1];

// sRGB(155,27,27,128)
var e_sRGB_TransparentRed = [0.607422, 0.105835, 0.105835, 0.501953];
// sRGB(27, 155, 27, 128)
var e_sRGB_TransparentGreen = [0.105835, 0.607422, 0.105835, 0.501953];
// sRGB(27, 27, 155, 128)
var e_sRGB_TransparentBlue = [0.105835, 0.105835, 0.607422, 0.501953];
// sRGB(27, 27, 27, 128)
var e_sRGB_TransparentBlack = [0.105835, 0.105835, 0.105835, 0.501953];

// sRGB(226,31,31,128)
var e_sRGB_TransparentRedImage = [0.886230, 0.121521, 0.121521, 0.501953];
// sRGB(226,31,31,128)
var e_sRGB_TransparentGreenImage = [0.121521, 0.886230, 0.121521, 0.501953];
// sRGB(226,31,31,128)
var e_sRGB_TransparentBlueImage = [0.121521, 0.121521, 0.886230, 0.501953];
// sRGB(226,31,31,128)
var e_sRGB_TransparentBlackImage = [0.121521, 0.121521, 0.121521, 0.501953];

function testPixels(ctx, tests, sourceType, imageSetting)
{
    var actual, expected, tolerance = 0.025;
    if (sourceType === 'video')
        tolerance = 0.03;
    for (var i = 0; i < tests.length; i++) {
        actual = ctx.getImageData(tests[i][0], tests[i][1], 1, 1, imageSetting).data;
        assert_implements(actual, 'ImageData data not supported');
        expected = tests[i][2];
        assert_equals(actual.length, expected.length);
        for (var j = 0; j < actual.length; j++)
           assert_approx_equals(actual[j], expected[j], tolerance, tests[i][3]);
    }
}

function checkNoCrop(imageBitmap, colorInfo, sourceType)
{
    var canvas = document.createElement('canvas');
    canvas.width = 50;
    canvas.height = 50;
    var ctx = canvas.getContext('2d',
        {colorSpace: 'srgb', pixelFormat:'float16'});
    var imageSetting = {colorSpace: 'srgb', storageFormat:'float32'}
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    ctx.drawImage(imageBitmap, 0, 0);
    var tests;
    if (colorInfo == 'fullColor')
        tests = [[0, 0, e_sRGB_Red, "This pixel should be e-sRGB red."],
                 [39, 0, e_sRGB_Green, "This pixel should be e-sRGB green."],
                 [0, 39, e_sRGB_Blue, "This pixel should be e-sRGB blue."],
                 [39, 39, e_sRGB_Black, "This pixel should be e-sRGB black."],
                 [41, 41, transparentBlack, "This pixel should be transparent black."]];
    else if (colorInfo == 'opaque')
        tests = [[0, 0, e_sRGB_OpaqueRed,
                     "This pixel should be e-sRGB like red."],
                 [39, 0, e_sRGB_OpaqueGreen,
                     "This pixel should be e-sRGB like green."],
                 [0, 39, e_sRGB_OpaqueBlue,
                     "This pixel should be e-sRGB like blue."],
                 [39, 39, e_sRGB_OpaqueBlack,
                     "This pixel should be e-sRGB like black."],
                 [41, 41, transparentBlack, "This pixel should be transparent black."]];
    else if (colorInfo == 'transparent')
        tests = [[0, 0, e_sRGB_TransparentRed,
                     "This pixel should be e-sRGB transparent red."],
                 [39, 0, e_sRGB_TransparentGreen,
                     "This pixel should be e-sRGB transparent green."],
                 [0, 39, e_sRGB_TransparentBlue,
                     "This pixel should be e-sRGB transparent blue."],
                 [39, 39, e_sRGB_TransparentBlack,
                     "This pixel should be e-sRGB transparent black."],
                 [41, 41, transparentBlack,
                     "This pixel should be transparent black."]];
    else if (colorInfo === 'transparent-image')
        tests = [[0, 0, e_sRGB_TransparentRedImage,
                     "This pixel should be e-sRGB transparent red."],
                 [39, 0, e_sRGB_TransparentGreenImage,
                     "This pixel should be e-sRGB transparent green."],
                 [0, 39, e_sRGB_TransparentBlueImage,
                     "This pixel should be e-sRGB transparent blue."],
                 [39, 39, e_sRGB_TransparentBlackImage,
                     "This pixel should be e-sRGB transparent black."],
                 [41, 41, transparentBlack,
                     "This pixel should be transparent black."]];
    testPixels(ctx, tests, sourceType, imageSetting);
}

function checkCrop(imageBitmap, colorInfo, sourceType)
{
    var canvas = document.createElement('canvas');
    canvas.width = 50;
    canvas.height = 50;
    var ctx = canvas.getContext('2d',
        {colorSpace: 'srgb', pixelFormat:'float16'});
    var imageSetting = {colorSpace: 'srgb', storageFormat:'float32'};
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    ctx.drawImage(imageBitmap, 0, 0);
    var tests;
    if (colorInfo === 'fullColor')
        tests = [[0, 0, e_sRGB_Red, "This pixel should be e-sRGB red."],
                 [19, 0, e_sRGB_Green, "This pixel should be e-sRGB green."],
                 [0, 19, e_sRGB_Blue, "This pixel should be e-sRGB blue."],
                 [19, 19, e_sRGB_Black, "This pixel should be e-sRGB black."],
                 [21, 21, transparentBlack, "This pixel should be transparent black."]];
    else if (colorInfo === 'opaque')
        tests = [[0, 0, e_sRGB_OpaqueRed,
                     "This pixel should be e-sRGB like red."],
                 [19, 0, e_sRGB_OpaqueGreen,
                     "This pixel should be e-sRGB like green."],
                 [0, 19, e_sRGB_OpaqueBlue,
                     "This pixel should be e-sRGB like blue."],
                 [19, 19, e_sRGB_OpaqueBlack,
                     "This pixel should be e-sRGB like black."],
                 [21, 21, transparentBlack, "This pixel should be transparent black."]];
    else if (colorInfo === 'transparent')
        tests = [[0, 0, e_sRGB_TransparentRed,
                     "This pixel should be e-sRGB transparent red."],
                 [19, 0, e_sRGB_TransparentGreen,
                     "This pixel should be e-sRGB transparent green."],
                 [0, 19, e_sRGB_TransparentBlue,
                     "This pixel should be e-sRGB transparent blue."],
                 [19, 19, e_sRGB_TransparentBlack,
                     "This pixel should be e-sRGB transparent black."],
                 [21, 21, transparentBlack,
                     "This pixel should be transparent black."]];
    else if (colorInfo === 'transparent-image')
        tests = [[0, 0, e_sRGB_TransparentRedImage,
                     "This pixel should be e-sRGB transparent red."],
                 [19, 0, e_sRGB_TransparentGreenImage,
                     "This pixel should be e-sRGB transparent green."],
                 [0, 19, e_sRGB_TransparentBlueImage,
                     "This pixel should be e-sRGB transparent blue."],
                 [19, 19, e_sRGB_TransparentBlackImage,
                     "This pixel should be e-sRGB transparent black."],
                 [21, 21, transparentBlack,
                     "This pixel should be transparent black."]];
    testPixels(ctx, tests, sourceType, imageSetting);
}


function compareBitmaps(bitmap1, bitmap2)
{
    var canvas1 = document.createElement('canvas');
    var canvas2 = document.createElement('canvas');
    canvas1.width = 50;
    canvas1.height = 50;
    canvas2.width = 50;
    canvas2.height = 50;
    var ctx1 = canvas1.getContext('2d',
        {colorSpace: 'srgb', pixelFormat:'float16'});
    var ctx2 = canvas2.getContext('2d',
        {colorSpace: 'srgb', pixelFormat:'float16'});
    ctx1.clearRect(0, 0, canvas1.width, canvas1.height);
    ctx2.clearRect(0, 0, canvas2.width, canvas2.height);
    ctx1.drawImage(bitmap1, 0, 0);
    ctx2.drawImage(bitmap2, 0, 0);
    var data1 = ctx1.getImageData(0, 0, 50, 50,
        {colorSpace: 'srgb', storageFormat:'float32'}).data;
    assert_implements(data1, 'ImageData data not supported');
    var data2 = ctx2.getImageData(0, 0, 50, 50,
        {colorSpace: 'srgb', storageFormat:'float32'}).data;
    assert_implements(data2, 'ImageData data not supported');
    var dataMatched = true;
    for (var i = 0; i < data1.length; i++) {
        if (data1[i] != data2[i]) {
            dataMatched = false;
            break;
        }
    }
    assert_false(dataMatched);
}

function testImageBitmap(source, colorInfo, sourceType)
{
    return Promise.all([
        createImageBitmap(source, {resizeWidth: 40, resizeHeight: 40, resizeQuality: "high"}),
        createImageBitmap(source, {resizeWidth: 40, resizeHeight: 40, resizeQuality: "medium"}),
        createImageBitmap(source, {resizeWidth: 40, resizeHeight: 40, resizeQuality: "low"}),
        createImageBitmap(source, {resizeWidth: 40, resizeHeight: 40, resizeQuality: "pixelated"}),
        createImageBitmap(source, 5, 5, 10, 10, {
            resizeWidth: 20, resizeHeight: 20, resizeQuality: "high"}),
        createImageBitmap(source, 5, 5, 10, 10, {
            resizeWidth: 20, resizeHeight: 20, resizeQuality: "medium"}),
        createImageBitmap(source, 5, 5, 10, 10, {
            resizeWidth: 20, resizeHeight: 20, resizeQuality: "low"}),
        createImageBitmap(source, 5, 5, 10, 10, {
            resizeWidth: 20, resizeHeight: 20, resizeQuality: "pixelated"}),
    ]).then(([noCropHigh, noCropMedium, noCropLow, noCropPixelated, cropHigh,
              cropMedium, cropLow, cropPixelated]) => {
        checkNoCrop(noCropHigh, colorInfo, sourceType);
        checkNoCrop(noCropMedium, colorInfo, sourceType);
        checkNoCrop(noCropLow, colorInfo, sourceType);
        checkNoCrop(noCropPixelated, colorInfo, sourceType);
        checkCrop(cropHigh, colorInfo, sourceType);
        checkCrop(cropMedium, colorInfo, sourceType);
        checkCrop(cropLow, colorInfo, sourceType);
        checkCrop(cropPixelated, colorInfo, sourceType);
        // Brute-force comparison among all bitmaps is too expensive.
        // In case of SVG, resize quality does not affect the images, so all
        // of them are the same and the tests fail. Since, we ignore this test
        // set for SVG.
        if (sourceType != 'svg') {
            compareBitmaps(noCropHigh, noCropMedium);
            compareBitmaps(noCropLow, noCropPixelated);
            compareBitmaps(cropHigh, cropMedium);
            compareBitmaps(cropLow, cropPixelated);
        }
    });
}

function testImageBitmapTransparent(source)
{
    return testImageBitmap(source, 'transparent', 'general');
}

function testImageBitmapFromTransparentImage(source)
{
    return testImageBitmap(source, 'transparent-image', 'general');
}

function testImageBitmapVideoSource(source)
{
    return testImageBitmap(source, 'fullColor', 'video');
}

function testImageBitmapOpaque(source)
{
    return testImageBitmap(source, 'opaque', 'general');
}

function testImageBitmapFromSVG(source)
{
    return testImageBitmap(source, 'opaque', 'svg');
}

function initializeTestCanvas(canvasColorSpace, canvasPixelFormat)
{
    var testCanvas = document.createElement("canvas");
    testCanvas.width = 20;
    testCanvas.height = 20;
    var testCtx = testCanvas.getContext('2d',
        {colorSpace: canvasColorSpace, pixelFormat:canvasPixelFormat});
    testCtx.fillStyle = "rgba(155, 27, 27, 1)";
    testCtx.fillRect(0, 0, 10, 10);
    testCtx.fillStyle = "rgba(27, 155, 27, 1)";
    testCtx.fillRect(10, 0, 10, 10);
    testCtx.fillStyle = "rgba(27, 27, 155, 1)";
    testCtx.fillRect(0, 10, 10, 10);
    testCtx.fillStyle = "rgba(27, 27, 27, 1)";
    testCtx.fillRect(10, 10, 10, 10);
    return testCanvas;
}

function initializeTestCanvasTransparent(canvasColorSpace, canvasPixelFormat)
{
    var testCanvas = document.createElement("canvas");
    testCanvas.width = 20;
    testCanvas.height = 20;
    var testCtx = testCanvas.getContext('2d',
        {colorSpace: canvasColorSpace, pixelFormat:canvasPixelFormat});
    testCtx.fillStyle = "rgba(155, 27, 27, 0.5)";
    testCtx.fillRect(0, 0, 10, 10);
    testCtx.fillStyle = "rgba(27, 155, 27, 0.5)";
    testCtx.fillRect(10, 0, 10, 10);
    testCtx.fillStyle = "rgba(27, 27, 155, 0.5)";
    testCtx.fillRect(0, 10, 10, 10);
    testCtx.fillStyle = "rgba(27, 27, 27, 0.5)";
    testCtx.fillRect(10, 10, 10, 10);
    return testCanvas;
}

////////////////////////////////////////////////////////////////////////////////

// HTMLImageElement - Opaque sRGB
// File formats: AVIF, Bitmap, GIF, ICO, JPEG, PNG, WEBP
['avif', 'bmp', 'gif', 'ico', 'jpg', 'png', 'webp'].forEach(ext => {
    promise_test(async () => {
        const image = new Image();
        image.src = 'resources/pattern-srgb.' + ext;
        await image.decode();
        await testImageBitmapOpaque(image);
    }, 'createImageBitmap in e-sRGB from an opaque sRGB HTMLImageElement (' + ext +
        ') with resize.');
});

// HTMLImageElement - Transparent sRGB
// File formats: AVIF, Bitmap, ICO, PNG, WEBP
['avif', 'bmp', 'ico', 'png', 'webp'].forEach(ext => {
    promise_test(async () => {
        const image = new Image();
        image.src = 'resources/pattern-srgb-transparent.' + ext;
        await image.decode();
        await testImageBitmapFromTransparentImage(image);
    }, 'createImageBitmap in e-sRGB from a transparent sRGB HTMLImageElement (' + ext +
        ') with resize.');
});

////////////////////////////////////////////////////////////////////////////////

// SVG Image - sRGB
promise_test(async () => {
    const image = new Image();
    image.src = 'resources/pattern-srgb.svg'
    await image.decode();
    await testImageBitmapFromSVG(image);
}, 'createImageBitmap in e-sRGB from a sRGB SVG image with resize.');

////////////////////////////////////////////////////////////////////////////////

// HTMLVideoElement - sRGB
promise_test(async () => {
    var video = document.createElement("video");
    assert_implements_optional(video.canPlayType("video/ogg"), "video/ogg not supported");
    let waitForFrame;
    if ("requestVideoFrameCallback" in HTMLVideoElement.prototype) {
        waitForFrame = new Promise((resolve) => {
            video.requestVideoFrameCallback(resolve);
        });
    } else {
        waitForFrame = new Promise((resolve, reject) => {
            video.onloadeddata = resolve;
            video.onerror = reject;
        });
    }
    video.preload = "auto";
    video.src = 'resources/pattern-srgb-fullcolor.ogv'
    await waitForFrame;
    await testImageBitmapVideoSource(video);
}, 'createImageBitmap in e-sRGB from a sRGB HTMLVideoElement with resize.');

////////////////////////////////////////////////////////////////////////////////

// HTMLCanvasElement - Opaque sRGB
promise_test(async () => {
    var testCanvas = initializeTestCanvas('srgb', 'uint8');
    await testImageBitmapOpaque(testCanvas);
}, 'createImageBitmap in e-sRGB from an opaque sRGB HTMLCanvasElement with resize.');

// HTMLCanvasElement - Opaque e-sRGB
promise_test(async () => {
    var testCanvas = initializeTestCanvas('srgb', 'float16');
    await testImageBitmapOpaque(testCanvas);
}, 'createImageBitmap in e-sRGB from an opaque e-sRGB HTMLCanvasElement with resize.');

////////////////////////////////////////////////////////////////////////////////

// HTMLCanvasElement - Transparent sRGB
promise_test(async () => {
    var testCanvas = initializeTestCanvasTransparent('srgb', 'uint8');
    await testImageBitmapTransparent(testCanvas);
}, 'createImageBitmap in e-sRGB from a transparent sRGB HTMLCanvasElement with resize.');

// HTMLCanvasElement - Transparent e-sRGB
promise_test(async () => {
    var testCanvas = initializeTestCanvasTransparent('srgb', 'float16');
    await testImageBitmapTransparent(testCanvas);
}, 'createImageBitmap in e-sRGB from a transparent e-sRGB HTMLCanvasElement with resize.');

//////////////////////////////////////////////////////////////////////////////

// Blob from file - Opaque sRGB
// File formats: AVIF, Bitmap, GIF, ICO, JPEG, PNG, WEBP
['avif', 'bmp', 'gif', 'ico', 'jpg', 'png', 'webp'].forEach(ext => {
    promise_test(async () => {
        const response = await fetch('resources/pattern-srgb.' + ext);
        assert_true(response.ok);
        const blob = await response.blob();
        await testImageBitmapOpaque(blob);
    }, 'createImageBitmap in e-sRGB from an opaque sRGB Blob (' + ext + ') with resize.');
});

// Blob form file - Transparent sRGB
// File formats: AVIF, Bitmap, ICO, PNG, WEBP
['avif', 'bmp', 'ico', 'png', 'webp'].forEach(ext => {
    promise_test(async () => {
        const response = await fetch('resources/pattern-srgb-transparent.' + ext);
        assert_true(response.ok);
        const blob = await response.blob();
        await testImageBitmapFromTransparentImage(blob);
    }, 'createImageBitmap in e-sRGB from a transparent sRGB Blob (' + ext + ') with resize.');
});

// Color managed blob from canvas
function testCreateImageBitmapFromColorManagedBlob(pixelFormat, isTransparent) {
    promise_test(async () => {
        let canvasPixelFormat = 'uint8';
        if (pixelFormat == 'uint16')
            canvasPixelFormat = 'float16';
        let testCanvas;
        if (isTransparent)
            testCanvas = initializeTestCanvasTransparent('srgb', canvasPixelFormat);
        else
            testCanvas = initializeTestCanvas('srgb', canvasPixelFormat);
        const blob = await testCanvas.convertToBlob({
            quality: 1,
            type: 'image/png',
            pixelFormat,
        });
        if (isTransparent)
            await testImageBitmapTransparent(blob);
        else
            await testImageBitmapOpaque(blob);
    }, 'createImageBitmap in e-sRGB from color managed Blob' +
       ' with resize. blobPixelFormat: ' + pixelFormat +
       ', transparency: ' + isTransparent);
}

function runAllCreateImageBitmapFromColorManagedBlobTests() {
    var blobPixelFormats = ['uint8', 'uint16'];
    var transparencies = [false, true];
    for (var j = 0; j < blobPixelFormats.length; j++)
        for (var k = 0; k < transparencies.length; k++) {
            testCreateImageBitmapFromColorManagedBlob(
                blobPixelFormats[j], transparencies[k]);
        }
}

runAllCreateImageBitmapFromColorManagedBlobTests();

////////////////////////////////////////////////////////////////////////////////

// ImageData - Opaque sRGB
promise_test(async () => {
    var canvas = initializeTestCanvas('srgb', 'uint8');
    var ctx = canvas.getContext('2d');
    var data = ctx.getImageData(0, 0, 20, 20,
        {colorSpace: 'srgb', storageFormat:'uint8'});
    await testImageBitmapOpaque(data);
}, 'createImageBitmap in e-sRGB from an opaque sRGB ImageData with resize.');

// ImageData - Opaque e-sRGB
promise_test(async () => {
    var canvas = initializeTestCanvas('srgb', 'float16');
    var ctx = canvas.getContext('2d',
        {colorSpace: 'srgb', pixelFormat:'float16'});
    var data = ctx.getImageData(0, 0, 20, 20,
        {colorSpace: 'srgb', storageFormat:'float32'});
    await testImageBitmapOpaque(data);
}, 'createImageBitmap in e-sRGB from an opaque e-sRGB ImageData with resize.');

////////////////////////////////////////////////////////////////////////////////

// ImageData - Transparent sRGB
promise_test(async () => {
    var canvas = initializeTestCanvasTransparent('srgb', 'uint8');
    var ctx = canvas.getContext('2d');
    var data = ctx.getImageData(0, 0, 20, 20,
        {colorSpace: 'srgb', storageFormat:'uint8'});
    await testImageBitmapTransparent(data);
}, 'createImageBitmap in e-sRGB from a transparent sRGB ImageData with resize.');

// ImageData - Transparent e-sRGB
promise_test(async () => {
    var canvas = initializeTestCanvasTransparent('srgb', 'float16');
    var ctx = canvas.getContext('2d',
        {colorSpace: 'srgb', pixelFormat:'float16'});
    var data = ctx.getImageData(0, 0, 20, 20,
        {colorSpace: 'srgb', storageFormat:'float32'});
    await testImageBitmapTransparent(data);
}, 'createImageBitmap in e-sRGB from a transparent e-sRGB ImageData with resize.');

////////////////////////////////////////////////////////////////////////////////

// ImageBitmap - Opaque sRGB
promise_test(async () => {
    var testCanvas = initializeTestCanvas('srgb', 'uint8');
    await createImageBitmap(testCanvas).then(testImageBitmapOpaque);
}, 'createImageBitmap in e-sRGB from an opaque sRGB ImageBitmap with resize.');

// ImageBitmap - Opaque e-sRGB
promise_test(async () => {
    var testCanvas = initializeTestCanvas('srgb', 'float16');
    await createImageBitmap(testCanvas).then(testImageBitmapOpaque);
}, 'createImageBitmap in e-sRGB from an opaque e-sRGB ImageBitmap with resize.');

////////////////////////////////////////////////////////////////////////////////

// ImageBitmap - Transparent sRGB
promise_test(async () => {
    var testCanvas = initializeTestCanvasTransparent('srgb', 'uint8');
    await createImageBitmap(testCanvas).then(testImageBitmapTransparent);
}, 'createImageBitmap in e-sRGB from a transparent sRGB ImageBitmap with resize.');

// ImageBitmap - Transparent e-sRGB
promise_test(async () => {
    var testCanvas = initializeTestCanvasTransparent('srgb', 'float16');
    await createImageBitmap(testCanvas).then(testImageBitmapTransparent);
}, 'createImageBitmap in e-sRGB from a transparent e-sRGB ImageBitmap with resize.');

////////////////////////////////////////////////////////////////////////////////

function initializeOffscreenCanvas(canvasColorSpace, canvasPixelFormat)
{
    var canvas = document.createElement("canvas");
    canvas.width = 20;
    canvas.height = 20;
    var offscreen = canvas.transferControlToOffscreen();
    var ctx = offscreen.getContext('2d',
        {colorSpace: canvasColorSpace, pixelFormat:canvasPixelFormat});
    ctx.fillStyle = "rgba(155, 27, 27, 1)";
    ctx.fillRect(0, 0, 10, 10);
    ctx.fillStyle = "rgba(27, 155, 27, 1)";
    ctx.fillRect(10, 0, 10, 10);
    ctx.fillStyle = "rgba(27, 27, 155, 1)";
    ctx.fillRect(0, 10, 10, 10);
    ctx.fillStyle = "rgba(27, 27, 27, 1)";
    ctx.fillRect(10, 10, 10, 10);
    return offscreen;
}

//OffscreenCanvas - Opaque sRGB
promise_test(async () => {
    var offscreen = initializeOffscreenCanvas('srgb', 'uint8');
    await testImageBitmapOpaque(offscreen);
}, 'createImageBitmap in e-sRGB from an opaque sRGB OffscreenCanvas with resize.');

//OffscreenCanvas - Opaque e-sRGB
promise_test(async () => {
    var offscreen = initializeOffscreenCanvas('srgb', 'float16');
    await testImageBitmapOpaque(offscreen);
}, 'createImageBitmap in e-sRGB from an opaque e-sRGB OffscreenCanvas with resize.');

////////////////////////////////////////////////////////////////////////////////

function initializeOffscreenCanvasTransparent(canvasColorSpace, canvasPixelFormat)
{
    var canvas = document.createElement("canvas");
    canvas.width = 20;
    canvas.height = 20;
    var offscreen = canvas.transferControlToOffscreen();
    var ctx = offscreen.getContext('2d',
        {colorSpace: canvasColorSpace, pixelFormat:canvasPixelFormat});
    ctx.fillStyle = "rgba(155, 27, 27, 0.5)";
    ctx.fillRect(0, 0, 10, 10);
    ctx.fillStyle = "rgba(27, 155, 27, 0.5)";
    ctx.fillRect(10, 0, 10, 10);
    ctx.fillStyle = "rgba(27, 27, 155, 0.5)";
    ctx.fillRect(0, 10, 10, 10);
    ctx.fillStyle = "rgba(27, 27, 27, 0.5)";
    ctx.fillRect(10, 10, 10, 10);
    return offscreen;
}

//OffscreenCanvas - Transparent sRGB
promise_test(async () => {
    var offscreen = initializeOffscreenCanvasTransparent('srgb', 'uint8');
    await testImageBitmapTransparent(offscreen);
}, 'createImageBitmap in e-sRGB from a transparent sRGB OffscreenCanvas with resize.');

//OffscreenCanvas - Transparent e-sRGB
promise_test(async () => {
    var offscreen = initializeOffscreenCanvasTransparent('srgb', 'float16');
    await testImageBitmapTransparent(offscreen);
}, 'createImageBitmap in e-sRGB from a transparent e-sRGB OffscreenCanvas with resize.');

////////////////////////////////////////////////////////////////////////////////

</script>
