Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
/* A class that handles style system image loads (other image loads are handled
* by the nodes in the content tree).
*/
#include "mozilla/css/ImageLoader.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/DocumentInlines.h"
#include "mozilla/dom/LargestContentfulPaint.h"
#include "mozilla/dom/ImageTracker.h"
#include "nsContentUtils.h"
#include "nsIReflowCallback.h"
#include "nsLayoutUtils.h"
#include "nsError.h"
#include "nsCanvasFrame.h"
#include "nsDisplayList.h"
#include "nsIFrameInlines.h"
#include "imgIContainer.h"
#include "imgINotificationObserver.h"
#include "Image.h"
#include "mozilla/PresShell.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/SVGObserverUtils.h"
#include "mozilla/layers/WebRenderUserData.h"
#include "nsTHashSet.h"
using namespace mozilla::dom;
namespace mozilla::css {
// This is a singleton observer which looks in the `GlobalRequestTable` to look
// at which loaders to notify.
struct GlobalImageObserver final : public imgINotificationObserver {
NS_DECL_ISUPPORTS
NS_DECL_IMGINOTIFICATIONOBSERVER
GlobalImageObserver() = default;
private:
virtual ~GlobalImageObserver() = default;
};
NS_IMPL_ADDREF(GlobalImageObserver)
NS_IMPL_RELEASE(GlobalImageObserver)
NS_INTERFACE_MAP_BEGIN(GlobalImageObserver)
NS_INTERFACE_MAP_ENTRY(imgINotificationObserver)
NS_INTERFACE_MAP_END
// Data associated with every started load.
struct ImageTableEntry {
// Set of all ImageLoaders that have registered this URL and care for updates
// for it.
nsTHashSet<ImageLoader*> mImageLoaders;
// The amount of style values that are sharing this image.
uint32_t mSharedCount = 1;
};
using GlobalRequestTable =
nsClassHashtable<nsRefPtrHashKey<imgIRequest>, ImageTableEntry>;
// A table of all loads, keyed by their id mapping them to the set of
// ImageLoaders they have been registered in, and recording their "canonical"
// image request.
//
// We use the load id as the key since we can only access sImages on the
// main thread, but LoadData objects might be destroyed from other threads,
// and we don't want to leave dangling pointers around.
static StaticAutoPtr<GlobalRequestTable> sImages;
static StaticRefPtr<GlobalImageObserver> sImageObserver;
/* static */
void ImageLoader::Init() {
sImages = new GlobalRequestTable();
sImageObserver = new GlobalImageObserver();
}
/* static */
void ImageLoader::Shutdown() {
for (const auto& entry : *sImages) {
imgIRequest* imgRequest = entry.GetKey();
// All the images we put in sImages are imgRequestProxy, see LoadImage, but
// it's non-trivial to make the hash table to use that without changing a
// lot of other code.
auto* req = static_cast<imgRequestProxy*>(imgRequest);
req->SetCancelable(true);
req->CancelAndForgetObserver(NS_BINDING_ABORTED);
}
sImages = nullptr;
sImageObserver = nullptr;
}
void ImageLoader::DropDocumentReference() {
MOZ_ASSERT(NS_IsMainThread());
// It's okay if GetPresContext returns null here (due to the presshell pointer
// on the document being null) as that means the presshell has already
// been destroyed, and it also calls ClearFrames when it is destroyed.
ClearFrames(GetPresContext());
mDocument = nullptr;
}
// Arrays of requests and frames are sorted by their pointer address,
// for faster lookup.
template <typename Elem, typename Item,
typename Comparator = nsDefaultComparator<Elem, Item>>
static size_t GetMaybeSortedIndex(const nsTArray<Elem>& aArray,
const Item& aItem, bool* aFound,
Comparator aComparator = Comparator()) {
size_t index = aArray.IndexOfFirstElementGt(aItem, aComparator);
*aFound = index > 0 && aComparator.Equals(aItem, aArray.ElementAt(index - 1));
return index;
}
// Returns true if an async decode is triggered for aRequest, and thus we will
// get an OnFrameComplete callback for this request eventually.
static bool TriggerAsyncDecodeAtIntrinsicSize(imgIRequest* aRequest) {
uint32_t status = 0;
// Don't block onload if we've already got a frame complete status
// (since in that case the image is already loaded), or if we get an
// error status (since then we know the image won't ever load).
if (NS_SUCCEEDED(aRequest->GetImageStatus(&status))) {
if (status & imgIRequest::STATUS_FRAME_COMPLETE) {
// Already decoded, no need to do it again.
return false;
}
if (status & imgIRequest::STATUS_ERROR) {
// Already errored, this would be useless.
return false;
}
}
// We want to request decode in such a way that avoids triggering sync decode.
// First, we attempt to convert the aRequest into a imgIContainer. If that
// succeeds, then aRequest has an image and we can request decoding for size
// at zero size, the size will be ignored because we don't pass the
// FLAG_HIGH_QUALITY_SCALING flag and an async decode (because we didn't pass
// any sync decoding flags) at the intrinsic size will be requested. If the
// conversion to imgIContainer is unsuccessful, then that means aRequest
// doesn't have an image yet, which means we can safely call StartDecoding()
// on it without triggering any synchronous work.
nsCOMPtr<imgIContainer> imgContainer;
aRequest->GetImage(getter_AddRefs(imgContainer));
if (imgContainer) {
imgContainer->RequestDecodeForSize(gfx::IntSize(0, 0),
imgIContainer::DECODE_FLAGS_DEFAULT);
} else {
// It's safe to call StartDecoding directly, since it can't
// trigger synchronous decode without an image. Flags are ignored.
aRequest->StartDecoding(imgIContainer::FLAG_NONE);
}
return true;
}
void ImageLoader::AssociateRequestToFrame(imgIRequest* aRequest,
nsIFrame* aFrame, Flags aFlags) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(!(aFlags & Flags::IsBlockingLoadEvent),
"Shouldn't be used in the public API");
{
nsCOMPtr<imgINotificationObserver> observer;
aRequest->GetNotificationObserver(getter_AddRefs(observer));
if (!observer) {
// The request has already been canceled, so ignore it. This is ok because
// we're not going to get any more notifications from a canceled request.
return;
}
MOZ_ASSERT(observer == sImageObserver);
}
auto* const frameSet =
mRequestToFrameMap
.LookupOrInsertWith(
aRequest,
[&] {
mDocument->ImageTracker()->Add(aRequest);
if (auto entry = sImages->Lookup(aRequest)) {
DebugOnly<bool> inserted =
entry.Data()->mImageLoaders.EnsureInserted(this);
MOZ_ASSERT(inserted);
} else {
MOZ_ASSERT_UNREACHABLE(
"Shouldn't be associating images not in sImages");
}
if (nsPresContext* presContext = GetPresContext()) {
nsLayoutUtils::RegisterImageRequestIfAnimated(
presContext, aRequest, nullptr);
}
return MakeUnique<FrameSet>();
})
.get();
auto* const requestSet =
mFrameToRequestMap
.LookupOrInsertWith(aFrame,
[=]() {
aFrame->SetHasImageRequest(true);
return MakeUnique<RequestSet>();
})
.get();
// Add frame to the frameSet, and handle any special processing the
// frame might require.
FrameWithFlags fwf(aFrame);
FrameWithFlags* fwfToModify = &fwf;
// See if the frameSet already has this frame.
bool found;
uint32_t i =
GetMaybeSortedIndex(*frameSet, fwf, &found, FrameOnlyComparator());
if (found) {
// We're already tracking this frame, so prepare to modify the
// existing FrameWithFlags object.
fwfToModify = &frameSet->ElementAt(i - 1);
}
// Check if the frame requires special processing.
if (aFlags & Flags::RequiresReflowOnSizeAvailable) {
MOZ_ASSERT(!(aFlags &
Flags::RequiresReflowOnFirstFrameCompleteAndLoadEventBlocking),
"These two are exclusive");
fwfToModify->mFlags |= Flags::RequiresReflowOnSizeAvailable;
}
if (aFlags & Flags::RequiresReflowOnFirstFrameCompleteAndLoadEventBlocking) {
fwfToModify->mFlags |=
Flags::RequiresReflowOnFirstFrameCompleteAndLoadEventBlocking;
// If we weren't already blocking onload, do that now.
if (!(fwfToModify->mFlags & Flags::IsBlockingLoadEvent)) {
if (TriggerAsyncDecodeAtIntrinsicSize(aRequest)) {
// If there's no error, and the image has not loaded yet, so we can
// block onload.
fwfToModify->mFlags |= Flags::IsBlockingLoadEvent;
// Block document onload until we either remove the frame in
// RemoveRequestToFrameMapping or onLoadComplete, or complete a reflow.
mDocument->BlockOnload();
}
}
}
// Do some sanity checking to ensure that we only add to one mapping
// iff we also add to the other mapping.
DebugOnly<bool> didAddToFrameSet(false);
DebugOnly<bool> didAddToRequestSet(false);
// If we weren't already tracking this frame, add it to the frameSet.
if (!found) {
frameSet->InsertElementAt(i, fwf);
didAddToFrameSet = true;
}
// Add request to the request set if it wasn't already there.
i = GetMaybeSortedIndex(*requestSet, aRequest, &found);
if (!found) {
requestSet->InsertElementAt(i, aRequest);
didAddToRequestSet = true;
}
MOZ_ASSERT(didAddToFrameSet == didAddToRequestSet,
"We should only add to one map iff we also add to the other map.");
}
void ImageLoader::RemoveRequestToFrameMapping(imgIRequest* aRequest,
nsIFrame* aFrame) {
#ifdef DEBUG
{
nsCOMPtr<imgINotificationObserver> observer;
aRequest->GetNotificationObserver(getter_AddRefs(observer));
MOZ_ASSERT(!observer || observer == sImageObserver);
}
#endif
if (auto entry = mRequestToFrameMap.Lookup(aRequest)) {
const auto& frameSet = entry.Data();
MOZ_ASSERT(frameSet, "This should never be null");
// Before we remove aFrame from the frameSet, unblock onload if needed.
bool found;
uint32_t i = GetMaybeSortedIndex(*frameSet, FrameWithFlags(aFrame), &found,
FrameOnlyComparator());
if (found) {
UnblockOnloadIfNeeded(frameSet->ElementAt(i - 1));
frameSet->RemoveElementAtUnsafe(i - 1);
}
if (frameSet->IsEmpty()) {
DeregisterImageRequest(aRequest, GetPresContext());
entry.Remove();
}
}
}
void ImageLoader::DeregisterImageRequest(imgIRequest* aRequest,
nsPresContext* aPresContext) {
mDocument->ImageTracker()->Remove(aRequest);
if (auto entry = sImages->Lookup(aRequest)) {
entry.Data()->mImageLoaders.EnsureRemoved(this);
}
if (aPresContext) {
nsLayoutUtils::DeregisterImageRequest(aPresContext, aRequest, nullptr);
}
}
void ImageLoader::RemoveFrameToRequestMapping(imgIRequest* aRequest,
nsIFrame* aFrame) {
if (auto entry = mFrameToRequestMap.Lookup(aFrame)) {
const auto& requestSet = entry.Data();
MOZ_ASSERT(requestSet, "This should never be null");
requestSet->RemoveElementSorted(aRequest);
if (requestSet->IsEmpty()) {
aFrame->SetHasImageRequest(false);
entry.Remove();
}
}
}
void ImageLoader::DisassociateRequestFromFrame(imgIRequest* aRequest,
nsIFrame* aFrame) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aFrame->HasImageRequest(), "why call me?");
RemoveRequestToFrameMapping(aRequest, aFrame);
RemoveFrameToRequestMapping(aRequest, aFrame);
}
void ImageLoader::DropRequestsForFrame(nsIFrame* aFrame) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aFrame->HasImageRequest(), "why call me?");
UniquePtr<RequestSet> requestSet;
mFrameToRequestMap.Remove(aFrame, &requestSet);
aFrame->SetHasImageRequest(false);
if (MOZ_UNLIKELY(!requestSet)) {
MOZ_ASSERT_UNREACHABLE("HasImageRequest was lying");
return;
}
for (imgIRequest* request : *requestSet) {
RemoveRequestToFrameMapping(request, aFrame);
}
}
void ImageLoader::SetAnimationMode(uint16_t aMode) {
MOZ_ASSERT(NS_IsMainThread());
NS_ASSERTION(aMode == imgIContainer::kNormalAnimMode ||
aMode == imgIContainer::kDontAnimMode ||
aMode == imgIContainer::kLoopOnceAnimMode,
"Wrong Animation Mode is being set!");
for (nsISupports* key : mRequestToFrameMap.Keys()) {
auto* request = static_cast<imgIRequest*>(key);
#ifdef DEBUG
{
nsCOMPtr<imgIRequest> debugRequest = request;
NS_ASSERTION(debugRequest == request, "This is bad");
}
#endif
nsCOMPtr<imgIContainer> container;
request->GetImage(getter_AddRefs(container));
if (!container) {
continue;
}
// This can fail if the image is in error, and we don't care.
container->SetAnimationMode(aMode);
}
}
void ImageLoader::ClearFrames(nsPresContext* aPresContext) {
MOZ_ASSERT(NS_IsMainThread());
for (const auto& key : mRequestToFrameMap.Keys()) {
auto* request = static_cast<imgIRequest*>(key);
#ifdef DEBUG
{
nsCOMPtr<imgIRequest> debugRequest = request;
NS_ASSERTION(debugRequest == request, "This is bad");
}
#endif
DeregisterImageRequest(request, aPresContext);
}
mRequestToFrameMap.Clear();
mFrameToRequestMap.Clear();
}
static CORSMode EffectiveCorsMode(nsIURI* aURI,
const StyleComputedImageUrl& aImage) {
MOZ_ASSERT(aURI);
StyleCorsMode mode = aImage.CorsMode();
if (mode == StyleCorsMode::None) {
return CORSMode::CORS_NONE;
}
MOZ_ASSERT(mode == StyleCorsMode::Anonymous);
if (aURI->SchemeIs("resource")) {
return CORSMode::CORS_NONE;
}
return CORSMode::CORS_ANONYMOUS;
}
/* static */
already_AddRefed<imgRequestProxy> ImageLoader::LoadImage(
const StyleComputedImageUrl& aImage, Document& aDocument) {
MOZ_ASSERT(NS_IsMainThread());
nsIURI* uri = aImage.GetURI();
if (!uri) {
return nullptr;
}
if (aImage.HasRef()) {
bool isEqualExceptRef = false;
nsIURI* docURI = aDocument.GetDocumentURI();
if (NS_SUCCEEDED(uri->EqualsExceptRef(docURI, &isEqualExceptRef)) &&
isEqualExceptRef) {
// Prevent loading an internal resource.
return nullptr;
}
}
int32_t loadFlags =
nsIRequest::LOAD_NORMAL |
nsContentUtils::CORSModeToLoadImageFlags(EffectiveCorsMode(uri, aImage));
const URLExtraData& data = aImage.ExtraData();
RefPtr<imgRequestProxy> request;
nsresult rv = nsContentUtils::LoadImage(
uri, &aDocument, &aDocument, data.Principal(), 0, data.ReferrerInfo(),
sImageObserver, loadFlags, u"css"_ns, getter_AddRefs(request));
if (NS_FAILED(rv) || !request) {
return nullptr;
}
// This image could be shared across documents, so its load cannot be
request->SetCancelable(false);
sImages->GetOrInsertNew(request);
return request.forget();
}
void ImageLoader::UnloadImage(imgRequestProxy* aImage) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aImage);
if (MOZ_UNLIKELY(!sImages)) {
return; // Shutdown() takes care of it.
}
auto lookup = sImages->Lookup(aImage);
MOZ_DIAGNOSTIC_ASSERT(lookup, "Unregistered image?");
if (MOZ_UNLIKELY(!lookup)) {
return;
}
if (MOZ_UNLIKELY(--lookup.Data()->mSharedCount)) {
// Someone else still cares about this image.
return;
}
// Now we want to really cancel the request.
aImage->SetCancelable(true);
aImage->CancelAndForgetObserver(NS_BINDING_ABORTED);
MOZ_DIAGNOSTIC_ASSERT(lookup.Data()->mImageLoaders.IsEmpty(),
"Shouldn't be keeping references to any loader "
"by now");
lookup.Remove();
}
void ImageLoader::NoteSharedLoad(imgRequestProxy* aImage) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aImage);
auto lookup = sImages->Lookup(aImage);
MOZ_DIAGNOSTIC_ASSERT(lookup, "Unregistered image?");
if (MOZ_UNLIKELY(!lookup)) {
return;
}
lookup.Data()->mSharedCount++;
}
nsPresContext* ImageLoader::GetPresContext() {
if (!mDocument) {
return nullptr;
}
return mDocument->GetPresContext();
}
static bool IsRenderNoImages(uint32_t aDisplayItemKey) {
DisplayItemType type = GetDisplayItemTypeFromKey(aDisplayItemKey);
uint8_t flags = GetDisplayItemFlagsForType(type);
return flags & TYPE_RENDERS_NO_IMAGES;
}
static void InvalidateImages(nsIFrame* aFrame, imgIRequest* aRequest,
bool aForcePaint) {
if (!aFrame->StyleVisibility()->IsVisible()) {
return;
}
if (aFrame->IsTablePart()) {
// Tables don't necessarily build border/background display items
// for the individual table part frames, so IterateRetainedDataFor
// might not find the right display item.
return aFrame->InvalidateFrame();
}
if (aFrame->IsPrimaryFrameOfRootOrBodyElement()) {
if (auto* canvas = aFrame->PresShell()->GetCanvasFrame()) {
// Try to invalidate the canvas too, in the probable case the background
// was propagated to it.
InvalidateImages(canvas, aRequest, aForcePaint);
}
}
bool invalidateFrame = aForcePaint;
if (auto userDataTable =
aFrame->GetProperty(layers::WebRenderUserDataProperty::Key())) {
for (RefPtr<layers::WebRenderUserData> data : userDataTable->Values()) {
switch (data->GetType()) {
case layers::WebRenderUserData::UserDataType::eFallback:
if (!IsRenderNoImages(data->GetDisplayItemKey())) {
static_cast<layers::WebRenderFallbackData*>(data.get())
->SetInvalid(true);
}
// XXX: handle Blob data
invalidateFrame = true;
break;
case layers::WebRenderUserData::UserDataType::eMask:
static_cast<layers::WebRenderMaskData*>(data.get())->Invalidate();
invalidateFrame = true;
break;
case layers::WebRenderUserData::UserDataType::eImageProvider:
if (static_cast<layers::WebRenderImageProviderData*>(data.get())
->Invalidate(aRequest->GetProviderId())) {
break;
}
[[fallthrough]];
default:
invalidateFrame = true;
break;
}
}
}
#ifdef XP_MACOSX
else if (aFrame->HasAnyStateBits(NS_FRAME_IN_POPUP)) {
// On macOS popups are painted with fallback rendering so they don't have
// webrender user data to tell us if the frame was painted last time, so we
// use webrender. (On other platforms tooltips type popups are still
// rendered with fallback, but we don't expect them to have images.)
invalidateFrame = true;
}
#endif
// Update ancestor rendering observers (-moz-element etc)
//
{
nsIFrame* f = aFrame;
while (f && !f->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) {
SVGObserverUtils::InvalidateDirectRenderingObservers(f);
f = nsLayoutUtils::GetCrossDocParentFrameInProcess(f);
}
}
if (invalidateFrame) {
aFrame->SchedulePaint();
}
}
void ImageLoader::UnblockOnloadIfNeeded(FrameWithFlags& aFwf) {
if (aFwf.mFlags & Flags::IsBlockingLoadEvent) {
mDocument->UnblockOnload(false);
aFwf.mFlags &= ~Flags::IsBlockingLoadEvent;
}
}
void ImageLoader::UnblockOnloadIfNeeded(nsIFrame* aFrame,
imgIRequest* aRequest) {
MOZ_ASSERT(aFrame);
MOZ_ASSERT(aRequest);
FrameSet* frameSet = mRequestToFrameMap.Get(aRequest);
if (!frameSet) {
return;
}
size_t i =
frameSet->BinaryIndexOf(FrameWithFlags(aFrame), FrameOnlyComparator());
if (i != FrameSet::NoIndex) {
UnblockOnloadIfNeeded(frameSet->ElementAt(i));
}
}
// This callback is used to unblock document onload after a reflow
// triggered from an image load.
struct ImageLoader::ImageReflowCallback final : public nsIReflowCallback {
RefPtr<ImageLoader> mLoader;
WeakFrame mFrame;
nsCOMPtr<imgIRequest> const mRequest;
ImageReflowCallback(ImageLoader* aLoader, nsIFrame* aFrame,
imgIRequest* aRequest)
: mLoader(aLoader), mFrame(aFrame), mRequest(aRequest) {}
bool ReflowFinished() override;
void ReflowCallbackCanceled() override;
};
bool ImageLoader::ImageReflowCallback::ReflowFinished() {
// Check that the frame is still valid. If it isn't, then onload was
// unblocked when the frame was removed from the FrameSet in
// RemoveRequestToFrameMapping.
if (mFrame.IsAlive()) {
mLoader->UnblockOnloadIfNeeded(mFrame, mRequest);
}
// Get rid of this callback object.
delete this;
// We don't need to trigger layout.
return false;
}
void ImageLoader::ImageReflowCallback::ReflowCallbackCanceled() {
// Check that the frame is still valid. If it isn't, then onload was
// unblocked when the frame was removed from the FrameSet in
// RemoveRequestToFrameMapping.
if (mFrame.IsAlive()) {
mLoader->UnblockOnloadIfNeeded(mFrame, mRequest);
}
// Get rid of this callback object.
delete this;
}
void GlobalImageObserver::Notify(imgIRequest* aRequest, int32_t aType,
const nsIntRect* aData) {
auto entry = sImages->Lookup(aRequest);
MOZ_DIAGNOSTIC_ASSERT(entry);
if (MOZ_UNLIKELY(!entry)) {
return;
}
const auto loadersToNotify =
ToTArray<nsTArray<RefPtr<ImageLoader>>>(entry.Data()->mImageLoaders);
for (const auto& loader : loadersToNotify) {
loader->Notify(aRequest, aType, aData);
}
}
void ImageLoader::Notify(imgIRequest* aRequest, int32_t aType,
const nsIntRect* aData) {
nsCString uriString;
if (profiler_is_active()) {
nsCOMPtr<nsIURI> uri;
aRequest->GetFinalURI(getter_AddRefs(uri));
if (uri) {
uri->GetSpec(uriString);
}
}
AUTO_PROFILER_LABEL_DYNAMIC_CSTR("ImageLoader::Notify", OTHER,
uriString.get());
if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
nsCOMPtr<imgIContainer> image;
aRequest->GetImage(getter_AddRefs(image));
return OnSizeAvailable(aRequest, image);
}
if (aType == imgINotificationObserver::IS_ANIMATED) {
return OnImageIsAnimated(aRequest);
}
if (aType == imgINotificationObserver::FRAME_COMPLETE) {
return OnFrameComplete(aRequest);
}
if (aType == imgINotificationObserver::FRAME_UPDATE) {
return OnFrameUpdate(aRequest);
}
if (aType == imgINotificationObserver::DECODE_COMPLETE) {
nsCOMPtr<imgIContainer> image;
aRequest->GetImage(getter_AddRefs(image));
if (image && mDocument) {
image->PropagateUseCounters(mDocument);
}
}
if (aType == imgINotificationObserver::LOAD_COMPLETE) {
return OnLoadComplete(aRequest);
}
}
void ImageLoader::OnSizeAvailable(imgIRequest* aRequest,
imgIContainer* aImage) {
nsPresContext* presContext = GetPresContext();
if (!presContext) {
return;
}
aImage->SetAnimationMode(presContext->ImageAnimationMode());
FrameSet* frameSet = mRequestToFrameMap.Get(aRequest);
if (!frameSet) {
return;
}
for (const FrameWithFlags& fwf : *frameSet) {
if (fwf.mFlags & Flags::RequiresReflowOnSizeAvailable) {
fwf.mFrame->PresShell()->FrameNeedsReflow(
fwf.mFrame, IntrinsicDirty::FrameAncestorsAndDescendants,
NS_FRAME_IS_DIRTY);
}
}
}
void ImageLoader::OnImageIsAnimated(imgIRequest* aRequest) {
if (!mDocument) {
return;
}
FrameSet* frameSet = mRequestToFrameMap.Get(aRequest);
if (!frameSet) {
return;
}
// Register with the refresh driver now that we are aware that
// we are animated.
nsPresContext* presContext = GetPresContext();
if (presContext) {
nsLayoutUtils::RegisterImageRequest(presContext, aRequest, nullptr);
}
}
void ImageLoader::OnFrameComplete(imgIRequest* aRequest) {
ImageFrameChanged(aRequest, /* aFirstFrame = */ true);
}
void ImageLoader::OnFrameUpdate(imgIRequest* aRequest) {
ImageFrameChanged(aRequest, /* aFirstFrame = */ false);
}
void ImageLoader::ImageFrameChanged(imgIRequest* aRequest, bool aFirstFrame) {
if (!mDocument) {
return;
}
FrameSet* frameSet = mRequestToFrameMap.Get(aRequest);
if (!frameSet) {
return;
}
for (FrameWithFlags& fwf : *frameSet) {
// Since we just finished decoding a frame, we always want to paint, in
// case we're now able to paint an image that we couldn't paint before
// (and hence that we don't have retained data for).
const bool forceRepaint = aFirstFrame;
InvalidateImages(fwf.mFrame, aRequest, forceRepaint);
if (!aFirstFrame) {
// We don't reflow / try to unblock onload for subsequent frame updates.
continue;
}
if (fwf.mFlags &
Flags::RequiresReflowOnFirstFrameCompleteAndLoadEventBlocking) {
// Tell the container of the frame to reflow because the image request
// has finished decoding its first frame.
// FIXME(emilio): Why requesting reflow on the _parent_?
nsIFrame* parent = fwf.mFrame->GetInFlowParent();
parent->PresShell()->FrameNeedsReflow(
parent, IntrinsicDirty::FrameAncestorsAndDescendants,
NS_FRAME_IS_DIRTY);
// If we need to also potentially unblock onload, do it once reflow is
// done, with a reflow callback.
if (fwf.mFlags & Flags::IsBlockingLoadEvent) {
auto* unblocker = new ImageReflowCallback(this, fwf.mFrame, aRequest);
parent->PresShell()->PostReflowCallback(unblocker);
}
}
}
}
void ImageLoader::OnLoadComplete(imgIRequest* aRequest) {
if (!mDocument) {
return;
}
uint32_t status = 0;
if (NS_FAILED(aRequest->GetImageStatus(&status))) {
return;
}
FrameSet* frameSet = mRequestToFrameMap.Get(aRequest);
if (!frameSet) {
return;
}
for (FrameWithFlags& fwf : *frameSet) {
if (status & imgIRequest::STATUS_ERROR) {
// Check if aRequest has an error state. If it does, we need to unblock
// Document onload for all the frames associated with this request that
// have blocked onload. This is what happens in a CORS mode violation, and
// may happen during other network events.
UnblockOnloadIfNeeded(fwf);
}
nsIFrame* frame = fwf.mFrame;
if (frame->StyleVisibility()->IsVisible()) {
frame->SchedulePaint();
}
if (StaticPrefs::dom_enable_largest_contentful_paint()) {
LargestContentfulPaint::MaybeProcessImageForElementTiming(
static_cast<imgRequestProxy*>(aRequest),
frame->GetContent()->AsElement());
}
}
}
} // namespace mozilla::css