summaryrefslogtreecommitdiffstats
path: root/dom/canvas/ImageBitmapRenderingContext.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /dom/canvas/ImageBitmapRenderingContext.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/canvas/ImageBitmapRenderingContext.cpp')
-rw-r--r--dom/canvas/ImageBitmapRenderingContext.cpp321
1 files changed, 321 insertions, 0 deletions
diff --git a/dom/canvas/ImageBitmapRenderingContext.cpp b/dom/canvas/ImageBitmapRenderingContext.cpp
new file mode 100644
index 0000000000..8abe32150b
--- /dev/null
+++ b/dom/canvas/ImageBitmapRenderingContext.cpp
@@ -0,0 +1,321 @@
+/* -*- 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 "ImageBitmapRenderingContext.h"
+#include "gfxPlatform.h"
+#include "gfx2DGlue.h"
+#include "mozilla/dom/ImageBitmapRenderingContextBinding.h"
+#include "mozilla/gfx/Types.h"
+#include "nsComponentManagerUtils.h"
+#include "nsRegion.h"
+#include "ImageContainer.h"
+
+namespace mozilla::dom {
+
+ImageBitmapRenderingContext::ImageBitmapRenderingContext()
+ : mWidth(0),
+ mHeight(0),
+ mFrameCaptureState(FrameCaptureState::CLEAN,
+ "ImageBitmapRenderingContext::mFrameCaptureState") {}
+
+ImageBitmapRenderingContext::~ImageBitmapRenderingContext() {
+ RemovePostRefreshObserver();
+}
+
+JSObject* ImageBitmapRenderingContext::WrapObject(
+ JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+ return ImageBitmapRenderingContext_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+already_AddRefed<layers::Image>
+ImageBitmapRenderingContext::ClipToIntrinsicSize() {
+ if (!mImage) {
+ return nullptr;
+ }
+
+ // If image is larger than canvas intrinsic size, clip it to the intrinsic
+ // size.
+ RefPtr<gfx::SourceSurface> surface;
+ RefPtr<layers::Image> result;
+ if (mWidth < mImage->GetSize().width || mHeight < mImage->GetSize().height) {
+ surface = MatchWithIntrinsicSize();
+ } else {
+ surface = mImage->GetAsSourceSurface();
+ }
+ if (!surface) {
+ return nullptr;
+ }
+ result =
+ new layers::SourceSurfaceImage(gfx::IntSize(mWidth, mHeight), surface);
+ return result.forget();
+}
+
+void ImageBitmapRenderingContext::GetCanvas(
+ Nullable<OwningHTMLCanvasElementOrOffscreenCanvas>& retval) const {
+ if (mCanvasElement && !mCanvasElement->IsInNativeAnonymousSubtree()) {
+ retval.SetValue().SetAsHTMLCanvasElement() = mCanvasElement;
+ } else if (mOffscreenCanvas) {
+ retval.SetValue().SetAsOffscreenCanvas() = mOffscreenCanvas;
+ } else {
+ retval.SetNull();
+ }
+}
+
+void ImageBitmapRenderingContext::TransferImageBitmap(ImageBitmap& aImageBitmap,
+ ErrorResult& aRv) {
+ TransferFromImageBitmap(&aImageBitmap, aRv);
+}
+
+void ImageBitmapRenderingContext::TransferFromImageBitmap(
+ ImageBitmap* aImageBitmap, ErrorResult& aRv) {
+ ResetBitmap();
+
+ if (aImageBitmap) {
+ mImage = aImageBitmap->TransferAsImage();
+
+ if (!mImage) {
+ aRv.ThrowInvalidStateError("The input ImageBitmap has been detached");
+ return;
+ }
+
+ // Note that this is reentrant and will call back into SetDimensions.
+ if (mCanvasElement) {
+ mCanvasElement->SetSize(mImage->GetSize(), aRv);
+ } else if (mOffscreenCanvas) {
+ mOffscreenCanvas->SetSize(mImage->GetSize(), aRv);
+ }
+
+ if (NS_WARN_IF(aRv.Failed())) {
+ mImage = nullptr;
+ return;
+ }
+
+ if (aImageBitmap->IsWriteOnly()) {
+ if (mCanvasElement) {
+ mCanvasElement->SetWriteOnly();
+ } else if (mOffscreenCanvas) {
+ mOffscreenCanvas->SetWriteOnly();
+ }
+ }
+ }
+
+ Redraw(gfxRect(0, 0, mWidth, mHeight));
+}
+
+NS_IMETHODIMP
+ImageBitmapRenderingContext::SetDimensions(int32_t aWidth, int32_t aHeight) {
+ mWidth = aWidth;
+ mHeight = aHeight;
+
+ if (mOffscreenCanvas) {
+ OffscreenCanvasDisplayData data;
+ data.mSize = {mWidth, mHeight};
+ data.mIsOpaque = GetIsOpaque();
+ data.mIsAlphaPremult = true;
+ data.mDoPaintCallbacks = false;
+ mOffscreenCanvas->UpdateDisplayData(data);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+ImageBitmapRenderingContext::InitializeWithDrawTarget(
+ nsIDocShell* aDocShell, NotNull<gfx::DrawTarget*> aTarget) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+already_AddRefed<gfx::DataSourceSurface>
+ImageBitmapRenderingContext::MatchWithIntrinsicSize() {
+ RefPtr<gfx::SourceSurface> surface = mImage->GetAsSourceSurface();
+ if (!surface) {
+ return nullptr;
+ }
+ RefPtr<gfx::DataSourceSurface> temp = gfx::Factory::CreateDataSourceSurface(
+ gfx::IntSize(mWidth, mHeight), surface->GetFormat());
+ if (!temp) {
+ return nullptr;
+ }
+
+ gfx::DataSourceSurface::ScopedMap map(temp,
+ gfx::DataSourceSurface::READ_WRITE);
+ if (!map.IsMapped()) {
+ return nullptr;
+ }
+
+ RefPtr<gfx::DrawTarget> dt = gfx::Factory::CreateDrawTargetForData(
+ gfxPlatform::GetPlatform()->GetSoftwareBackend(), map.GetData(),
+ temp->GetSize(), map.GetStride(), temp->GetFormat());
+ if (!dt || !dt->IsValid()) {
+ gfxWarning()
+ << "ImageBitmapRenderingContext::MatchWithIntrinsicSize failed";
+ return nullptr;
+ }
+
+ dt->ClearRect(gfx::Rect(0, 0, mWidth, mHeight));
+ dt->CopySurface(
+ surface,
+ gfx::IntRect(0, 0, surface->GetSize().width, surface->GetSize().height),
+ gfx::IntPoint(0, 0));
+
+ return temp.forget();
+}
+
+mozilla::UniquePtr<uint8_t[]> ImageBitmapRenderingContext::GetImageBuffer(
+ int32_t* aFormat, gfx::IntSize* aImageSize) {
+ *aFormat = 0;
+ *aImageSize = {};
+
+ if (!mImage) {
+ return nullptr;
+ }
+
+ RefPtr<gfx::SourceSurface> surface = mImage->GetAsSourceSurface();
+ if (!surface) {
+ return nullptr;
+ }
+ RefPtr<gfx::DataSourceSurface> data = surface->GetDataSurface();
+ if (!data) {
+ return nullptr;
+ }
+
+ if (data->GetSize() != gfx::IntSize(mWidth, mHeight)) {
+ data = MatchWithIntrinsicSize();
+ if (!data) {
+ return nullptr;
+ }
+ }
+
+ *aFormat = imgIEncoder::INPUT_FORMAT_HOSTARGB;
+ *aImageSize = data->GetSize();
+
+ UniquePtr<uint8_t[]> ret = gfx::SurfaceToPackedBGRA(data);
+
+ if (ret && ShouldResistFingerprinting(RFPTarget::CanvasRandomization)) {
+ nsRFPService::RandomizePixels(
+ GetCookieJarSettings(), ret.get(), data->GetSize().width,
+ data->GetSize().height,
+ data->GetSize().width * data->GetSize().height * 4,
+ gfx::SurfaceFormat::A8R8G8B8_UINT32);
+ }
+ return ret;
+}
+
+NS_IMETHODIMP
+ImageBitmapRenderingContext::GetInputStream(const char* aMimeType,
+ const nsAString& aEncoderOptions,
+ nsIInputStream** aStream) {
+ nsCString enccid("@mozilla.org/image/encoder;2?type=");
+ enccid += aMimeType;
+ nsCOMPtr<imgIEncoder> encoder = do_CreateInstance(enccid.get());
+ if (!encoder) {
+ return NS_ERROR_FAILURE;
+ }
+
+ int32_t format = 0;
+ gfx::IntSize imageSize = {};
+ UniquePtr<uint8_t[]> imageBuffer = GetImageBuffer(&format, &imageSize);
+ if (!imageBuffer) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return ImageEncoder::GetInputStream(imageSize.width, imageSize.height,
+ imageBuffer.get(), format, encoder,
+ aEncoderOptions, aStream);
+}
+
+already_AddRefed<mozilla::gfx::SourceSurface>
+ImageBitmapRenderingContext::GetSurfaceSnapshot(
+ gfxAlphaType* const aOutAlphaType) {
+ if (!mImage) {
+ return nullptr;
+ }
+
+ if (aOutAlphaType) {
+ *aOutAlphaType =
+ (GetIsOpaque() ? gfxAlphaType::Opaque : gfxAlphaType::Premult);
+ }
+
+ RefPtr<gfx::SourceSurface> surface = mImage->GetAsSourceSurface();
+ if (!surface) {
+ return nullptr;
+ }
+
+ if (surface->GetSize() != gfx::IntSize(mWidth, mHeight)) {
+ return MatchWithIntrinsicSize();
+ }
+
+ return surface.forget();
+}
+
+void ImageBitmapRenderingContext::SetOpaqueValueFromOpaqueAttr(
+ bool aOpaqueAttrValue) {
+ // ignored
+}
+
+bool ImageBitmapRenderingContext::GetIsOpaque() { return false; }
+
+void ImageBitmapRenderingContext::ResetBitmap() {
+ if (mCanvasElement) {
+ mCanvasElement->InvalidateCanvas();
+ }
+
+ mImage = nullptr;
+ mFrameCaptureState = FrameCaptureState::CLEAN;
+}
+
+bool ImageBitmapRenderingContext::UpdateWebRenderCanvasData(
+ nsDisplayListBuilder* aBuilder, WebRenderCanvasData* aCanvasData) {
+ if (!mImage) {
+ // No DidTransactionCallback will be received, so mark the context clean
+ // now so future invalidations will be dispatched.
+ MarkContextClean();
+ return false;
+ }
+
+ RefPtr<layers::ImageContainer> imageContainer =
+ aCanvasData->GetImageContainer();
+ AutoTArray<layers::ImageContainer::NonOwningImage, 1> imageList;
+ RefPtr<layers::Image> image = ClipToIntrinsicSize();
+ if (!image) {
+ return false;
+ }
+
+ imageList.AppendElement(layers::ImageContainer::NonOwningImage(image));
+ imageContainer->SetCurrentImages(imageList);
+ return true;
+}
+
+void ImageBitmapRenderingContext::MarkContextClean() {}
+
+NS_IMETHODIMP
+ImageBitmapRenderingContext::Redraw(const gfxRect& aDirty) {
+ mFrameCaptureState = FrameCaptureState::DIRTY;
+
+ if (mOffscreenCanvas) {
+ mOffscreenCanvas->CommitFrameToCompositor();
+ } else if (mCanvasElement) {
+ mozilla::gfx::Rect rect = ToRect(aDirty);
+ mCanvasElement->InvalidateCanvasContent(&rect);
+ }
+
+ return NS_OK;
+}
+
+void ImageBitmapRenderingContext::DidRefresh() {}
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ImageBitmapRenderingContext)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ImageBitmapRenderingContext)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(ImageBitmapRenderingContext,
+ mCanvasElement, mOffscreenCanvas)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ImageBitmapRenderingContext)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsICanvasRenderingContextInternal)
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+} // namespace mozilla::dom