<!DOCTYPE html>
<html>
<head>
<title>data:uri images should load if loadsImagesAutomatically is disabled</title>
<script>
if (window.testRunner)
    testRunner.dumpAsText();
if (window.internals)
    internals.settings.setLoadsImagesAutomatically(false);

function runTest() {
    var image = document.getElementsByTagName('img')[0];
    if (image.naturalHeight != 0 || image.naturalWidth != 0)
        document.write('PASS');
    else
        document.write('FAIL: data:uri images should loaded regardless of loadsImagesAutomatically');
}
</script>
</head>
<body onload="runTest()">
  This test verifies that data: uri images are loaded regardless of loadsImagesAutomatically setting value.
  On success, the image must be loaded, and &quot;PASS&quot; message printed.
  FAIL
  <img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAIAAAD/gAIDAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAnklEQVR42u3QMQEAAAgDoGlyo1vBzwciUJlw1ApkyZIlS5YsBbJkyZIlS5YCWbJkyZIlS4EsWbJkyZKlQJYsWbJkyVIgS5YsWbJkKZAlS5YsWbIUyJIlS5YsWQpkyZIlS5YsBbJkyZIlS5YCWbJkyZIlS4EsWbJkyZKlQJYsWbJkyVIgS5YsWbJkKZAlS5YsWbIUyJIlS5YsWQpkyfq2MosBSIeKONMAAAAASUVORK5CYII=">
</body>
</html>
