summaryrefslogtreecommitdiffstats
path: root/image/RasterImage.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-28 14:29:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-28 14:29:10 +0000
commit2aa4a82499d4becd2284cdb482213d541b8804dd (patch)
treeb80bf8bf13c3766139fbacc530efd0dd9d54394c /image/RasterImage.cpp
parentInitial commit. (diff)
downloadfirefox-2aa4a82499d4becd2284cdb482213d541b8804dd.tar.xz
firefox-2aa4a82499d4becd2284cdb482213d541b8804dd.zip
Adding upstream version 86.0.1.upstream/86.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'image/RasterImage.cpp')
-rw-r--r--image/RasterImage.cpp1929
1 files changed, 1929 insertions, 0 deletions
diff --git a/image/RasterImage.cpp b/image/RasterImage.cpp
new file mode 100644
index 0000000000..b16f6fce50
--- /dev/null
+++ b/image/RasterImage.cpp
@@ -0,0 +1,1929 @@
+/* -*- 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/. */
+
+// Must #include ImageLogging.h before any IPDL-generated files or other files
+// that #include prlog.h
+#include "RasterImage.h"
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <utility>
+
+#include "DecodePool.h"
+#include "Decoder.h"
+#include "FrameAnimator.h"
+#include "GeckoProfiler.h"
+#include "IDecodingTask.h"
+#include "ImageLogging.h"
+#include "ImageRegion.h"
+#include "Layers.h"
+#include "LookupResult.h"
+#include "OrientedImage.h"
+#include "SourceBuffer.h"
+#include "SurfaceCache.h"
+#include "gfx2DGlue.h"
+#include "gfxContext.h"
+#include "gfxPlatform.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Likely.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/SizeOfState.h"
+#include "mozilla/StaticPrefs_image.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Tuple.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Scale.h"
+#include "nsComponentManagerUtils.h"
+#include "nsError.h"
+#include "nsIConsoleService.h"
+#include "nsIInputStream.h"
+#include "nsIScriptError.h"
+#include "nsISupportsPrimitives.h"
+#include "nsMemory.h"
+#include "nsPresContext.h"
+#include "nsProperties.h"
+#include "prenv.h"
+#include "prsystem.h"
+
+namespace mozilla {
+
+using namespace gfx;
+using namespace layers;
+
+namespace image {
+
+using std::ceil;
+using std::min;
+
+#ifndef DEBUG
+NS_IMPL_ISUPPORTS(RasterImage, imgIContainer)
+#else
+NS_IMPL_ISUPPORTS(RasterImage, imgIContainer, imgIContainerDebug)
+#endif
+
+//******************************************************************************
+RasterImage::RasterImage(nsIURI* aURI /* = nullptr */)
+ : ImageResource(aURI), // invoke superclass's constructor
+ mSize(0, 0),
+ mLockCount(0),
+ mDecoderType(DecoderType::UNKNOWN),
+ mDecodeCount(0),
+#ifdef DEBUG
+ mFramesNotified(0),
+#endif
+ mSourceBuffer(MakeNotNull<SourceBuffer*>()) {
+ StoreHandledOrientation(StaticPrefs::image_honor_orientation_metadata());
+}
+
+//******************************************************************************
+RasterImage::~RasterImage() {
+ // Make sure our SourceBuffer is marked as complete. This will ensure that any
+ // outstanding decoders terminate.
+ if (!mSourceBuffer->IsComplete()) {
+ mSourceBuffer->Complete(NS_ERROR_ABORT);
+ }
+
+ // Release all frames from the surface cache.
+ SurfaceCache::RemoveImage(ImageKey(this));
+
+ // Record Telemetry.
+ Telemetry::Accumulate(Telemetry::IMAGE_DECODE_COUNT, mDecodeCount);
+}
+
+nsresult RasterImage::Init(const char* aMimeType, uint32_t aFlags) {
+ // We don't support re-initialization
+ if (mInitialized) {
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+
+ // Not sure an error can happen before init, but be safe
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // We want to avoid redecodes for transient images.
+ MOZ_ASSERT_IF(aFlags & INIT_FLAG_TRANSIENT,
+ !(aFlags & INIT_FLAG_DISCARDABLE));
+
+ // Store initialization data
+ StoreDiscardable(!!(aFlags & INIT_FLAG_DISCARDABLE));
+ StoreWantFullDecode(!!(aFlags & INIT_FLAG_DECODE_IMMEDIATELY));
+ StoreTransient(!!(aFlags & INIT_FLAG_TRANSIENT));
+ StoreSyncLoad(!!(aFlags & INIT_FLAG_SYNC_LOAD));
+
+ // Use the MIME type to select a decoder type, and make sure there *is* a
+ // decoder for this MIME type.
+ NS_ENSURE_ARG_POINTER(aMimeType);
+ mDecoderType = DecoderFactory::GetDecoderType(aMimeType);
+ if (mDecoderType == DecoderType::UNKNOWN) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Lock this image's surfaces in the SurfaceCache if we're not discardable.
+ if (!LoadDiscardable()) {
+ mLockCount++;
+ SurfaceCache::LockImage(ImageKey(this));
+ }
+
+ // Mark us as initialized
+ mInitialized = true;
+
+ return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP_(void)
+RasterImage::RequestRefresh(const TimeStamp& aTime) {
+ if (HadRecentRefresh(aTime)) {
+ return;
+ }
+
+ EvaluateAnimation();
+
+ if (!mAnimating) {
+ return;
+ }
+
+ RefreshResult res;
+ if (mAnimationState) {
+ MOZ_ASSERT(mFrameAnimator);
+ res = mFrameAnimator->RequestRefresh(*mAnimationState, aTime);
+ }
+
+#ifdef DEBUG
+ if (res.mFrameAdvanced) {
+ mFramesNotified++;
+ }
+#endif
+
+ // Notify listeners that our frame has actually changed, but do this only
+ // once for all frames that we've now passed (if AdvanceFrame() was called
+ // more than once).
+ if (!res.mDirtyRect.IsEmpty() || res.mFrameAdvanced) {
+ auto dirtyRect = UnorientedIntRect::FromUnknownRect(res.mDirtyRect);
+ NotifyProgress(NoProgress, dirtyRect);
+ }
+
+ if (res.mAnimationFinished) {
+ StoreAnimationFinished(true);
+ EvaluateAnimation();
+ }
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetWidth(int32_t* aWidth) {
+ NS_ENSURE_ARG_POINTER(aWidth);
+
+ if (mError) {
+ *aWidth = 0;
+ return NS_ERROR_FAILURE;
+ }
+
+ *aWidth = mSize.width;
+ return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetHeight(int32_t* aHeight) {
+ NS_ENSURE_ARG_POINTER(aHeight);
+
+ if (mError) {
+ *aHeight = 0;
+ return NS_ERROR_FAILURE;
+ }
+
+ *aHeight = mSize.height;
+ return NS_OK;
+}
+
+//******************************************************************************
+nsresult RasterImage::GetNativeSizes(nsTArray<IntSize>& aNativeSizes) const {
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ aNativeSizes.Clear();
+
+ if (mNativeSizes.IsEmpty()) {
+ aNativeSizes.AppendElement(mSize.ToUnknownSize());
+ } else {
+ for (const auto& size : mNativeSizes) {
+ aNativeSizes.AppendElement(size.ToUnknownSize());
+ }
+ }
+
+ return NS_OK;
+}
+
+//******************************************************************************
+size_t RasterImage::GetNativeSizesLength() const {
+ if (mError || !LoadHasSize()) {
+ return 0;
+ }
+
+ if (mNativeSizes.IsEmpty()) {
+ return 1;
+ }
+
+ return mNativeSizes.Length();
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetIntrinsicSize(nsSize* aSize) {
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aSize = nsSize(nsPresContext::CSSPixelsToAppUnits(mSize.width),
+ nsPresContext::CSSPixelsToAppUnits(mSize.height));
+ return NS_OK;
+}
+
+//******************************************************************************
+Maybe<AspectRatio> RasterImage::GetIntrinsicRatio() {
+ if (mError) {
+ return Nothing();
+ }
+
+ return Some(AspectRatio::FromSize(mSize.width, mSize.height));
+}
+
+NS_IMETHODIMP_(Orientation)
+RasterImage::GetOrientation() { return mOrientation; }
+
+NS_IMETHODIMP_(bool)
+RasterImage::HandledOrientation() { return LoadHandledOrientation(); }
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetType(uint16_t* aType) {
+ NS_ENSURE_ARG_POINTER(aType);
+
+ *aType = imgIContainer::TYPE_RASTER;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+RasterImage::GetProducerId(uint32_t* aId) {
+ NS_ENSURE_ARG_POINTER(aId);
+
+ *aId = ImageResource::GetImageProducerId();
+ return NS_OK;
+}
+
+LookupResult RasterImage::LookupFrameInternal(const UnorientedIntSize& aSize,
+ uint32_t aFlags,
+ PlaybackType aPlaybackType,
+ bool aMarkUsed) {
+ if (mAnimationState && aPlaybackType == PlaybackType::eAnimated) {
+ MOZ_ASSERT(mFrameAnimator);
+ MOZ_ASSERT(ToSurfaceFlags(aFlags) == DefaultSurfaceFlags(),
+ "Can't composite frames with non-default surface flags");
+ return mFrameAnimator->GetCompositedFrame(*mAnimationState, aMarkUsed);
+ }
+
+ SurfaceFlags surfaceFlags = ToSurfaceFlags(aFlags);
+
+ // We don't want any substitution for sync decodes, and substitution would be
+ // illegal when high quality downscaling is disabled, so we use
+ // SurfaceCache::Lookup in this case.
+ if ((aFlags & FLAG_SYNC_DECODE) || !(aFlags & FLAG_HIGH_QUALITY_SCALING)) {
+ return SurfaceCache::Lookup(
+ ImageKey(this),
+ RasterSurfaceKey(aSize.ToUnknownSize(), surfaceFlags,
+ PlaybackType::eStatic),
+ aMarkUsed);
+ }
+
+ // We'll return the best match we can find to the requested frame.
+ return SurfaceCache::LookupBestMatch(
+ ImageKey(this),
+ RasterSurfaceKey(aSize.ToUnknownSize(), surfaceFlags,
+ PlaybackType::eStatic),
+ aMarkUsed);
+}
+
+LookupResult RasterImage::LookupFrame(const UnorientedIntSize& aSize,
+ uint32_t aFlags,
+ PlaybackType aPlaybackType,
+ bool aMarkUsed) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ // If we're opaque, we don't need to care about premultiplied alpha, because
+ // that can only matter for frames with transparency.
+ if (IsOpaque()) {
+ aFlags &= ~FLAG_DECODE_NO_PREMULTIPLY_ALPHA;
+ }
+
+ UnorientedIntSize requestedSize =
+ CanDownscaleDuringDecode(aSize, aFlags) ? aSize : ToUnoriented(mSize);
+ if (requestedSize.IsEmpty()) {
+ // Can't decode to a surface of zero size.
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ LookupResult result =
+ LookupFrameInternal(requestedSize, aFlags, aPlaybackType, aMarkUsed);
+
+ if (!result && !LoadHasSize()) {
+ // We can't request a decode without knowing our intrinsic size. Give up.
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ const bool syncDecode = aFlags & FLAG_SYNC_DECODE;
+ const bool avoidRedecode = aFlags & FLAG_AVOID_REDECODE_FOR_SIZE;
+ if (result.Type() == MatchType::NOT_FOUND ||
+ (result.Type() == MatchType::SUBSTITUTE_BECAUSE_NOT_FOUND &&
+ !avoidRedecode) ||
+ (syncDecode && !avoidRedecode && !result)) {
+ // We don't have a copy of this frame, and there's no decoder working on
+ // one. (Or we're sync decoding and the existing decoder hasn't even started
+ // yet.) Trigger decoding so it'll be available next time.
+ MOZ_ASSERT(aPlaybackType != PlaybackType::eAnimated ||
+ StaticPrefs::image_mem_animated_discardable_AtStartup() ||
+ !mAnimationState || mAnimationState->KnownFrameCount() < 1,
+ "Animated frames should be locked");
+
+ // The surface cache may suggest the preferred size we are supposed to
+ // decode at. This should only happen if we accept substitutions.
+ if (!result.SuggestedSize().IsEmpty()) {
+ MOZ_ASSERT(!syncDecode && (aFlags & FLAG_HIGH_QUALITY_SCALING));
+ requestedSize =
+ UnorientedIntSize::FromUnknownSize(result.SuggestedSize());
+ }
+
+ bool ranSync = false, failed = false;
+ Decode(requestedSize, aFlags, aPlaybackType, ranSync, failed);
+ if (failed) {
+ result.SetFailedToRequestDecode();
+ }
+
+ // If we can or did sync decode, we should already have the frame.
+ if (ranSync || syncDecode) {
+ result =
+ LookupFrameInternal(requestedSize, aFlags, aPlaybackType, aMarkUsed);
+ }
+ }
+
+ if (!result) {
+ // We still weren't able to get a frame. Give up.
+ return result;
+ }
+
+ // Sync decoding guarantees that we got the frame, but if it's owned by an
+ // async decoder that's currently running, the contents of the frame may not
+ // be available yet. Make sure we get everything.
+ if (LoadAllSourceData() && syncDecode) {
+ result.Surface()->WaitUntilFinished();
+ }
+
+ // If we could have done some decoding in this function we need to check if
+ // that decoding encountered an error and hence aborted the surface. We want
+ // to avoid calling IsAborted if we weren't passed any sync decode flag
+ // because IsAborted acquires the monitor for the imgFrame.
+ if (aFlags & (FLAG_SYNC_DECODE | FLAG_SYNC_DECODE_IF_FAST) &&
+ result.Surface()->IsAborted()) {
+ DrawableSurface tmp = std::move(result.Surface());
+ return result;
+ }
+
+ return result;
+}
+
+bool RasterImage::IsOpaque() {
+ if (mError) {
+ return false;
+ }
+
+ Progress progress = mProgressTracker->GetProgress();
+
+ // If we haven't yet finished decoding, the safe answer is "not opaque".
+ if (!(progress & FLAG_DECODE_COMPLETE)) {
+ return false;
+ }
+
+ // Other, we're opaque if FLAG_HAS_TRANSPARENCY is not set.
+ return !(progress & FLAG_HAS_TRANSPARENCY);
+}
+
+NS_IMETHODIMP_(bool)
+RasterImage::WillDrawOpaqueNow() {
+ if (!IsOpaque()) {
+ return false;
+ }
+
+ if (mAnimationState) {
+ if (!StaticPrefs::image_mem_animated_discardable_AtStartup()) {
+ // We never discard frames of animated images.
+ return true;
+ } else {
+ if (mAnimationState->GetCompositedFrameInvalid()) {
+ // We're not going to draw anything at all.
+ return false;
+ }
+ }
+ }
+
+ // If we are not locked our decoded data could get discard at any time (ie
+ // between the call to this function and when we are asked to draw), so we
+ // have to return false if we are unlocked.
+ if (mLockCount == 0) {
+ return false;
+ }
+
+ auto size = ToUnoriented(mSize);
+ LookupResult result = SurfaceCache::LookupBestMatch(
+ ImageKey(this),
+ RasterSurfaceKey(size.ToUnknownSize(), DefaultSurfaceFlags(),
+ PlaybackType::eStatic),
+ /* aMarkUsed = */ false);
+ MatchType matchType = result.Type();
+ if (matchType == MatchType::NOT_FOUND || matchType == MatchType::PENDING ||
+ !result.Surface()->IsFinished()) {
+ return false;
+ }
+
+ return true;
+}
+
+void RasterImage::OnSurfaceDiscarded(const SurfaceKey& aSurfaceKey) {
+ MOZ_ASSERT(mProgressTracker);
+
+ bool animatedFramesDiscarded =
+ mAnimationState && aSurfaceKey.Playback() == PlaybackType::eAnimated;
+
+ nsCOMPtr<nsIEventTarget> eventTarget;
+ if (mProgressTracker) {
+ eventTarget = mProgressTracker->GetEventTarget();
+ } else {
+ eventTarget = do_GetMainThread();
+ }
+
+ RefPtr<RasterImage> image = this;
+ nsCOMPtr<nsIRunnable> ev =
+ NS_NewRunnableFunction("RasterImage::OnSurfaceDiscarded", [=]() -> void {
+ image->OnSurfaceDiscardedInternal(animatedFramesDiscarded);
+ });
+ eventTarget->Dispatch(ev.forget(), NS_DISPATCH_NORMAL);
+}
+
+void RasterImage::OnSurfaceDiscardedInternal(bool aAnimatedFramesDiscarded) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (aAnimatedFramesDiscarded && mAnimationState) {
+ MOZ_ASSERT(StaticPrefs::image_mem_animated_discardable_AtStartup());
+ ReleaseImageContainer();
+
+ auto size = ToUnoriented(mSize);
+ IntRect rect = mAnimationState->UpdateState(this, size.ToUnknownSize());
+
+ auto dirtyRect = UnorientedIntRect::FromUnknownRect(rect);
+ NotifyProgress(NoProgress, dirtyRect);
+ }
+
+ if (mProgressTracker) {
+ mProgressTracker->OnDiscard();
+ }
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetAnimated(bool* aAnimated) {
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ NS_ENSURE_ARG_POINTER(aAnimated);
+
+ // If we have an AnimationState, we can know for sure.
+ if (mAnimationState) {
+ *aAnimated = true;
+ return NS_OK;
+ }
+
+ // Otherwise, we need to have been decoded to know for sure, since if we were
+ // decoded at least once mAnimationState would have been created for animated
+ // images. This is true even though we check for animation during the
+ // metadata decode, because we may still discover animation only during the
+ // full decode for corrupt images.
+ if (!LoadHasBeenDecoded()) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ // We know for sure
+ *aAnimated = false;
+
+ return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP_(int32_t)
+RasterImage::GetFirstFrameDelay() {
+ if (mError) {
+ return -1;
+ }
+
+ bool animated = false;
+ if (NS_FAILED(GetAnimated(&animated)) || !animated) {
+ return -1;
+ }
+
+ MOZ_ASSERT(mAnimationState, "Animated images should have an AnimationState");
+ return mAnimationState->FirstFrameTimeout().AsEncodedValueDeprecated();
+}
+
+NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
+RasterImage::GetFrame(uint32_t aWhichFrame, uint32_t aFlags) {
+ return GetFrameAtSize(mSize.ToUnknownSize(), aWhichFrame, aFlags);
+}
+
+NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
+RasterImage::GetFrameAtSize(const IntSize& aSize, uint32_t aWhichFrame,
+ uint32_t aFlags) {
+#ifdef DEBUG
+ NotifyDrawingObservers();
+#endif
+
+ auto result = GetFrameInternal(aSize, Nothing(), aWhichFrame, aFlags);
+ return mozilla::Get<2>(result).forget();
+}
+
+Tuple<ImgDrawResult, IntSize, RefPtr<SourceSurface>>
+RasterImage::GetFrameInternal(const IntSize& aSize,
+ const Maybe<SVGImageContext>& aSVGContext,
+ uint32_t aWhichFrame, uint32_t aFlags) {
+ MOZ_ASSERT(aWhichFrame <= FRAME_MAX_VALUE);
+
+ auto size = OrientedIntSize::FromUnknownSize(aSize);
+
+ if (aSize.IsEmpty() || aWhichFrame > FRAME_MAX_VALUE) {
+ return MakeTuple(ImgDrawResult::BAD_ARGS, aSize, RefPtr<SourceSurface>());
+ }
+
+ if (mError) {
+ return MakeTuple(ImgDrawResult::BAD_IMAGE, aSize, RefPtr<SourceSurface>());
+ }
+
+ // Get the frame. If it's not there, it's probably the caller's fault for
+ // not waiting for the data to be loaded from the network or not passing
+ // FLAG_SYNC_DECODE.
+ LookupResult result =
+ LookupFrame(ToUnoriented(size), aFlags, ToPlaybackType(aWhichFrame),
+ /* aMarkUsed = */ true);
+ auto resultSuggestedSize =
+ UnorientedIntSize::FromUnknownSize(result.SuggestedSize());
+
+ // The surface cache may have suggested we use a different size than the
+ // given size in the future. This may or may not be accompanied by an
+ // actual surface, depending on what it has in its cache.
+ OrientedIntSize suggestedSize = ToOriented(resultSuggestedSize);
+ if (suggestedSize.IsEmpty()) {
+ suggestedSize = size;
+ }
+ MOZ_ASSERT_IF(result.Type() == MatchType::SUBSTITUTE_BECAUSE_BEST,
+ suggestedSize != size);
+
+ if (!result) {
+ // The OS threw this frame away and we couldn't redecode it.
+ return MakeTuple(ImgDrawResult::TEMPORARY_ERROR,
+ suggestedSize.ToUnknownSize(), RefPtr<SourceSurface>());
+ }
+
+ RefPtr<SourceSurface> surface = result.Surface()->GetSourceSurface();
+
+ // If this RasterImage requires orientation, we must return a newly created
+ // surface with the oriented image instead of returning the frame's surface
+ // directly.
+ surface = OrientedImage::OrientSurface(UsedOrientation(), surface);
+
+ if (!result.Surface()->IsFinished()) {
+ return MakeTuple(ImgDrawResult::INCOMPLETE, suggestedSize.ToUnknownSize(),
+ std::move(surface));
+ }
+
+ return MakeTuple(ImgDrawResult::SUCCESS, suggestedSize.ToUnknownSize(),
+ std::move(surface));
+}
+
+Tuple<ImgDrawResult, IntSize> RasterImage::GetImageContainerSize(
+ LayerManager* aManager, const IntSize& aRequestedSize, uint32_t aFlags) {
+ if (!LoadHasSize()) {
+ return MakeTuple(ImgDrawResult::NOT_READY, IntSize(0, 0));
+ }
+
+ if (aRequestedSize.IsEmpty()) {
+ return MakeTuple(ImgDrawResult::BAD_ARGS, IntSize(0, 0));
+ }
+
+ // We check the minimum size because while we support downscaling, we do not
+ // support upscaling. If aRequestedSize > mSize, we will never give a larger
+ // surface than mSize. If mSize > aRequestedSize, and mSize > maxTextureSize,
+ // we still want to use image containers if aRequestedSize <= maxTextureSize.
+ int32_t maxTextureSize = aManager->GetMaxTextureSize();
+ if (min(mSize.width, aRequestedSize.width) > maxTextureSize ||
+ min(mSize.height, aRequestedSize.height) > maxTextureSize) {
+ return MakeTuple(ImgDrawResult::NOT_SUPPORTED, IntSize(0, 0));
+ }
+
+ auto requestedSize = OrientedIntSize::FromUnknownSize(aRequestedSize);
+ if (!CanDownscaleDuringDecode(ToUnoriented(requestedSize), aFlags)) {
+ return MakeTuple(ImgDrawResult::SUCCESS, mSize.ToUnknownSize());
+ }
+
+ return MakeTuple(ImgDrawResult::SUCCESS, aRequestedSize);
+}
+
+NS_IMETHODIMP_(bool)
+RasterImage::IsImageContainerAvailable(LayerManager* aManager,
+ uint32_t aFlags) {
+ return IsImageContainerAvailableAtSize(aManager, mSize.ToUnknownSize(),
+ aFlags);
+}
+
+NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
+RasterImage::GetImageContainer(LayerManager* aManager, uint32_t aFlags) {
+ RefPtr<ImageContainer> container;
+ ImgDrawResult drawResult =
+ GetImageContainerImpl(aManager, mSize.ToUnknownSize(), Nothing(), aFlags,
+ getter_AddRefs(container));
+
+ // We silence the unused warning here because anything that needs the draw
+ // result should be using GetImageContainerAtSize, not GetImageContainer.
+ (void)drawResult;
+ return container.forget();
+}
+
+NS_IMETHODIMP_(bool)
+RasterImage::IsImageContainerAvailableAtSize(LayerManager* aManager,
+ const IntSize& aRequestedSize,
+ uint32_t aFlags) {
+ // We check the minimum size because while we support downscaling, we do not
+ // support upscaling. If aRequestedSize > mSize, we will never give a larger
+ // surface than mSize. If mSize > aRequestedSize, and mSize > maxTextureSize,
+ // we still want to use image containers if aRequestedSize <= maxTextureSize.
+ int32_t maxTextureSize = aManager->GetMaxTextureSize();
+ if (!LoadHasSize() || aRequestedSize.IsEmpty() ||
+ min(mSize.width, aRequestedSize.width) > maxTextureSize ||
+ min(mSize.height, aRequestedSize.height) > maxTextureSize) {
+ return false;
+ }
+
+ return true;
+}
+
+NS_IMETHODIMP_(ImgDrawResult)
+RasterImage::GetImageContainerAtSize(layers::LayerManager* aManager,
+ const gfx::IntSize& aSize,
+ const Maybe<SVGImageContext>& aSVGContext,
+ uint32_t aFlags,
+ layers::ImageContainer** aOutContainer) {
+ // We do not pass in the given SVG context because in theory it could differ
+ // between calls, but actually have no impact on the actual contents of the
+ // image container.
+ return GetImageContainerImpl(aManager, aSize, Nothing(), aFlags,
+ aOutContainer);
+}
+
+size_t RasterImage::SizeOfSourceWithComputedFallback(
+ SizeOfState& aState) const {
+ return mSourceBuffer->SizeOfIncludingThisWithComputedFallback(
+ aState.mMallocSizeOf);
+}
+
+void RasterImage::CollectSizeOfSurfaces(
+ nsTArray<SurfaceMemoryCounter>& aCounters,
+ MallocSizeOf aMallocSizeOf) const {
+ SurfaceCache::CollectSizeOfSurfaces(ImageKey(this), aCounters, aMallocSizeOf);
+}
+
+bool RasterImage::SetMetadata(const ImageMetadata& aMetadata,
+ bool aFromMetadataDecode) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (mError) {
+ return true;
+ }
+
+ if (aMetadata.HasSize()) {
+ auto metadataSize = UnorientedIntSize::FromUnknownSize(aMetadata.GetSize());
+ if (metadataSize.width < 0 || metadataSize.height < 0) {
+ NS_WARNING("Image has negative intrinsic size");
+ DoError();
+ return true;
+ }
+
+ MOZ_ASSERT(aMetadata.HasOrientation());
+ Orientation orientation = aMetadata.GetOrientation();
+
+ // If we already have a size, check the new size against the old one.
+ if (LoadHasSize() &&
+ (metadataSize != ToUnoriented(mSize) || orientation != mOrientation)) {
+ NS_WARNING(
+ "Image changed size or orientation on redecode! "
+ "This should not happen!");
+ DoError();
+ return true;
+ }
+
+ // Set the size and flag that we have it.
+ mOrientation = orientation;
+ mSize = ToOriented(metadataSize);
+ mNativeSizes.Clear();
+ for (const auto& nativeSize : aMetadata.GetNativeSizes()) {
+ mNativeSizes.AppendElement(
+ ToOriented(UnorientedIntSize::FromUnknownSize(nativeSize)));
+ }
+ StoreHasSize(true);
+ }
+
+ if (LoadHasSize() && aMetadata.HasAnimation() && !mAnimationState) {
+ // We're becoming animated, so initialize animation stuff.
+ mAnimationState.emplace(mAnimationMode);
+ mFrameAnimator =
+ MakeUnique<FrameAnimator>(this, ToUnoriented(mSize).ToUnknownSize());
+
+ if (!StaticPrefs::image_mem_animated_discardable_AtStartup()) {
+ // We don't support discarding animated images (See bug 414259).
+ // Lock the image and throw away the key.
+ LockImage();
+ }
+
+ if (!aFromMetadataDecode) {
+ // The metadata decode reported that this image isn't animated, but we
+ // discovered that it actually was during the full decode. This is a
+ // rare failure that only occurs for corrupt images. To recover, we need
+ // to discard all existing surfaces and redecode.
+ return false;
+ }
+ }
+
+ if (mAnimationState) {
+ mAnimationState->SetLoopCount(aMetadata.GetLoopCount());
+ mAnimationState->SetFirstFrameTimeout(aMetadata.GetFirstFrameTimeout());
+
+ if (aMetadata.HasLoopLength()) {
+ mAnimationState->SetLoopLength(aMetadata.GetLoopLength());
+ }
+ if (aMetadata.HasFirstFrameRefreshArea()) {
+ mAnimationState->SetFirstFrameRefreshArea(
+ aMetadata.GetFirstFrameRefreshArea());
+ }
+ }
+
+ if (aMetadata.HasHotspot()) {
+ // NOTE(heycam): We shouldn't have any image formats that support both
+ // orientation and hotspots, so we assert that rather than add code
+ // to orient the hotspot point correctly.
+ MOZ_ASSERT(UsedOrientation().IsIdentity(),
+ "Would need to orient hotspot point");
+
+ auto hotspot = aMetadata.GetHotspot();
+ mHotspot.x = std::max(std::min(hotspot.x, mSize.width - 1), 0);
+ mHotspot.y = std::max(std::min(hotspot.y, mSize.height - 1), 0);
+ }
+
+ return true;
+}
+
+NS_IMETHODIMP
+RasterImage::SetAnimationMode(uint16_t aAnimationMode) {
+ if (mAnimationState) {
+ mAnimationState->SetAnimationMode(aAnimationMode);
+ }
+ return SetAnimationModeInternal(aAnimationMode);
+}
+
+//******************************************************************************
+
+nsresult RasterImage::StartAnimation() {
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_ASSERT(ShouldAnimate(), "Should not animate!");
+
+ // If we're not ready to animate, then set mPendingAnimation, which will cause
+ // us to start animating if and when we do become ready.
+ StorePendingAnimation(!mAnimationState ||
+ mAnimationState->KnownFrameCount() < 1);
+ if (LoadPendingAnimation()) {
+ return NS_OK;
+ }
+
+ // Don't bother to animate if we're displaying the first frame forever.
+ if (mAnimationState->GetCurrentAnimationFrameIndex() == 0 &&
+ mAnimationState->FirstFrameTimeout() == FrameTimeout::Forever()) {
+ StoreAnimationFinished(true);
+ return NS_ERROR_ABORT;
+ }
+
+ // We need to set the time that this initial frame was first displayed, as
+ // this is used in AdvanceFrame().
+ mAnimationState->InitAnimationFrameTimeIfNecessary();
+
+ return NS_OK;
+}
+
+//******************************************************************************
+nsresult RasterImage::StopAnimation() {
+ MOZ_ASSERT(mAnimating, "Should be animating!");
+
+ nsresult rv = NS_OK;
+ if (mError) {
+ rv = NS_ERROR_FAILURE;
+ } else {
+ mAnimationState->SetAnimationFrameTime(TimeStamp());
+ }
+
+ mAnimating = false;
+ return rv;
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::ResetAnimation() {
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ StorePendingAnimation(false);
+
+ if (mAnimationMode == kDontAnimMode || !mAnimationState ||
+ mAnimationState->GetCurrentAnimationFrameIndex() == 0) {
+ return NS_OK;
+ }
+
+ StoreAnimationFinished(false);
+
+ if (mAnimating) {
+ StopAnimation();
+ }
+
+ MOZ_ASSERT(mAnimationState, "Should have AnimationState");
+ MOZ_ASSERT(mFrameAnimator, "Should have FrameAnimator");
+ mFrameAnimator->ResetAnimation(*mAnimationState);
+
+ IntRect area = mAnimationState->FirstFrameRefreshArea();
+ NotifyProgress(NoProgress, UnorientedIntRect::FromUnknownRect(area));
+
+ // Start the animation again. It may not have been running before, if
+ // mAnimationFinished was true before entering this function.
+ EvaluateAnimation();
+
+ return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP_(void)
+RasterImage::SetAnimationStartTime(const TimeStamp& aTime) {
+ if (mError || mAnimationMode == kDontAnimMode || mAnimating ||
+ !mAnimationState) {
+ return;
+ }
+
+ mAnimationState->SetAnimationFrameTime(aTime);
+}
+
+NS_IMETHODIMP_(float)
+RasterImage::GetFrameIndex(uint32_t aWhichFrame) {
+ MOZ_ASSERT(aWhichFrame <= FRAME_MAX_VALUE, "Invalid argument");
+ return (aWhichFrame == FRAME_FIRST || !mAnimationState)
+ ? 0.0f
+ : mAnimationState->GetCurrentAnimationFrameIndex();
+}
+
+NS_IMETHODIMP_(IntRect)
+RasterImage::GetImageSpaceInvalidationRect(const IntRect& aRect) {
+ // Note that we do not transform aRect into an UnorientedIntRect, since
+ // RasterImage::NotifyProgress notifies all consumers of the image using
+ // OrientedIntRect values. (This is unlike OrientedImage, which notifies
+ // using inner image coordinates.)
+ return aRect;
+}
+
+nsresult RasterImage::OnImageDataComplete(nsIRequest*, nsISupports*,
+ nsresult aStatus, bool aLastPart) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ // Record that we have all the data we're going to get now.
+ StoreAllSourceData(true);
+
+ // Let decoders know that there won't be any more data coming.
+ mSourceBuffer->Complete(aStatus);
+
+ // Allow a synchronous metadata decode if mSyncLoad was set, or if we're
+ // running on a single thread (in which case waiting for the async metadata
+ // decoder could delay this image's load event quite a bit), or if this image
+ // is transient.
+ bool canSyncDecodeMetadata =
+ LoadSyncLoad() || LoadTransient() || DecodePool::NumberOfCores() < 2;
+
+ if (canSyncDecodeMetadata && !LoadHasSize()) {
+ // We're loading this image synchronously, so it needs to be usable after
+ // this call returns. Since we haven't gotten our size yet, we need to do a
+ // synchronous metadata decode here.
+ DecodeMetadata(FLAG_SYNC_DECODE);
+ }
+
+ // Determine our final status, giving precedence to Necko failure codes. We
+ // check after running the metadata decode in case it triggered an error.
+ nsresult finalStatus = mError ? NS_ERROR_FAILURE : NS_OK;
+ if (NS_FAILED(aStatus)) {
+ finalStatus = aStatus;
+ }
+
+ // If loading failed, report an error.
+ if (NS_FAILED(finalStatus)) {
+ DoError();
+ }
+
+ Progress loadProgress = LoadCompleteProgress(aLastPart, mError, finalStatus);
+
+ if (!LoadHasSize() && !mError) {
+ // We don't have our size yet, so we'll fire the load event in SetSize().
+ MOZ_ASSERT(!canSyncDecodeMetadata,
+ "Firing load async after metadata sync decode?");
+ mLoadProgress = Some(loadProgress);
+ return finalStatus;
+ }
+
+ NotifyForLoadEvent(loadProgress);
+
+ return finalStatus;
+}
+
+void RasterImage::NotifyForLoadEvent(Progress aProgress) {
+ MOZ_ASSERT(LoadHasSize() || mError,
+ "Need to know size before firing load event");
+ MOZ_ASSERT(
+ !LoadHasSize() || (mProgressTracker->GetProgress() & FLAG_SIZE_AVAILABLE),
+ "Should have notified that the size is available if we have it");
+
+ // If we encountered an error, make sure we notify for that as well.
+ if (mError) {
+ aProgress |= FLAG_HAS_ERROR;
+ }
+
+ // Notify our listeners, which will fire this image's load event.
+ NotifyProgress(aProgress);
+}
+
+nsresult RasterImage::OnImageDataAvailable(nsIRequest*, nsISupports*,
+ nsIInputStream* aInputStream,
+ uint64_t, uint32_t aCount) {
+ nsresult rv = mSourceBuffer->AppendFromInputStream(aInputStream, aCount);
+ if (NS_SUCCEEDED(rv) && !LoadSomeSourceData()) {
+ StoreSomeSourceData(true);
+ if (!LoadSyncLoad()) {
+ // Create an async metadata decoder and verify we succeed in doing so.
+ rv = DecodeMetadata(DECODE_FLAGS_DEFAULT);
+ }
+ }
+
+ if (NS_FAILED(rv)) {
+ DoError();
+ }
+ return rv;
+}
+
+nsresult RasterImage::SetSourceSizeHint(uint32_t aSizeHint) {
+ if (aSizeHint == 0) {
+ return NS_OK;
+ }
+
+ nsresult rv = mSourceBuffer->ExpectLength(aSizeHint);
+ if (rv == NS_ERROR_OUT_OF_MEMORY) {
+ // Flush memory, try to get some back, and try again.
+ rv = nsMemory::HeapMinimize(true);
+ if (NS_SUCCEEDED(rv)) {
+ rv = mSourceBuffer->ExpectLength(aSizeHint);
+ }
+ }
+
+ return rv;
+}
+
+nsresult RasterImage::GetHotspotX(int32_t* aX) {
+ *aX = mHotspot.x;
+ return NS_OK;
+}
+
+nsresult RasterImage::GetHotspotY(int32_t* aY) {
+ *aY = mHotspot.y;
+ return NS_OK;
+}
+
+void RasterImage::Discard() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(CanDiscard(), "Asked to discard but can't");
+ MOZ_ASSERT(!mAnimationState ||
+ StaticPrefs::image_mem_animated_discardable_AtStartup(),
+ "Asked to discard for animated image");
+
+ // Delete all the decoded frames.
+ SurfaceCache::RemoveImage(ImageKey(this));
+
+ if (mAnimationState) {
+ ReleaseImageContainer();
+
+ auto size = ToUnoriented(mSize);
+ IntRect rect = mAnimationState->UpdateState(this, size.ToUnknownSize());
+
+ auto dirtyRect = UnorientedIntRect::FromUnknownRect(rect);
+ NotifyProgress(NoProgress, dirtyRect);
+ }
+
+ // Notify that we discarded.
+ if (mProgressTracker) {
+ mProgressTracker->OnDiscard();
+ }
+}
+
+bool RasterImage::CanDiscard() {
+ return LoadAllSourceData() &&
+ // Can discard animated images if the pref is set
+ (!mAnimationState ||
+ StaticPrefs::image_mem_animated_discardable_AtStartup());
+}
+
+NS_IMETHODIMP
+RasterImage::StartDecoding(uint32_t aFlags, uint32_t aWhichFrame) {
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (!LoadHasSize()) {
+ StoreWantFullDecode(true);
+ return NS_OK;
+ }
+
+ uint32_t flags = (aFlags & FLAG_ASYNC_NOTIFY) | FLAG_SYNC_DECODE_IF_FAST |
+ FLAG_HIGH_QUALITY_SCALING;
+ return RequestDecodeForSize(mSize.ToUnknownSize(), flags, aWhichFrame);
+}
+
+bool RasterImage::StartDecodingWithResult(uint32_t aFlags,
+ uint32_t aWhichFrame) {
+ if (mError) {
+ return false;
+ }
+
+ if (!LoadHasSize()) {
+ StoreWantFullDecode(true);
+ return false;
+ }
+
+ uint32_t flags = (aFlags & FLAG_ASYNC_NOTIFY) | FLAG_SYNC_DECODE_IF_FAST |
+ FLAG_HIGH_QUALITY_SCALING;
+ LookupResult result =
+ RequestDecodeForSizeInternal(ToUnoriented(mSize), flags, aWhichFrame);
+ DrawableSurface surface = std::move(result.Surface());
+ return surface && surface->IsFinished();
+}
+
+imgIContainer::DecodeResult RasterImage::RequestDecodeWithResult(
+ uint32_t aFlags, uint32_t aWhichFrame) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (mError) {
+ return imgIContainer::DECODE_REQUEST_FAILED;
+ }
+
+ uint32_t flags = aFlags | FLAG_ASYNC_NOTIFY;
+ LookupResult result =
+ RequestDecodeForSizeInternal(ToUnoriented(mSize), flags, aWhichFrame);
+ DrawableSurface surface = std::move(result.Surface());
+ if (surface && surface->IsFinished()) {
+ return imgIContainer::DECODE_SURFACE_AVAILABLE;
+ }
+ if (result.GetFailedToRequestDecode()) {
+ return imgIContainer::DECODE_REQUEST_FAILED;
+ }
+ return imgIContainer::DECODE_REQUESTED;
+}
+
+NS_IMETHODIMP
+RasterImage::RequestDecodeForSize(const IntSize& aSize, uint32_t aFlags,
+ uint32_t aWhichFrame) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RequestDecodeForSizeInternal(
+ ToUnoriented(OrientedIntSize::FromUnknownSize(aSize)), aFlags,
+ aWhichFrame);
+
+ return NS_OK;
+}
+
+LookupResult RasterImage::RequestDecodeForSizeInternal(
+ const UnorientedIntSize& aSize, uint32_t aFlags, uint32_t aWhichFrame) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (aWhichFrame > FRAME_MAX_VALUE) {
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ if (mError) {
+ LookupResult result = LookupResult(MatchType::NOT_FOUND);
+ result.SetFailedToRequestDecode();
+ return result;
+ }
+
+ if (!LoadHasSize()) {
+ StoreWantFullDecode(true);
+ return LookupResult(MatchType::NOT_FOUND);
+ }
+
+ // Decide whether to sync decode images we can decode quickly. Here we are
+ // explicitly trading off flashing for responsiveness in the case that we're
+ // redecoding an image (see bug 845147).
+ bool shouldSyncDecodeIfFast =
+ !LoadHasBeenDecoded() && (aFlags & FLAG_SYNC_DECODE_IF_FAST);
+
+ uint32_t flags =
+ shouldSyncDecodeIfFast ? aFlags : aFlags & ~FLAG_SYNC_DECODE_IF_FAST;
+
+ // Perform a frame lookup, which will implicitly start decoding if needed.
+ return LookupFrame(aSize, flags, ToPlaybackType(aWhichFrame),
+ /* aMarkUsed = */ false);
+}
+
+static bool LaunchDecodingTask(IDecodingTask* aTask, RasterImage* aImage,
+ uint32_t aFlags, bool aHaveSourceData) {
+ if (aHaveSourceData) {
+ nsCString uri(aImage->GetURIString());
+
+ // If we have all the data, we can sync decode if requested.
+ if (aFlags & imgIContainer::FLAG_SYNC_DECODE) {
+ DecodePool::Singleton()->SyncRunIfPossible(aTask, uri);
+ return true;
+ }
+
+ if (aFlags & imgIContainer::FLAG_SYNC_DECODE_IF_FAST) {
+ return DecodePool::Singleton()->SyncRunIfPreferred(aTask, uri);
+ }
+ }
+
+ // Perform an async decode. We also take this path if we don't have all the
+ // source data yet, since sync decoding is impossible in that situation.
+ DecodePool::Singleton()->AsyncRun(aTask);
+ return false;
+}
+
+void RasterImage::Decode(const UnorientedIntSize& aSize, uint32_t aFlags,
+ PlaybackType aPlaybackType, bool& aOutRanSync,
+ bool& aOutFailed) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (mError) {
+ aOutFailed = true;
+ return;
+ }
+
+ // If we don't have a size yet, we can't do any other decoding.
+ if (!LoadHasSize()) {
+ StoreWantFullDecode(true);
+ return;
+ }
+
+ // We're about to decode again, which may mean that some of the previous sizes
+ // we've decoded at aren't useful anymore. We can allow them to expire from
+ // the cache by unlocking them here. When the decode finishes, it will send an
+ // invalidation that will cause all instances of this image to redraw. If this
+ // image is locked, any surfaces that are still useful will become locked
+ // again when LookupFrame touches them, and the remainder will eventually
+ // expire.
+ SurfaceCache::UnlockEntries(ImageKey(this));
+
+ // Determine which flags we need to decode this image with.
+ DecoderFlags decoderFlags = DefaultDecoderFlags();
+ if (aFlags & FLAG_ASYNC_NOTIFY) {
+ decoderFlags |= DecoderFlags::ASYNC_NOTIFY;
+ }
+ if (LoadTransient()) {
+ decoderFlags |= DecoderFlags::IMAGE_IS_TRANSIENT;
+ }
+ if (LoadHasBeenDecoded()) {
+ decoderFlags |= DecoderFlags::IS_REDECODE;
+ }
+ if ((aFlags & FLAG_SYNC_DECODE) || !(aFlags & FLAG_HIGH_QUALITY_SCALING)) {
+ // Used SurfaceCache::Lookup instead of SurfaceCache::LookupBestMatch. That
+ // means the caller can handle a differently sized surface to be returned
+ // at any point.
+ decoderFlags |= DecoderFlags::CANNOT_SUBSTITUTE;
+ }
+
+ SurfaceFlags surfaceFlags = ToSurfaceFlags(aFlags);
+ if (IsOpaque()) {
+ // If there's no transparency, it doesn't matter whether we premultiply
+ // alpha or not.
+ surfaceFlags &= ~SurfaceFlags::NO_PREMULTIPLY_ALPHA;
+ }
+
+ // Create a decoder.
+ RefPtr<IDecodingTask> task;
+ nsresult rv;
+ bool animated = mAnimationState && aPlaybackType == PlaybackType::eAnimated;
+ if (animated) {
+ size_t currentFrame = mAnimationState->GetCurrentAnimationFrameIndex();
+ rv = DecoderFactory::CreateAnimationDecoder(
+ mDecoderType, WrapNotNull(this), mSourceBuffer,
+ ToUnoriented(mSize).ToUnknownSize(), decoderFlags, surfaceFlags,
+ currentFrame, getter_AddRefs(task));
+ } else {
+ rv = DecoderFactory::CreateDecoder(
+ mDecoderType, WrapNotNull(this), mSourceBuffer,
+ ToUnoriented(mSize).ToUnknownSize(), aSize.ToUnknownSize(),
+ decoderFlags, surfaceFlags, getter_AddRefs(task));
+ }
+
+ if (rv == NS_ERROR_ALREADY_INITIALIZED) {
+ // We raced with an already pending decoder, and it finished before we
+ // managed to insert the new decoder. Pretend we did a sync call to make
+ // the caller lookup in the surface cache again.
+ MOZ_ASSERT(!task);
+ aOutRanSync = true;
+ return;
+ }
+
+ if (animated) {
+ // We pass false for aAllowInvalidation because we may be asked to use
+ // async notifications. Any potential invalidation here will be sent when
+ // RequestRefresh is called, or NotifyDecodeComplete.
+#ifdef DEBUG
+ IntRect rect =
+#endif
+ mAnimationState->UpdateState(this, ToUnoriented(mSize).ToUnknownSize(),
+ false);
+ MOZ_ASSERT(rect.IsEmpty());
+ }
+
+ // Make sure DecoderFactory was able to create a decoder successfully.
+ if (NS_FAILED(rv)) {
+ MOZ_ASSERT(!task);
+ aOutFailed = true;
+ return;
+ }
+
+ MOZ_ASSERT(task);
+ mDecodeCount++;
+
+ // We're ready to decode; start the decoder.
+ aOutRanSync = LaunchDecodingTask(task, this, aFlags, LoadAllSourceData());
+}
+
+NS_IMETHODIMP
+RasterImage::DecodeMetadata(uint32_t aFlags) {
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_ASSERT(!LoadHasSize(), "Should not do unnecessary metadata decodes");
+
+ // Create a decoder.
+ RefPtr<IDecodingTask> task = DecoderFactory::CreateMetadataDecoder(
+ mDecoderType, WrapNotNull(this), mSourceBuffer);
+
+ // Make sure DecoderFactory was able to create a decoder successfully.
+ if (!task) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // We're ready to decode; start the decoder.
+ LaunchDecodingTask(task, this, aFlags, LoadAllSourceData());
+ return NS_OK;
+}
+
+void RasterImage::RecoverFromInvalidFrames(const UnorientedIntSize& aSize,
+ uint32_t aFlags) {
+ if (!LoadHasSize()) {
+ return;
+ }
+
+ NS_WARNING("A RasterImage's frames became invalid. Attempting to recover...");
+
+ // Discard all existing frames, since they're probably all now invalid.
+ SurfaceCache::RemoveImage(ImageKey(this));
+
+ // Relock the image if it's supposed to be locked.
+ if (mLockCount > 0) {
+ SurfaceCache::LockImage(ImageKey(this));
+ }
+
+ bool unused1, unused2;
+
+ // Animated images require some special handling, because we normally require
+ // that they never be discarded.
+ if (mAnimationState) {
+ Decode(ToUnoriented(mSize), aFlags | FLAG_SYNC_DECODE,
+ PlaybackType::eAnimated, unused1, unused2);
+ ResetAnimation();
+ return;
+ }
+
+ // For non-animated images, it's fine to recover using an async decode.
+ Decode(aSize, aFlags, PlaybackType::eStatic, unused1, unused2);
+}
+
+static bool HaveSkia() {
+#ifdef MOZ_ENABLE_SKIA
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool RasterImage::CanDownscaleDuringDecode(const UnorientedIntSize& aSize,
+ uint32_t aFlags) {
+ // Check basic requirements: downscale-during-decode is enabled, Skia is
+ // available, this image isn't transient, we have all the source data and know
+ // our size, and the flags allow us to do it.
+ if (!LoadHasSize() || LoadTransient() || !HaveSkia() ||
+ !StaticPrefs::image_downscale_during_decode_enabled() ||
+ !(aFlags & imgIContainer::FLAG_HIGH_QUALITY_SCALING)) {
+ return false;
+ }
+
+ // We don't downscale animated images during decode.
+ if (mAnimationState) {
+ return false;
+ }
+
+ // Never upscale.
+ UnorientedIntSize ourSize = ToUnoriented(mSize);
+ if (aSize.width >= ourSize.width || aSize.height >= ourSize.height) {
+ return false;
+ }
+
+ // Zero or negative width or height is unacceptable.
+ if (aSize.width < 1 || aSize.height < 1) {
+ return false;
+ }
+
+ // There's no point in scaling if we can't store the result.
+ if (!SurfaceCache::CanHold(aSize.ToUnknownSize())) {
+ return false;
+ }
+
+ return true;
+}
+
+ImgDrawResult RasterImage::DrawInternal(DrawableSurface&& aSurface,
+ gfxContext* aContext,
+ const UnorientedIntSize& aSize,
+ const ImageRegion& aRegion,
+ SamplingFilter aSamplingFilter,
+ uint32_t aFlags, float aOpacity) {
+ gfxContextMatrixAutoSaveRestore saveMatrix(aContext);
+ ImageRegion region(aRegion);
+ bool frameIsFinished = aSurface->IsFinished();
+
+#ifdef DEBUG
+ NotifyDrawingObservers();
+#endif
+
+ // By now we may have a frame with the requested size. If not, we need to
+ // adjust the drawing parameters accordingly.
+ IntSize finalSize = aSurface->GetSize();
+ bool couldRedecodeForBetterFrame = false;
+ if (finalSize != aSize.ToUnknownSize()) {
+ gfx::Size scale(double(aSize.width) / finalSize.width,
+ double(aSize.height) / finalSize.height);
+ aContext->Multiply(gfxMatrix::Scaling(scale.width, scale.height));
+ region.Scale(1.0 / scale.width, 1.0 / scale.height);
+
+ couldRedecodeForBetterFrame = CanDownscaleDuringDecode(aSize, aFlags);
+ }
+
+ if (!aSurface->Draw(aContext, region, aSamplingFilter, aFlags, aOpacity)) {
+ RecoverFromInvalidFrames(aSize, aFlags);
+ return ImgDrawResult::TEMPORARY_ERROR;
+ }
+ if (!frameIsFinished) {
+ return ImgDrawResult::INCOMPLETE;
+ }
+ if (couldRedecodeForBetterFrame) {
+ return ImgDrawResult::WRONG_SIZE;
+ }
+ return ImgDrawResult::SUCCESS;
+}
+
+//******************************************************************************
+NS_IMETHODIMP_(ImgDrawResult)
+RasterImage::Draw(gfxContext* aContext, const IntSize& aSize,
+ const ImageRegion& aRegion, uint32_t aWhichFrame,
+ SamplingFilter aSamplingFilter,
+ const Maybe<SVGImageContext>& /*aSVGContext - ignored*/,
+ uint32_t aFlags, float aOpacity) {
+ if (aWhichFrame > FRAME_MAX_VALUE) {
+ return ImgDrawResult::BAD_ARGS;
+ }
+
+ if (mError) {
+ return ImgDrawResult::BAD_IMAGE;
+ }
+
+ // Illegal -- you can't draw with non-default decode flags.
+ // (Disabling colorspace conversion might make sense to allow, but
+ // we don't currently.)
+ if (ToSurfaceFlags(aFlags) != DefaultSurfaceFlags()) {
+ return ImgDrawResult::BAD_ARGS;
+ }
+
+ if (!aContext) {
+ return ImgDrawResult::BAD_ARGS;
+ }
+
+ if (mAnimationConsumers == 0) {
+ SendOnUnlockedDraw(aFlags);
+ }
+
+ // If we're not using SamplingFilter::GOOD, we shouldn't high-quality scale or
+ // downscale during decode.
+ uint32_t flags = aSamplingFilter == SamplingFilter::GOOD
+ ? aFlags
+ : aFlags & ~FLAG_HIGH_QUALITY_SCALING;
+
+ auto size = ToUnoriented(OrientedIntSize::FromUnknownSize(aSize));
+ LookupResult result = LookupFrame(size, flags, ToPlaybackType(aWhichFrame),
+ /* aMarkUsed = */ true);
+ if (!result) {
+ // Getting the frame (above) touches the image and kicks off decoding.
+ if (mDrawStartTime.IsNull()) {
+ mDrawStartTime = TimeStamp::Now();
+ }
+ return ImgDrawResult::NOT_READY;
+ }
+
+ bool shouldRecordTelemetry =
+ !mDrawStartTime.IsNull() && result.Surface()->IsFinished();
+
+ ImgDrawResult drawResult;
+ {
+ gfxContextMatrixAutoSaveRestore asr;
+ ImageRegion region(aRegion);
+
+ if (!UsedOrientation().IsIdentity()) {
+ // Apply a transform so that the unoriented image is drawn in the
+ // orientation expected by the caller.
+ gfxMatrix matrix = OrientationMatrix(size);
+ asr.SetContext(aContext);
+ aContext->Multiply(matrix);
+
+ // Convert the region to unoriented coordinates.
+ gfxMatrix inverseMatrix = OrientationMatrix(size, /* aInvert = */ true);
+ region.TransformBoundsBy(inverseMatrix);
+ }
+
+ drawResult = DrawInternal(std::move(result.Surface()), aContext, size,
+ region, aSamplingFilter, flags, aOpacity);
+ }
+
+ if (shouldRecordTelemetry) {
+ TimeDuration drawLatency = TimeStamp::Now() - mDrawStartTime;
+ Telemetry::Accumulate(Telemetry::IMAGE_DECODE_ON_DRAW_LATENCY,
+ int32_t(drawLatency.ToMicroseconds()));
+ mDrawStartTime = TimeStamp();
+ }
+
+ return drawResult;
+}
+
+//******************************************************************************
+
+NS_IMETHODIMP
+RasterImage::LockImage() {
+ MOZ_ASSERT(NS_IsMainThread(),
+ "Main thread to encourage serialization with UnlockImage");
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Increment the lock count
+ mLockCount++;
+
+ // Lock this image's surfaces in the SurfaceCache.
+ if (mLockCount == 1) {
+ SurfaceCache::LockImage(ImageKey(this));
+ }
+
+ return NS_OK;
+}
+
+//******************************************************************************
+
+NS_IMETHODIMP
+RasterImage::UnlockImage() {
+ MOZ_ASSERT(NS_IsMainThread(),
+ "Main thread to encourage serialization with LockImage");
+ if (mError) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // It's an error to call this function if the lock count is 0
+ MOZ_ASSERT(mLockCount > 0, "Calling UnlockImage with mLockCount == 0!");
+ if (mLockCount == 0) {
+ return NS_ERROR_ABORT;
+ }
+
+ // Decrement our lock count
+ mLockCount--;
+
+ // Unlock this image's surfaces in the SurfaceCache.
+ if (mLockCount == 0) {
+ SurfaceCache::UnlockImage(ImageKey(this));
+ }
+
+ return NS_OK;
+}
+
+//******************************************************************************
+
+NS_IMETHODIMP
+RasterImage::RequestDiscard() {
+ if (LoadDiscardable() && // Enabled at creation time...
+ mLockCount == 0 && // ...not temporarily disabled...
+ CanDiscard()) {
+ Discard();
+ }
+
+ return NS_OK;
+}
+
+// Idempotent error flagging routine. If a decoder is open, shuts it down.
+void RasterImage::DoError() {
+ // If we've flagged an error before, we have nothing to do
+ if (mError) {
+ return;
+ }
+
+ // We can't safely handle errors off-main-thread, so dispatch a worker to
+ // do it.
+ if (!NS_IsMainThread()) {
+ HandleErrorWorker::DispatchIfNeeded(this);
+ return;
+ }
+
+ // Put the container in an error state.
+ mError = true;
+
+ // Stop animation and release our FrameAnimator.
+ if (mAnimating) {
+ StopAnimation();
+ }
+ mAnimationState = Nothing();
+ mFrameAnimator = nullptr;
+
+ // Release all locks.
+ mLockCount = 0;
+ SurfaceCache::UnlockImage(ImageKey(this));
+
+ // Release all frames from the surface cache.
+ SurfaceCache::RemoveImage(ImageKey(this));
+
+ // Invalidate to get rid of any partially-drawn image content.
+ auto dirtyRect = UnorientedIntRect({0, 0}, ToUnoriented(mSize));
+ NotifyProgress(NoProgress, dirtyRect);
+
+ MOZ_LOG(gImgLog, LogLevel::Error,
+ ("RasterImage: [this=%p] Error detected for image\n", this));
+}
+
+/* static */
+void RasterImage::HandleErrorWorker::DispatchIfNeeded(RasterImage* aImage) {
+ RefPtr<HandleErrorWorker> worker = new HandleErrorWorker(aImage);
+ NS_DispatchToMainThread(worker);
+}
+
+RasterImage::HandleErrorWorker::HandleErrorWorker(RasterImage* aImage)
+ : Runnable("image::RasterImage::HandleErrorWorker"), mImage(aImage) {
+ MOZ_ASSERT(mImage, "Should have image");
+}
+
+NS_IMETHODIMP
+RasterImage::HandleErrorWorker::Run() {
+ mImage->DoError();
+
+ return NS_OK;
+}
+
+bool RasterImage::ShouldAnimate() {
+ return ImageResource::ShouldAnimate() && mAnimationState &&
+ mAnimationState->KnownFrameCount() >= 1 && !LoadAnimationFinished();
+}
+
+#ifdef DEBUG
+NS_IMETHODIMP
+RasterImage::GetFramesNotified(uint32_t* aFramesNotified) {
+ NS_ENSURE_ARG_POINTER(aFramesNotified);
+
+ *aFramesNotified = mFramesNotified;
+
+ return NS_OK;
+}
+#endif
+
+void RasterImage::NotifyProgress(
+ Progress aProgress,
+ const UnorientedIntRect& aInvalidRect /* = UnorientedIntRect() */,
+ const Maybe<uint32_t>& aFrameCount /* = Nothing() */,
+ DecoderFlags aDecoderFlags /* = DefaultDecoderFlags() */,
+ SurfaceFlags aSurfaceFlags /* = DefaultSurfaceFlags() */) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ // Ensure that we stay alive long enough to finish notifying.
+ RefPtr<RasterImage> image = this;
+
+ UnorientedIntRect invalidRect = aInvalidRect;
+
+ if (!(aDecoderFlags & DecoderFlags::FIRST_FRAME_ONLY)) {
+ // We may have decoded new animation frames; update our animation state.
+ MOZ_ASSERT_IF(aFrameCount && *aFrameCount > 1, mAnimationState || mError);
+ if (mAnimationState && aFrameCount) {
+ mAnimationState->UpdateKnownFrameCount(*aFrameCount);
+ }
+
+ // If we should start animating right now, do so.
+ if (mAnimationState && aFrameCount == Some(1u) && LoadPendingAnimation() &&
+ ShouldAnimate()) {
+ StartAnimation();
+ }
+
+ if (mAnimationState) {
+ auto size = ToUnoriented(mSize);
+ IntRect rect = mAnimationState->UpdateState(this, size.ToUnknownSize());
+
+ invalidRect.UnionRect(invalidRect,
+ UnorientedIntRect::FromUnknownRect(rect));
+ }
+ }
+
+ const bool wasDefaultFlags = aSurfaceFlags == DefaultSurfaceFlags();
+
+ auto orientedInvalidRect = ToOriented(invalidRect);
+
+ if (!orientedInvalidRect.IsEmpty() && wasDefaultFlags) {
+ // Update our image container since we're invalidating.
+ UpdateImageContainer(Some(orientedInvalidRect.ToUnknownRect()));
+ }
+
+ // Tell the observers what happened.
+ image->mProgressTracker->SyncNotifyProgress(
+ aProgress, orientedInvalidRect.ToUnknownRect());
+}
+
+void RasterImage::NotifyDecodeComplete(
+ const DecoderFinalStatus& aStatus, const ImageMetadata& aMetadata,
+ const DecoderTelemetry& aTelemetry, Progress aProgress,
+ const UnorientedIntRect& aInvalidRect, const Maybe<uint32_t>& aFrameCount,
+ DecoderFlags aDecoderFlags, SurfaceFlags aSurfaceFlags) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ // If the decoder detected an error, log it to the error console.
+ if (aStatus.mShouldReportError) {
+ ReportDecoderError();
+ }
+
+ // Record all the metadata the decoder gathered about this image.
+ bool metadataOK = SetMetadata(aMetadata, aStatus.mWasMetadataDecode);
+ if (!metadataOK) {
+ // This indicates a serious error that requires us to discard all existing
+ // surfaces and redecode to recover. We'll drop the results from this
+ // decoder on the floor, since they aren't valid.
+ RecoverFromInvalidFrames(ToUnoriented(mSize),
+ FromSurfaceFlags(aSurfaceFlags));
+ return;
+ }
+
+ MOZ_ASSERT(mError || LoadHasSize() || !aMetadata.HasSize(),
+ "SetMetadata should've gotten a size");
+
+ if (!aStatus.mWasMetadataDecode && aStatus.mFinished) {
+ // Flag that we've been decoded before.
+ StoreHasBeenDecoded(true);
+ }
+
+ // Send out any final notifications.
+ NotifyProgress(aProgress, aInvalidRect, aFrameCount, aDecoderFlags,
+ aSurfaceFlags);
+
+ if (!(aDecoderFlags & DecoderFlags::FIRST_FRAME_ONLY)) {
+ // We may have decoded new animation frames; update our animation state.
+ MOZ_ASSERT_IF(aFrameCount && *aFrameCount > 1, mAnimationState || mError);
+ if (mAnimationState && aFrameCount) {
+ mAnimationState->UpdateKnownFrameCount(*aFrameCount);
+ }
+
+ // If we should start animating right now, do so.
+ if (mAnimationState && aFrameCount == Some(1u) && LoadPendingAnimation() &&
+ ShouldAnimate()) {
+ StartAnimation();
+ }
+
+ if (mAnimationState && LoadHasBeenDecoded()) {
+ // We've finished a full decode of all animation frames and our
+ // AnimationState has been notified about them all, so let it know not to
+ // expect anymore.
+ mAnimationState->NotifyDecodeComplete();
+
+ auto size = ToUnoriented(mSize);
+ IntRect rect = mAnimationState->UpdateState(this, size.ToUnknownSize());
+
+ if (!rect.IsEmpty()) {
+ auto dirtyRect = UnorientedIntRect::FromUnknownRect(rect);
+ NotifyProgress(NoProgress, dirtyRect);
+ }
+ }
+ }
+
+ // Do some telemetry if this isn't a metadata decode.
+ if (!aStatus.mWasMetadataDecode) {
+ if (aTelemetry.mChunkCount) {
+ Telemetry::Accumulate(Telemetry::IMAGE_DECODE_CHUNKS,
+ aTelemetry.mChunkCount);
+ }
+
+ if (aStatus.mFinished) {
+ Telemetry::Accumulate(Telemetry::IMAGE_DECODE_TIME,
+ int32_t(aTelemetry.mDecodeTime.ToMicroseconds()));
+
+ if (aTelemetry.mSpeedHistogram && aTelemetry.mBytesDecoded) {
+ Telemetry::Accumulate(*aTelemetry.mSpeedHistogram, aTelemetry.Speed());
+ }
+ }
+ }
+
+ // Only act on errors if we have no usable frames from the decoder.
+ if (aStatus.mHadError &&
+ (!mAnimationState || mAnimationState->KnownFrameCount() == 0)) {
+ DoError();
+ } else if (aStatus.mWasMetadataDecode && !LoadHasSize()) {
+ DoError();
+ }
+
+ // XXX(aosmond): Can we get this far without mFinished == true?
+ if (aStatus.mFinished && aStatus.mWasMetadataDecode) {
+ // If we were waiting to fire the load event, go ahead and fire it now.
+ if (mLoadProgress) {
+ NotifyForLoadEvent(*mLoadProgress);
+ mLoadProgress = Nothing();
+ }
+
+ // If we were a metadata decode and a full decode was requested, do it.
+ if (LoadWantFullDecode()) {
+ StoreWantFullDecode(false);
+ RequestDecodeForSize(mSize.ToUnknownSize(),
+ DECODE_FLAGS_DEFAULT | FLAG_HIGH_QUALITY_SCALING,
+ FRAME_CURRENT);
+ }
+ }
+}
+
+void RasterImage::ReportDecoderError() {
+ nsCOMPtr<nsIConsoleService> consoleService =
+ do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+ nsCOMPtr<nsIScriptError> errorObject =
+ do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
+
+ if (consoleService && errorObject) {
+ nsAutoString msg(u"Image corrupt or truncated."_ns);
+ nsAutoString src;
+ if (GetURI()) {
+ nsAutoCString uri;
+ if (!GetSpecTruncatedTo1k(uri)) {
+ msg += u" URI in this note truncated due to length."_ns;
+ }
+ CopyUTF8toUTF16(uri, src);
+ }
+ if (NS_SUCCEEDED(errorObject->InitWithWindowID(msg, src, u""_ns, 0, 0,
+ nsIScriptError::errorFlag,
+ "Image", InnerWindowID()))) {
+ consoleService->LogMessage(errorObject);
+ }
+ }
+}
+
+already_AddRefed<imgIContainer> RasterImage::Unwrap() {
+ nsCOMPtr<imgIContainer> self(this);
+ return self.forget();
+}
+
+void RasterImage::PropagateUseCounters(dom::Document*) {
+ // No use counters.
+}
+
+IntSize RasterImage::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");
+
+ if (mSize.IsEmpty() || aDest.IsEmpty()) {
+ return IntSize(0, 0);
+ }
+
+ auto dest = OrientedIntSize::FromUnknownSize(
+ IntSize::Ceil(aDest.width, aDest.height));
+
+ if (aSamplingFilter == SamplingFilter::GOOD &&
+ CanDownscaleDuringDecode(ToUnoriented(dest), aFlags)) {
+ return dest.ToUnknownSize();
+ }
+
+ // We can't scale to this size. Use our intrinsic size for now.
+ return mSize.ToUnknownSize();
+}
+
+gfxMatrix RasterImage::OrientationMatrix(const UnorientedIntSize& aSize,
+ bool aInvert) const {
+ return OrientedImage::OrientationMatrix(UsedOrientation(),
+ aSize.ToUnknownSize(), aInvert);
+}
+
+/**
+ * Rotate aRect by the given angle within the space specified by aSize.
+ *
+ * For example, with aRect = [20, 10, 5, 5] and aSize = [100, 100], rotating
+ * with Angle::D90 will result in aRect = [85, 20, 5, 5].
+ */
+static void Rotate(IntRect& aRect, const IntSize& aSize, Angle aAngle) {
+ switch (aAngle) {
+ case Angle::D0:
+ break;
+ case Angle::D90:
+ aRect = {aSize.height - aRect.YMost(), aRect.x, aRect.height,
+ aRect.width};
+ break;
+ case Angle::D180:
+ aRect.MoveTo(aSize.width - aRect.XMost(), aSize.height - aRect.YMost());
+ break;
+ case Angle::D270:
+ aRect = {aRect.y, aSize.width - aRect.XMost(), aRect.height, aRect.width};
+ break;
+ }
+}
+
+/**
+ * Flip aRect along the central axis within aSize.
+ *
+ * For example, with aRect = [20, 10, 5, 5] and aSize = [100, 100], flipping
+ * with Flip::Horizontal will result in aRect = [75, 10, 5, 5].
+ */
+static void Flip(IntRect& aRect, const IntSize& aSize, Flip aFlip) {
+ switch (aFlip) {
+ case Flip::Unflipped:
+ break;
+ case Flip::Horizontal:
+ aRect.x = aSize.width - aRect.XMost();
+ break;
+ }
+}
+
+OrientedIntRect RasterImage::ToOriented(UnorientedIntRect aRect) const {
+ IntRect rect = aRect.ToUnknownRect();
+ auto size = ToUnoriented(mSize);
+
+ MOZ_ASSERT(!UsedOrientation().flipFirst,
+ "flipFirst should only be used by OrientedImage");
+
+ // UsedOrientation() specifies the transformation from a correctly oriented
+ // image to the pixels stored in the file, so we need to rotate by the
+ // negation of the given angle.
+ Angle angle = Orientation::InvertAngle(UsedOrientation().rotation);
+ Rotate(rect, size.ToUnknownSize(), angle);
+
+ // Use mSize instead of size, since after the Rotate call, the size of the
+ // space that rect is in has had its width and height swapped.
+ Flip(rect, mSize.ToUnknownSize(), UsedOrientation().flip);
+
+ return OrientedIntRect::FromUnknownRect(rect);
+}
+
+UnorientedIntRect RasterImage::ToUnoriented(OrientedIntRect aRect) const {
+ IntRect rect = aRect.ToUnknownRect();
+
+ Flip(rect, mSize.ToUnknownSize(), UsedOrientation().flip);
+ Rotate(rect, mSize.ToUnknownSize(), UsedOrientation().rotation);
+
+ MOZ_ASSERT(!UsedOrientation().flipFirst,
+ "flipFirst should only be used by OrientedImage");
+
+ return UnorientedIntRect::FromUnknownRect(rect);
+}
+
+} // namespace image
+} // namespace mozilla