From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- image/ImageWrapper.cpp | 289 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 289 insertions(+) create mode 100644 image/ImageWrapper.cpp (limited to 'image/ImageWrapper.cpp') diff --git a/image/ImageWrapper.cpp b/image/ImageWrapper.cpp new file mode 100644 index 0000000000..eafd6ffe04 --- /dev/null +++ b/image/ImageWrapper.cpp @@ -0,0 +1,289 @@ +/* -*- 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 "ImageWrapper.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/RefPtr.h" +#include "Orientation.h" +#include "mozilla/image/Resolution.h" + +#include "mozilla/MemoryReporting.h" + +namespace mozilla { + +using dom::Document; +using gfx::IntSize; +using gfx::SamplingFilter; +using gfx::SourceSurface; +using layers::ImageContainer; + +namespace image { + +// Inherited methods from Image. + +already_AddRefed ImageWrapper::GetProgressTracker() { + return mInnerImage->GetProgressTracker(); +} + +size_t ImageWrapper::SizeOfSourceWithComputedFallback( + SizeOfState& aState) const { + return mInnerImage->SizeOfSourceWithComputedFallback(aState); +} + +void ImageWrapper::CollectSizeOfSurfaces( + nsTArray& aCounters, + MallocSizeOf aMallocSizeOf) const { + mInnerImage->CollectSizeOfSurfaces(aCounters, aMallocSizeOf); +} + +void ImageWrapper::IncrementAnimationConsumers() { + MOZ_ASSERT(NS_IsMainThread(), + "Main thread only to encourage serialization " + "with DecrementAnimationConsumers"); + mInnerImage->IncrementAnimationConsumers(); +} + +void ImageWrapper::DecrementAnimationConsumers() { + MOZ_ASSERT(NS_IsMainThread(), + "Main thread only to encourage serialization " + "with IncrementAnimationConsumers"); + mInnerImage->DecrementAnimationConsumers(); +} + +#ifdef DEBUG +uint32_t ImageWrapper::GetAnimationConsumers() { + return mInnerImage->GetAnimationConsumers(); +} +#endif + +nsresult ImageWrapper::OnImageDataAvailable(nsIRequest* aRequest, + nsIInputStream* aInStr, + uint64_t aSourceOffset, + uint32_t aCount) { + return mInnerImage->OnImageDataAvailable(aRequest, aInStr, aSourceOffset, + aCount); +} + +nsresult ImageWrapper::OnImageDataComplete(nsIRequest* aRequest, + nsresult aStatus, bool aLastPart) { + return mInnerImage->OnImageDataComplete(aRequest, aStatus, aLastPart); +} + +void ImageWrapper::OnSurfaceDiscarded(const SurfaceKey& aSurfaceKey) { + return mInnerImage->OnSurfaceDiscarded(aSurfaceKey); +} + +void ImageWrapper::SetInnerWindowID(uint64_t aInnerWindowId) { + mInnerImage->SetInnerWindowID(aInnerWindowId); +} + +uint64_t ImageWrapper::InnerWindowID() const { + return mInnerImage->InnerWindowID(); +} + +bool ImageWrapper::HasError() { return mInnerImage->HasError(); } + +void ImageWrapper::SetHasError() { mInnerImage->SetHasError(); } + +nsIURI* ImageWrapper::GetURI() const { return mInnerImage->GetURI(); } + +// Methods inherited from XPCOM interfaces. + +NS_IMPL_ISUPPORTS(ImageWrapper, imgIContainer) + +NS_IMETHODIMP +ImageWrapper::GetWidth(int32_t* aWidth) { + return mInnerImage->GetWidth(aWidth); +} + +NS_IMETHODIMP +ImageWrapper::GetHeight(int32_t* aHeight) { + return mInnerImage->GetHeight(aHeight); +} + +void ImageWrapper::MediaFeatureValuesChangedAllDocuments( + const mozilla::MediaFeatureChange& aChange) {} + +nsresult ImageWrapper::GetNativeSizes(nsTArray& aNativeSizes) { + return mInnerImage->GetNativeSizes(aNativeSizes); +} + +size_t ImageWrapper::GetNativeSizesLength() { + return mInnerImage->GetNativeSizesLength(); +} + +NS_IMETHODIMP +ImageWrapper::GetIntrinsicSize(nsSize* aSize) { + return mInnerImage->GetIntrinsicSize(aSize); +} + +Maybe ImageWrapper::GetIntrinsicRatio() { + return mInnerImage->GetIntrinsicRatio(); +} + +nsresult ImageWrapper::GetHotspotX(int32_t* aX) { + return Image::GetHotspotX(aX); +} + +nsresult ImageWrapper::GetHotspotY(int32_t* aY) { + return Image::GetHotspotY(aY); +} + +NS_IMETHODIMP_(Orientation) +ImageWrapper::GetOrientation() { return mInnerImage->GetOrientation(); } + +NS_IMETHODIMP_(Resolution) +ImageWrapper::GetResolution() { return mInnerImage->GetResolution(); } + +NS_IMETHODIMP +ImageWrapper::GetType(uint16_t* aType) { return mInnerImage->GetType(aType); } + +NS_IMETHODIMP +ImageWrapper::GetProviderId(uint32_t* aId) { + return mInnerImage->GetProviderId(aId); +} + +NS_IMETHODIMP +ImageWrapper::GetAnimated(bool* aAnimated) { + return mInnerImage->GetAnimated(aAnimated); +} + +NS_IMETHODIMP_(already_AddRefed) +ImageWrapper::GetFrame(uint32_t aWhichFrame, uint32_t aFlags) { + return mInnerImage->GetFrame(aWhichFrame, aFlags); +} + +NS_IMETHODIMP_(already_AddRefed) +ImageWrapper::GetFrameAtSize(const IntSize& aSize, uint32_t aWhichFrame, + uint32_t aFlags) { + return mInnerImage->GetFrameAtSize(aSize, aWhichFrame, aFlags); +} + +NS_IMETHODIMP_(bool) +ImageWrapper::WillDrawOpaqueNow() { return mInnerImage->WillDrawOpaqueNow(); } + +NS_IMETHODIMP_(bool) +ImageWrapper::IsImageContainerAvailable(WindowRenderer* aRenderer, + uint32_t aFlags) { + return mInnerImage->IsImageContainerAvailable(aRenderer, aFlags); +} + +NS_IMETHODIMP_(ImgDrawResult) +ImageWrapper::GetImageProvider(WindowRenderer* aRenderer, + const gfx::IntSize& aSize, + const SVGImageContext& aSVGContext, + const Maybe& aRegion, + uint32_t aFlags, + WebRenderImageProvider** aProvider) { + return mInnerImage->GetImageProvider(aRenderer, aSize, aSVGContext, aRegion, + aFlags, aProvider); +} + +NS_IMETHODIMP_(ImgDrawResult) +ImageWrapper::Draw(gfxContext* aContext, const nsIntSize& aSize, + const ImageRegion& aRegion, uint32_t aWhichFrame, + SamplingFilter aSamplingFilter, + const SVGImageContext& aSVGContext, uint32_t aFlags, + float aOpacity) { + return mInnerImage->Draw(aContext, aSize, aRegion, aWhichFrame, + aSamplingFilter, aSVGContext, aFlags, aOpacity); +} + +NS_IMETHODIMP +ImageWrapper::StartDecoding(uint32_t aFlags, uint32_t aWhichFrame) { + return mInnerImage->StartDecoding(aFlags, aWhichFrame); +} + +bool ImageWrapper::StartDecodingWithResult(uint32_t aFlags, + uint32_t aWhichFrame) { + return mInnerImage->StartDecodingWithResult(aFlags, aWhichFrame); +} + +bool ImageWrapper::HasDecodedPixels() { + return InnerImage()->HasDecodedPixels(); +} + +imgIContainer::DecodeResult ImageWrapper::RequestDecodeWithResult( + uint32_t aFlags, uint32_t aWhichFrame) { + return mInnerImage->RequestDecodeWithResult(aFlags, aWhichFrame); +} + +NS_IMETHODIMP +ImageWrapper::RequestDecodeForSize(const nsIntSize& aSize, uint32_t aFlags, + uint32_t aWhichFrame) { + return mInnerImage->RequestDecodeForSize(aSize, aFlags, aWhichFrame); +} + +NS_IMETHODIMP +ImageWrapper::LockImage() { + MOZ_ASSERT(NS_IsMainThread(), + "Main thread to encourage serialization with UnlockImage"); + return mInnerImage->LockImage(); +} + +NS_IMETHODIMP +ImageWrapper::UnlockImage() { + MOZ_ASSERT(NS_IsMainThread(), + "Main thread to encourage serialization with LockImage"); + return mInnerImage->UnlockImage(); +} + +NS_IMETHODIMP +ImageWrapper::RequestDiscard() { return mInnerImage->RequestDiscard(); } + +NS_IMETHODIMP_(void) +ImageWrapper::RequestRefresh(const TimeStamp& aTime) { + return mInnerImage->RequestRefresh(aTime); +} + +NS_IMETHODIMP +ImageWrapper::GetAnimationMode(uint16_t* aAnimationMode) { + return mInnerImage->GetAnimationMode(aAnimationMode); +} + +NS_IMETHODIMP +ImageWrapper::SetAnimationMode(uint16_t aAnimationMode) { + return mInnerImage->SetAnimationMode(aAnimationMode); +} + +NS_IMETHODIMP +ImageWrapper::ResetAnimation() { return mInnerImage->ResetAnimation(); } + +NS_IMETHODIMP_(float) +ImageWrapper::GetFrameIndex(uint32_t aWhichFrame) { + return mInnerImage->GetFrameIndex(aWhichFrame); +} + +NS_IMETHODIMP_(int32_t) +ImageWrapper::GetFirstFrameDelay() { return mInnerImage->GetFirstFrameDelay(); } + +NS_IMETHODIMP_(void) +ImageWrapper::SetAnimationStartTime(const TimeStamp& aTime) { + mInnerImage->SetAnimationStartTime(aTime); +} + +void ImageWrapper::PropagateUseCounters(Document* aReferencingDocument) { + mInnerImage->PropagateUseCounters(aReferencingDocument); +} + +nsIntSize ImageWrapper::OptimalImageSizeForDest(const gfxSize& aDest, + uint32_t aWhichFrame, + SamplingFilter aSamplingFilter, + uint32_t aFlags) { + return mInnerImage->OptimalImageSizeForDest(aDest, aWhichFrame, + aSamplingFilter, aFlags); +} + +NS_IMETHODIMP_(nsIntRect) +ImageWrapper::GetImageSpaceInvalidationRect(const nsIntRect& aRect) { + return mInnerImage->GetImageSpaceInvalidationRect(aRect); +} + +already_AddRefed ImageWrapper::Unwrap() { + return mInnerImage->Unwrap(); +} + +} // namespace image +} // namespace mozilla -- cgit v1.2.3