tools/run-wasm-gm-tests/run-wasm-gm-tests.html - skia - Git at Google

 <!-- This runs the GMs and unit tests which have been compiled to WASM. When this completes,
 either window._error will be set or window._testsDone will be true and window._results will be an
 array of the test names and what they drew.
 -->
 <!DOCTYPE html>
 <html>
 <head>
   <title>WASM Runner of GMs and Unit Tests</title>
   <meta charset="utf-8" />
   <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <script src="/static/wasm_gm_tests.js" type="text/javascript" charset="utf-8"></script>
   <style type="text/css" media="screen">
     #status_text {
       min-width: 900px;
       min-height: 500px;
     }
   </style>
 </head>
 <body>
 <main>
   <button id=start_tests>Start Tests</button>
   <br>
   <pre id=status_text></pre>

   <canvas id=gm_canvas></canvas>
 </main>
 <script type="text/javascript" charset="utf-8">
   const loadTestsPromise = InitWasmGMTests({
     locateFile: (file) => '/static/'+file,
   });

   const loadKnownHashesPromise = fetch('/static/hashes.txt').then((resp) => resp.text());

   const resourceNames = [];
   const loadResourceListing = fetch('/static/resource_listing.json').then((resp) => resp.json())
     .then((json) => {
     console.debug('should fetch resources', json);
     const loadingPromises = [];
     for (const resource of json) {
       resourceNames.push(resource);
       const url = `/static/resources/${resource}`;
       loadingPromises.push(fetch(url).then((resp) => resp.arrayBuffer()));
     }
     return Promise.all(loadingPromises).catch((e) => {
       console.error(e);
       window._error = `Failed getting resources: ${JSON.stringify(e)}`;
     });
   });

   let attemptedPOSTs = 0;
   let successfulPOSTs = 0;
   Promise.all([loadTestsPromise, loadKnownHashesPromise, loadResourceListing]).then(([GM, hashes, resourceBuffers]) => {
     GM.Init();
     LoadResources(GM, resourceNames, resourceBuffers);
     LoadKnownHashes(GM, hashes);
     document.getElementById('start_tests').addEventListener('click', async () => {
       window._testsProgress = 0;
       window._log = 'Starting\n';
       window._failed = [];
       await RunTests(GM);
       if (window._error) {
         console.log(window._error);
         return;
       }
       await RunGMs(GM);
       if (attemptedPOSTs !== successfulPOSTs) {
         window._error = `Failed to POST all the PNG files (expected ${attemptedPOSTs}, finished ${successfulPOSTs})`;
       } else {
         window._testsDone = true;
       }
     });
     window._testsReady = true;
   });

   const statusElement = document.getElementById('status_text');
   function log(line) {
     console.log(line);
     line += '\n';
     statusElement.innerText += line;
     window._log += line;
   }

   function LoadResources(GM, resourceNames, resourceBuffers) {
     for (let i = 0; i < resourceNames.length; i++) {
       const name = resourceNames[i];
       const buffer = resourceBuffers[i];
       if (name.includes('mandril')) {
         console.log(name, new Uint8Array(buffer).slice(0, 20));
       }
       GM.LoadResource(name, buffer);
     }
   }

   // There's a global set of known hashes that we preload with the md5 hashes that are already
   // uploaded to Gold. This saves us some time to encode them and write them to disk.
   function LoadKnownHashes(GM, hashes) {
     log(`Loading ${hashes.length} hashes`);
     console.time('load_hashes');
     for (const hash of hashes.split('\n')) {
       if (hash.length < 5) { // be sure not to add empty lines
         continue;
       }
       GM.LoadKnownDigest(hash);
     }
     console.timeEnd('load_hashes');
     log('hashes loaded');
   }

   const gmSkipList = new Set([
     // gm names can be added here to skip, if failing.
   ]);

   async function RunGMs(GM) {
     const canvas = document.getElementById('gm_canvas');
     const ctx = GM.GetWebGLContext(canvas, 2);
     const grcontext = GM.MakeGrContext(ctx);
     window._results = [];

     const names = GM.ListGMs();
     names.sort();
     for (const name of names) {
       if (gmSkipList.has(name)) {
         continue;
       }
       log(`Starting GM ${name}`);
       const pngAndMetadata = GM.RunGM(grcontext, name);
       if (!pngAndMetadata || !pngAndMetadata.hash) {
         console.debug('No output for ', name);
         continue; // Was skipped
       }
       log(`    drew ${pngAndMetadata.hash}`);
       window._results.push({
         name: name,
         digest: pngAndMetadata.hash,
       });
       if (pngAndMetadata.png) {
         await postPNG(pngAndMetadata.hash, pngAndMetadata.png);
       }
       window._testsProgress++;
     }
     grcontext.delete();
   }

   async function postPNG(hash, data) {
     attemptedPOSTs += 1;
     await fetch('/write_png', {
       method: 'POST',
       body: data,
       headers: {
         'Content-type': 'image/png',
         'X-MD5-Hash': hash, // this will be used server side to create the name of the png.
       }
     }).then((resp) => {
       if (resp.ok) {
         successfulPOSTs += 1;
       } else {
         console.error('not ok response', resp);
       }
     }).catch((e) => {
       console.error('Could not post PNG', e);
     });
   }

   const testSkipList = new Set([
     // These tests all crash https://bugs.chromium.org/p/skia/issues/detail?id=10869
     'AsyncReadPixelsContextShutdown',
     'BulkFillRectTest',
     'BulkTextureRectTest',
     'CharacterizationFBO0nessTest',
     'ClearOp',
     'CompressedBackendAllocationTest',
     'CopySurface',
     'DDLCompatibilityTest',
     'DDLCreateCharacterizationFailures',
     'DDLInvalidRecorder',
     'DDLMakeRenderTargetTest',
     'DDLMultipleDDLs',
     'DDLNonTextureabilityTest',
     'DDLOperatorEqTest',
     'DDLSkSurfaceFlush',
     'DDLSurfaceCharacterizationTest',
     'DDLTextureFlagsTest',
     'DDLWrapBackendTest',
     'Data',
     'DeferredProxyTest',
     'DefferredProxyConversionTest',
     'DSLBitwiseAnd',
     'DSLBitwiseNot',
     'DSLBitwiseOr',
     'DSLBitwiseXor',
     'DSLBool',
     'DSLComma',
     'DSLDecrement',
     'DSLDivide',
     'DSLEqual',
     'DSLFloat',
     'DSLGreaterThan',
     'DSLGreaterThanOrEqual',
     'DSLHalf',
     'DSLIncrement',
     'DSLInt',
     'DSLLessThan',
     'DSLLessThanOrEqual',
     'DSLLogicalAnd',
     'DSLLogicalNot',
     'DSLLogicalOr',
     'DSLMinus',
     'DSLMod',
     'DSLMultiply',
     'DSLNotEqual',
     'DSLPlus',
     'DSLShl',
     'DSLShort',
     'DSLShr',
     'DSLStartup',
     'ES2BlendWithNoTexture',
     'ExtendedSkColorTypeTests_gpu',
     'FlushFinishedProcTest',
     'FlushSubmittedProcTest',
     'FullScreenClearWithLayers',
     'GLTextureParameters',
     'GPUMemorySize',
     'GrClipStack_SWMask',
     'GrContextDump',
     'GrContextFactory_abandon',
     'GrContextFactory_executorAndTaskGroup',
     'GrContextFactory_sharedContexts',
     'GrContext_abandonContext',
     'GrContext_colorTypeSupportedAsSurface',
     'GrContext_maxSurfaceSamplesForColorType',
     'GrContext_oomed',
     'GrDDLImage_MakeSubset',
     'GrDefaultPathRendererTest',
     'GrDrawCollapsedPath',
     'GrMeshTest',
     'GrPathKeys',
     'GrPipelineDynamicStateTest',
     'GrStyledShape',
     'GrSurface',
     'GrSurfaceRenderability',
     'GrTestingBackendTextureUploadTest',
     'GrTextBlobMoveAround',
     'GrTextBlobScaleAnimation',
     'HalfFloatAlphaTextureTest',
     'HalfFloatRGBATextureTest',
     'ImageAsyncReadPixels',
     'ImageFilterBlurLargeImage_Gpu',
     'ImageFilterCache_GPUBacked',
     'ImageFilterCache_ImageBackedGPU',
     'ImageFilterHugeBlur_Gpu',
     'ImageIsOpaqueTest_Gpu',
     'ImageNewShader_GPU',
     'InitialTextureClear',
     'MatrixColorFilter_TransparentBlack',
     'OnFlushCallbackTest',
     'OverbudgetFlush',
     'OverdrawSurface_Gpu',
     'PinnedImageTest',
     'PreinstantiatedProxyConversionTest',
     'PremulAlphaRoundTrip_Gpu',
     'ProcessorCloneTest',
     'ProcessorOptimizationValidationTest',
     'ProcessorRefTest',
     'Programs',
     'PromiseImageNullFulfill',
     'PromiseImageTest',
     'PromiseImageTextureFullCache',
     'PromiseImageTextureShutdown',
     'ProxyRefTest',
     'RGB565TextureTest',
     'RGBA4444TextureTest',
     'ReadOnlyTexture',
     'ReadPixels_Texture',
     'RectangleTexture',
     'RefCnt',
     'RenderTargetContextTest',
     'ReplaceSurfaceBackendTexture',
     'ResourceAllocatorCurOpsTaskIndexTest',
     'ResourceAllocatorOverBudgetTest',
     'ResourceAllocatorStressTest',
     'ResourceAllocatorTest',
     'ResourceCacheCache',
     'ResourceCacheStencilBuffers',
     'ResourceMessagesAfterAbandon',
     'SRGBReadWritePixels',
     'SkRemoteGlyphCache_CacheMissReporting',
     'SkRemoteGlyphCache_DrawTextAsDFT',
     'SkRemoteGlyphCache_DrawTextAsPath',
     'SkRemoteGlyphCache_DrawTextXY',
     'SkRemoteGlyphCache_StrikeSerialization',
     'SkRemoteGlyphCache_TypefaceWithNoPaths',
     'SkRuntimeEffectThreaded',
     'SkSLCross',
     'SkScalerCacheMultiThread',
     'SkTraceMemoryDump_ownedGLBuffer',
     'SkTraceMemoryDump_ownedGLTexture',
     'SkTraceMemoryDump_unownedGLRenderTarget',
     'SkTraceMemoryDump_unownedGLTexture',
     'SmallBoxBlurBug',
     'SpecialImage_GPUDevice',
     'SpecialImage_Gpu',
     'SpecialSurface_Gpu1',
     'SrcSrcOverBatchTest',
     'Stream',
     'StreamBuffer',
     'StreamPeek',
     'String_Threaded',
     'SurfaceAttachStencil_Gpu',
     'SurfaceBackendHandleAccessIDs_Gpu',
     'SurfaceBackendSurfaceAccessCopyOnWrite_Gpu',
     'SurfaceBudget',
     'SurfaceCRBug263329_Gpu',
     'SurfaceCanvasPeek_Gpu',
     'SurfaceCopyOnWrite_Gpu',
     'SurfaceNoCanvas_Gpu',
     'SurfacePartialDraw_Gpu',
     'SurfacepeekTexture_Gpu',
     'SurfaceContextReadPixels',
     'SurfaceContextWritePixels',
     'SurfaceWrappedWithRelease_Gpu',
     'SurfaceWriteableAfterSnapshotRelease_Gpu',
     'TextBlobJaggedGlyph',
     'TextBlobSmoothScroll',
     'TextBlobStressAbnormal',
     'TextBlobStressCache',
     'TextureIdleProcCacheManipulationTest',
     'TextureIdleProcFlushTest',
     'TextureIdleProcRerefTest',
     'TextureIdleProcTest',
     'TextureIdleStateTest',
     'TextureProxyTest',
     'TextureStripAtlasManagerColorFilterTest',
     'TextureStripAtlasManagerGradientTest',
     'TriangulatingPathRendererTests',
     'VertexAttributeCount',
     'WrappedProxyTest',
     'WritePixelsNonTextureMSAA_Gpu',
     'WritePixelsNonTexture_Gpu',
     'WritePixelsPendingIO',
     'XfermodeImageFilterCroppedInput_Gpu',
     'ZeroSizedProxyTest',
     'skbug5221_GPU',

     // These tests are failing because they can't make an SkSurface
     'ApplyGamma',
     'BlurMaskBiggerThanDest',
     'RepeatedClippedBlurTest',
     'SurfaceClear_Gpu',
     'SurfaceSnapshotAlphaType_Gpu',
     'TestGpuAllContexts',
     'TestGpuRenderingContexts',
     'TestMockContext',
     'TextBlobAbnormal',
     'TextBlobCache',

     // These tests time out
     'SkTraceMemoryDump_ownedGLRenderTarget',

     // These tests are failing for unknown reasons
     'FILEStreamWithOffset',

   ]);

   async function RunTests(GM) {
     const canvas = document.getElementById('gm_canvas');
     const ctx = GM.GetWebGLContext(canvas, 2);
     // This sets up the GL context for all tests.
     const grcontext = GM.MakeGrContext(ctx);
     if (!grcontext) {
       window._error = 'Could not make GrContext for tests';
       return;
     }
     // We run these tests in batchs so as not to lock up the main thread, which makes it easier
     // to read the progress as well as making the page more responsive when debugging.
     await new Promise((resolve, reject) => {
       const names = GM.ListTests();
       names.sort();
       console.log(names);
       let testIdx = -1;
       const nextBatch = () => {
         for (let i = 0; i < 10 && testIdx < names.length; i++) {
           testIdx++;
           const name = names[testIdx];
           if (!name) {
             testIdx = names.length;
             break;
           }
           if (testSkipList.has(name)) {
             continue;
           }
           log(`Running test ${name}`);
           try {
             const result = GM.RunTest(name);
             log('    ' + result.result, result.msg || '');
             if (result.result !== 'passed' && result.result !== 'skipped') {
               window._failed.push(name);
             }
           } catch (e) {
             log(`${name} crashed with ${e.toString()} ${e.stack}`);
             window._error = e.toString();
             reject();
             return;
           }
           window._testsProgress++;
         }
         if (testIdx >= names.length) {
           resolve();
           return;
         }
         setTimeout(nextBatch);
       };
       setTimeout(nextBatch);
     });

     grcontext.delete();
   }
 </script>
 </body>
 </html>
	<!-- This runs the GMs and unit tests which have been compiled to WASM. When this completes,
	either window._error will be set or window._testsDone will be true and window._results will be an
	array of the test names and what they drew.
	-->
	<!DOCTYPE html>
	<html>
	<head>
	<title>WASM Runner of GMs and Unit Tests</title>
	<meta charset="utf-8" />
	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<script src="/static/wasm_gm_tests.js" type="text/javascript" charset="utf-8"></script>
	<style type="text/css" media="screen">
	#status_text {
	min-width: 900px;
	min-height: 500px;
	}
	</style>
	</head>
	<body>
	<main>
	<button id=start_tests>Start Tests</button>
	<br>
	<pre id=status_text></pre>

	<canvas id=gm_canvas></canvas>
	</main>
	<script type="text/javascript" charset="utf-8">
	const loadTestsPromise = InitWasmGMTests({
	locateFile: (file) => '/static/'+file,
	});

	const loadKnownHashesPromise = fetch('/static/hashes.txt').then((resp) => resp.text());

	const resourceNames = [];
	const loadResourceListing = fetch('/static/resource_listing.json').then((resp) => resp.json())
	.then((json) => {
	console.debug('should fetch resources', json);
	const loadingPromises = [];
	for (const resource of json) {
	resourceNames.push(resource);
	const url = `/static/resources/${resource}`;
	loadingPromises.push(fetch(url).then((resp) => resp.arrayBuffer()));
	}
	return Promise.all(loadingPromises).catch((e) => {
	console.error(e);
	window._error = `Failed getting resources: ${JSON.stringify(e)}`;
	});
	});

	let attemptedPOSTs = 0;
	let successfulPOSTs = 0;
	Promise.all([loadTestsPromise, loadKnownHashesPromise, loadResourceListing]).then(([GM, hashes, resourceBuffers]) => {
	GM.Init();
	LoadResources(GM, resourceNames, resourceBuffers);
	LoadKnownHashes(GM, hashes);
	document.getElementById('start_tests').addEventListener('click', async () => {
	window._testsProgress = 0;
	window._log = 'Starting\n';
	window._failed = [];
	await RunTests(GM);
	if (window._error) {
	console.log(window._error);
	return;
	}
	await RunGMs(GM);
	if (attemptedPOSTs !== successfulPOSTs) {
	window._error = `Failed to POST all the PNG files (expected ${attemptedPOSTs}, finished ${successfulPOSTs})`;
	} else {
	window._testsDone = true;
	}
	});
	window._testsReady = true;
	});

	const statusElement = document.getElementById('status_text');
	function log(line) {
	console.log(line);
	line += '\n';
	statusElement.innerText += line;
	window._log += line;
	}

	function LoadResources(GM, resourceNames, resourceBuffers) {
	for (let i = 0; i < resourceNames.length; i++) {
	const name = resourceNames[i];
	const buffer = resourceBuffers[i];
	if (name.includes('mandril')) {
	console.log(name, new Uint8Array(buffer).slice(0, 20));
	}
	GM.LoadResource(name, buffer);
	}
	}

	// There's a global set of known hashes that we preload with the md5 hashes that are already
	// uploaded to Gold. This saves us some time to encode them and write them to disk.
	function LoadKnownHashes(GM, hashes) {
	log(`Loading ${hashes.length} hashes`);
	console.time('load_hashes');
	for (const hash of hashes.split('\n')) {
	if (hash.length < 5) { // be sure not to add empty lines
	continue;
	}
	GM.LoadKnownDigest(hash);
	}
	console.timeEnd('load_hashes');
	log('hashes loaded');
	}

	const gmSkipList = new Set([
	// gm names can be added here to skip, if failing.
	]);

	async function RunGMs(GM) {
	const canvas = document.getElementById('gm_canvas');
	const ctx = GM.GetWebGLContext(canvas, 2);
	const grcontext = GM.MakeGrContext(ctx);
	window._results = [];

	const names = GM.ListGMs();
	names.sort();
	for (const name of names) {
	if (gmSkipList.has(name)) {
	continue;
	}
	log(`Starting GM ${name}`);
	const pngAndMetadata = GM.RunGM(grcontext, name);
	if (!pngAndMetadata \|\| !pngAndMetadata.hash) {
	console.debug('No output for ', name);
	continue; // Was skipped
	}
	log(` drew ${pngAndMetadata.hash}`);
	window._results.push({
	name: name,
	digest: pngAndMetadata.hash,
	});
	if (pngAndMetadata.png) {
	await postPNG(pngAndMetadata.hash, pngAndMetadata.png);
	}
	window._testsProgress++;
	}
	grcontext.delete();
	}

	async function postPNG(hash, data) {
	attemptedPOSTs += 1;
	await fetch('/write_png', {
	method: 'POST',
	body: data,
	headers: {
	'Content-type': 'image/png',
	'X-MD5-Hash': hash, // this will be used server side to create the name of the png.
	}
	}).then((resp) => {
	if (resp.ok) {
	successfulPOSTs += 1;
	} else {
	console.error('not ok response', resp);
	}
	}).catch((e) => {
	console.error('Could not post PNG', e);
	});
	}

	const testSkipList = new Set([
	// These tests all crash https://bugs.chromium.org/p/skia/issues/detail?id=10869
	'AsyncReadPixelsContextShutdown',
	'BulkFillRectTest',
	'BulkTextureRectTest',
	'CharacterizationFBO0nessTest',
	'ClearOp',
	'CompressedBackendAllocationTest',
	'CopySurface',
	'DDLCompatibilityTest',
	'DDLCreateCharacterizationFailures',
	'DDLInvalidRecorder',
	'DDLMakeRenderTargetTest',
	'DDLMultipleDDLs',
	'DDLNonTextureabilityTest',
	'DDLOperatorEqTest',
	'DDLSkSurfaceFlush',
	'DDLSurfaceCharacterizationTest',
	'DDLTextureFlagsTest',
	'DDLWrapBackendTest',
	'Data',
	'DeferredProxyTest',
	'DefferredProxyConversionTest',
	'DSLBitwiseAnd',
	'DSLBitwiseNot',
	'DSLBitwiseOr',
	'DSLBitwiseXor',
	'DSLBool',
	'DSLComma',
	'DSLDecrement',
	'DSLDivide',
	'DSLEqual',
	'DSLFloat',
	'DSLGreaterThan',
	'DSLGreaterThanOrEqual',
	'DSLHalf',
	'DSLIncrement',
	'DSLInt',
	'DSLLessThan',
	'DSLLessThanOrEqual',
	'DSLLogicalAnd',
	'DSLLogicalNot',
	'DSLLogicalOr',
	'DSLMinus',
	'DSLMod',
	'DSLMultiply',
	'DSLNotEqual',
	'DSLPlus',
	'DSLShl',
	'DSLShort',
	'DSLShr',
	'DSLStartup',
	'ES2BlendWithNoTexture',
	'ExtendedSkColorTypeTests_gpu',
	'FlushFinishedProcTest',
	'FlushSubmittedProcTest',
	'FullScreenClearWithLayers',
	'GLTextureParameters',
	'GPUMemorySize',
	'GrClipStack_SWMask',
	'GrContextDump',
	'GrContextFactory_abandon',
	'GrContextFactory_executorAndTaskGroup',
	'GrContextFactory_sharedContexts',
	'GrContext_abandonContext',
	'GrContext_colorTypeSupportedAsSurface',
	'GrContext_maxSurfaceSamplesForColorType',
	'GrContext_oomed',
	'GrDDLImage_MakeSubset',
	'GrDefaultPathRendererTest',
	'GrDrawCollapsedPath',
	'GrMeshTest',
	'GrPathKeys',
	'GrPipelineDynamicStateTest',
	'GrStyledShape',
	'GrSurface',
	'GrSurfaceRenderability',
	'GrTestingBackendTextureUploadTest',
	'GrTextBlobMoveAround',
	'GrTextBlobScaleAnimation',
	'HalfFloatAlphaTextureTest',
	'HalfFloatRGBATextureTest',
	'ImageAsyncReadPixels',
	'ImageFilterBlurLargeImage_Gpu',
	'ImageFilterCache_GPUBacked',
	'ImageFilterCache_ImageBackedGPU',
	'ImageFilterHugeBlur_Gpu',
	'ImageIsOpaqueTest_Gpu',
	'ImageNewShader_GPU',
	'InitialTextureClear',
	'MatrixColorFilter_TransparentBlack',
	'OnFlushCallbackTest',
	'OverbudgetFlush',
	'OverdrawSurface_Gpu',
	'PinnedImageTest',
	'PreinstantiatedProxyConversionTest',
	'PremulAlphaRoundTrip_Gpu',
	'ProcessorCloneTest',
	'ProcessorOptimizationValidationTest',
	'ProcessorRefTest',
	'Programs',
	'PromiseImageNullFulfill',
	'PromiseImageTest',
	'PromiseImageTextureFullCache',
	'PromiseImageTextureShutdown',
	'ProxyRefTest',
	'RGB565TextureTest',
	'RGBA4444TextureTest',
	'ReadOnlyTexture',
	'ReadPixels_Texture',
	'RectangleTexture',
	'RefCnt',
	'RenderTargetContextTest',
	'ReplaceSurfaceBackendTexture',
	'ResourceAllocatorCurOpsTaskIndexTest',
	'ResourceAllocatorOverBudgetTest',
	'ResourceAllocatorStressTest',
	'ResourceAllocatorTest',
	'ResourceCacheCache',
	'ResourceCacheStencilBuffers',
	'ResourceMessagesAfterAbandon',
	'SRGBReadWritePixels',
	'SkRemoteGlyphCache_CacheMissReporting',
	'SkRemoteGlyphCache_DrawTextAsDFT',
	'SkRemoteGlyphCache_DrawTextAsPath',
	'SkRemoteGlyphCache_DrawTextXY',
	'SkRemoteGlyphCache_StrikeSerialization',
	'SkRemoteGlyphCache_TypefaceWithNoPaths',
	'SkRuntimeEffectThreaded',
	'SkSLCross',
	'SkScalerCacheMultiThread',
	'SkTraceMemoryDump_ownedGLBuffer',
	'SkTraceMemoryDump_ownedGLTexture',
	'SkTraceMemoryDump_unownedGLRenderTarget',
	'SkTraceMemoryDump_unownedGLTexture',
	'SmallBoxBlurBug',
	'SpecialImage_GPUDevice',
	'SpecialImage_Gpu',
	'SpecialSurface_Gpu1',
	'SrcSrcOverBatchTest',
	'Stream',
	'StreamBuffer',
	'StreamPeek',
	'String_Threaded',
	'SurfaceAttachStencil_Gpu',
	'SurfaceBackendHandleAccessIDs_Gpu',
	'SurfaceBackendSurfaceAccessCopyOnWrite_Gpu',
	'SurfaceBudget',
	'SurfaceCRBug263329_Gpu',
	'SurfaceCanvasPeek_Gpu',
	'SurfaceCopyOnWrite_Gpu',
	'SurfaceNoCanvas_Gpu',
	'SurfacePartialDraw_Gpu',
	'SurfacepeekTexture_Gpu',
	'SurfaceContextReadPixels',
	'SurfaceContextWritePixels',
	'SurfaceWrappedWithRelease_Gpu',
	'SurfaceWriteableAfterSnapshotRelease_Gpu',
	'TextBlobJaggedGlyph',
	'TextBlobSmoothScroll',
	'TextBlobStressAbnormal',
	'TextBlobStressCache',
	'TextureIdleProcCacheManipulationTest',
	'TextureIdleProcFlushTest',
	'TextureIdleProcRerefTest',
	'TextureIdleProcTest',
	'TextureIdleStateTest',
	'TextureProxyTest',
	'TextureStripAtlasManagerColorFilterTest',
	'TextureStripAtlasManagerGradientTest',
	'TriangulatingPathRendererTests',
	'VertexAttributeCount',
	'WrappedProxyTest',
	'WritePixelsNonTextureMSAA_Gpu',
	'WritePixelsNonTexture_Gpu',
	'WritePixelsPendingIO',
	'XfermodeImageFilterCroppedInput_Gpu',
	'ZeroSizedProxyTest',
	'skbug5221_GPU',

	// These tests are failing because they can't make an SkSurface
	'ApplyGamma',
	'BlurMaskBiggerThanDest',
	'RepeatedClippedBlurTest',
	'SurfaceClear_Gpu',
	'SurfaceSnapshotAlphaType_Gpu',
	'TestGpuAllContexts',
	'TestGpuRenderingContexts',
	'TestMockContext',
	'TextBlobAbnormal',
	'TextBlobCache',

	// These tests time out
	'SkTraceMemoryDump_ownedGLRenderTarget',

	// These tests are failing for unknown reasons
	'FILEStreamWithOffset',

	]);

	async function RunTests(GM) {
	const canvas = document.getElementById('gm_canvas');
	const ctx = GM.GetWebGLContext(canvas, 2);
	// This sets up the GL context for all tests.
	const grcontext = GM.MakeGrContext(ctx);
	if (!grcontext) {
	window._error = 'Could not make GrContext for tests';
	return;
	}
	// We run these tests in batchs so as not to lock up the main thread, which makes it easier
	// to read the progress as well as making the page more responsive when debugging.
	await new Promise((resolve, reject) => {
	const names = GM.ListTests();
	names.sort();
	console.log(names);
	let testIdx = -1;
	const nextBatch = () => {
	for (let i = 0; i < 10 && testIdx < names.length; i++) {
	testIdx++;
	const name = names[testIdx];
	if (!name) {
	testIdx = names.length;
	break;
	}
	if (testSkipList.has(name)) {
	continue;
	}
	log(`Running test ${name}`);
	try {
	const result = GM.RunTest(name);
	log(' ' + result.result, result.msg \|\| '');
	if (result.result !== 'passed' && result.result !== 'skipped') {
	window._failed.push(name);
	}
	} catch (e) {
	log(`${name} crashed with ${e.toString()} ${e.stack}`);
	window._error = e.toString();
	reject();
	return;
	}
	window._testsProgress++;
	}
	if (testIdx >= names.length) {
	resolve();
	return;
	}
	setTimeout(nextBatch);
	};
	setTimeout(nextBatch);
	});

	grcontext.delete();
	}
	</script>
	</body>
	</html>