SSL VectorImage.cpp
Interaktion und PortierbarkeitC
/* -*- 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/. */
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();
}
// 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;
};
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();
}
}
// 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.
};
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);
// 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?");
// 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.
}
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;
}
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);
}
//******************************************************************************
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(); if (MOZ_UNLIKELY(!rootElem)) { // Unlikely to reach this code; we should have a root SVG elem, since we // finished loading without errors. But we can sometimes get here during // shutdown (as part of gathering a memory report) if the internal SVG // document has already been torn down by a shutdown listener.
*aWidth = 0; return NS_ERROR_FAILURE;
}
LengthPercentage rootElemWidth = rootElem->GetIntrinsicWidth();
if (!rootElemWidth.IsLength()) {
*aWidth = 0; return NS_ERROR_FAILURE;
}
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 had any surface providers 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
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(); if (MOZ_UNLIKELY(!rootElem)) { // Unlikely to reach this code; we should have a root SVG elem, since we // finished loading without errors. But we can sometimes get here during // shutdown (as part of gathering a memory report) if the internal SVG // document has already been torn down by a shutdown listener.
*aHeight = 0; return NS_ERROR_FAILURE;
}
LengthPercentage rootElemHeight = rootElem->GetIntrinsicHeight();
if (!rootElemHeight.IsLength()) {
*aHeight = 0; return NS_ERROR_FAILURE;
}
// 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;
}
// 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?
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. returnfalse;
}
// 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;
}
// Only blob recordings support a region to restrict drawing. constbool 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);
// 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);
// 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;
}
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));
}
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();
}
}
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");
// 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;
}
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> 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);
}
// 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);
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;
}
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::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();
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();
// 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);
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 = do_GetMainThread();
// 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();
}
}
}
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
