diff options
Diffstat (limited to 'image/VectorImage.cpp')
| -rw-r--r-- | image/VectorImage.cpp | 1644 |
1 files changed, 1644 insertions, 0 deletions
diff --git a/image/VectorImage.cpp b/image/VectorImage.cpp new file mode 100644 index 0000000000..b86f396e64 --- /dev/null +++ b/image/VectorImage.cpp @@ -0,0 +1,1644 @@ +/* -*- 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/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; + } + + 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 |