Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-28 23:31:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
10a37b47c1
gecko-dev/image/VectorImage.cpp
Sylvestre Ledru d0f6c7fc66 Bug 1856795 - Remove redundant member init r=emilio 
Done with:
./mach static-analysis check --checks="-*, readability-redundant-member-init" --fix .

https://clang.llvm.org/extra/clang-tidy/checks/readability/redundant-member-init.html

Differential Revision: https://phabricator.services.mozilla.com/D190002
2023-10-15 15:29:02 +00:00

1651 lines
55 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "VectorImage.h"
#include "AutoRestoreSVGState.h"
#include "gfx2DGlue.h"
#include "gfxContext.h"
#include "gfxDrawable.h"
#include "gfxPlatform.h"
#include "gfxUtils.h"
#include "imgFrame.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/MediaFeatureChange.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/SVGSVGElement.h"
#include "mozilla/dom/SVGDocument.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/PendingAnimationTracker.h"
#include "mozilla/PresShell.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/RefPtr.h"
#include "mozilla/StaticPrefs_image.h"
#include "mozilla/SVGObserverUtils.h" // for SVGRenderingObserver
#include "mozilla/SVGUtils.h"
#include "nsIStreamListener.h"
#include "nsMimeTypes.h"
#include "nsPresContext.h"
#include "nsRect.h"
#include "nsString.h"
#include "nsStubDocumentObserver.h"
#include "nsWindowSizes.h"
#include "ImageRegion.h"
#include "ISurfaceProvider.h"
#include "LookupResult.h"
#include "Orientation.h"
#include "SVGDocumentWrapper.h"
#include "SVGDrawingCallback.h"
#include "SVGDrawingParameters.h"
#include "nsIDOMEventListener.h"
#include "SurfaceCache.h"
#include "BlobSurfaceProvider.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/DocumentInlines.h"
#include "mozilla/image/Resolution.h"
#include "WindowRenderer.h"
namespace mozilla {
using namespace dom;
using namespace dom::SVGPreserveAspectRatio_Binding;
using namespace gfx;
using namespace layers;
namespace image {
// Helper-class: SVGRootRenderingObserver
class SVGRootRenderingObserver final : public SVGRenderingObserver {
public:
NS_DECL_ISUPPORTS
SVGRootRenderingObserver(SVGDocumentWrapper* aDocWrapper,
VectorImage* aVectorImage)
: mDocWrapper(aDocWrapper),
mVectorImage(aVectorImage),
mHonoringInvalidations(true) {
MOZ_ASSERT(mDocWrapper, "Need a non-null SVG document wrapper");
MOZ_ASSERT(mVectorImage, "Need a non-null VectorImage");
StartObserving();
Element* elem = GetReferencedElementWithoutObserving();
MOZ_ASSERT(elem, "no root SVG node for us to observe");
SVGObserverUtils::AddRenderingObserver(elem, this);
mInObserverSet = true;
}
void ResumeHonoringInvalidations() { mHonoringInvalidations = true; }
protected:
virtual ~SVGRootRenderingObserver() {
// This needs to call our GetReferencedElementWithoutObserving override,
// so must be called here rather than in our base class's dtor.
StopObserving();
}
Element* GetReferencedElementWithoutObserving() final {
return mDocWrapper->GetRootSVGElem();
}
virtual void OnRenderingChange() override {
Element* elem = GetReferencedElementWithoutObserving();
MOZ_ASSERT(elem, "missing root SVG node");
if (mHonoringInvalidations && !mDocWrapper->ShouldIgnoreInvalidation()) {
nsIFrame* frame = elem->GetPrimaryFrame();
if (!frame || frame->PresShell()->IsDestroying()) {
// We're being destroyed. Bail out.
return;
}
// Ignore further invalidations until we draw.
mHonoringInvalidations = false;
mVectorImage->InvalidateObserversOnNextRefreshDriverTick();
}
// Our caller might've removed us from rendering-observer list.
// Add ourselves back!
if (!mInObserverSet) {
SVGObserverUtils::AddRenderingObserver(elem, this);
mInObserverSet = true;
}
}
// Private data
const RefPtr<SVGDocumentWrapper> mDocWrapper;
VectorImage* const mVectorImage; // Raw pointer because it owns me.
bool mHonoringInvalidations;
};
NS_IMPL_ISUPPORTS(SVGRootRenderingObserver, nsIMutationObserver)
class SVGParseCompleteListener final : public nsStubDocumentObserver {
public:
NS_DECL_ISUPPORTS
SVGParseCompleteListener(SVGDocument* aDocument, VectorImage* aImage)
: mDocument(aDocument), mImage(aImage) {
MOZ_ASSERT(mDocument, "Need an SVG document");
MOZ_ASSERT(mImage, "Need an image");
mDocument->AddObserver(this);
}
private:
~SVGParseCompleteListener() {
if (mDocument) {
// The document must have been destroyed before we got our event.
// Otherwise this can't happen, since documents hold strong references to
// their observers.
Cancel();
}
}
public:
void EndLoad(Document* aDocument) override {
MOZ_ASSERT(aDocument == mDocument, "Got EndLoad for wrong document?");
// OnSVGDocumentParsed will release our owner's reference to us, so ensure
// we stick around long enough to complete our work.
RefPtr<SVGParseCompleteListener> kungFuDeathGrip(this);
mImage->OnSVGDocumentParsed();
}
void Cancel() {
MOZ_ASSERT(mDocument, "Duplicate call to Cancel");
if (mDocument) {
mDocument->RemoveObserver(this);
mDocument = nullptr;
}
}
private:
RefPtr<SVGDocument> mDocument;
VectorImage* const mImage; // Raw pointer to owner.
};
NS_IMPL_ISUPPORTS(SVGParseCompleteListener, nsIDocumentObserver)
class SVGLoadEventListener final : public nsIDOMEventListener {
public:
NS_DECL_ISUPPORTS
SVGLoadEventListener(Document* aDocument, VectorImage* aImage)
: mDocument(aDocument), mImage(aImage) {
MOZ_ASSERT(mDocument, "Need an SVG document");
MOZ_ASSERT(mImage, "Need an image");
mDocument->AddEventListener(u"MozSVGAsImageDocumentLoad"_ns, this, true,
false);
}
private:
~SVGLoadEventListener() {
if (mDocument) {
// The document must have been destroyed before we got our event.
// Otherwise this can't happen, since documents hold strong references to
// their observers.
Cancel();
}
}
public:
NS_IMETHOD HandleEvent(Event* aEvent) override {
MOZ_ASSERT(mDocument, "Need an SVG document. Received multiple events?");
// OnSVGDocumentLoaded will release our owner's reference
// to us, so ensure we stick around long enough to complete our work.
RefPtr<SVGLoadEventListener> kungFuDeathGrip(this);
#ifdef DEBUG
nsAutoString eventType;
aEvent->GetType(eventType);
MOZ_ASSERT(eventType.EqualsLiteral("MozSVGAsImageDocumentLoad"),
"Received unexpected event");
#endif
mImage->OnSVGDocumentLoaded();
return NS_OK;
}
void Cancel() {
MOZ_ASSERT(mDocument, "Duplicate call to Cancel");
if (mDocument) {
mDocument->RemoveEventListener(u"MozSVGAsImageDocumentLoad"_ns, this,
true);
mDocument = nullptr;
}
}
private:
nsCOMPtr<Document> mDocument;
VectorImage* const mImage; // Raw pointer to owner.
};
NS_IMPL_ISUPPORTS(SVGLoadEventListener, nsIDOMEventListener)
SVGDrawingCallback::SVGDrawingCallback(SVGDocumentWrapper* aSVGDocumentWrapper,
const IntSize& aViewportSize,
const IntSize& aSize,
uint32_t aImageFlags)
: mSVGDocumentWrapper(aSVGDocumentWrapper),
mViewportSize(aViewportSize),
mSize(aSize),
mImageFlags(aImageFlags) {}
SVGDrawingCallback::~SVGDrawingCallback() = default;
// Based loosely on SVGIntegrationUtils' PaintFrameCallback::operator()
bool SVGDrawingCallback::operator()(gfxContext* aContext,
const gfxRect& aFillRect,
const SamplingFilter aSamplingFilter,
const gfxMatrix& aTransform) {
MOZ_ASSERT(mSVGDocumentWrapper, "need an SVGDocumentWrapper");
// Get (& sanity-check) the helper-doc's presShell
RefPtr<PresShell> presShell = mSVGDocumentWrapper->GetPresShell();
MOZ_ASSERT(presShell, "GetPresShell returned null for an SVG image?");
Document* doc = presShell->GetDocument();
[[maybe_unused]] nsIURI* uri = doc ? doc->GetDocumentURI() : nullptr;
AUTO_PROFILER_LABEL_DYNAMIC_NSCSTRING(
"SVG Image drawing", GRAPHICS,
nsPrintfCString("%dx%d %s", mSize.width, mSize.height,
uri ? uri->GetSpecOrDefault().get() : "N/A"));
gfxContextAutoSaveRestore contextRestorer(aContext);
// Clip to aFillRect so that we don't paint outside.
aContext->Clip(aFillRect);
gfxMatrix matrix = aTransform;
if (!matrix.Invert()) {
return false;
}
aContext->SetMatrixDouble(
aContext->CurrentMatrixDouble().PreMultiply(matrix).PreScale(
double(mSize.width) / mViewportSize.width,
double(mSize.height) / mViewportSize.height));
nsPresContext* presContext = presShell->GetPresContext();
MOZ_ASSERT(presContext, "pres shell w/out pres context");
nsRect svgRect(0, 0, presContext->DevPixelsToAppUnits(mViewportSize.width),
presContext->DevPixelsToAppUnits(mViewportSize.height));
RenderDocumentFlags renderDocFlags =
RenderDocumentFlags::IgnoreViewportScrolling;
if (!(mImageFlags & imgIContainer::FLAG_SYNC_DECODE)) {
renderDocFlags |= RenderDocumentFlags::AsyncDecodeImages;
}
if (mImageFlags & imgIContainer::FLAG_HIGH_QUALITY_SCALING) {
renderDocFlags |= RenderDocumentFlags::UseHighQualityScaling;
}
presShell->RenderDocument(svgRect, renderDocFlags,
NS_RGBA(0, 0, 0, 0), // transparent
aContext);
return true;
}
// Implement VectorImage's nsISupports-inherited methods
NS_IMPL_ISUPPORTS(VectorImage, imgIContainer, nsIStreamListener,
nsIRequestObserver)
//------------------------------------------------------------------------------
// Constructor / Destructor
VectorImage::VectorImage(nsIURI* aURI /* = nullptr */)
: ImageResource(aURI), // invoke superclass's constructor
mLockCount(0),
mIsInitialized(false),
mDiscardable(false),
mIsFullyLoaded(false),
mHaveAnimations(false),
mHasPendingInvalidation(false) {}
VectorImage::~VectorImage() {
ReportDocumentUseCounters();
CancelAllListeners();
SurfaceCache::RemoveImage(ImageKey(this));
}
//------------------------------------------------------------------------------
// Methods inherited from Image.h
nsresult VectorImage::Init(const char* aMimeType, uint32_t aFlags) {
// We don't support re-initialization
if (mIsInitialized) {
return NS_ERROR_ILLEGAL_VALUE;
}
MOZ_ASSERT(!mIsFullyLoaded && !mHaveAnimations && !mError,
"Flags unexpectedly set before initialization");
MOZ_ASSERT(!strcmp(aMimeType, IMAGE_SVG_XML), "Unexpected mimetype");
mDiscardable = !!(aFlags & INIT_FLAG_DISCARDABLE);
// Lock this image's surfaces in the SurfaceCache if we're not discardable.
if (!mDiscardable) {
mLockCount++;
SurfaceCache::LockImage(ImageKey(this));
}
mIsInitialized = true;
return NS_OK;
}
size_t VectorImage::SizeOfSourceWithComputedFallback(
SizeOfState& aState) const {
if (!mSVGDocumentWrapper) {
return 0; // No document, so no memory used for the document.
}
SVGDocument* doc = mSVGDocumentWrapper->GetDocument();
if (!doc) {
return 0; // No document, so no memory used for the document.
}
nsWindowSizes windowSizes(aState);
doc->DocAddSizeOfIncludingThis(windowSizes);
if (windowSizes.getTotalSize() == 0) {
// MallocSizeOf fails on this platform. Because we also use this method for
// determining the size of cache entries, we need to return something
// reasonable here. Unfortunately, there's no way to estimate the document's
// size accurately, so we just use a constant value of 100KB, which will
// generally underestimate the true size.
return 100 * 1024;
}
return windowSizes.getTotalSize();
}
nsresult VectorImage::OnImageDataComplete(nsIRequest* aRequest,
nsresult aStatus, bool aLastPart) {
// Call our internal OnStopRequest method, which only talks to our embedded
// SVG document. This won't have any effect on our ProgressTracker.
nsresult finalStatus = OnStopRequest(aRequest, aStatus);
// Give precedence to Necko failure codes.
if (NS_FAILED(aStatus)) {
finalStatus = aStatus;
}
Progress loadProgress = LoadCompleteProgress(aLastPart, mError, finalStatus);
if (mIsFullyLoaded || mError) {
// Our document is loaded, so we're ready to notify now.
mProgressTracker->SyncNotifyProgress(loadProgress);
} else {
// Record our progress so far; we'll actually send the notifications in
// OnSVGDocumentLoaded or OnSVGDocumentError.
mLoadProgress = Some(loadProgress);
}
return finalStatus;
}
nsresult VectorImage::OnImageDataAvailable(nsIRequest* aRequest,
nsIInputStream* aInStr,
uint64_t aSourceOffset,
uint32_t aCount) {
return OnDataAvailable(aRequest, aInStr, aSourceOffset, aCount);
}
nsresult VectorImage::StartAnimation() {
if (mError) {
return NS_ERROR_FAILURE;
}
MOZ_ASSERT(ShouldAnimate(), "Should not animate!");
mSVGDocumentWrapper->StartAnimation();
return NS_OK;
}
nsresult VectorImage::StopAnimation() {
nsresult rv = NS_OK;
if (mError) {
rv = NS_ERROR_FAILURE;
} else {
MOZ_ASSERT(mIsFullyLoaded && mHaveAnimations,
"Should not have been animating!");
mSVGDocumentWrapper->StopAnimation();
}
mAnimating = false;
return rv;
}
bool VectorImage::ShouldAnimate() {
return ImageResource::ShouldAnimate() && mIsFullyLoaded && mHaveAnimations;
}
NS_IMETHODIMP_(void)
VectorImage::SetAnimationStartTime(const TimeStamp& aTime) {
// We don't care about animation start time.
}
//------------------------------------------------------------------------------
// imgIContainer methods
//******************************************************************************
NS_IMETHODIMP
VectorImage::GetWidth(int32_t* aWidth) {
if (mError || !mIsFullyLoaded) {
// XXXdholbert Technically we should leave outparam untouched when we
// fail. But since many callers don't check for failure, we set it to 0 on
// failure, for sane/predictable results.
*aWidth = 0;
return NS_ERROR_FAILURE;
}
SVGSVGElement* rootElem = mSVGDocumentWrapper->GetRootSVGElem();
MOZ_ASSERT(rootElem,
"Should have a root SVG elem, since we finished "
"loading without errors");
LengthPercentage rootElemWidth = rootElem->GetIntrinsicWidth();
if (!rootElemWidth.IsLength()) {
*aWidth = 0;
return NS_ERROR_FAILURE;
}
*aWidth = SVGUtils::ClampToInt(rootElemWidth.AsLength().ToCSSPixels());
return NS_OK;
}
//******************************************************************************
nsresult VectorImage::GetNativeSizes(nsTArray<IntSize>& aNativeSizes) {
return NS_ERROR_NOT_IMPLEMENTED;
}
//******************************************************************************
size_t VectorImage::GetNativeSizesLength() { return 0; }
//******************************************************************************
NS_IMETHODIMP_(void)
VectorImage::RequestRefresh(const TimeStamp& aTime) {
if (HadRecentRefresh(aTime)) {
return;
}
Document* doc = mSVGDocumentWrapper->GetDocument();
if (!doc) {
// We are racing between shutdown and a refresh.
return;
}
PendingAnimationTracker* tracker = doc->GetPendingAnimationTracker();
if (tracker && ShouldAnimate()) {
tracker->TriggerPendingAnimationsOnNextTick(aTime);
}
EvaluateAnimation();
mSVGDocumentWrapper->TickRefreshDriver();
if (mHasPendingInvalidation) {
SendInvalidationNotifications();
}
}
void VectorImage::SendInvalidationNotifications() {
// Animated images don't send out invalidation notifications as soon as
// they're generated. Instead, InvalidateObserversOnNextRefreshDriverTick
// records that there are pending invalidations and then returns immediately.
// The notifications are actually sent from RequestRefresh(). We send these
// notifications there to ensure that there is actually a document observing
// us. Otherwise, the notifications are just wasted effort.
//
// Non-animated images post an event to call this method from
// InvalidateObserversOnNextRefreshDriverTick, because RequestRefresh is never
// called for them. Ordinarily this isn't needed, since we send out
// invalidation notifications in OnSVGDocumentLoaded, but in rare cases the
// SVG document may not be 100% ready to render at that time. In those cases
// we would miss the subsequent invalidations if we didn't send out the
// notifications indirectly in |InvalidateObservers...|.
mHasPendingInvalidation = false;
if (SurfaceCache::InvalidateImage(ImageKey(this))) {
// If we still have recordings in the cache, make sure we handle future
// invalidations.
MOZ_ASSERT(mRenderingObserver, "Should have a rendering observer by now");
mRenderingObserver->ResumeHonoringInvalidations();
}
if (mProgressTracker) {
mProgressTracker->SyncNotifyProgress(FLAG_FRAME_COMPLETE,
GetMaxSizedIntRect());
}
}
NS_IMETHODIMP_(IntRect)
VectorImage::GetImageSpaceInvalidationRect(const IntRect& aRect) {
return aRect;
}
//******************************************************************************
NS_IMETHODIMP
VectorImage::GetHeight(int32_t* aHeight) {
if (mError || !mIsFullyLoaded) {
// XXXdholbert Technically we should leave outparam untouched when we
// fail. But since many callers don't check for failure, we set it to 0 on
// failure, for sane/predictable results.
*aHeight = 0;
return NS_ERROR_FAILURE;
}
SVGSVGElement* rootElem = mSVGDocumentWrapper->GetRootSVGElem();
MOZ_ASSERT(rootElem,
"Should have a root SVG elem, since we finished "
"loading without errors");
LengthPercentage rootElemHeight = rootElem->GetIntrinsicHeight();
if (!rootElemHeight.IsLength()) {
*aHeight = 0;
return NS_ERROR_FAILURE;
}
*aHeight = SVGUtils::ClampToInt(rootElemHeight.AsLength().ToCSSPixels());
return NS_OK;
}
//******************************************************************************
NS_IMETHODIMP
VectorImage::GetIntrinsicSize(nsSize* aSize) {
if (mError || !mIsFullyLoaded) {
return NS_ERROR_FAILURE;
}
nsIFrame* rootFrame = mSVGDocumentWrapper->GetRootLayoutFrame();
if (!rootFrame) {
return NS_ERROR_FAILURE;
}
*aSize = nsSize(-1, -1);
IntrinsicSize rfSize = rootFrame->GetIntrinsicSize();
if (rfSize.width) {
aSize->width = *rfSize.width;
}
if (rfSize.height) {
aSize->height = *rfSize.height;
}
return NS_OK;
}
//******************************************************************************
Maybe<AspectRatio> VectorImage::GetIntrinsicRatio() {
if (mError || !mIsFullyLoaded) {
return Nothing();
}
nsIFrame* rootFrame = mSVGDocumentWrapper->GetRootLayoutFrame();
if (!rootFrame) {
return Nothing();
}
return Some(rootFrame->GetIntrinsicRatio());
}
NS_IMETHODIMP_(Orientation)
VectorImage::GetOrientation() { return Orientation(); }
NS_IMETHODIMP_(Resolution)
VectorImage::GetResolution() { return {}; }
//******************************************************************************
NS_IMETHODIMP
VectorImage::GetType(uint16_t* aType) {
NS_ENSURE_ARG_POINTER(aType);
*aType = imgIContainer::TYPE_VECTOR;
return NS_OK;
}
//******************************************************************************
NS_IMETHODIMP
VectorImage::GetProviderId(uint32_t* aId) {
NS_ENSURE_ARG_POINTER(aId);
*aId = ImageResource::GetImageProviderId();
return NS_OK;
}
//******************************************************************************
NS_IMETHODIMP
VectorImage::GetAnimated(bool* aAnimated) {
if (mError || !mIsFullyLoaded) {
return NS_ERROR_FAILURE;
}
*aAnimated = mSVGDocumentWrapper->IsAnimated();
return NS_OK;
}
//******************************************************************************
int32_t VectorImage::GetFirstFrameDelay() {
if (mError) {
return -1;
}
if (!mSVGDocumentWrapper->IsAnimated()) {
return -1;
}
// We don't really have a frame delay, so just pretend that we constantly
// need updates.
return 0;
}
NS_IMETHODIMP_(bool)
VectorImage::WillDrawOpaqueNow() {
return false; // In general, SVG content is not opaque.
}
//******************************************************************************
NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
VectorImage::GetFrame(uint32_t aWhichFrame, uint32_t aFlags) {
if (mError) {
return nullptr;
}
// Look up height & width
// ----------------------
SVGSVGElement* svgElem = mSVGDocumentWrapper->GetRootSVGElem();
MOZ_ASSERT(svgElem,
"Should have a root SVG elem, since we finished "
"loading without errors");
LengthPercentage width = svgElem->GetIntrinsicWidth();
LengthPercentage height = svgElem->GetIntrinsicHeight();
if (!width.IsLength() || !height.IsLength()) {
// The SVG is lacking a definite size for its width or height, so we do not
// know how big of a surface to generate. Hence, we just bail.
return nullptr;
}
nsIntSize imageIntSize(SVGUtils::ClampToInt(width.AsLength().ToCSSPixels()),
SVGUtils::ClampToInt(height.AsLength().ToCSSPixels()));
return GetFrameAtSize(imageIntSize, aWhichFrame, aFlags);
}
NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
VectorImage::GetFrameAtSize(const IntSize& aSize, uint32_t aWhichFrame,
uint32_t aFlags) {
MOZ_ASSERT(aWhichFrame <= FRAME_MAX_VALUE);
AutoProfilerImagePaintMarker PROFILER_RAII(this);
#ifdef DEBUG
NotifyDrawingObservers();
#endif
if (aSize.IsEmpty() || aWhichFrame > FRAME_MAX_VALUE || mError ||
!mIsFullyLoaded) {
return nullptr;
}
uint32_t whichFrame = mHaveAnimations ? aWhichFrame : FRAME_FIRST;
auto [sourceSurface, decodeSize] =
LookupCachedSurface(aSize, SVGImageContext(), aFlags);
if (sourceSurface) {
return sourceSurface.forget();
}
if (mSVGDocumentWrapper->IsDrawing()) {
NS_WARNING("Refusing to make re-entrant call to VectorImage::Draw");
return nullptr;
}
float animTime = (whichFrame == FRAME_FIRST)
? 0.0f
: mSVGDocumentWrapper->GetCurrentTimeAsFloat();
// By using a null gfxContext, we ensure that we will always attempt to
// create a surface, even if we aren't capable of caching it (e.g. due to our
// flags, having an animation, etc). Otherwise CreateSurface will assume that
// the caller is capable of drawing directly to its own draw target if we
// cannot cache.
SVGImageContext svgContext;
SVGDrawingParameters params(
nullptr, decodeSize, aSize, ImageRegion::Create(decodeSize),
SamplingFilter::POINT, svgContext, animTime, aFlags, 1.0);
bool didCache; // Was the surface put into the cache?
AutoRestoreSVGState autoRestore(params, mSVGDocumentWrapper,
/* aContextPaint */ false);
RefPtr<gfxDrawable> svgDrawable = CreateSVGDrawable(params);
RefPtr<SourceSurface> surface = CreateSurface(params, svgDrawable, didCache);
if (!surface) {
MOZ_ASSERT(!didCache);
return nullptr;
}
SendFrameComplete(didCache, params.flags);
return surface.forget();
}
NS_IMETHODIMP_(bool)
VectorImage::IsImageContainerAvailable(WindowRenderer* aRenderer,
uint32_t aFlags) {
if (mError || !mIsFullyLoaded ||
aRenderer->GetBackendType() != LayersBackend::LAYERS_WR) {
return false;
}
if (mHaveAnimations && !StaticPrefs::image_svg_blob_image()) {
// We don't support rasterizing animation SVGs. We can put them in a blob
// recording however instead of using fallback.
return false;
}
return true;
}
//******************************************************************************
NS_IMETHODIMP_(ImgDrawResult)
VectorImage::GetImageProvider(WindowRenderer* aRenderer,
const gfx::IntSize& aSize,
const SVGImageContext& aSVGContext,
const Maybe<ImageIntRegion>& aRegion,
uint32_t aFlags,
WebRenderImageProvider** aProvider) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aRenderer);
MOZ_ASSERT(!(aFlags & FLAG_BYPASS_SURFACE_CACHE), "Unsupported flags");
// We don't need to check if the size is too big since we only support
// WebRender backends.
if (aSize.IsEmpty()) {
return ImgDrawResult::BAD_ARGS;
}
if (mError) {
return ImgDrawResult::BAD_IMAGE;
}
if (!mIsFullyLoaded) {
return ImgDrawResult::NOT_READY;
}
if (mHaveAnimations && !(aFlags & FLAG_RECORD_BLOB)) {
// We don't support rasterizing animation SVGs. We can put them in a blob
// recording however instead of using fallback.
return ImgDrawResult::NOT_SUPPORTED;
}
AutoProfilerImagePaintMarker PROFILER_RAII(this);
#ifdef DEBUG
NotifyDrawingObservers();
#endif
// Only blob recordings support a region to restrict drawing.
const bool blobRecording = aFlags & FLAG_RECORD_BLOB;
MOZ_ASSERT_IF(!blobRecording, aRegion.isNothing());
LookupResult result(MatchType::NOT_FOUND);
auto playbackType =
mHaveAnimations ? PlaybackType::eAnimated : PlaybackType::eStatic;
auto surfaceFlags = ToSurfaceFlags(aFlags);
SVGImageContext newSVGContext = aSVGContext;
bool contextPaint = MaybeRestrictSVGContext(newSVGContext, aFlags);
SurfaceKey surfaceKey = VectorSurfaceKey(aSize, aRegion, newSVGContext,
surfaceFlags, playbackType);
if ((aFlags & FLAG_SYNC_DECODE) || !(aFlags & FLAG_HIGH_QUALITY_SCALING)) {
result = SurfaceCache::Lookup(ImageKey(this), surfaceKey,
/* aMarkUsed = */ true);
} else {
result = SurfaceCache::LookupBestMatch(ImageKey(this), surfaceKey,
/* aMarkUsed = */ true);
}
// Unless we get a best match (exact or factor of 2 limited), then we want to
// generate a new recording/rerasterize, even if we have a substitute.
if (result && (result.Type() == MatchType::EXACT ||
result.Type() == MatchType::SUBSTITUTE_BECAUSE_BEST)) {
result.Surface().TakeProvider(aProvider);
return ImgDrawResult::SUCCESS;
}
// Ensure we store the surface with the correct key if we switched to factor
// of 2 sizing or we otherwise got clamped.
IntSize rasterSize(aSize);
if (!result.SuggestedSize().IsEmpty()) {
rasterSize = result.SuggestedSize();
surfaceKey = surfaceKey.CloneWithSize(rasterSize);
}
// We're about to rerasterize, which may mean that some of the previous
// surfaces we've rasterized aren't useful anymore. We can allow them to
// expire from the cache by unlocking them here, and then sending out an
// invalidation. If this image is locked, any surfaces that are still useful
// will become locked again when Draw touches them, and the remainder will
// eventually expire.
bool mayCache = SurfaceCache::CanHold(rasterSize);
if (mayCache) {
SurfaceCache::UnlockEntries(ImageKey(this));
}
// Blob recorded vector images just create a provider responsible for
// generating blob keys and recording bindings. The recording won't happen
// until the caller requests the key explicitly.
RefPtr<ISurfaceProvider> provider;
if (blobRecording) {
provider = MakeRefPtr<BlobSurfaceProvider>(ImageKey(this), surfaceKey,
mSVGDocumentWrapper, aFlags);
} else {
if (mSVGDocumentWrapper->IsDrawing()) {
NS_WARNING("Refusing to make re-entrant call to VectorImage::Draw");
return ImgDrawResult::TEMPORARY_ERROR;
}
if (!SurfaceCache::IsLegalSize(rasterSize) ||
!Factory::AllowedSurfaceSize(rasterSize)) {
// If either of these is true then the InitWithDrawable call below will
// fail, so fail early and use this opportunity to return NOT_SUPPORTED
// instead of TEMPORARY_ERROR as we do for any InitWithDrawable failure.
// This means that we will use fallback which has a path that will draw
// directly into the gfxContext without having to allocate a surface. It
// means we will have to use fallback and re-rasterize for everytime we
// have to draw this image, but it's better than not drawing anything at
// all.
return ImgDrawResult::NOT_SUPPORTED;
}
// We aren't using blobs, so we need to rasterize.
float animTime =
mHaveAnimations ? mSVGDocumentWrapper->GetCurrentTimeAsFloat() : 0.0f;
// By using a null gfxContext, we ensure that we will always attempt to
// create a surface, even if we aren't capable of caching it (e.g. due to
// our flags, having an animation, etc). Otherwise CreateSurface will assume
// that the caller is capable of drawing directly to its own draw target if
// we cannot cache.
SVGDrawingParameters params(
nullptr, rasterSize, aSize, ImageRegion::Create(rasterSize),
SamplingFilter::POINT, newSVGContext, animTime, aFlags, 1.0);
RefPtr<gfxDrawable> svgDrawable = CreateSVGDrawable(params);
AutoRestoreSVGState autoRestore(params, mSVGDocumentWrapper, contextPaint);
mSVGDocumentWrapper->UpdateViewportBounds(params.viewportSize);
mSVGDocumentWrapper->FlushImageTransformInvalidation();
// Given we have no context, the default backend is fine.
BackendType backend =
gfxPlatform::GetPlatform()->GetDefaultContentBackend();
// Try to create an imgFrame, initializing the surface it contains by
// drawing our gfxDrawable into it. (We use FILTER_NEAREST since we never
// scale here.)
auto frame = MakeNotNull<RefPtr<imgFrame>>();
nsresult rv = frame->InitWithDrawable(
svgDrawable, params.size, SurfaceFormat::OS_RGBA, SamplingFilter::POINT,
params.flags, backend);
// If we couldn't create the frame, it was probably because it would end
// up way too big. Generally it also wouldn't fit in the cache, but the
// prefs could be set such that the cache isn't the limiting factor.
if (NS_FAILED(rv)) {
return ImgDrawResult::TEMPORARY_ERROR;
}
provider =
MakeRefPtr<SimpleSurfaceProvider>(ImageKey(this), surfaceKey, frame);
}
if (mayCache) {
// Attempt to cache the frame.
if (SurfaceCache::Insert(WrapNotNull(provider)) == InsertOutcome::SUCCESS) {
if (rasterSize != aSize) {
// We created a new surface that wasn't the size we requested, which
// means we entered factor-of-2 mode. We should purge any surfaces we
// no longer need rather than waiting for the cache to expire them.
SurfaceCache::PruneImage(ImageKey(this));
}
SendFrameComplete(/* aDidCache */ true, aFlags);
}
}
MOZ_ASSERT(provider);
provider.forget(aProvider);
return ImgDrawResult::SUCCESS;
}
bool VectorImage::MaybeRestrictSVGContext(SVGImageContext& aSVGContext,
uint32_t aFlags) {
bool overridePAR = (aFlags & FLAG_FORCE_PRESERVEASPECTRATIO_NONE);
bool haveContextPaint = aSVGContext.GetContextPaint();
bool blockContextPaint =
haveContextPaint && !SVGContextPaint::IsAllowedForImageFromURI(mURI);
if (overridePAR || blockContextPaint) {
if (overridePAR) {
// The SVGImageContext must take account of the preserveAspectRatio
// override:
MOZ_ASSERT(!aSVGContext.GetPreserveAspectRatio(),
"FLAG_FORCE_PRESERVEASPECTRATIO_NONE is not expected if a "
"preserveAspectRatio override is supplied");
Maybe<SVGPreserveAspectRatio> aspectRatio = Some(SVGPreserveAspectRatio(
SVG_PRESERVEASPECTRATIO_NONE, SVG_MEETORSLICE_UNKNOWN));
aSVGContext.SetPreserveAspectRatio(aspectRatio);
}
if (blockContextPaint) {
// The SVGImageContext must not include context paint if the image is
// not allowed to use it:
aSVGContext.ClearContextPaint();
}
}
return haveContextPaint && !blockContextPaint;
}
//******************************************************************************
NS_IMETHODIMP_(ImgDrawResult)
VectorImage::Draw(gfxContext* aContext, const nsIntSize& aSize,
const ImageRegion& aRegion, uint32_t aWhichFrame,
SamplingFilter aSamplingFilter,
const SVGImageContext& aSVGContext, uint32_t aFlags,
float aOpacity) {
if (aWhichFrame > FRAME_MAX_VALUE) {
return ImgDrawResult::BAD_ARGS;
}
if (!aContext) {
return ImgDrawResult::BAD_ARGS;
}
if (mError) {
return ImgDrawResult::BAD_IMAGE;
}
if (!mIsFullyLoaded) {
return ImgDrawResult::NOT_READY;
}
if (mAnimationConsumers == 0 && mHaveAnimations) {
SendOnUnlockedDraw(aFlags);
}
// We should bypass the cache when:
// - We are using a DrawTargetRecording because we prefer the drawing commands
// in general to the rasterized surface. This allows blob images to avoid
// rasterized SVGs with WebRender.
if (aContext->GetDrawTarget()->GetBackendType() == BackendType::RECORDING) {
aFlags |= FLAG_BYPASS_SURFACE_CACHE;
}
MOZ_ASSERT(!(aFlags & FLAG_FORCE_PRESERVEASPECTRATIO_NONE) ||
aSVGContext.GetViewportSize(),
"Viewport size is required when using "
"FLAG_FORCE_PRESERVEASPECTRATIO_NONE");
uint32_t whichFrame = mHaveAnimations ? aWhichFrame : FRAME_FIRST;
float animTime = (whichFrame == FRAME_FIRST)
? 0.0f
: mSVGDocumentWrapper->GetCurrentTimeAsFloat();
SVGImageContext newSVGContext = aSVGContext;
bool contextPaint = MaybeRestrictSVGContext(newSVGContext, aFlags);
SVGDrawingParameters params(aContext, aSize, aSize, aRegion, aSamplingFilter,
newSVGContext, animTime, aFlags, aOpacity);
// If we have an prerasterized version of this image that matches the
// drawing parameters, use that.
RefPtr<SourceSurface> sourceSurface;
std::tie(sourceSurface, params.size) =
LookupCachedSurface(aSize, params.svgContext, aFlags);
if (sourceSurface) {
RefPtr<gfxDrawable> drawable =
new gfxSurfaceDrawable(sourceSurface, params.size);
Show(drawable, params);
return ImgDrawResult::SUCCESS;
}
// else, we need to paint the image:
if (mSVGDocumentWrapper->IsDrawing()) {
NS_WARNING("Refusing to make re-entrant call to VectorImage::Draw");
return ImgDrawResult::TEMPORARY_ERROR;
}
AutoRestoreSVGState autoRestore(params, mSVGDocumentWrapper, contextPaint);
bool didCache; // Was the surface put into the cache?
RefPtr<gfxDrawable> svgDrawable = CreateSVGDrawable(params);
sourceSurface = CreateSurface(params, svgDrawable, didCache);
if (!sourceSurface) {
MOZ_ASSERT(!didCache);
Show(svgDrawable, params);
return ImgDrawResult::SUCCESS;
}
RefPtr<gfxDrawable> drawable =
new gfxSurfaceDrawable(sourceSurface, params.size);
Show(drawable, params);
SendFrameComplete(didCache, params.flags);
return ImgDrawResult::SUCCESS;
}
already_AddRefed<gfxDrawable> VectorImage::CreateSVGDrawable(
const SVGDrawingParameters& aParams) {
RefPtr<gfxDrawingCallback> cb = new SVGDrawingCallback(
mSVGDocumentWrapper, aParams.viewportSize, aParams.size, aParams.flags);
RefPtr<gfxDrawable> svgDrawable = new gfxCallbackDrawable(cb, aParams.size);
return svgDrawable.forget();
}
std::tuple<RefPtr<SourceSurface>, IntSize> VectorImage::LookupCachedSurface(
const IntSize& aSize, const SVGImageContext& aSVGContext, uint32_t aFlags) {
// We can't use cached surfaces if we:
// - Explicitly disallow it via FLAG_BYPASS_SURFACE_CACHE
// - Want a blob recording which aren't supported by the cache.
// - Have animations which aren't supported by the cache.
if (aFlags & (FLAG_BYPASS_SURFACE_CACHE | FLAG_RECORD_BLOB) ||
mHaveAnimations) {
return std::make_tuple(RefPtr<SourceSurface>(), aSize);
}
LookupResult result(MatchType::NOT_FOUND);
SurfaceKey surfaceKey = VectorSurfaceKey(aSize, aSVGContext);
if ((aFlags & FLAG_SYNC_DECODE) || !(aFlags & FLAG_HIGH_QUALITY_SCALING)) {
result = SurfaceCache::Lookup(ImageKey(this), surfaceKey,
/* aMarkUsed = */ true);
} else {
result = SurfaceCache::LookupBestMatch(ImageKey(this), surfaceKey,
/* aMarkUsed = */ true);
}
IntSize rasterSize =
result.SuggestedSize().IsEmpty() ? aSize : result.SuggestedSize();
MOZ_ASSERT(result.Type() != MatchType::SUBSTITUTE_BECAUSE_PENDING);
if (!result || result.Type() == MatchType::SUBSTITUTE_BECAUSE_NOT_FOUND) {
// No matching surface, or the OS freed the volatile buffer.
return std::make_tuple(RefPtr<SourceSurface>(), rasterSize);
}
RefPtr<SourceSurface> sourceSurface = result.Surface()->GetSourceSurface();
if (!sourceSurface) {
// Something went wrong. (Probably a GPU driver crash or device reset.)
// Attempt to recover.
RecoverFromLossOfSurfaces();
return std::make_tuple(RefPtr<SourceSurface>(), rasterSize);
}
return std::make_tuple(std::move(sourceSurface), rasterSize);
}
already_AddRefed<SourceSurface> VectorImage::CreateSurface(
const SVGDrawingParameters& aParams, gfxDrawable* aSVGDrawable,
bool& aWillCache) {
MOZ_ASSERT(mSVGDocumentWrapper->IsDrawing());
MOZ_ASSERT(!(aParams.flags & FLAG_RECORD_BLOB));
mSVGDocumentWrapper->UpdateViewportBounds(aParams.viewportSize);
mSVGDocumentWrapper->FlushImageTransformInvalidation();
// Determine whether or not we should put the surface to be created into
// the cache. If we fail, we need to reset this to false to let the caller
// know nothing was put in the cache.
aWillCache = !(aParams.flags & FLAG_BYPASS_SURFACE_CACHE) &&
// Refuse to cache animated images:
// XXX(seth): We may remove this restriction in bug 922893.
!mHaveAnimations &&
// The image is too big to fit in the cache:
SurfaceCache::CanHold(aParams.size);
// If we weren't given a context, then we know we just want the rasterized
// surface. We will create the frame below but only insert it into the cache
// if we actually need to.
if (!aWillCache && aParams.context) {
return nullptr;
}
// We're about to rerasterize, which may mean that some of the previous
// surfaces we've rasterized aren't useful anymore. We can allow them to
// expire from the cache by unlocking them here, and then sending out an
// invalidation. If this image is locked, any surfaces that are still useful
// will become locked again when Draw touches them, and the remainder will
// eventually expire.
if (aWillCache) {
SurfaceCache::UnlockEntries(ImageKey(this));
}
// If there is no context, the default backend is fine.
BackendType backend =
aParams.context ? aParams.context->GetDrawTarget()->GetBackendType()
: gfxPlatform::GetPlatform()->GetDefaultContentBackend();
if (backend == BackendType::DIRECT2D1_1) {
// We don't want to draw arbitrary content with D2D anymore
// because it doesn't support PushLayerWithBlend so switch to skia
backend = BackendType::SKIA;
}
// Try to create an imgFrame, initializing the surface it contains by drawing
// our gfxDrawable into it. (We use FILTER_NEAREST since we never scale here.)
auto frame = MakeNotNull<RefPtr<imgFrame>>();
nsresult rv = frame->InitWithDrawable(
aSVGDrawable, aParams.size, SurfaceFormat::OS_RGBA, SamplingFilter::POINT,
aParams.flags, backend);
// If we couldn't create the frame, it was probably because it would end
// up way too big. Generally it also wouldn't fit in the cache, but the prefs
// could be set such that the cache isn't the limiting factor.
if (NS_FAILED(rv)) {
aWillCache = false;
return nullptr;
}
// Take a strong reference to the frame's surface and make sure it hasn't
// already been purged by the operating system.
RefPtr<SourceSurface> surface = frame->GetSourceSurface();
if (!surface) {
aWillCache = false;
return nullptr;
}
// We created the frame, but only because we had no context to draw to
// directly. All the caller wants is the surface in this case.
if (!aWillCache) {
return surface.forget();
}
// Attempt to cache the frame.
SurfaceKey surfaceKey = VectorSurfaceKey(aParams.size, aParams.svgContext);
NotNull<RefPtr<ISurfaceProvider>> provider =
MakeNotNull<SimpleSurfaceProvider*>(ImageKey(this), surfaceKey, frame);
if (SurfaceCache::Insert(provider) == InsertOutcome::SUCCESS) {
if (aParams.size != aParams.drawSize) {
// We created a new surface that wasn't the size we requested, which means
// we entered factor-of-2 mode. We should purge any surfaces we no longer
// need rather than waiting for the cache to expire them.
SurfaceCache::PruneImage(ImageKey(this));
}
} else {
aWillCache = false;
}
return surface.forget();
}
void VectorImage::SendFrameComplete(bool aDidCache, uint32_t aFlags) {
// If the cache was not updated, we have nothing to do.
if (!aDidCache) {
return;
}
// Send out an invalidation so that surfaces that are still in use get
// re-locked. See the discussion of the UnlockSurfaces call above.
if (!(aFlags & FLAG_ASYNC_NOTIFY)) {
mProgressTracker->SyncNotifyProgress(FLAG_FRAME_COMPLETE,
GetMaxSizedIntRect());
} else {
NotNull<RefPtr<VectorImage>> image = WrapNotNull(this);
NS_DispatchToMainThread(CreateRenderBlockingRunnable(NS_NewRunnableFunction(
"ProgressTracker::SyncNotifyProgress", [=]() -> void {
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
if (tracker) {
tracker->SyncNotifyProgress(FLAG_FRAME_COMPLETE,
GetMaxSizedIntRect());
}
})));
}
}
void VectorImage::Show(gfxDrawable* aDrawable,
const SVGDrawingParameters& aParams) {
// The surface size may differ from the size at which we wish to draw. As
// such, we may need to adjust the context/region to take this into account.
gfxContextMatrixAutoSaveRestore saveMatrix(aParams.context);
ImageRegion region(aParams.region);
if (aParams.drawSize != aParams.size) {
gfx::MatrixScales scale(
double(aParams.drawSize.width) / aParams.size.width,
double(aParams.drawSize.height) / aParams.size.height);
aParams.context->Multiply(gfx::Matrix::Scaling(scale));
region.Scale(1.0 / scale.xScale, 1.0 / scale.yScale);
}
MOZ_ASSERT(aDrawable, "Should have a gfxDrawable by now");
gfxUtils::DrawPixelSnapped(aParams.context, aDrawable,
SizeDouble(aParams.size), region,
SurfaceFormat::OS_RGBA, aParams.samplingFilter,
aParams.flags, aParams.opacity, false);
AutoProfilerImagePaintMarker PROFILER_RAII(this);
#ifdef DEBUG
NotifyDrawingObservers();
#endif
MOZ_ASSERT(mRenderingObserver, "Should have a rendering observer by now");
mRenderingObserver->ResumeHonoringInvalidations();
}
void VectorImage::RecoverFromLossOfSurfaces() {
NS_WARNING("An imgFrame became invalid. Attempting to recover...");
// Discard all existing frames, since they're probably all now invalid.
SurfaceCache::RemoveImage(ImageKey(this));
}
NS_IMETHODIMP
VectorImage::StartDecoding(uint32_t aFlags, uint32_t aWhichFrame) {
// Nothing to do for SVG images
return NS_OK;
}
bool VectorImage::StartDecodingWithResult(uint32_t aFlags,
uint32_t aWhichFrame) {
// SVG images are ready to draw when they are loaded
return mIsFullyLoaded;
}
bool VectorImage::HasDecodedPixels() {
MOZ_ASSERT_UNREACHABLE("calling VectorImage::HasDecodedPixels");
return mIsFullyLoaded;
}
imgIContainer::DecodeResult VectorImage::RequestDecodeWithResult(
uint32_t aFlags, uint32_t aWhichFrame) {
// SVG images are ready to draw when they are loaded and don't have an error.
if (mError) {
return imgIContainer::DECODE_REQUEST_FAILED;
}
if (!mIsFullyLoaded) {
return imgIContainer::DECODE_REQUESTED;
}
return imgIContainer::DECODE_SURFACE_AVAILABLE;
}
NS_IMETHODIMP
VectorImage::RequestDecodeForSize(const nsIntSize& aSize, uint32_t aFlags,
uint32_t aWhichFrame) {
// Nothing to do for SVG images, though in theory we could rasterize to the
// provided size ahead of time if we supported off-main-thread SVG
// rasterization...
return NS_OK;
}
//******************************************************************************
NS_IMETHODIMP
VectorImage::LockImage() {
MOZ_ASSERT(NS_IsMainThread());
if (mError) {
return NS_ERROR_FAILURE;
}
mLockCount++;
if (mLockCount == 1) {
// Lock this image's surfaces in the SurfaceCache.
SurfaceCache::LockImage(ImageKey(this));
}
return NS_OK;
}
//******************************************************************************
NS_IMETHODIMP
VectorImage::UnlockImage() {
MOZ_ASSERT(NS_IsMainThread());
if (mError) {
return NS_ERROR_FAILURE;
}
if (mLockCount == 0) {
MOZ_ASSERT_UNREACHABLE("Calling UnlockImage with a zero lock count");
return NS_ERROR_ABORT;
}
mLockCount--;
if (mLockCount == 0) {
// Unlock this image's surfaces in the SurfaceCache.
SurfaceCache::UnlockImage(ImageKey(this));
}
return NS_OK;
}
//******************************************************************************
NS_IMETHODIMP
VectorImage::RequestDiscard() {
MOZ_ASSERT(NS_IsMainThread());
if (mDiscardable && mLockCount == 0) {
SurfaceCache::RemoveImage(ImageKey(this));
mProgressTracker->OnDiscard();
}
return NS_OK;
}
void VectorImage::OnSurfaceDiscarded(const SurfaceKey& aSurfaceKey) {
MOZ_ASSERT(mProgressTracker);
NS_DispatchToMainThread(NewRunnableMethod("ProgressTracker::OnDiscard",
mProgressTracker,
&ProgressTracker::OnDiscard));
}
//******************************************************************************
NS_IMETHODIMP
VectorImage::ResetAnimation() {
if (mError) {
return NS_ERROR_FAILURE;
}
if (!mIsFullyLoaded || !mHaveAnimations) {
return NS_OK; // There are no animations to be reset.
}
mSVGDocumentWrapper->ResetAnimation();
return NS_OK;
}
NS_IMETHODIMP_(float)
VectorImage::GetFrameIndex(uint32_t aWhichFrame) {
MOZ_ASSERT(aWhichFrame <= FRAME_MAX_VALUE, "Invalid argument");
return aWhichFrame == FRAME_FIRST
? 0.0f
: mSVGDocumentWrapper->GetCurrentTimeAsFloat();
}
//------------------------------------------------------------------------------
// nsIRequestObserver methods
//******************************************************************************
NS_IMETHODIMP
VectorImage::OnStartRequest(nsIRequest* aRequest) {
MOZ_ASSERT(!mSVGDocumentWrapper,
"Repeated call to OnStartRequest -- can this happen?");
mSVGDocumentWrapper = new SVGDocumentWrapper();
nsresult rv = mSVGDocumentWrapper->OnStartRequest(aRequest);
if (NS_FAILED(rv)) {
mSVGDocumentWrapper = nullptr;
mError = true;
return rv;
}
// Create a listener to wait until the SVG document is fully loaded, which
// will signal that this image is ready to render. Certain error conditions
// will prevent us from ever getting this notification, so we also create a
// listener that waits for parsing to complete and cancels the
// SVGLoadEventListener if needed. The listeners are automatically attached
// to the document by their constructors.
SVGDocument* document = mSVGDocumentWrapper->GetDocument();
mLoadEventListener = new SVGLoadEventListener(document, this);
mParseCompleteListener = new SVGParseCompleteListener(document, this);
// Displayed documents will call InitUseCounters under SetScriptGlobalObject,
// but SVG image documents never get a script global object, so we initialize
// use counters here, right after the document has been created.
document->InitUseCounters();
return NS_OK;
}
//******************************************************************************
NS_IMETHODIMP
VectorImage::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
if (mError) {
return NS_ERROR_FAILURE;
}
return mSVGDocumentWrapper->OnStopRequest(aRequest, aStatus);
}
void VectorImage::OnSVGDocumentParsed() {
MOZ_ASSERT(mParseCompleteListener, "Should have the parse complete listener");
MOZ_ASSERT(mLoadEventListener, "Should have the load event listener");
if (!mSVGDocumentWrapper->GetRootSVGElem()) {
// This is an invalid SVG document. It may have failed to parse, or it may
// be missing the <svg> root element, or the <svg> root element may not
// declare the correct namespace. In any of these cases, we'll never be
// notified that the SVG finished loading, so we need to treat this as an
// error.
OnSVGDocumentError();
}
}
void VectorImage::CancelAllListeners() {
if (mParseCompleteListener) {
mParseCompleteListener->Cancel();
mParseCompleteListener = nullptr;
}
if (mLoadEventListener) {
mLoadEventListener->Cancel();
mLoadEventListener = nullptr;
}
}
void VectorImage::OnSVGDocumentLoaded() {
MOZ_ASSERT(mSVGDocumentWrapper->GetRootSVGElem(),
"Should have parsed successfully");
MOZ_ASSERT(!mIsFullyLoaded && !mHaveAnimations,
"These flags shouldn't get set until OnSVGDocumentLoaded. "
"Duplicate calls to OnSVGDocumentLoaded?");
CancelAllListeners();
// XXX Flushing is wasteful if embedding frame hasn't had initial reflow.
mSVGDocumentWrapper->FlushLayout();
// This is the earliest point that we can get accurate use counter data
// for a valid SVG document. Without the FlushLayout call, we would miss
// any CSS property usage that comes from SVG presentation attributes.
mSVGDocumentWrapper->GetDocument()->ReportDocumentUseCounters();
mIsFullyLoaded = true;
mHaveAnimations = mSVGDocumentWrapper->IsAnimated();
// Start listening to our image for rendering updates.
mRenderingObserver = new SVGRootRenderingObserver(mSVGDocumentWrapper, this);
// ProgressTracker::SyncNotifyProgress may release us, so ensure we
// stick around long enough to complete our work.
RefPtr<VectorImage> kungFuDeathGrip(this);
// Tell *our* observers that we're done loading.
if (mProgressTracker) {
Progress progress = FLAG_SIZE_AVAILABLE | FLAG_HAS_TRANSPARENCY |
FLAG_FRAME_COMPLETE | FLAG_DECODE_COMPLETE;
if (mHaveAnimations) {
progress |= FLAG_IS_ANIMATED;
}
// Merge in any saved progress from OnImageDataComplete.
if (mLoadProgress) {
progress |= *mLoadProgress;
mLoadProgress = Nothing();
}
mProgressTracker->SyncNotifyProgress(progress, GetMaxSizedIntRect());
}
EvaluateAnimation();
}
void VectorImage::OnSVGDocumentError() {
CancelAllListeners();
mError = true;
// We won't enter OnSVGDocumentLoaded, so report use counters now for this
// invalid document.
ReportDocumentUseCounters();
if (mProgressTracker) {
// Notify observers about the error and unblock page load.
Progress progress = FLAG_HAS_ERROR;
// Merge in any saved progress from OnImageDataComplete.
if (mLoadProgress) {
progress |= *mLoadProgress;
mLoadProgress = Nothing();
}
mProgressTracker->SyncNotifyProgress(progress);
}
}
//------------------------------------------------------------------------------
// nsIStreamListener method
//******************************************************************************
NS_IMETHODIMP
VectorImage::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInStr,
uint64_t aSourceOffset, uint32_t aCount) {
if (mError) {
return NS_ERROR_FAILURE;
}
return mSVGDocumentWrapper->OnDataAvailable(aRequest, aInStr, aSourceOffset,
aCount);
}
// --------------------------
// Invalidation helper method
void VectorImage::InvalidateObserversOnNextRefreshDriverTick() {
if (mHasPendingInvalidation) {
return;
}
mHasPendingInvalidation = true;
// Animated images can wait for the refresh tick.
if (mHaveAnimations) {
return;
}
// Non-animated images won't get the refresh tick, so we should just send an
// invalidation outside the current execution context. We need to defer
// because the layout tree is in the middle of invalidation, and the tree
// state needs to be consistent. Specifically only some of the frames have
// had the NS_FRAME_DESCENDANT_NEEDS_PAINT and/or NS_FRAME_NEEDS_PAINT bits
// set by InvalidateFrameInternal in layout/generic/nsFrame.cpp. These bits
// get cleared when we repaint the SVG into a surface by
// nsIFrame::ClearInvalidationStateBits in nsDisplayList::PaintRoot.
nsCOMPtr<nsIEventTarget> eventTarget;
if (mProgressTracker) {
eventTarget = mProgressTracker->GetEventTarget();
} else {
eventTarget = do_GetMainThread();
}
RefPtr<VectorImage> self(this);
nsCOMPtr<nsIRunnable> ev(NS_NewRunnableFunction(
"VectorImage::SendInvalidationNotifications",
[=]() -> void { self->SendInvalidationNotifications(); }));
eventTarget->Dispatch(CreateRenderBlockingRunnable(ev.forget()),
NS_DISPATCH_NORMAL);
}
void VectorImage::PropagateUseCounters(Document* aReferencingDocument) {
if (Document* doc = mSVGDocumentWrapper->GetDocument()) {
doc->PropagateImageUseCounters(aReferencingDocument);
}
}
nsIntSize VectorImage::OptimalImageSizeForDest(const gfxSize& aDest,
uint32_t aWhichFrame,
SamplingFilter aSamplingFilter,
uint32_t aFlags) {
MOZ_ASSERT(aDest.width >= 0 || ceil(aDest.width) <= INT32_MAX ||
aDest.height >= 0 || ceil(aDest.height) <= INT32_MAX,
"Unexpected destination size");
// We can rescale SVGs freely, so just return the provided destination size.
return nsIntSize::Ceil(aDest.width, aDest.height);
}
already_AddRefed<imgIContainer> VectorImage::Unwrap() {
nsCOMPtr<imgIContainer> self(this);
return self.forget();
}
void VectorImage::MediaFeatureValuesChangedAllDocuments(
const MediaFeatureChange& aChange) {
if (!mSVGDocumentWrapper) {
return;
}
// Don't bother if the document hasn't loaded yet.
if (!mIsFullyLoaded) {
return;
}
if (Document* doc = mSVGDocumentWrapper->GetDocument()) {
if (RefPtr<nsPresContext> presContext = doc->GetPresContext()) {
presContext->MediaFeatureValuesChanged(
aChange, MediaFeatureChangePropagation::All);
// Media feature value changes don't happen in the middle of layout,
// so we don't need to call InvalidateObserversOnNextRefreshDriverTick
// to invalidate asynchronously.
if (presContext->FlushPendingMediaFeatureValuesChanged()) {
// NOTE(emilio): SendInvalidationNotifications flushes layout via
// VectorImage::CreateSurface -> FlushImageTransformInvalidation.
SendInvalidationNotifications();
}
}
}
}
nsresult VectorImage::GetHotspotX(int32_t* aX) {
return Image::GetHotspotX(aX);
}
nsresult VectorImage::GetHotspotY(int32_t* aY) {
return Image::GetHotspotY(aY);
}
void VectorImage::ReportDocumentUseCounters() {
if (!mSVGDocumentWrapper) {
return;
}
if (Document* doc = mSVGDocumentWrapper->GetDocument()) {
doc->ReportDocumentUseCounters();
}
}
} // namespace image
} // namespace mozilla
Reference in New Issue View Git Blame Copy Permalink