{

if (!p)

return;

ValueCheck<WebCore::Element*>::checkConsistency(&p->element());

{

auto* frame = document.frame();

return frame && frame->loader().pageDismissalEventBeingDispatched() != FrameLoader::PageDismissalType::None;

{

RefPtr resource = MemoryCache::singleton().resourceForRequest(request.resourceRequest(), document.page()->sessionID());

if (!resource || resource->stillNeedsLoad() || resource->isPreloaded())

return false;

if (resource->options().mode == FetchOptions::Mode::Cors && !protect(document.securityOrigin())->isSameOriginAs(*protect(resource->origin())))

return false;

if (resource->options().mode != request.options().mode || resource->options().credentials != request.options().credentials)

return false;

return true;

: m_element(element)

, m_derefElementTimer(*this, &ImageLoader::timerFired)

, m_hasPendingBeforeLoadEvent(false)

, m_hasPendingLoadEvent(false)

, m_hasPendingErrorEvent(false)

, m_imageComplete(true)

, m_loadManually(false)

, m_elementIsProtected(false)

{

{

clearImageWithoutConsideringPendingLoadEvent();

// 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();

{

LOG_WITH_STREAM(LazyLoading, stream << "ImageLoader " << this << " clearImageWithoutConsideringPendingLoadEvent");

ASSERT(m_failedLoadURL.isEmpty());

if (RefPtr oldImage = std::exchange(m_image, nullptr)) {

m_hasPendingBeforeLoadEvent = false;

if (m_hasPendingLoadEvent || m_hasPendingErrorEvent) {

loadEventSender().cancelEvent(*this);

m_hasPendingLoadEvent = m_hasPendingErrorEvent = false;

}

m_imageComplete = true;

oldImage->removeClient(*this);

}

if (CheckedPtr imageResource = renderImageResource())

imageResource->resetAnimation();

{

// This is implementing https://html.spec.whatwg.org/#update-the-image-data

//

// 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.

Ref element = this->element();

Ref document = element->document();

if (!document->hasLivingRenderTree())

return;

AtomString attr = element->imageSourceURL();

LOG_WITH_STREAM(LazyLoading, stream << "ImageLoader " << this << " updateFromElement, current URL is " << attr);

// Avoid loading a URL we already failed to load.

if (!m_failedLoadURL.isEmpty() && attr == m_failedLoadURL)

return;

RefPtr<CachedImage> newImage;

// Do not load any image if the 'src' attribute is missing.

if (attr.isNull()) {

didUpdateCachedImage(relevantMutation, WTF::move(newImage));

return;

}

// Fire an error event if the URL contains only whitespace.

if (StringView(attr).containsOnly<isASCIIWhitespace<char16_t>>()) {

m_failedLoadURL = attr;

m_hasPendingErrorEvent = true;

loadEventSender().dispatchEventSoon(*this, eventNames().errorEvent);

didUpdateCachedImage(relevantMutation, WTF::move(newImage));

return;

}

// Set up resource loading options.

ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();

auto loadingForElementInShadowTree = element->isInUserAgentShadowTree() || m_elementIsUserAgentShadowRootResource;

options.contentSecurityPolicyImposition = loadingForElementInShadowTree ? ContentSecurityPolicyImposition::SkipPolicyCheck : ContentSecurityPolicyImposition::DoPolicyCheck;

options.shouldEnableContentExtensionsCheck = loadingForElementInShadowTree ? ShouldEnableContentExtensionsCheck::No : ShouldEnableContentExtensionsCheck::Yes;

options.loadedFromPluginElement = is<HTMLPlugInElement>(element) ? LoadedFromPluginElement::Yes : LoadedFromPluginElement::No;

options.sameOriginDataURLFlag = SameOriginDataURLFlag::Set;

options.serviceWorkersMode = is<HTMLPlugInElement>(element) ? ServiceWorkersMode::None : ServiceWorkersMode::All;

RefPtr imageElement = dynamicDowncast<HTMLImageElement>(element);

if (imageElement) {

options.referrerPolicy = imageElement->referrerPolicy();

options.fetchPriority = imageElement->fetchPriority();

if (imageElement->usesSrcsetOrPicture())

options.initiator = Initiator::Imageset;

}

auto crossOriginAttribute = element->attributeWithoutSynchronization(HTMLNames::crossoriginAttr);

// Use URL from original request for same URL loads in order to preserve the original base URL.

URL imageURL;

if (RefPtr image = m_image; image && attr == m_pendingURL)

imageURL = image->url();

else {

if (imageElement) {

// It is possible that attributes are bulk-set via Element::parserSetAttributes. In that case, it is possible that attribute vectors are already configured,

// but corresponding attributeChanged is not called yet. This causes inconsistency in HTMLImageElement. Eventually, we will get the consistent state, but

// if "src" attributeChanged is not called yet, imageURL can be invalid and it does not work well for ResourceRequest.

// In this case, we should behave same as attr.isNull().

imageURL = imageElement->currentURL();

if (imageURL.isNull()) {

didUpdateCachedImage(relevantMutation, WTF::move(newImage));

return;

}

} else

imageURL = document->completeURL(attr);

m_pendingURL = attr;

}

ResourceRequest resourceRequest(WTF::move(imageURL));

resourceRequest.setInspectorInitiatorNodeIdentifier(InspectorInstrumentation::identifierForNode(element));

auto request = createPotentialAccessControlRequest(WTF::move(resourceRequest), WTF::move(options), document, crossOriginAttribute);

request.setInitiator(element);

if (m_loadManually) {

Ref cachedResourceLoader = document->cachedResourceLoader();

bool autoLoadOtherImages = cachedResourceLoader->autoLoadImages();

cachedResourceLoader->setAutoLoadImages(false);

RefPtr page = m_element->document().page();

// FIXME: We shouldn't do an explicit `new` here.

newImage = adoptRef(*new CachedImage(WTF::move(request), page->sessionID(), &page->cookieJar()));

newImage->setStatus(CachedResource::Pending);

newImage->setLoading(true);

cachedResourceLoader->m_documentResources.set(newImage->url().string(), *newImage);

cachedResourceLoader->setAutoLoadImages(autoLoadOtherImages);

} else {

#if !LOG_DISABLED

auto oldState = m_lazyImageLoadState;

#endif

if (m_lazyImageLoadState == LazyImageLoadState::None && imageElement) {

if (imageElement->isLazyLoadable() && document->settings().lazyImageLoadingEnabled() && !canReuseFromListOfAvailableImages(request, document)) {

m_lazyImageLoadState = LazyImageLoadState::Deferred;

request.setIgnoreForRequestCount(true);

}

}

auto imageLoading = (m_lazyImageLoadState == LazyImageLoadState::Deferred) ? ImageLoading::DeferredUntilVisible : ImageLoading::Immediate;

newImage = protect(document->cachedResourceLoader())->requestImage(WTF::move(request), imageLoading).value_or(nullptr);

LOG_WITH_STREAM(LazyLoading, stream << "ImageLoader " << this << " updateFromElement " << element.get() << " - state changed from " << oldState << " to " << m_lazyImageLoadState << ", loading is " << imageLoading << " new image " << newImage.get());

}

#if ENABLE(MULTI_REPRESENTATION_HEIC)

// Adaptive image glyphs need to load both the high fidelity HEIC and the

// fallback PNG resource, as both resources are treated as an atomic unit.

if (imageElement && imageElement->isMultiRepresentationHEIC()) {

auto fallbackURL = imageElement->getURLAttribute(HTMLNames::srcAttr);

if (!fallbackURL.isNull()) {

ResourceLoaderOptions fallbackOptions = CachedResourceLoader::defaultCachedResourceOptions();

fallbackOptions.contentSecurityPolicyImposition = loadingForElementInShadowTree ? ContentSecurityPolicyImposition::SkipPolicyCheck : ContentSecurityPolicyImposition::DoPolicyCheck;

fallbackOptions.sameOriginDataURLFlag = SameOriginDataURLFlag::Set;

ResourceRequest fallbackResourceRequest(WTF::move(fallbackURL));

fallbackResourceRequest.setInspectorInitiatorNodeIdentifier(InspectorInstrumentation::identifierForNode(*imageElement));

auto fallbackRequest = createPotentialAccessControlRequest(WTF::move(fallbackResourceRequest), WTF::move(fallbackOptions), document, crossOriginAttribute);

fallbackRequest.setInitiator(*imageElement);

protect(document->cachedResourceLoader())->requestImage(WTF::move(fallbackRequest));

}

}

#endif

// If we do not have an image here, it means that a cross-site

// violation occurred, or that the image was blocked via Content

// Security Policy, or the page is being dismissed. Trigger an

// error event if the page is not being dismissed.

if (!newImage && !pageIsBeingDismissed(document)) {

m_failedLoadURL = attr;

m_hasPendingErrorEvent = true;

loadEventSender().dispatchEventSoon(*this, eventNames().errorEvent);

} else

clearFailedLoadURL();

didUpdateCachedImage(relevantMutation, WTF::move(newImage));

{

LOG_WITH_STREAM(LazyLoading, stream << "ImageLoader " << this << " didUpdateCachedImage " << newImage.get());

Ref document = element().document();

RefPtr oldImage = m_image;

if (newImage != oldImage || relevantMutation == RelevantMutation::Yes) {

LOG_WITH_STREAM(LazyLoading, stream << " switching from old image " << oldImage.get() << " to image " << newImage.get() << " " << (newImage ? newImage->url() : URL()));

m_hasPendingBeforeLoadEvent = false;

if (m_hasPendingLoadEvent) {

loadEventSender().cancelEvent(*this, eventNames().loadEvent);

m_hasPendingLoadEvent = false;

}

// 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

// 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) {

loadEventSender().cancelEvent(*this, eventNames().errorEvent);

m_hasPendingErrorEvent = false;

}

m_image = newImage;

m_hasPendingBeforeLoadEvent = !document->isImageDocument() && newImage;

m_hasPendingLoadEvent = newImage;

m_imageComplete = !newImage;

if (newImage) {

if (!document->isImageDocument())

dispatchPendingBeforeLoadEvent();

else

updateRenderer();

if (m_lazyImageLoadState == LazyImageLoadState::Deferred)

LazyLoadImageObserver::observe(protect(element()));

// If newImage is cached, addClient() will result in the load event

// being queued to fire.

newImage->addClient(*this);

} else

resetLazyImageLoading(protect(element().document()));

if (oldImage) {

oldImage->removeClient(*this);

updateRenderer();

}

}

if (CheckedPtr imageResource = renderImageResource())

imageResource->resetAnimation();

// 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();

{

clearFailedLoadURL();

updateFromElement(relevantMutation);

{

if (!m_image || !m_image->allowsCaching() || !m_failedLoadURL.isEmpty() || element().document().activeServiceWorker()) {

updateFromElementIgnoringPreviousError(RelevantMutation::Yes);

return;

}

if (m_hasPendingLoadEvent || !m_pendingURL.isEmpty())

return;

ASSERT(m_image);

m_hasPendingLoadEvent = true;

notifyFinished(*protect(image()), NetworkLoadMetrics { });

{

ASSERT(!promises.isEmpty());

auto promisesToBeResolved = std::exchange(promises, { });

for (auto& promise : promisesToBeResolved)

promise->resolve();

{

ASSERT(!promises.isEmpty());

auto promisesToBeRejected = std::exchange(promises, { });

for (auto& promise : promisesToBeRejected)

promise->reject(Exception { ExceptionCode::EncodingError, message });

{

LOG_WITH_STREAM(LazyLoading, stream << "ImageLoader " << this << " notifyFinished - hasPendingLoadEvent " << m_hasPendingLoadEvent);

ASSERT(m_failedLoadURL.isEmpty());

ASSERT_UNUSED(resource, &resource == m_image.get());

m_pendingURL = { };

if (isDeferred()) {

LazyLoadImageObserver::unobserve(protect(element()), protect(document()));

m_lazyImageLoadState = LazyImageLoadState::FullImage;

LOG_WITH_STREAM(LazyLoading, stream << "ImageLoader " << this << " notifyFinished() for element " << element() << " setting lazy load state to " << m_lazyImageLoadState);

}

if (!m_hasPendingLoadEvent) {

setImageCompleteAndMaybeUpdateRenderer();

return;

}

RefPtr image = m_image;

if (image->resourceError().isAccessControl()) {

setImageCompleteAndMaybeUpdateRenderer();

auto imageURL = image->url();

clearImageWithoutConsideringPendingLoadEvent();

m_hasPendingErrorEvent = true;

loadEventSender().dispatchEventSoon(*this, eventNames().errorEvent);

auto message = makeString("Cannot load image "_s, imageURL.string(), " due to access control checks."_s);

protect(document())->addConsoleMessage(MessageSource::Security, MessageLevel::Error, message);

if (hasPendingDecodePromises())

rejectDecodePromises("Access control error."_s);

ASSERT(!m_hasPendingLoadEvent);

// 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 (image->wasCanceled()) {

setImageCompleteAndMaybeUpdateRenderer();

if (hasPendingDecodePromises())

rejectDecodePromises("Loading was canceled."_s);

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;

}

protect(image->image())->subresourcesAreFinished(protect(document()).ptr(), [this, protectedThis = Ref { *this }]() mutable {

// It is technically possible state changed underneath us.

if (!m_hasPendingLoadEvent)

return;

setImageCompleteAndMaybeUpdateRenderer();

if (hasPendingDecodePromises())

decode();

loadEventSender().dispatchEventSoon(*this, eventNames().loadEvent);

#if ENABLE(QUICKLOOK_FULLSCREEN)

if (RefPtr page = element().document().page())

page->chrome().client().updateImageSource(protect(element()).get());

#endif

#if ENABLE(SPATIAL_IMAGE_CONTROLS)

if (RefPtr imageElement = dynamicDowncast<HTMLImageElement>(element()))

SpatialImageControls::updateSpatialImageControls(*imageElement);

#endif

});

{

CheckedPtr imageResource = renderImageResource();

if (!imageResource)

return;

// Only update the renderer if it doesn't have an image or if what we have

// is a complete image. This prevents flickering in the case where a dynamic

// change is happening between two images.

RefPtr cachedImage = imageResource->cachedImage();

if (m_image != cachedImage && (m_imageComplete || !cachedImage))

imageResource->setCachedImage(protect(m_image));

{

m_imageComplete = true;

if (!hasPendingBeforeLoadEvent())

updateRenderer();

{

// 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 = hasPendingActivity();

if (wasProtected == m_elementIsProtected)

return;

if (m_elementIsProtected) {

if (m_derefElementTimer.isActive())

m_derefElementTimer.stop();

else

m_protectedElement = element();

} else {

ASSERT(!m_derefElementTimer.isActive());

m_derefElementTimer.startOneShot(0_s);

}

{

m_decodingPromises.append(WTF::move(promise));

if (!element().document().window()) {

rejectDecodePromises("Inactive document."_s);

return;

}

auto attr = protect(element())->imageSourceURL();

if (StringView(attr).containsOnly<isASCIIWhitespace<char16_t>>()) {

rejectDecodePromises("Missing source URL."_s);

return;

}

if (m_imageComplete)

decode();

{

ASSERT(hasPendingDecodePromises());

if (!element().document().window()) {

rejectDecodePromises("Inactive document."_s);

return;

}

RefPtr image = m_image;

if (!image || !image->image() || image->errorOccurred()) {

rejectDecodePromises("Loading error."_s);

return;

}

RefPtr bitmapImage = dynamicDowncast<BitmapImage>(image->image());

if (!bitmapImage) {

resolveDecodePromises();

return;

}

bitmapImage->decode([promises = WTF::move(m_decodingPromises)](DecodingStatus decodingStatus) mutable {

ASSERT(decodingStatus != DecodingStatus::Decoding);

if (decodingStatus == DecodingStatus::Invalid)

rejectPromises(promises, "Decoding error."_s);

else

resolvePromises(promises);

});

{

// Because of lazy image loading, an image's load may be deferred indefinitely. To avoid leaking the element, we only

// protect it once the load has actually started.

// We are using SUPPRESS_UNCOUNTED_ARG and not ref'ing m_image here because this function

// may get called on the GC thread, and it would trip threading assertion in RefCounted.

SUPPRESS_UNCOUNTED_ARG bool imageWillBeLoadedLater = m_image && !m_image->isLoading() && m_image->stillNeedsLoad();

return (m_hasPendingLoadEvent && !imageWillBeLoadedLater) || m_hasPendingErrorEvent;

{

ASSERT_UNUSED(eventSender, eventSender == &loadEventSender());

if (eventType == eventNames().loadEvent)

dispatchPendingLoadEvent();

if (eventType == eventNames().errorEvent)

dispatchPendingErrorEvent();

{

if (!m_hasPendingBeforeLoadEvent)

return;

if (!m_image)

return;

if (!element().document().hasLivingRenderTree())

return;

m_hasPendingBeforeLoadEvent = false;

if (!element().isConnected())

return;

updateRenderer();

{

if (!m_hasPendingLoadEvent)

return;

if (!m_image)

return;

m_hasPendingLoadEvent = false;

if (element().document().hasLivingRenderTree())

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();

{

if (!m_hasPendingErrorEvent)

return;

m_hasPendingErrorEvent = false;

loadEventSender().cancelEvent(*this, eventNames().errorEvent);

if (element().document().hasLivingRenderTree())

protect(element())->dispatchEvent(Event::create(eventNames().errorEvent, Event::CanBubble::No, Event::IsCancelable::No));

// 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();

{

clearFailedLoadURL();

clearImage();

resetLazyImageLoading(oldDocument);

{

LOG_WITH_STREAM(LazyLoading, stream << "ImageLoader " << this << " loadDeferredImage - state is " << m_lazyImageLoadState);

if (m_lazyImageLoadState != LazyImageLoadState::Deferred)

return;

m_lazyImageLoadState = LazyImageLoadState::LoadImmediately;

updateFromElement(RelevantMutation::No);

{

LOG_WITH_STREAM(LazyLoading, stream << "ImageLoader " << this << " resetLazyImageLoading - state is " << m_lazyImageLoadState);

if (isDeferred())

LazyLoadImageObserver::unobserve(protect(element()), document);

m_lazyImageLoadState = LazyImageLoadState::None;

{

if (&element().document() != &document)

return VisibleInViewportState::No;

CheckedPtr renderReplaced = dynamicDowncast<RenderReplaced>(element().renderer());

return renderReplaced && renderReplaced->isContentLikelyVisibleInViewport() ? VisibleInViewportState::Yes : VisibleInViewportState::No;

{

#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)

if (candidate.originAttribute == ImageCandidate::SrcOrigin)

return false;

Ref document = element().document();

RefPtr loader = document->loader();

if (!loader || !loader->hasArchiveResourceCollection())

return false;

auto candidateURL = URL { protect(element())->resolveURLStringIfNeeded(candidate.string.toString()) };

if (loader->archiveResourceForURL(candidateURL))

return false;

RefPtr page = document->page();

return !page || !page->allowsLoadFromURL(candidateURL, MainFrameMainResource::No);

#else

UNUSED_PARAM(candidate);

return false;

#endif