summaryrefslogtreecommitdiffstats
path: root/image/ImageWrapper.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
commit0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d (patch)
treea31f07c9bcca9d56ce61e9a1ffd30ef350d513aa /image/ImageWrapper.cpp
parentInitial commit. (diff)
downloadfirefox-esr-upstream/115.8.0esr.tar.xz
firefox-esr-upstream/115.8.0esr.zip
Adding upstream version 115.8.0esr.upstream/115.8.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--image/ImageWrapper.cpp289
1 files changed, 289 insertions, 0 deletions
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<ProgressTracker> ImageWrapper::GetProgressTracker() {
+ return mInnerImage->GetProgressTracker();
+}
+
+size_t ImageWrapper::SizeOfSourceWithComputedFallback(
+ SizeOfState& aState) const {
+ return mInnerImage->SizeOfSourceWithComputedFallback(aState);
+}
+
+void ImageWrapper::CollectSizeOfSurfaces(
+ nsTArray<SurfaceMemoryCounter>& 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<IntSize>& aNativeSizes) {
+ return mInnerImage->GetNativeSizes(aNativeSizes);
+}
+
+size_t ImageWrapper::GetNativeSizesLength() {
+ return mInnerImage->GetNativeSizesLength();
+}
+
+NS_IMETHODIMP
+ImageWrapper::GetIntrinsicSize(nsSize* aSize) {
+ return mInnerImage->GetIntrinsicSize(aSize);
+}
+
+Maybe<AspectRatio> 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<SourceSurface>)
+ImageWrapper::GetFrame(uint32_t aWhichFrame, uint32_t aFlags) {
+ return mInnerImage->GetFrame(aWhichFrame, aFlags);
+}
+
+NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
+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<ImageIntRegion>& 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<imgIContainer> ImageWrapper::Unwrap() {
+ return mInnerImage->Unwrap();
+}
+
+} // namespace image
+} // namespace mozilla