Attachment 266613 Details for Bug 134488 – Patch

[patch] Patch

bug-134488-20151204115553.patch (text/plain), 42.04 KB, created by Yoav Weiss on 2015-12-04 02:56:20 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Yoav Weiss

Created: 2015-12-04 02:56:20 PST

Size: 42.04 KB

patch

obsolete

>Subversion Revision: 193365
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 19637aa56e9e32d12a618db3fdacba6878afda9f..20b788b2df8c820fa407c45ed447c5b3b4c2863c 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,62 @@
>+2015-12-04  Yoav Weiss  <yoav@yoav.ws>
>+
>+        Async loading of image resources
>+        https://bugs.webkit.org/show_bug.cgi?id=134488
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch changes image loading to be asynchronous (per spec), in order
>+        for it to be agnostic to property setting order when it comes to src, srcset and crossorigin,
>+        as well as to enable <picture>-based selection logic without double downloads.
>+
>+        Tests: fast/dom/HTMLImageElement/image-load-post-onload.html
>+        fast/dom/HTMLImageElement/sizes/image-sizes-js-change-reverse.html
>+        loader/data-uri-images-load-asynchronously.html
>+
>+        * bindings/js/JSEventListener.cpp:
>+        (WebCore::JSEventListener::handleEvent): Add a microtask checkpoint after event handling.
>+        * bindings/js/ScheduledAction.cpp:
>+        (WebCore::ScheduledAction::execute): Add a microtask checkpoint after running of a scheduled action.
>+        * html/HTMLImageElement.cpp:
>+        (WebCore::HTMLImageElement::didMoveToNewDocument): Add the old document to call of elementDidMoveToNewDocument.
>+        * html/HTMLImageLoader.cpp:
>+        (WebCore::HTMLImageLoader::notifyFinished): Avoid a crash when notifyFinished is called and there's no CachedImage.
>+        * html/HTMLInputElement.cpp:
>+        (WebCore::HTMLInputElement::didMoveToNewDocument): Add the old document to call of elementDidMoveToNewDocument.
>+        * html/HTMLPlugInImageElement.cpp:
>+        (WebCore::HTMLPlugInImageElement::didMoveToNewDocument): Add the old document to call of elementDidMoveToNewDocument.
>+        * html/HTMLVideoElement.cpp:
>+        (WebCore::HTMLVideoElement::didMoveToNewDocument): Add the old document to call of elementDidMoveToNewDocument.
>+        * html/parser/HTMLDocumentParser.cpp:
>+        (WebCore::HTMLDocumentParser::attemptToRunDeferredScriptsAndEnd): Add a microtask checkpoint.
>+        * loader/ImageLoader.cpp: Move image resource loading to be asynchronous.
>+        (WebCore::ImageLoader::ImageLoaderTask::create):
>+        (WebCore::ImageLoader::ImageLoaderTask::run): Run the image loading microtask and called doUpdateFromElement.
>+        (WebCore::ImageLoader::ImageLoaderTask::ImageLoaderTask):
>+        (WebCore::ImageLoader::ImageLoader):
>+        (WebCore::ImageLoader::doUpdateFromElement): This is split from the previous updateFromElement, and performs the actual resource loading.
>+        (WebCore::ImageLoader::updateFromElement): Now only prepares the stage for the actual image resource loading.
>+        (WebCore::ImageLoader::shouldLoadImmediately): If this returns true, the image resource is loaded immediately, without queueing a microtask.
>+        (WebCore::ImageLoader::notifyFinished): Add asserts.
>+        (WebCore::ImageLoader::elementDidMoveToNewDocument): Handle document load event counters decrementing and incrementing.
>+        * loader/ImageLoader.h:
>+        (WebCore::ImageLoader::imageComplete): Make sure that the image is complete only if there aren't any pending tasks.
>+        (WebCore::ImageLoader::hasPendingActivity): Make sure that pending activity takes pending tasks into account.
>+        (WebCore::ImageLoader::hasPendingTask): Getter to know if an ImageLoader has a pending task. (Used by the image loading microtask)
>+        (WebCore::ImageLoader::createWeakPtr): Create a weakPtr to be used by the microtask, so it can called back the loader if it's still alive.
>+        * loader/cache/CachedResourceLoader.cpp:
>+        (WebCore::CachedResourceLoader::canRequest): Add a 'shouldBypassMainWorldContentSecurityPolicy' flag and act upon it.
>+        (WebCore::CachedResourceLoader::requestImage): Add a 'shouldBypassMainWorldContentSecurityPolicy' flag.
>+        (WebCore::CachedResourceLoader::requestResource): Add a 'shouldBypassMainWorldContentSecurityPolicy' flag.
>+        * loader/cache/CachedResourceLoader.h:
>+        (WebCore::CachedResourceLoader::canRequest): Add a 'shouldBypassMainWorldContentSecurityPolicy' flag and act upon it.
>+        (WebCore::CachedResourceLoader::requestImage): Add a 'shouldBypassMainWorldContentSecurityPolicy' flag.
>+        (WebCore::CachedResourceLoader::requestResource): Add a 'shouldBypassMainWorldContentSecurityPolicy' flag.
>+        * svg/SVGImageElement.cpp:
>+        (WebCore::SVGImageElement::didMoveToNewDocument): Add the old document to call of elementDidMoveToNewDocument.
>+        * xml/parser/XMLDocumentParser.cpp:
>+        (WebCore::XMLDocumentParser::end): Add a microtask checkpoint after XML finishes parsing.
>+
> 2015-12-03  Brady Eidson  <beidson@apple.com>
> 
>         Modern IDB: storage/indexeddb/cursor-advance.html fails.
>diff --git a/Source/WebCore/bindings/js/JSEventListener.cpp b/Source/WebCore/bindings/js/JSEventListener.cpp
>index 83eca94a407e3a1299cabf729882647cef685f75..547f7829aa308068b34027c022ea1194669f35ad 100644
>--- a/Source/WebCore/bindings/js/JSEventListener.cpp
>+++ b/Source/WebCore/bindings/js/JSEventListener.cpp
>@@ -29,6 +29,7 @@
> #include "JSEventTarget.h"
> #include "JSMainThreadExecState.h"
> #include "JSMainThreadExecStateInstrumentation.h"
>+#include "Microtasks.h"
> #include "ScriptController.h"
> #include "WorkerGlobalScope.h"
> #include <runtime/ExceptionHelpers.h>
>@@ -153,6 +154,8 @@ void JSEventListener::handleEvent(ScriptExecutionContext* scriptExecutionContext
>             }
>         }
>     }
>+    if (scriptExecutionContext->isDocument())
>+        MicrotaskQueue::mainThreadQueue().performMicrotaskCheckpoint();
> }
> 
> bool JSEventListener::virtualisAttribute() const
>diff --git a/Source/WebCore/bindings/js/ScheduledAction.cpp b/Source/WebCore/bindings/js/ScheduledAction.cpp
>index febd2900e625e7ce36fc729337a492b8396d5d5a..60b1460ceb0587dbd8000b438c8e9598f70b9016 100644
>--- a/Source/WebCore/bindings/js/ScheduledAction.cpp
>+++ b/Source/WebCore/bindings/js/ScheduledAction.cpp
>@@ -34,6 +34,7 @@
> #include "JSMainThreadExecState.h"
> #include "JSMainThreadExecStateInstrumentation.h"
> #include "JSWorkerGlobalScope.h"
>+#include "Microtasks.h"
> #include "ScriptController.h"
> #include "ScriptExecutionContext.h"
> #include "ScriptSourceCode.h"
>@@ -78,6 +79,7 @@ void ScheduledAction::execute(ScriptExecutionContext& context)
>         execute(downcast<Document>(context));
>     else
>         execute(downcast<WorkerGlobalScope>(context));
>+    MicrotaskQueue::mainThreadQueue().performMicrotaskCheckpoint();
> }
> 
> void ScheduledAction::executeFunctionInContext(JSGlobalObject* globalObject, JSValue thisValue, ScriptExecutionContext& context)
>diff --git a/Source/WebCore/html/HTMLImageElement.cpp b/Source/WebCore/html/HTMLImageElement.cpp
>index a9424b3b7b8e6b6c48d50383385b83274f06965b..eefa21d20dfa6c7aa4ec960fc18c65b3733b8004 100644
>--- a/Source/WebCore/html/HTMLImageElement.cpp
>+++ b/Source/WebCore/html/HTMLImageElement.cpp
>@@ -508,7 +508,7 @@ void HTMLImageElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
> 
> void HTMLImageElement::didMoveToNewDocument(Document* oldDocument)
> {
>-    m_imageLoader.elementDidMoveToNewDocument();
>+    m_imageLoader.elementDidMoveToNewDocument(oldDocument);
>     HTMLElement::didMoveToNewDocument(oldDocument);
> }
> 
>diff --git a/Source/WebCore/html/HTMLImageLoader.cpp b/Source/WebCore/html/HTMLImageLoader.cpp
>index 3e5f81c52f633278f3a64ff79d206bcff7a73fb3..b81de3170848319718032a79874103d8f4fc9e80 100644
>--- a/Source/WebCore/html/HTMLImageLoader.cpp
>+++ b/Source/WebCore/html/HTMLImageLoader.cpp
>@@ -76,6 +76,8 @@ String HTMLImageLoader::sourceURI(const AtomicString& attr) const
> void HTMLImageLoader::notifyFinished(CachedResource*)
> {
>     CachedImage* cachedImage = image();
>+    if (!cachedImage)
>+        return;
> 
>     Ref<Element> protect(element());
>     ImageLoader::notifyFinished(cachedImage);
>diff --git a/Source/WebCore/html/HTMLInputElement.cpp b/Source/WebCore/html/HTMLInputElement.cpp
>index 9706941f4a4b4cb7e8bda505ca4a2ab51ebe3c59..71b2c2c7c5dd70cfa4150a8483a9baaeb8ac527f 100644
>--- a/Source/WebCore/html/HTMLInputElement.cpp
>+++ b/Source/WebCore/html/HTMLInputElement.cpp
>@@ -1496,7 +1496,7 @@ void HTMLInputElement::removedFrom(ContainerNode& insertionPoint)
> void HTMLInputElement::didMoveToNewDocument(Document* oldDocument)
> {
>     if (imageLoader())
>-        imageLoader()->elementDidMoveToNewDocument();
>+        imageLoader()->elementDidMoveToNewDocument(oldDocument);
> 
>     bool needsSuspensionCallback = this->needsSuspensionCallback();
>     if (oldDocument) {
>diff --git a/Source/WebCore/html/HTMLPlugInImageElement.cpp b/Source/WebCore/html/HTMLPlugInImageElement.cpp
>index ee2696fd09fffcd800aa51dec62bb6815ade9978..50e59e414c33c26a016722a264303c342f7c7250 100644
>--- a/Source/WebCore/html/HTMLPlugInImageElement.cpp
>+++ b/Source/WebCore/html/HTMLPlugInImageElement.cpp
>@@ -306,7 +306,7 @@ void HTMLPlugInImageElement::didMoveToNewDocument(Document* oldDocument)
>     }
> 
>     if (m_imageLoader)
>-        m_imageLoader->elementDidMoveToNewDocument();
>+        m_imageLoader->elementDidMoveToNewDocument(oldDocument);
> 
>     HTMLPlugInElement::didMoveToNewDocument(oldDocument);
> }
>diff --git a/Source/WebCore/html/HTMLVideoElement.cpp b/Source/WebCore/html/HTMLVideoElement.cpp
>index 4256f449a70e70ba910cbc424d76dcc3339517d9..e45d542a7e78a67985b6fa6986236a32158cae22 100644
>--- a/Source/WebCore/html/HTMLVideoElement.cpp
>+++ b/Source/WebCore/html/HTMLVideoElement.cpp
>@@ -318,7 +318,7 @@ void HTMLVideoElement::setWebkitWirelessVideoPlaybackDisabled(bool disabled)
> void HTMLVideoElement::didMoveToNewDocument(Document* oldDocument)
> {
>     if (m_imageLoader)
>-        m_imageLoader->elementDidMoveToNewDocument();
>+        m_imageLoader->elementDidMoveToNewDocument(oldDocument);
>     HTMLMediaElement::didMoveToNewDocument(oldDocument);
> }
> 
>diff --git a/Source/WebCore/html/parser/HTMLDocumentParser.cpp b/Source/WebCore/html/parser/HTMLDocumentParser.cpp
>index f6faebd8c721425aa02cb73c2076d503a97653c7..7b90c26c9865d242dd7187c3fc60df261b40a919 100644
>--- a/Source/WebCore/html/parser/HTMLDocumentParser.cpp
>+++ b/Source/WebCore/html/parser/HTMLDocumentParser.cpp
>@@ -34,6 +34,7 @@
> #include "HTMLPreloadScanner.h"
> #include "HTMLScriptRunner.h"
> #include "HTMLTreeBuilder.h"
>+#include "Microtasks.h"
> 
> namespace WebCore {
> 
>@@ -400,6 +401,8 @@ void HTMLDocumentParser::attemptToRunDeferredScriptsAndEnd()
>     if (m_scriptRunner && !m_scriptRunner->executeScriptsWaitingForParsing())
>         return;
>     end();
>+    if (!isExecutingScript())
>+        MicrotaskQueue::mainThreadQueue().performMicrotaskCheckpoint();
> }
> 
> void HTMLDocumentParser::attemptToEnd()
>diff --git a/Source/WebCore/loader/ImageLoader.cpp b/Source/WebCore/loader/ImageLoader.cpp
>index ed17fa9850a594508a0880d69159aafbc4723995..e1e7e3da78e775de890b1138e3ef469a21e0a3d2 100644
>--- a/Source/WebCore/loader/ImageLoader.cpp
>+++ b/Source/WebCore/loader/ImageLoader.cpp
>@@ -2,6 +2,8 @@
>  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
>  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
>  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 Apple Inc. All rights reserved.
>+ * Copyright 2014 The Chromium Authors. All rights reserved.
>+ * Copyright (C) 2015 Akamai Technologies Inc. All rights reserved.
>  *
>  * This library is free software; you can redistribute it and/or
>  * modify it under the terms of the GNU Library General Public
>@@ -34,9 +36,11 @@
> #include "HTMLNames.h"
> #include "HTMLObjectElement.h"
> #include "HTMLParserIdioms.h"
>+#include "MemoryCache.h"
> #include "Page.h"
> #include "RenderImage.h"
> #include "RenderSVGImage.h"
>+#include "ScriptController.h"
> #include "SecurityOrigin.h"
> #include <wtf/NeverDestroyed.h>
> 
>@@ -63,6 +67,26 @@ template<> struct ValueCheck<WebCore::ImageLoader*> {
> 
> namespace WebCore {
> 
>+class ImageLoader::ImageLoaderTask : public Microtask {
>+public:
>+    ImageLoaderTask(WeakPtr<ImageLoader> loader, CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy)
>+        : m_loader(loader)
>+        , m_shouldBypassMainWorldContentSecurityPolicy(shouldBypassMainWorldContentSecurityPolicy)
>+    {
>+    }
>+
>+private:
>+    virtual Result run() override
>+    {
>+        if (m_loader && m_loader->hasPendingTask())
>+            m_loader->doUpdateFromElement(m_shouldBypassMainWorldContentSecurityPolicy);
>+        return Result::Done;
>+    }
>+
>+    WeakPtr<ImageLoader> m_loader;
>+    CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy m_shouldBypassMainWorldContentSecurityPolicy;
>+};
>+
> static ImageEventSender& beforeLoadEventSender()
> {
>     static NeverDestroyed<ImageEventSender> sender(eventNames().beforeloadEvent);
>@@ -91,12 +115,14 @@ ImageLoader::ImageLoader(Element& element)
>     : m_element(element)
>     , m_image(nullptr)
>     , m_derefElementTimer(*this, &ImageLoader::timerFired)
>+    , m_weakFactory(this)
>     , m_hasPendingBeforeLoadEvent(false)
>     , m_hasPendingLoadEvent(false)
>     , m_hasPendingErrorEvent(false)
>     , m_imageComplete(true)
>     , m_loadManually(false)
>     , m_elementIsProtected(false)
>+    , m_hasPendingTask(false)
> {
> }
> 
>@@ -154,8 +180,9 @@ void ImageLoader::clearImageWithoutConsideringPendingLoadEvent()
>         imageResource->resetAnimation();
> }
> 
>-void ImageLoader::updateFromElement()
>+void ImageLoader::doUpdateFromElement(CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy)
> {
>+    m_hasPendingTask = false;
>     // If we're not making renderers for the page, then don't load images. We don't want to slow
>     // down the raw HTML parsing case by loading images we don't intend to display.
>     Document& document = element().document();
>@@ -163,22 +190,24 @@ void ImageLoader::updateFromElement()
>         return;
> 
>     AtomicString attr = element().imageSourceURL();
>-
>-    // Avoid loading a URL we already failed to load.
>-    if (!m_failedLoadURL.isEmpty() && attr == m_failedLoadURL)
>-        return;
>+    String srcURI = sourceURI(attr);
>+    URL url;
>+    // Set url value only if srcURI is not empty. Otherwise, url will be the URL for the document itself.
>+    if (!srcURI.isEmpty())
>+        url = document.completeURL(srcURI);
> 
>     // Do not load any image if the 'src' attribute is missing or if it is
>     // an empty string.
>     CachedResourceHandle<CachedImage> newImage = nullptr;
>-    if (!attr.isNull() && !stripLeadingAndTrailingHTMLSpaces(attr).isEmpty()) {
>+    if (!url.isNull()) {
>         ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
>         options.setContentSecurityPolicyImposition(element().isInUserAgentShadowTree() ? ContentSecurityPolicyImposition::SkipPolicyCheck : ContentSecurityPolicyImposition::DoPolicyCheck);
> 
>-        CachedResourceRequest request(ResourceRequest(document.completeURL(sourceURI(attr))), options);
>+        ResourceRequest resourceRequest(url);
>+        CachedResourceRequest request(resourceRequest, options);
>         request.setInitiator(&element());
> 
>-        String crossOriginMode = element().fastGetAttribute(HTMLNames::crossoriginAttr);
>+        AtomicString crossOriginMode = m_element.fastGetAttribute(HTMLNames::crossoriginAttr);
>         if (!crossOriginMode.isNull()) {
>             StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
>             updateRequestForAccessControl(request.mutableResourceRequest(), document.securityOrigin(), allowCredentials);
>@@ -193,7 +222,7 @@ void ImageLoader::updateFromElement()
>             document.cachedResourceLoader().m_documentResources.set(newImage->url(), newImage.get());
>             document.cachedResourceLoader().setAutoLoadImages(autoLoadOtherImages);
>         } else
>-            newImage = document.cachedResourceLoader().requestImage(request);
>+            newImage = document.cachedResourceLoader().requestImage(request, shouldBypassMainWorldContentSecurityPolicy);
> 
>         // If we do not have an image here, it means that a cross-site
>         // violation occurred, or that the image was blocked via Content
>@@ -211,7 +240,7 @@ void ImageLoader::updateFromElement()
>         m_hasPendingErrorEvent = true;
>         errorEventSender().dispatchEventSoon(*this);
>     }
>-    
>+
>     CachedImage* oldImage = m_image.get();
>     if (newImage != oldImage) {
>         if (m_hasPendingBeforeLoadEvent) {
>@@ -263,6 +292,48 @@ void ImageLoader::updateFromElement()
>     // Only consider updating the protection ref-count of the Element immediately before returning
>     // from this function as doing so might result in the destruction of this ImageLoader.
>     updatedHasPendingEvent();
>+    document.decrementLoadEventDelayCount();
>+}
>+
>+void ImageLoader::updateFromElement()
>+{
>+    AtomicString attribute = m_element.imageSourceURL();
>+
>+    // Avoid loading a URL we already failed to load.
>+    if (!m_failedLoadURL.isEmpty() && attribute == m_failedLoadURL)
>+        return;
>+
>+    // If we're not making renderers for the page, then don't load images. We don't want to slow
>+    // down the raw HTML parsing case by loading images we don't intend to display.
>+    Document& document = element().document();
>+    if (!document.hasLivingRenderTree())
>+        return;
>+
>+    CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy = CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy::No;
>+    if (document.frame() && document.frame()->script().shouldBypassMainWorldContentSecurityPolicy())
>+        shouldBypassMainWorldContentSecurityPolicy = CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy::Yes;
>+
>+    if (!m_hasPendingTask) {
>+        m_hasPendingTask = true;
>+        document.incrementLoadEventDelayCount();
>+        if (shouldLoadImmediately(attribute))
>+            doUpdateFromElement(CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy::No);
>+        else
>+            MicrotaskQueue::mainThreadQueue().append(std::make_unique<ImageLoaderTask>(createWeakPtr(), shouldBypassMainWorldContentSecurityPolicy));
>+    }
>+}
>+
>+bool ImageLoader::shouldLoadImmediately(const AtomicString& attribute) const
>+{
>+    String srcURI = sourceURI(attribute);
>+    URL url = element().document().completeURL(srcURI);
>+    ResourceRequest resourceRequest(url);
>+    return (srcURI.isEmpty()
>+        || url.isEmpty()
>+        || m_loadManually
>+        || !is<HTMLImageElement>(m_element)
>+        || url.protocolIsData()
>+        || MemoryCache::singleton().resourceForRequest(resourceRequest, element().document().page()->sessionID()));
> }
> 
> void ImageLoader::updateFromElementIgnoringPreviousError()
>@@ -274,6 +345,7 @@ void ImageLoader::updateFromElementIgnoringPreviousError()
> void ImageLoader::notifyFinished(CachedResource* resource)
> {
>     ASSERT(m_failedLoadURL.isEmpty());
>+    ASSERT(resource);
>     ASSERT(resource == m_image.get());
> 
>     m_imageComplete = true;
>@@ -459,8 +531,13 @@ void ImageLoader::dispatchPendingErrorEvents()
>     errorEventSender().dispatchPendingEvents();
> }
> 
>-void ImageLoader::elementDidMoveToNewDocument()
>+void ImageLoader::elementDidMoveToNewDocument(Document* oldDocument)
> {
>+    if (m_hasPendingTask) {
>+        if (oldDocument)
>+            oldDocument->decrementLoadEventDelayCount();
>+        m_element.document().incrementLoadEventDelayCount();
>+    }
>     clearFailedLoadURL();
>     clearImage();
> }
>diff --git a/Source/WebCore/loader/ImageLoader.h b/Source/WebCore/loader/ImageLoader.h
>index cfacbc626da262a76070495fa089de8a2c4ea3b9..0f051b77c01eff68c639e2842477029f328a46cb 100644
>--- a/Source/WebCore/loader/ImageLoader.h
>+++ b/Source/WebCore/loader/ImageLoader.h
>@@ -25,14 +25,21 @@
> 
> #include "CachedImageClient.h"
> #include "CachedResourceHandle.h"
>+#include "CachedResourceLoader.h"
>+#include "Microtasks.h"
> #include "Timer.h"
>+#include <wtf/RefCounted.h>
>+#include <wtf/WeakPtr.h>
> #include <wtf/text/AtomicString.h>
> 
> namespace WebCore {
> 
>+class Document;
> class Element;
> class ImageLoader;
> class RenderImageResource;
>+class URL;
>+class Task;
> 
> template<typename T> class EventSender;
> typedef EventSender<ImageLoader> ImageEventSender;
>@@ -50,12 +57,12 @@ public:
>     // doesn't change; starts new load unconditionally (matches Firefox and Opera behavior).
>     void updateFromElementIgnoringPreviousError();
> 
>-    void elementDidMoveToNewDocument();
>+    void elementDidMoveToNewDocument(Document* oldDocument);
> 
>     Element& element() { return m_element; }
>     const Element& element() const { return m_element; }
> 
>-    bool imageComplete() const { return m_imageComplete; }
>+    bool imageComplete() const { return m_imageComplete && !m_hasPendingTask; }
> 
>     CachedImage* image() const { return m_image.get(); }
>     void clearImage(); // Cancels pending beforeload and load events, and doesn't dispatch new ones.
>@@ -63,7 +70,7 @@ public:
>     void setLoadManually(bool loadManually) { m_loadManually = loadManually; }
> 
>     bool hasPendingBeforeLoadEvent() const { return m_hasPendingBeforeLoadEvent; }
>-    bool hasPendingActivity() const { return m_hasPendingLoadEvent || m_hasPendingErrorEvent; }
>+    bool hasPendingActivity() const { return m_hasPendingLoadEvent || m_hasPendingErrorEvent || m_hasPendingTask; }
> 
>     void dispatchPendingEvent(ImageEventSender*);
> 
>@@ -71,11 +78,17 @@ public:
>     static void dispatchPendingLoadEvents();
>     static void dispatchPendingErrorEvents();
> 
>+    bool hasPendingTask() const { return m_hasPendingTask; }
>+
> protected:
>     explicit ImageLoader(Element&);
>     virtual void notifyFinished(CachedResource*) override;
> 
> private:
>+    class ImageLoaderTask;
>+
>+    // Called from the task or from updateFromElement to initiate the load.
>+    void doUpdateFromElement(CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy);
>     virtual void dispatchLoadEvent() = 0;
>     virtual String sourceURI(const AtomicString&) const = 0;
> 
>@@ -93,10 +106,15 @@ private:
> 
>     void timerFired();
> 
>+    // Determine whether to initiate a synchronous load or to schedule a microtask.
>+    bool shouldLoadImmediately(const AtomicString& attribtue) const;
>+    WeakPtr<ImageLoader> createWeakPtr() { return m_weakFactory.createWeakPtr(); }
>+
>     Element& m_element;
>     CachedResourceHandle<CachedImage> m_image;
>     Timer m_derefElementTimer;
>     RefPtr<Element> m_protectedElement;
>+    WeakPtrFactory<ImageLoader> m_weakFactory;
>     AtomicString m_failedLoadURL;
>     bool m_hasPendingBeforeLoadEvent : 1;
>     bool m_hasPendingLoadEvent : 1;
>@@ -104,6 +122,7 @@ private:
>     bool m_imageComplete : 1;
>     bool m_loadManually : 1;
>     bool m_elementIsProtected : 1;
>+    bool m_hasPendingTask : 1;
> };
> 
> }
>diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
>index da55548a495f5b10cf499defefb31e52a4bde1e3..fa4feb99f0b496f479952a59265640542bad0f27 100644
>--- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp
>+++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
>@@ -174,7 +174,7 @@ SessionID CachedResourceLoader::sessionID() const
>     return sessionID;
> }
> 
>-CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request)
>+CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request, ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy)
> {
>     if (Frame* frame = this->frame()) {
>         if (frame->loader().pageDismissalEventBeingDispatched() != FrameLoader::PageDismissalType::None) {
>@@ -186,7 +186,7 @@ CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResou
>     }
>     
>     request.setDefer(clientDefersImage(request.resourceRequest().url()) ? CachedResourceRequest::DeferredByClient : CachedResourceRequest::NoDefer);
>-    return downcast<CachedImage>(requestResource(CachedResource::ImageResource, request).get());
>+    return downcast<CachedImage>(requestResource(CachedResource::ImageResource, request, shouldBypassMainWorldContentSecurityPolicy).get());
> }
> 
> CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest& request, bool isSVG)
>@@ -358,7 +358,7 @@ bool CachedResourceLoader::checkInsecureContent(CachedResource::Type type, const
>     return true;
> }
> 
>-bool CachedResourceLoader::canRequest(CachedResource::Type type, const URL& url, const ResourceLoaderOptions& options, bool forPreload)
>+bool CachedResourceLoader::canRequest(CachedResource::Type type, const URL& url, const ResourceLoaderOptions& options, bool forPreload, ShouldBypassMainWorldContentSecurityPolicy bypassMainWorldContentSecurityPolicy)
> {
>     if (document() && !document()->securityOrigin()->canDisplay(url)) {
>         if (!forPreload)
>@@ -367,7 +367,8 @@ bool CachedResourceLoader::canRequest(CachedResource::Type type, const URL& url,
>         return false;
>     }
> 
>-    bool skipContentSecurityPolicyCheck = options.contentSecurityPolicyImposition() == ContentSecurityPolicyImposition::SkipPolicyCheck;
>+    bool skipContentSecurityPolicyCheck = (bypassMainWorldContentSecurityPolicy == ShouldBypassMainWorldContentSecurityPolicy::Yes)
>+        || (options.contentSecurityPolicyImposition() == ContentSecurityPolicyImposition::SkipPolicyCheck);
> 
>     // Some types of resources can be loaded only from the same origin.  Other
>     // types of resources, like Images, Scripts, and CSS, can be loaded from
>@@ -499,7 +500,7 @@ static inline void logMemoryCacheResourceRequest(Frame* frame, const String& des
>         frame->mainFrame().diagnosticLoggingClient().logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceRequestKey(), description, value, ShouldSample::Yes);
> }
> 
>-CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request)
>+CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request, ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy)
> {
>     URL url = request.resourceRequest().url();
>     
>@@ -511,7 +512,7 @@ CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(Cache
>     if (!url.isValid())
>         return nullptr;
> 
>-    if (!canRequest(type, url, request.options(), request.forPreload()))
>+    if (!canRequest(type, url, request.options(), request.forPreload(), shouldBypassMainWorldContentSecurityPolicy))
>         return nullptr;
> 
> #if ENABLE(CONTENT_EXTENSIONS)
>diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.h b/Source/WebCore/loader/cache/CachedResourceLoader.h
>index d00ca3a766ee1369e1dae4141bacc1b226f99a65..76c5d27778066b1c9f37ecf17a34c31b53d58729 100644
>--- a/Source/WebCore/loader/cache/CachedResourceLoader.h
>+++ b/Source/WebCore/loader/cache/CachedResourceLoader.h
>@@ -71,7 +71,9 @@ public:
>     static Ref<CachedResourceLoader> create(DocumentLoader* documentLoader) { return adoptRef(*new CachedResourceLoader(documentLoader)); }
>     ~CachedResourceLoader();
> 
>-    CachedResourceHandle<CachedImage> requestImage(CachedResourceRequest&);
>+    enum class ShouldBypassMainWorldContentSecurityPolicy { No, Yes };
>+
>+    CachedResourceHandle<CachedImage> requestImage(CachedResourceRequest&, ShouldBypassMainWorldContentSecurityPolicy = ShouldBypassMainWorldContentSecurityPolicy::No);
>     CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(CachedResourceRequest&);
>     CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(CachedResourceRequest&);
>     CachedResourceHandle<CachedScript> requestScript(CachedResourceRequest&);
>@@ -130,7 +132,7 @@ public:
>     void preload(CachedResource::Type, CachedResourceRequest&, const String& charset);
>     void checkForPendingPreloads();
>     void printPreloadStats();
>-    bool canRequest(CachedResource::Type, const URL&, const ResourceLoaderOptions&, bool forPreload = false);
>+    bool canRequest(CachedResource::Type, const URL&, const ResourceLoaderOptions&, bool forPreload = false, ShouldBypassMainWorldContentSecurityPolicy = ShouldBypassMainWorldContentSecurityPolicy::No);
> 
>     static const ResourceLoaderOptions& defaultCachedResourceOptions();
> 
>@@ -139,7 +141,7 @@ public:
> private:
>     explicit CachedResourceLoader(DocumentLoader*);
> 
>-    CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, CachedResourceRequest&);
>+    CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, CachedResourceRequest&, ShouldBypassMainWorldContentSecurityPolicy = ShouldBypassMainWorldContentSecurityPolicy::No);
>     CachedResourceHandle<CachedResource> revalidateResource(const CachedResourceRequest&, CachedResource*);
>     CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, CachedResourceRequest&);
> #if ENABLE(RESOURCE_TIMING)
>diff --git a/Source/WebCore/svg/SVGImageElement.cpp b/Source/WebCore/svg/SVGImageElement.cpp
>index b2e97dd7b94320f197e69135d1372ce09c5609d3..ee4db9fc817e43ceb9695dee2c95c783f918c1e0 100644
>--- a/Source/WebCore/svg/SVGImageElement.cpp
>+++ b/Source/WebCore/svg/SVGImageElement.cpp
>@@ -205,7 +205,7 @@ void SVGImageElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
> 
> void SVGImageElement::didMoveToNewDocument(Document* oldDocument)
> {
>-    m_imageLoader.elementDidMoveToNewDocument();
>+    m_imageLoader.elementDidMoveToNewDocument(oldDocument);
>     SVGGraphicsElement::didMoveToNewDocument(oldDocument);
> }
> 
>diff --git a/Source/WebCore/xml/parser/XMLDocumentParser.cpp b/Source/WebCore/xml/parser/XMLDocumentParser.cpp
>index ef4cb41b4a87150f227d1622deccf84693514202..9360f1c3ab3054ba0b2e72084c9b44dcd9f0dd4f 100644
>--- a/Source/WebCore/xml/parser/XMLDocumentParser.cpp
>+++ b/Source/WebCore/xml/parser/XMLDocumentParser.cpp
>@@ -40,6 +40,7 @@
> #include "HTMLNames.h"
> #include "HTMLStyleElement.h"
> #include "ImageLoader.h"
>+#include "Microtasks.h"
> #include "ProcessingInstruction.h"
> #include "ResourceError.h"
> #include "ResourceRequest.h"
>@@ -207,6 +208,7 @@ void XMLDocumentParser::end()
>     document()->setReadyState(Document::Interactive);
>     clearCurrentNodeStack();
>     document()->finishedParsing();
>+    MicrotaskQueue::mainThreadQueue().performMicrotaskCheckpoint();
> }
> 
> void XMLDocumentParser::finish()
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 5fd915b90eacfea28d754d88c45169e1016dd4ac..de06a06d5aa9c249b8b3395054922c655d465245 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,24 @@
>+2015-12-04  Yoav Weiss  <yoav@yoav.ws>
>+
>+        Async loading of image resources
>+        https://bugs.webkit.org/show_bug.cgi?id=134488
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * fast/dom/HTMLImageElement/image-load-post-onload-expected.txt: Added.
>+        * fast/dom/HTMLImageElement/image-load-post-onload.html: Added.
>+        * fast/dom/HTMLImageElement/image-loading-gc.html: Cosmetic changes.
>+        * fast/dom/HTMLImageElement/sizes/image-sizes-js-change-reverse-expected.txt: Added.
>+        * fast/dom/HTMLImageElement/sizes/image-sizes-js-change-reverse.html: Added.
>+        * fast/dom/image-object.html: Cosmetic changes.
>+        * http/tests/misc/image-blocked-src-change-expected.txt: Removed line numbers from console.
>+        * http/tests/misc/image-blocked-src-no-change-expected.txt: Removed line numbers from console.
>+        * http/tests/security/contentSecurityPolicy/report-blocked-file-uri-expected.txt: Removed line numbers from console.
>+        * http/tests/security/frame-loading-via-document-write-expected.txt: Removed line numbers from console.
>+        * http/tests/security/local-image-from-remote-expected.txt: Removed line numbers from console.
>+        * loader/data-uri-images-load-asynchronously-expected.txt: Added.
>+        * loader/data-uri-images-load-asynchronously.html: Added.
>+
> 2015-12-03  Brady Eidson  <beidson@apple.com>
> 
>         Modern IDB: storage/indexeddb/cursor-advance.html fails.
>diff --git a/LayoutTests/fast/dom/HTMLImageElement/image-load-post-onload-expected.txt b/LayoutTests/fast/dom/HTMLImageElement/image-load-post-onload-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..484c1d559e70fc1cc5c158f375759bb115893f3a
>--- /dev/null
>+++ b/LayoutTests/fast/dom/HTMLImageElement/image-load-post-onload-expected.txt
>@@ -0,0 +1,2 @@
>+This tests that an image element is loading even if its src was changed after the page's onload event.
>+SUCCESS
>diff --git a/LayoutTests/fast/dom/HTMLImageElement/image-load-post-onload.html b/LayoutTests/fast/dom/HTMLImageElement/image-load-post-onload.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..95ae520a4c3d02a9caa1c58380090d6592b4bc51
>--- /dev/null
>+++ b/LayoutTests/fast/dom/HTMLImageElement/image-load-post-onload.html
>@@ -0,0 +1,29 @@
>+<!DOCTYPE html>
>+<html>
>+<script>
>+function runTest() {
>+    if (window.testRunner) {
>+        testRunner.dumpAsText();
>+        testRunner.waitUntilDone();
>+    }
>+
>+    var image = new Image();
>+    var first = true;
>+    image.onload = function () {
>+        if (!first) {
>+            document.getElementById('result').innerHTML = 'SUCCESS';
>+            if (window.testRunner)
>+                testRunner.notifyDone();
>+        }
>+        image.src = 'resources/image-set-4x.png';
>+        first = false;
>+    }
>+
>+    image.src = 'resources/blue_rect.jpg'
>+}
>+</script>
>+<body onload="runTest()">
>+    <div>This tests that an image element is loading even if its src was changed after the page's onload event.</div>
>+<div id="result">FAILURE</div>
>+</body>
>+</html>
>diff --git a/LayoutTests/fast/dom/HTMLImageElement/image-loading-gc.html b/LayoutTests/fast/dom/HTMLImageElement/image-loading-gc.html
>index 7203500d031315e1cde0cfb9c4f5ca948b8f1938..869dad36229b2a0daf89c7f68a775d89963cd5f3 100644
>--- a/LayoutTests/fast/dom/HTMLImageElement/image-loading-gc.html
>+++ b/LayoutTests/fast/dom/HTMLImageElement/image-loading-gc.html
>@@ -32,7 +32,7 @@ function runTest() {
> }
> </script>
> <body onload="runTest()">
>-<div>This tests that an image element won't be garbage collected when it's loading, even if it doesn't have any references.
>+    <div>This tests that an image element won't be garbage collected when it's loading, even if it doesn't have any references.</div>
> <div id="result">FAILURE</div>
> </body>
> </html>
>diff --git a/LayoutTests/fast/dom/HTMLImageElement/sizes/image-sizes-js-change-reverse-expected.txt b/LayoutTests/fast/dom/HTMLImageElement/sizes/image-sizes-js-change-reverse-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1599929865526e86ed41db104b11df0df564e87b
>--- /dev/null
>+++ b/LayoutTests/fast/dom/HTMLImageElement/sizes/image-sizes-js-change-reverse-expected.txt
>@@ -0,0 +1,6 @@
>+image-set-4x.png has MIME type image/png
>+PASS currentSrcFileName("foo") is "image-set-4x.png"
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/fast/dom/HTMLImageElement/sizes/image-sizes-js-change-reverse.html b/LayoutTests/fast/dom/HTMLImageElement/sizes/image-sizes-js-change-reverse.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..a17e4fe2b2610ea42455841fa6191fca8b3431c1
>--- /dev/null
>+++ b/LayoutTests/fast/dom/HTMLImageElement/sizes/image-sizes-js-change-reverse.html
>@@ -0,0 +1,28 @@
>+<!DOCTYPE html>
>+<script src="../../../../resources/srcset-helper.js"></script>
>+<script src="../../../../resources/js-test.js"></script>
>+<script src="../resources/currentSrcHelper.js"></script>
>+<script>
>+    if (window.testRunner)
>+        testRunner.dumpAsText();
>+
>+    function updateSrc() {
>+        var img = document.getElementById("foo");
>+        // Here we're setting sizes last, and srcset after src to make sure image loading is done is "stable-state"
>+        img.src = "../resources/blue-100-px-square.png"
>+        img.srcset = "../../../hidpi/resources/image-set-1x.png 200w, ../../../hidpi/resources/image-set-2x.png 400w, ../resources/image-set-4x.png 800w";
>+        img.sizes = "400px";
>+    }
>+
>+    addEventListener("DOMContentLoaded", function() {
>+        if (sessionStorage.pageReloaded)
>+            testRunner.dumpResourceResponseMIMETypes();
>+        updateSrc();
>+    }, false);
>+
>+    function runTest()
>+    {
>+        shouldBe('currentSrcFileName("foo")', '"image-set-4x.png"');
>+    }
>+</script>
>+<img id="foo">
>diff --git a/LayoutTests/fast/dom/image-object.html b/LayoutTests/fast/dom/image-object.html
>index 94729336ba2171e51ec6f2aa7ba1fb5752700d92..0b7512f299777921f86052516d4f321f1f10352d 100644
>--- a/LayoutTests/fast/dom/image-object.html
>+++ b/LayoutTests/fast/dom/image-object.html
>@@ -46,8 +46,7 @@ function runTests() {
>         debug('FAILURE: Empty image should have complete set to true.');
>         numErrs++;
>     }
>-    
>-    i2 = new Image()
>+    i2 = new Image();
>     i2.onload = imageLoaded;
>     i2.src = 'resources/apple.gif';
> }
>diff --git a/LayoutTests/http/tests/misc/image-blocked-src-change-expected.txt b/LayoutTests/http/tests/misc/image-blocked-src-change-expected.txt
>index 65ab53fac2409bdad10150cf8d557dd0f532dad0..6b53db77168541082d043eaddf06489dc2aac613 100644
>--- a/LayoutTests/http/tests/misc/image-blocked-src-change-expected.txt
>+++ b/LayoutTests/http/tests/misc/image-blocked-src-change-expected.txt
>@@ -1,4 +1,4 @@
>-CONSOLE MESSAGE: line 44: Not allowed to load local resource: compass.jpg
>+CONSOLE MESSAGE: Not allowed to load local resource: compass.jpg
> Test case for bug 17897 : Not Rendering Images Imported from XHTML Document
> 
> You should see PASSED once and 250 x 50 green box. The console should also show a blocked attempt to load a local resource.
>diff --git a/LayoutTests/http/tests/misc/image-blocked-src-no-change-expected.txt b/LayoutTests/http/tests/misc/image-blocked-src-no-change-expected.txt
>index 552f00a733cec49365c56e0443401c0d9dbba7f7..7ec9097e901900c983fe6e640aa2eb8bdd1f32c4 100644
>--- a/LayoutTests/http/tests/misc/image-blocked-src-no-change-expected.txt
>+++ b/LayoutTests/http/tests/misc/image-blocked-src-no-change-expected.txt
>@@ -1,5 +1,5 @@
>-CONSOLE MESSAGE: line 27: Not allowed to load local resource: compass.jpg
>-CONSOLE MESSAGE: line 21: Not allowed to load local resource: compass.jpg
>+CONSOLE MESSAGE: Not allowed to load local resource: compass.jpg
>+CONSOLE MESSAGE: Not allowed to load local resource: compass.jpg
> Test case for bug 17897 : Not Rendering Images Imported from XHTML Document
> 
> This test checks that setting an image url should lead to load even if the image was in error and the url is not changed.
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/report-blocked-file-uri-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/report-blocked-file-uri-expected.txt
>index 2ca2b090f0d63417b00253ee6bd631ec8afb0c41..43b76e4ff86749fbb2670dabd0efb199ebc60b21 100644
>--- a/LayoutTests/http/tests/security/contentSecurityPolicy/report-blocked-file-uri-expected.txt
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/report-blocked-file-uri-expected.txt
>@@ -5,4 +5,4 @@ CONTENT_TYPE: application/json
> HTTP_REFERER: http://127.0.0.1:8000/security/contentSecurityPolicy/report-blocked-file-uri.html
> REQUEST_METHOD: POST
> === POST DATA ===
>-{"csp-report":{"document-uri":"http://127.0.0.1:8000/security/contentSecurityPolicy/report-blocked-file-uri.html","referrer":"","violated-directive":"img-src 'none'","original-policy":"img-src 'none'; report-uri resources/save-report.php","blocked-uri":"file","source-file":"http://127.0.0.1:8000/security/contentSecurityPolicy/report-blocked-file-uri.html","line-number":12}}
>+{"csp-report":{"document-uri":"http://127.0.0.1:8000/security/contentSecurityPolicy/report-blocked-file-uri.html","referrer":"","violated-directive":"img-src 'none'","original-policy":"img-src 'none'; report-uri resources/save-report.php","blocked-uri":"file"}}
>diff --git a/LayoutTests/http/tests/security/frame-loading-via-document-write-expected.txt b/LayoutTests/http/tests/security/frame-loading-via-document-write-expected.txt
>index d4b9f90b5c86c3d12ccfac88a6b073a4602718af..78e874673056d4007ea11f2b10b0585b07c4bc46 100644
>--- a/LayoutTests/http/tests/security/frame-loading-via-document-write-expected.txt
>+++ b/LayoutTests/http/tests/security/frame-loading-via-document-write-expected.txt
>@@ -1,4 +1,4 @@
>-CONSOLE MESSAGE: line 1: Not allowed to load local resource: abe.png
>+CONSOLE MESSAGE: Not allowed to load local resource: abe.png
> 
> 
> --------
>diff --git a/LayoutTests/http/tests/security/local-image-from-remote-expected.txt b/LayoutTests/http/tests/security/local-image-from-remote-expected.txt
>index 17ea23be0a82228ae28362d81cff8f700273a9ff..3fcc3ec452b5db817883b16e48fad99daaec69a3 100644
>--- a/LayoutTests/http/tests/security/local-image-from-remote-expected.txt
>+++ b/LayoutTests/http/tests/security/local-image-from-remote-expected.txt
>@@ -1,4 +1,4 @@
>-CONSOLE MESSAGE: line 14: Not allowed to load local resource: compass.jpg
>+CONSOLE MESSAGE: Not allowed to load local resource: compass.jpg
> This test is to see if a remote file can include a local image. 
> Currently this test cannot be run manually on Windows because we do not have a function like pathToLocalResource() outside of DRT. 
> 
>diff --git a/LayoutTests/loader/data-uri-images-load-asynchronously-expected.txt b/LayoutTests/loader/data-uri-images-load-asynchronously-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..21927c9f2f9757690a8d3fbe1044051624fa5985
>--- /dev/null
>+++ b/LayoutTests/loader/data-uri-images-load-asynchronously-expected.txt
>@@ -0,0 +1,2 @@
>+Test for crbug.com/224317: data:uri images should load asynchronously.
>+PASS
>diff --git a/LayoutTests/loader/data-uri-images-load-asynchronously.html b/LayoutTests/loader/data-uri-images-load-asynchronously.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..370eff19dcaac001e811e9d70d81557be3fb2b92
>--- /dev/null
>+++ b/LayoutTests/loader/data-uri-images-load-asynchronously.html
>@@ -0,0 +1,18 @@
>+<!DOCTYPE html>
>+<html>
>+<body>
>+Test for crbug.com/224317: data:uri images should load asynchronously.<br/>
>+<script>
>+    if (window.testRunner)
>+        testRunner.dumpAsText();
>+
>+    var image = new Image();
>+    image.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAIAAAD/gAIDAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAnklEQVR42u3QMQEAAAgDoGlyo1vBzwciUJlw1ApkyZIlS5YsBbJkyZIlS5YCWbJkyZIlS4EsWbJkyZKlQJYsWbJkyVIgS5YsWbJkKZAlS5YsWbIUyJIlS5YsWQpkyZIlS5YsBbJkyZIlS5YCWbJkyZIlS4EsWbJkyZKlQJYsWbJkyVIgS5YsWbJkKZAlS5YsWbIUyJIlS5YsWQpkyfq2MosBSIeKONMAAAAASUVORK5CYII=";
>+
>+    if (image.width == 100 && image.height == 100)
>+        document.write("FAIL");
>+    else
>+        document.write("PASS");
>+</script>
>+</body>
>+</html>

Actions: View | Formatted Diff | Diff

Attachments on bug 134488: 234157 | 234160 | 234163 | 234164 | 239023 | 239044 | 239058 | 239061 | 239322 | 239325 | 239327 | 239329 | 239332 | 248223 | 248225 | 248226 | 249397 | 249398 | 249399 | 249400 | 249558 | 249560 | 249561 | 249716 | 249717 | 249718 | 249722 | 249723 | 249724 | 249725 | 249755 | 249902 | 266607 | 266609 | 266610 | 266611 | 266613 | 266616 | 266617 | 266618 | 376850 | 376855 | 376864 | 376875 | 376896 | 376910 | 376993 | 376995 | 377027 | 377036 | 377064 | 377110 | 377117