[Not committed] Make image load completion async and remove EventSender from ImageLoader

third_party/WebKit/Source/core/loader/ImageLoader.cpp

 /*
  * 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.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 12 matching lines @@
 
 #include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/IncrementLoadEventDelayCount.h"
 #include "core/events/Event.h"
-#include "core/events/EventSender.h"
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/CrossOriginAttribute.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutVideo.h"
 #include "core/layout/svg/LayoutSVGImage.h"
 #include "core/svg/graphics/SVGImage.h"
 #include "platform/Logging.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebTaskRunner.h"
+#include "public/platform/WebTraceLocation.h"
 #include "public/platform/WebURLRequest.h"
 
 namespace blink {
 
-static ImageEventSender& loadEventSender()
-{
-    DEFINE_STATIC_LOCAL(ImageEventSender, sender, (ImageEventSender::create(EventTypeNames::load)));
-    return sender;
-}
-
-static ImageEventSender& errorEventSender()
-{
-    DEFINE_STATIC_LOCAL(ImageEventSender, sender, (ImageEventSender::create(EventTypeNames::error)));
-    return sender;
-}
-
 static inline bool pageIsBeingDismissed(Document* document)
 {
     return document->pageDismissalEventBeingDispatched() != Document::NoDismissal;
 }
 
 static ImageLoader::BypassMainWorldBehavior shouldBypassMainWorldCSP(ImageLoader* loader)
 {
     ASSERT(loader);
     ASSERT(loader->element());
     if (loader->element()->document().frame() && loader->element()->document().frame()->script().shouldBypassMainWorldCSP())
@@ skipping 65 matching lines @@
     UpdateFromElementBehavior m_updateBehavior;
     RefPtr<ScriptState> m_scriptState;
     WeakPtrFactory<Task> m_weakFactory;
     ReferrerPolicy m_referrerPolicy;
     int m_operationId;
 };
 
 ImageLoader::ImageLoader(Element* element)
     : m_element(element)
     , m_derefElementTimer(this, &ImageLoader::timerFired)
+    , m_finishTask(CancellableTaskFactory::create(this, &ImageLoader::finish))
+    , m_dispatchErrorEventTask(CancellableTaskFactory::create(this, &ImageLoader::dispatchErrorEvent))
     , m_hasPendingLoadEvent(false)
-    , m_hasPendingErrorEvent(false)
     , m_imageComplete(true)
     , m_loadingImageDocument(false)
     , m_elementIsProtected(false)
     , m_suppressErrorEvents(false)
 {
     WTF_LOG(Timers, "new ImageLoader %p", this);
 #if ENABLE(OILPAN)
     ThreadState::current()->registerPreFinalizer(this);
 #endif
 }
 
 ImageLoader::~ImageLoader()
 {
 #if !ENABLE(OILPAN)
     dispose();
 #endif
 }
 
+void ImageLoader::cancelPendingFinish()
+{
+    if (m_loadDelayCounterForFinish) {
+        m_finishTask->cancel();
+        m_loadDelayCounterForFinish.clear();
+    }
+    m_hasPendingLoadEvent = false;
+}
+
+void ImageLoader::cancelPendingErrorEvent()
+{
+    if (m_loadDelayCounterForError) {
+        m_dispatchErrorEventTask->cancel();
+        m_loadDelayCounterForError.clear();
+    }
+}
+
 void ImageLoader::dispose()
 {
-    WTF_LOG(Timers, "~ImageLoader %p; m_hasPendingLoadEvent=%d, m_hasPendingErrorEvent=%d",
-        this, m_hasPendingLoadEvent, m_hasPendingErrorEvent);
+    WTF_LOG(Timers, "~ImageLoader %p; m_hasPendingLoadEvent=%d, hasPendingErrorEvent=%d",
+        this, m_hasPendingLoadEvent, hasPendingError());
 
 #if !ENABLE(OILPAN)
-    if (m_pendingTask)
-        m_pendingTask->clearLoader();
+    if (m_pendingMicrotask)
+        m_pendingMicrotask->clearLoader();
 #endif
 
     if (m_image) {
         m_image->removeObserver(this);
         m_image = nullptr;
     }
-
-#if !ENABLE(OILPAN)
-    ASSERT(m_hasPendingLoadEvent || !loadEventSender().hasPendingEvents(this));
-    if (m_hasPendingLoadEvent)
-        loadEventSender().cancelEvent(this);
-
-    ASSERT(m_hasPendingErrorEvent || !errorEventSender().hasPendingEvents(this));
-    if (m_hasPendingErrorEvent)
-        errorEventSender().cancelEvent(this);
-#endif
+    cancelPendingFinish();
+    cancelPendingErrorEvent();
 }
 
 DEFINE_TRACE(ImageLoader)
 {
     visitor->trace(m_image);
     visitor->trace(m_element);
 }
 
 void ImageLoader::setImage(ImageResource* newImage)
 {
     setImageWithoutConsideringPendingLoadEvent(newImage);
 
     // 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();
 }
 
 void ImageLoader::setImageWithoutConsideringPendingLoadEvent(ImageResource* newImage)
 {
     ASSERT(m_failedLoadURL.isEmpty());
     ImageResource* oldImage = m_image.get();
     if (newImage != oldImage) {
         m_image = newImage;
-        if (m_hasPendingLoadEvent) {
-            loadEventSender().cancelEvent(this);
-            m_hasPendingLoadEvent = false;
-        }
-        if (m_hasPendingErrorEvent) {
-            errorEventSender().cancelEvent(this);
-            m_hasPendingErrorEvent = false;
-        }
+        cancelPendingFinish();
+        cancelPendingErrorEvent();
         m_imageComplete = true;
         if (newImage) {
             newImage->addObserver(this);
         }
         if (oldImage) {
             oldImage->removeObserver(this);
         }
     }
 
     if (LayoutImageResource* imageResource = layoutImageResource())
         imageResource->resetAnimation();
 }
 
 static void configureRequest(FetchRequest& request, ImageLoader::BypassMainWorldBehavior bypassBehavior, Element& element, const ClientHintsPreferences& clientHintsPreferences)
 {
     if (bypassBehavior == ImageLoader::BypassMainWorldCSP)
         request.setContentSecurityCheck(DoNotCheckContentSecurityPolicy);
 
     CrossOriginAttributeValue crossOrigin = crossOriginAttributeValue(element.fastGetAttribute(HTMLNames::crossoriginAttr));
     if (crossOrigin != CrossOriginAttributeNotSet)
         request.setCrossOriginAccessControl(element.document().getSecurityOrigin(), crossOrigin);
 
     if (clientHintsPreferences.shouldSendResourceWidth() && isHTMLImageElement(element))
         request.setResourceWidth(toHTMLImageElement(element).getResourceWidth());
 }
 
-inline void ImageLoader::dispatchErrorEvent()
+inline void ImageLoader::scheduleErrorEvent()
 {
-    m_hasPendingErrorEvent = true;
-    errorEventSender().dispatchEventSoon(this);
+    m_loadDelayCounterForError = IncrementLoadEventDelayCount::create(m_element->document());
+    Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, m_dispatchErrorEventTask->cancelAndCreate());
 }
 
 inline void ImageLoader::crossSiteOrCSPViolationOccurred(AtomicString imageSourceURL)
 {
     m_failedLoadURL = imageSourceURL;
 }
 
 inline void ImageLoader::clearFailedLoadURL()
 {
     m_failedLoadURL = AtomicString();
 }
 
 inline void ImageLoader::enqueueImageLoadingMicroTask(UpdateFromElementBehavior updateBehavior, ReferrerPolicy referrerPolicy)
 {
     OwnPtr<Task> task = Task::create(this, updateBehavior, referrerPolicy);
-    m_pendingTask = task->createWeakPtr();
+    m_pendingMicrotask = task->createWeakPtr();
     Microtask::enqueueMicrotask(task.release());
-    m_loadDelayCounter = IncrementLoadEventDelayCount::create(m_element->document());
+    m_loadDelayCounterForMicrotask = IncrementLoadEventDelayCount::create(m_element->document());
 }
 
 void ImageLoader::doUpdateFromElement(BypassMainWorldBehavior bypassBehavior, UpdateFromElementBehavior updateBehavior, ReferrerPolicy referrerPolicy)
 {
     // FIXME: According to
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/embedded-content.html#the-img-element:the-img-element-55
     // When "update image" is called due to environment changes and the load fails, onerror should not be called.
     // That is currently not the case.
     //
     // We don't need to call clearLoader here: Either we were called from the
     // task, or our caller updateFromElement cleared the task's loader (and set
-    // m_pendingTask to null).
-    m_pendingTask.clear();
+    // m_pendingMicrotask to null).
+    m_pendingMicrotask.clear();
     // Make sure to only decrement the count when we exit this function
     OwnPtr<IncrementLoadEventDelayCount> loadDelayCounter;
-    loadDelayCounter.swap(m_loadDelayCounter);
+    loadDelayCounter.swap(m_loadDelayCounterForMicrotask);
 
     Document& document = m_element->document();
     if (!document.isActive())
         return;
 
     AtomicString imageSourceURL = m_element->imageSourceURL();
     KURL url = imageSourceToKURL(imageSourceURL);
     RawPtr<ImageResource> newImage = nullptr;
     RawPtr<Element> protectElement(m_element.get());
     if (!url.isNull()) {
@@ skipping 24 matching lines @@
             request.setDefer(FetchRequest::DeferredByClient);
             request.setContentSecurityCheck(DoNotCheckContentSecurityPolicy);
         }
 
         newImage = ImageResource::fetch(request, document.fetcher());
         if (m_loadingImageDocument && newImage)
             newImage->setStatus(Resource::Pending);
 
         if (!newImage && !pageIsBeingDismissed(&document)) {
             crossSiteOrCSPViolationOccurred(imageSourceURL);
-            dispatchErrorEvent();
+            scheduleErrorEvent();
         } else {
             clearFailedLoadURL();
         }
     } else {
         if (!imageSourceURL.isNull()) {
             // Fire an error event if the url string is not empty, but the KURL is.
-            dispatchErrorEvent();
+            scheduleErrorEvent();
         }
         noImageResourceToLoad();
     }
 
     RawPtr<ImageResource> oldImage = m_image.get();
     if (updateBehavior == UpdateSizeChanged && m_element->layoutObject() && m_element->layoutObject()->isImage() && newImage == oldImage) {
         toLayoutImage(m_element->layoutObject())->intrinsicSizeChanged();
     } else {
-        if (m_hasPendingLoadEvent) {
-            loadEventSender().cancelEvent(this);
-            m_hasPendingLoadEvent = false;
-        }
+        cancelPendingFinish();
 
         // Cancel error events that belong to the previous load, which is now cancelled by changing the src attribute.
-        // If newImage is null and m_hasPendingErrorEvent is true, we know the error event has been just posted by
+        // If newImage is null and hasPendingError() is true, we know the error event has been just posted by
         // this load and we should not cancel the event.
         // FIXME: If both previous load and this one got blocked with an error, we can receive one error event instead of two.
-        if (m_hasPendingErrorEvent && newImage) {
-            errorEventSender().cancelEvent(this);
-            m_hasPendingErrorEvent = false;
-        }
+        if (newImage)
+            cancelPendingErrorEvent();
 
         m_image = newImage;
         m_hasPendingLoadEvent = newImage;
         m_imageComplete = !newImage;
 
         updateLayoutObject();
         // If newImage exists and is cached, addObserver() will result in the load event
         // being queued to fire. Ensure this happens after beforeload is dispatched.
         if (newImage) {
             newImage->addObserver(this);
@@ skipping 17 matching lines @@
     m_suppressErrorEvents = (updateBehavior == UpdateSizeChanged);
 
     if (updateBehavior == UpdateIgnorePreviousError)
         clearFailedLoadURL();
 
     if (!m_failedLoadURL.isEmpty() && imageSourceURL == m_failedLoadURL)
         return;
 
     // If we have a pending task, we have to clear it -- either we're
     // now loading immediately, or we need to reset the task's state.
-    if (m_pendingTask) {
-        m_pendingTask->clearLoader();
-        m_pendingTask.clear();
+    if (m_pendingMicrotask) {
+        m_pendingMicrotask->clearLoader();
+        m_pendingMicrotask.clear();
     }
 
     KURL url = imageSourceToKURL(imageSourceURL);
     if (shouldLoadImmediately(url)) {
         doUpdateFromElement(DoNotBypassMainWorldCSP, updateBehavior, referrerPolicy);
         return;
     }
     // Allow the idiom "img.src=''; img.src='.." to clear down the image before
     // an asynchronous load completes.
     if (imageSourceURL.isEmpty()) {
         ImageResource* image = m_image.get();
         if (image) {
             image->removeObserver(this);
         }
         m_image = nullptr;
+        cancelPendingFinish();
+        cancelPendingErrorEvent();
     }
 
     // Don't load images for inactive documents. We don't want to slow down the
     // raw HTML parsing case by loading images we don't intend to display.
     Document& document = m_element->document();
     if (document.isActive())
         enqueueImageLoadingMicroTask(updateBehavior, referrerPolicy);
 }
 
 KURL ImageLoader::imageSourceToKURL(AtomicString imageSourceURL) const
@@ skipping 29 matching lines @@
 }
 
 void ImageLoader::imageNotifyFinished(ImageResource* resource)
 {
     WTF_LOG(Timers, "ImageLoader::imageNotifyFinished %p; m_hasPendingLoadEvent=%d",
         this, m_hasPendingLoadEvent);
 
     ASSERT(m_failedLoadURL.isEmpty());
     ASSERT(resource == m_image.get());
 
+    m_loadDelayCounterForFinish = IncrementLoadEventDelayCount::create(m_element->document());
+    Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, m_finishTask->cancelAndCreate());
+}
+
+void ImageLoader::finish()
+{
     m_imageComplete = true;
+    ImageResource* imageResource = m_image.get();
+    ASSERT(imageResource);
 
-    // Update ImageAnimationPolicy for m_image.
-    if (m_image)
-        m_image->updateImageAnimationPolicy();
+    // Update ImageAnimationPolicy for |imageResource|.
+    if (imageResource)
+        imageResource->updateImageAnimationPolicy();
 
     updateLayoutObject();
 
-    if (m_image && m_image->getImage() && m_image->getImage()->isSVGImage())
-        toSVGImage(m_image->getImage())->updateUseCounters(element()->document());
+    if (imageResource && imageResource->getImage() && imageResource->getImage()->isSVGImage())
+        toSVGImage(imageResource->getImage())->updateUseCounters(element()->document());
 
-    if (!m_hasPendingLoadEvent)
-        return;
+    finishInternal(imageResource);
 
-    if (resource->errorOccurred()) {
-        loadEventSender().cancelEvent(this);
+    // Dispatches image's load/error event.
+    if (m_hasPendingLoadEvent) {
         m_hasPendingLoadEvent = false;
 
-        if (resource->resourceError().isAccessCheck())
-            crossSiteOrCSPViolationOccurred(AtomicString(resource->resourceError().failingURL()));
+        if (imageResource->errorOccurred()) {
+            if (imageResource->resourceError().isAccessCheck())
+                crossSiteOrCSPViolationOccurred(AtomicString(imageResource->resourceError().failingURL()));
 
-        // The error event should not fire if the image data update is a result of environment change.
-        // https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element:the-img-element-55
-        if (!m_suppressErrorEvents)
-            dispatchErrorEvent();
+            // The error event should not fire if the image data update is a result of environment change.
+            // https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element:the-img-element-55
+            if (!m_suppressErrorEvents)
+                dispatchErrorEventWithoutUpdatedHasPendingEvent();
+        } else if (!imageResource->wasCanceled()) {
+            if (element()->document().frame())
+                dispatchLoadEvent();
+        }
+    }
 
-        // 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();
-        return;
-    }
-    if (resource->wasCanceled()) {
-        m_hasPendingLoadEvent = false;
-        // 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();
-        return;
-    }
-    loadEventSender().dispatchEventSoon(this);
+    // Dispatches document's load event if applicable.
+    // Calling checkCompleted() and document load event synchronously here has
+    // no problem regarding reentrancy because ImageLoader::finish() is
+    // always executed as a CancellableTask and not called by others.
+    m_loadDelayCounterForFinish.clear();
+    if (element()->document().frame())
+        element()->document().frame()->loader().checkCompleted();
+
+    // 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();
 }
 
 LayoutImageResource* ImageLoader::layoutImageResource()
 {
     LayoutObject* layoutObject = m_element->layoutObject();
 
     if (!layoutObject)
         return 0;
 
     // We don't return style generated image because it doesn't belong to the ImageLoader.
@@ skipping 25 matching lines @@
         imageResource->setImageResource(m_image.get());
 }
 
 void ImageLoader::updatedHasPendingEvent()
 {
     // If an Element that does image loading is removed from the DOM the load/error event for the image is still observable.
     // As long as the ImageLoader is actively loading, the Element itself needs to be ref'ed to keep it from being
     // destroyed by DOM manipulation or garbage collection.
     // If such an Element wishes for the load to stop when removed from the DOM it needs to stop the ImageLoader explicitly.
     bool wasProtected = m_elementIsProtected;
-    m_elementIsProtected = m_hasPendingLoadEvent || m_hasPendingErrorEvent;
+    m_elementIsProtected = m_hasPendingLoadEvent || hasPendingError();
     if (wasProtected == m_elementIsProtected)
         return;
 
     if (m_elementIsProtected) {
         if (m_derefElementTimer.isActive())
             m_derefElementTimer.stop();
         else
             m_keepAlive = m_element;
     } else {
         ASSERT(!m_derefElementTimer.isActive());
         m_derefElementTimer.startOneShot(0, BLINK_FROM_HERE);
     }
 }
 
 void ImageLoader::timerFired(Timer<ImageLoader>*)
 {
     m_keepAlive.clear();
 }
 
-void ImageLoader::dispatchPendingEvent(ImageEventSender* eventSender)
+void ImageLoader::dispatchErrorEventWithoutUpdatedHasPendingEvent()
 {
-    WTF_LOG(Timers, "ImageLoader::dispatchPendingEvent %p", this);
-    ASSERT(eventSender == &loadEventSender() || eventSender == &errorEventSender());
-    const AtomicString& eventType = eventSender->eventType();
-    if (eventType == EventTypeNames::load)
-        dispatchPendingLoadEvent();
-    if (eventType == EventTypeNames::error)
-        dispatchPendingErrorEvent();
+    if (element()->document().frame())
+        element()->dispatchEvent(Event::create(EventTypeNames::error));
+    m_loadDelayCounterForError.clear();
 }
 
-void ImageLoader::dispatchPendingLoadEvent()
+void ImageLoader::dispatchErrorEvent()
 {
-    if (!m_hasPendingLoadEvent)
-        return;
-    if (!m_image)
-        return;
-    m_hasPendingLoadEvent = false;
-    if (element()->document().frame())
-        dispatchLoadEvent();
+    dispatchErrorEventWithoutUpdatedHasPendingEvent();
 
     // 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();
-}
-
-void ImageLoader::dispatchPendingErrorEvent()
-{
-    if (!m_hasPendingErrorEvent)
-        return;
-    m_hasPendingErrorEvent = false;
-
-    if (element()->document().frame())
-        element()->dispatchEvent(Event::create(EventTypeNames::error));
-
-    // 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();
 }
 
 bool ImageLoader::getImageAnimationPolicy(ImageAnimationPolicy& policy)
 {
     if (!element()->document().settings())
         return false;
 
     policy = element()->document().settings()->imageAnimationPolicy();
     return true;
 }
 
-void ImageLoader::dispatchPendingLoadEvents()
-{
-    loadEventSender().dispatchPendingEvents();
-}
-
-void ImageLoader::dispatchPendingErrorEvents()
-{
-    errorEventSender().dispatchPendingEvents();
-}
-
 void ImageLoader::elementDidMoveToNewDocument()
 {
-    if (m_loadDelayCounter)
-        m_loadDelayCounter->documentChanged(m_element->document());
+    if (m_loadDelayCounterForMicrotask)
+        m_loadDelayCounterForMicrotask->documentChanged(m_element->document());
+    if (m_loadDelayCounterForFinish)
+        m_loadDelayCounterForFinish->documentChanged(m_element->document());
+    if (m_loadDelayCounterForError)
+        m_loadDelayCounterForError->documentChanged(m_element->document());
     clearFailedLoadURL();
     setImage(0);
 }
 
 } // namespace blink