summaryrefslogtreecommitdiffstats
path: root/gfx/layers/wr/WebRenderUserData.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /gfx/layers/wr/WebRenderUserData.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/layers/wr/WebRenderUserData.h')
-rw-r--r--gfx/layers/wr/WebRenderUserData.h385
1 files changed, 385 insertions, 0 deletions
diff --git a/gfx/layers/wr/WebRenderUserData.h b/gfx/layers/wr/WebRenderUserData.h
new file mode 100644
index 0000000000..c8b6b33002
--- /dev/null
+++ b/gfx/layers/wr/WebRenderUserData.h
@@ -0,0 +1,385 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef GFX_WEBRENDERUSERDATA_H
+#define GFX_WEBRENDERUSERDATA_H
+
+#include <vector>
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/image/WebRenderImageProvider.h"
+#include "mozilla/layers/AnimationInfo.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "mozilla/dom/RemoteBrowser.h"
+#include "mozilla/UniquePtr.h"
+#include "nsIFrame.h"
+#include "nsRefPtrHashtable.h"
+#include "nsTHashSet.h"
+#include "ImageTypes.h"
+#include "ImgDrawResult.h"
+#include "DisplayItemClip.h"
+
+namespace mozilla {
+
+class nsDisplayItemGeometry;
+
+namespace webgpu {
+class WebGPUChild;
+}
+
+namespace wr {
+class IpcResourceUpdateQueue;
+}
+
+namespace gfx {
+class SourceSurface;
+}
+
+namespace layers {
+
+class BasicLayerManager;
+class CanvasRenderer;
+class ImageClient;
+class ImageContainer;
+class WebRenderBridgeChild;
+class WebRenderCanvasData;
+class WebRenderCanvasRenderer;
+class WebRenderCanvasRendererAsync;
+class WebRenderImageData;
+class WebRenderImageProviderData;
+class WebRenderFallbackData;
+class RenderRootStateManager;
+class WebRenderGroupData;
+
+class WebRenderBackgroundData {
+ public:
+ WebRenderBackgroundData(wr::LayoutRect aBounds, wr::ColorF aColor)
+ : mBounds(aBounds), mColor(aColor) {}
+ void AddWebRenderCommands(wr::DisplayListBuilder& aBuilder);
+
+ protected:
+ wr::LayoutRect mBounds;
+ wr::ColorF mColor;
+};
+
+/// Parent class for arbitrary WebRender-specific data that can be associated
+/// to an nsFrame.
+class WebRenderUserData {
+ public:
+ typedef nsTHashSet<RefPtr<WebRenderUserData>> WebRenderUserDataRefTable;
+
+ static bool SupportsAsyncUpdate(nsIFrame* aFrame);
+
+ static bool ProcessInvalidateForImage(nsIFrame* aFrame, DisplayItemType aType,
+ image::ImageProviderId aProviderId);
+
+ NS_INLINE_DECL_REFCOUNTING(WebRenderUserData)
+
+ WebRenderUserData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+ WebRenderUserData(RenderRootStateManager* aManager, uint32_t mDisplayItemKey,
+ nsIFrame* aFrame);
+
+ virtual WebRenderImageData* AsImageData() { return nullptr; }
+ virtual WebRenderImageProviderData* AsImageProviderData() { return nullptr; }
+ virtual WebRenderFallbackData* AsFallbackData() { return nullptr; }
+ virtual WebRenderCanvasData* AsCanvasData() { return nullptr; }
+ virtual WebRenderGroupData* AsGroupData() { return nullptr; }
+
+ enum class UserDataType {
+ eImage,
+ eFallback,
+ eAPZAnimation,
+ eAnimation,
+ eCanvas,
+ eRemote,
+ eGroup,
+ eMask,
+ eImageProvider, // ImageLib
+ eInProcessImage,
+ };
+
+ virtual UserDataType GetType() = 0;
+ bool IsUsed() { return mUsed; }
+ void SetUsed(bool aUsed) { mUsed = aUsed; }
+ nsIFrame* GetFrame() { return mFrame; }
+ uint32_t GetDisplayItemKey() { return mDisplayItemKey; }
+ void RemoveFromTable();
+ virtual nsDisplayItemGeometry* GetGeometry() { return nullptr; }
+
+ protected:
+ virtual ~WebRenderUserData();
+
+ WebRenderBridgeChild* WrBridge() const;
+
+ RefPtr<RenderRootStateManager> mManager;
+ nsIFrame* mFrame;
+ uint32_t mDisplayItemKey;
+ WebRenderUserDataRefTable* mTable;
+ bool mUsed;
+};
+
+struct WebRenderUserDataKey {
+ WebRenderUserDataKey(uint32_t aFrameKey,
+ WebRenderUserData::UserDataType aType)
+ : mFrameKey(aFrameKey), mType(aType) {}
+
+ bool operator==(const WebRenderUserDataKey& other) const {
+ return mFrameKey == other.mFrameKey && mType == other.mType;
+ }
+ PLDHashNumber Hash() const {
+ return HashGeneric(
+ mFrameKey,
+ static_cast<std::underlying_type<decltype(mType)>::type>(mType));
+ }
+
+ uint32_t mFrameKey;
+ WebRenderUserData::UserDataType mType;
+};
+
+typedef nsRefPtrHashtable<
+ nsGenericHashKey<mozilla::layers::WebRenderUserDataKey>, WebRenderUserData>
+ WebRenderUserDataTable;
+
+/// Holds some data used to share TextureClient/ImageClient with the parent
+/// process.
+class WebRenderImageData : public WebRenderUserData {
+ public:
+ WebRenderImageData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+ WebRenderImageData(RenderRootStateManager* aManager, uint32_t aDisplayItemKey,
+ nsIFrame* aFrame);
+ virtual ~WebRenderImageData();
+
+ WebRenderImageData* AsImageData() override { return this; }
+ UserDataType GetType() override { return UserDataType::eImage; }
+ static UserDataType Type() { return UserDataType::eImage; }
+ Maybe<wr::ImageKey> GetImageKey() { return mKey; }
+ void SetImageKey(const wr::ImageKey& aKey);
+ already_AddRefed<ImageClient> GetImageClient();
+
+ Maybe<wr::ImageKey> UpdateImageKey(ImageContainer* aContainer,
+ wr::IpcResourceUpdateQueue& aResources,
+ bool aFallback = false);
+
+ void CreateAsyncImageWebRenderCommands(
+ mozilla::wr::DisplayListBuilder& aBuilder, ImageContainer* aContainer,
+ const StackingContextHelper& aSc, const LayoutDeviceRect& aBounds,
+ const LayoutDeviceRect& aSCBounds, VideoInfo::Rotation aRotation,
+ const wr::ImageRendering& aFilter, const wr::MixBlendMode& aMixBlendMode,
+ bool aIsBackfaceVisible);
+
+ void CreateImageClientIfNeeded();
+
+ bool IsAsync() { return mPipelineId.isSome(); }
+
+ void ClearImageKey();
+
+ protected:
+ Maybe<wr::ImageKey> mKey;
+ RefPtr<TextureClient> mTextureOfImage;
+ RefPtr<ImageClient> mImageClient;
+ Maybe<wr::PipelineId> mPipelineId;
+ RefPtr<ImageContainer> mContainer;
+};
+
+/// Holds some data used to share ImageLib results with the parent process.
+/// This may be either in the form of a blob recording or a rasterized surface.
+class WebRenderImageProviderData final : public WebRenderUserData {
+ public:
+ WebRenderImageProviderData(RenderRootStateManager* aManager,
+ nsDisplayItem* aItem);
+ WebRenderImageProviderData(RenderRootStateManager* aManager,
+ uint32_t aDisplayItemKey, nsIFrame* aFrame);
+ ~WebRenderImageProviderData() override;
+
+ WebRenderImageProviderData* AsImageProviderData() override { return this; }
+ UserDataType GetType() override { return UserDataType::eImageProvider; }
+ static UserDataType Type() { return UserDataType::eImageProvider; }
+
+ Maybe<wr::ImageKey> UpdateImageKey(image::WebRenderImageProvider* aProvider,
+ image::ImgDrawResult aDrawResult,
+ wr::IpcResourceUpdateQueue& aResources);
+
+ bool Invalidate(image::ImageProviderId aProviderId) const;
+
+ protected:
+ RefPtr<image::WebRenderImageProvider> mProvider;
+ Maybe<wr::ImageKey> mKey;
+ image::ImgDrawResult mDrawResult = image::ImgDrawResult::NOT_READY;
+};
+
+/// Used for fallback rendering.
+///
+/// In most cases this uses blob images but it can also render on the content
+/// side directly into a texture.
+class WebRenderFallbackData : public WebRenderUserData {
+ public:
+ WebRenderFallbackData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+ virtual ~WebRenderFallbackData();
+
+ WebRenderFallbackData* AsFallbackData() override { return this; }
+ UserDataType GetType() override { return UserDataType::eFallback; }
+ static UserDataType Type() { return UserDataType::eFallback; }
+ nsDisplayItemGeometry* GetGeometry() override { return mGeometry.get(); }
+
+ void SetInvalid(bool aInvalid) { mInvalid = aInvalid; }
+ bool IsInvalid() { return mInvalid; }
+ void SetFonts(const std::vector<RefPtr<gfx::ScaledFont>>& aFonts) {
+ mFonts = aFonts;
+ }
+ Maybe<wr::BlobImageKey> GetBlobImageKey() { return mBlobKey; }
+ void SetBlobImageKey(const wr::BlobImageKey& aKey);
+ Maybe<wr::ImageKey> GetImageKey();
+
+ /// Create a WebRenderImageData to manage the image we are about to render
+ /// into.
+ WebRenderImageData* PaintIntoImage();
+
+ std::vector<RefPtr<gfx::SourceSurface>> mExternalSurfaces;
+ UniquePtr<nsDisplayItemGeometry> mGeometry;
+ DisplayItemClip mClip;
+ nsRect mBounds;
+ nsRect mBuildingRect;
+ gfx::MatrixScales mScale;
+ float mOpacity;
+
+ protected:
+ void ClearImageKey();
+
+ std::vector<RefPtr<gfx::ScaledFont>> mFonts;
+ Maybe<wr::BlobImageKey> mBlobKey;
+ // When rendering into a blob image, mImageData is null. It is non-null only
+ // when we render directly into a texture on the content side.
+ RefPtr<WebRenderImageData> mImageData;
+ bool mInvalid;
+};
+
+class WebRenderAPZAnimationData : public WebRenderUserData {
+ public:
+ WebRenderAPZAnimationData(RenderRootStateManager* aManager,
+ nsDisplayItem* aItem);
+ virtual ~WebRenderAPZAnimationData() = default;
+
+ UserDataType GetType() override { return UserDataType::eAPZAnimation; }
+ static UserDataType Type() { return UserDataType::eAPZAnimation; }
+ uint64_t GetAnimationId() { return mAnimationId; }
+
+ private:
+ uint64_t mAnimationId;
+};
+
+class WebRenderAnimationData : public WebRenderUserData {
+ public:
+ WebRenderAnimationData(RenderRootStateManager* aManager,
+ nsDisplayItem* aItem);
+ virtual ~WebRenderAnimationData();
+
+ UserDataType GetType() override { return UserDataType::eAnimation; }
+ static UserDataType Type() { return UserDataType::eAnimation; }
+ AnimationInfo& GetAnimationInfo() { return mAnimationInfo; }
+
+ protected:
+ AnimationInfo mAnimationInfo;
+};
+
+class WebRenderCanvasData : public WebRenderUserData {
+ public:
+ WebRenderCanvasData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+ virtual ~WebRenderCanvasData();
+
+ WebRenderCanvasData* AsCanvasData() override { return this; }
+ UserDataType GetType() override { return UserDataType::eCanvas; }
+ static UserDataType Type() { return UserDataType::eCanvas; }
+
+ void ClearCanvasRenderer();
+ WebRenderCanvasRendererAsync* GetCanvasRenderer();
+ WebRenderCanvasRendererAsync* CreateCanvasRenderer();
+ bool SetCanvasRenderer(CanvasRenderer* aCanvasRenderer);
+
+ void SetImageContainer(ImageContainer* aImageContainer);
+ ImageContainer* GetImageContainer();
+ void ClearImageContainer();
+
+ protected:
+ RefPtr<WebRenderCanvasRendererAsync> mCanvasRenderer;
+ RefPtr<ImageContainer> mContainer;
+};
+
+class WebRenderRemoteData : public WebRenderUserData {
+ public:
+ WebRenderRemoteData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
+ virtual ~WebRenderRemoteData();
+
+ UserDataType GetType() override { return UserDataType::eRemote; }
+ static UserDataType Type() { return UserDataType::eRemote; }
+
+ void SetRemoteBrowser(dom::RemoteBrowser* aBrowser) {
+ mRemoteBrowser = aBrowser;
+ }
+
+ protected:
+ RefPtr<dom::RemoteBrowser> mRemoteBrowser;
+};
+
+class WebRenderMaskData : public WebRenderUserData {
+ public:
+ explicit WebRenderMaskData(RenderRootStateManager* aManager,
+ nsDisplayItem* aItem)
+ : WebRenderUserData(aManager, aItem),
+ mMaskStyle(nsStyleImageLayers::LayerType::Mask),
+ mShouldHandleOpacity(false) {
+ MOZ_COUNT_CTOR(WebRenderMaskData);
+ }
+ virtual ~WebRenderMaskData() {
+ MOZ_COUNT_DTOR(WebRenderMaskData);
+ ClearImageKey();
+ }
+
+ void ClearImageKey();
+ void Invalidate();
+
+ UserDataType GetType() override { return UserDataType::eMask; }
+ static UserDataType Type() { return UserDataType::eMask; }
+
+ Maybe<wr::BlobImageKey> mBlobKey;
+ std::vector<RefPtr<gfx::ScaledFont>> mFonts;
+ std::vector<RefPtr<gfx::SourceSurface>> mExternalSurfaces;
+ LayerIntRect mItemRect;
+ nsPoint mMaskOffset;
+ nsStyleImageLayers mMaskStyle;
+ gfx::MatrixScales mScale;
+ bool mShouldHandleOpacity;
+};
+
+extern void DestroyWebRenderUserDataTable(WebRenderUserDataTable* aTable);
+
+struct WebRenderUserDataProperty {
+ NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(Key, WebRenderUserDataTable,
+ DestroyWebRenderUserDataTable)
+};
+
+template <class T>
+already_AddRefed<T> GetWebRenderUserData(const nsIFrame* aFrame,
+ uint32_t aPerFrameKey) {
+ MOZ_ASSERT(aFrame);
+ WebRenderUserDataTable* userDataTable =
+ aFrame->GetProperty(WebRenderUserDataProperty::Key());
+ if (!userDataTable) {
+ return nullptr;
+ }
+
+ WebRenderUserData* data =
+ userDataTable->GetWeak(WebRenderUserDataKey(aPerFrameKey, T::Type()));
+ if (data) {
+ RefPtr<T> result = static_cast<T*>(data);
+ return result.forget();
+ }
+
+ return nullptr;
+}
+
+} // namespace layers
+} // namespace mozilla
+
+#endif /* GFX_WEBRENDERUSERDATA_H */