1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 #ifndef GFX_WEBRENDERUSERDATA_H
8 #define GFX_WEBRENDERUSERDATA_H
11 #include "mozilla/gfx/DrawEventRecorder.h"
12 #include "mozilla/webrender/WebRenderAPI.h"
13 #include "mozilla/image/WebRenderImageProvider.h"
14 #include "mozilla/layers/AnimationInfo.h"
15 #include "mozilla/layers/LayersTypes.h"
16 #include "mozilla/UniquePtr.h"
18 #include "nsRefPtrHashtable.h"
19 #include "nsTHashSet.h"
20 #include "ImageTypes.h"
21 #include "ImgDrawResult.h"
22 #include "DisplayItemClip.h"
26 class nsDisplayItemGeometry
;
33 class IpcResourceUpdateQueue
;
42 class BasicLayerManager
;
46 class WebRenderBridgeChild
;
47 class WebRenderCanvasData
;
48 class WebRenderCanvasRenderer
;
49 class WebRenderCanvasRendererAsync
;
50 class WebRenderImageData
;
51 class WebRenderImageProviderData
;
52 class WebRenderFallbackData
;
53 class RenderRootStateManager
;
54 class WebRenderGroupData
;
56 class WebRenderBackgroundData
{
58 WebRenderBackgroundData(wr::LayoutRect aBounds
, wr::ColorF aColor
)
59 : mBounds(aBounds
), mColor(aColor
) {}
60 void AddWebRenderCommands(wr::DisplayListBuilder
& aBuilder
);
63 wr::LayoutRect mBounds
;
67 /// Parent class for arbitrary WebRender-specific data that can be associated
69 class WebRenderUserData
{
71 typedef nsTHashSet
<RefPtr
<WebRenderUserData
>> WebRenderUserDataRefTable
;
73 static bool SupportsAsyncUpdate(nsIFrame
* aFrame
);
75 static bool ProcessInvalidateForImage(nsIFrame
* aFrame
, DisplayItemType aType
,
76 image::ImageProviderId aProviderId
);
78 NS_INLINE_DECL_REFCOUNTING(WebRenderUserData
)
80 WebRenderUserData(RenderRootStateManager
* aManager
, nsDisplayItem
* aItem
);
81 WebRenderUserData(RenderRootStateManager
* aManager
, uint32_t mDisplayItemKey
,
84 virtual WebRenderImageData
* AsImageData() { return nullptr; }
85 virtual WebRenderImageProviderData
* AsImageProviderData() { return nullptr; }
86 virtual WebRenderFallbackData
* AsFallbackData() { return nullptr; }
87 virtual WebRenderCanvasData
* AsCanvasData() { return nullptr; }
88 virtual WebRenderGroupData
* AsGroupData() { return nullptr; }
90 enum class UserDataType
{
99 eImageProvider
, // ImageLib
103 virtual UserDataType
GetType() = 0;
104 bool IsUsed() { return mUsed
; }
105 void SetUsed(bool aUsed
) { mUsed
= aUsed
; }
106 nsIFrame
* GetFrame() { return mFrame
; }
107 uint32_t GetDisplayItemKey() { return mDisplayItemKey
; }
108 void RemoveFromTable();
109 virtual nsDisplayItemGeometry
* GetGeometry() { return nullptr; }
112 virtual ~WebRenderUserData();
114 WebRenderBridgeChild
* WrBridge() const;
116 RefPtr
<RenderRootStateManager
> mManager
;
118 uint32_t mDisplayItemKey
;
119 WebRenderUserDataRefTable
* mTable
;
123 struct WebRenderUserDataKey
{
124 WebRenderUserDataKey(uint32_t aFrameKey
,
125 WebRenderUserData::UserDataType aType
)
126 : mFrameKey(aFrameKey
), mType(aType
) {}
128 bool operator==(const WebRenderUserDataKey
& other
) const {
129 return mFrameKey
== other
.mFrameKey
&& mType
== other
.mType
;
131 PLDHashNumber
Hash() const {
134 static_cast<std::underlying_type
<decltype(mType
)>::type
>(mType
));
138 WebRenderUserData::UserDataType mType
;
141 typedef nsRefPtrHashtable
<
142 nsGenericHashKey
<mozilla::layers::WebRenderUserDataKey
>, WebRenderUserData
>
143 WebRenderUserDataTable
;
145 /// Holds some data used to share TextureClient/ImageClient with the parent
147 class WebRenderImageData
: public WebRenderUserData
{
149 WebRenderImageData(RenderRootStateManager
* aManager
, nsDisplayItem
* aItem
);
150 WebRenderImageData(RenderRootStateManager
* aManager
, uint32_t aDisplayItemKey
,
152 virtual ~WebRenderImageData();
154 WebRenderImageData
* AsImageData() override
{ return this; }
155 UserDataType
GetType() override
{ return UserDataType::eImage
; }
156 static UserDataType
Type() { return UserDataType::eImage
; }
157 Maybe
<wr::ImageKey
> GetImageKey() { return mKey
; }
158 void SetImageKey(const wr::ImageKey
& aKey
);
159 already_AddRefed
<ImageClient
> GetImageClient();
161 Maybe
<wr::ImageKey
> UpdateImageKey(ImageContainer
* aContainer
,
162 wr::IpcResourceUpdateQueue
& aResources
,
163 bool aFallback
= false);
165 void CreateAsyncImageWebRenderCommands(
166 mozilla::wr::DisplayListBuilder
& aBuilder
, ImageContainer
* aContainer
,
167 const StackingContextHelper
& aSc
, const LayoutDeviceRect
& aBounds
,
168 const LayoutDeviceRect
& aSCBounds
, wr::WrRotation aRotation
,
169 const wr::ImageRendering
& aFilter
, const wr::MixBlendMode
& aMixBlendMode
,
170 bool aIsBackfaceVisible
);
172 void CreateImageClientIfNeeded();
174 bool IsAsync() { return mPipelineId
.isSome(); }
176 void ClearImageKey();
179 Maybe
<wr::ImageKey
> mKey
;
180 RefPtr
<TextureClient
> mTextureOfImage
;
181 RefPtr
<ImageClient
> mImageClient
;
182 Maybe
<wr::PipelineId
> mPipelineId
;
183 RefPtr
<ImageContainer
> mContainer
;
186 /// Holds some data used to share ImageLib results with the parent process.
187 /// This may be either in the form of a blob recording or a rasterized surface.
188 class WebRenderImageProviderData final
: public WebRenderUserData
{
190 WebRenderImageProviderData(RenderRootStateManager
* aManager
,
191 nsDisplayItem
* aItem
);
192 WebRenderImageProviderData(RenderRootStateManager
* aManager
,
193 uint32_t aDisplayItemKey
, nsIFrame
* aFrame
);
194 ~WebRenderImageProviderData() override
;
196 WebRenderImageProviderData
* AsImageProviderData() override
{ return this; }
197 UserDataType
GetType() override
{ return UserDataType::eImageProvider
; }
198 static UserDataType
Type() { return UserDataType::eImageProvider
; }
200 Maybe
<wr::ImageKey
> UpdateImageKey(image::WebRenderImageProvider
* aProvider
,
201 image::ImgDrawResult aDrawResult
,
202 wr::IpcResourceUpdateQueue
& aResources
);
204 bool Invalidate(image::ImageProviderId aProviderId
) const;
207 RefPtr
<image::WebRenderImageProvider
> mProvider
;
208 Maybe
<wr::ImageKey
> mKey
;
209 image::ImgDrawResult mDrawResult
= image::ImgDrawResult::NOT_READY
;
212 /// Used for fallback rendering.
214 /// In most cases this uses blob images but it can also render on the content
215 /// side directly into a texture.
216 class WebRenderFallbackData
: public WebRenderUserData
{
218 WebRenderFallbackData(RenderRootStateManager
* aManager
, nsDisplayItem
* aItem
);
219 virtual ~WebRenderFallbackData();
221 WebRenderFallbackData
* AsFallbackData() override
{ return this; }
222 UserDataType
GetType() override
{ return UserDataType::eFallback
; }
223 static UserDataType
Type() { return UserDataType::eFallback
; }
224 nsDisplayItemGeometry
* GetGeometry() override
{ return mGeometry
.get(); }
226 void SetInvalid(bool aInvalid
) { mInvalid
= aInvalid
; }
227 bool IsInvalid() { return mInvalid
; }
228 void SetFonts(const std::vector
<RefPtr
<gfx::ScaledFont
>>& aFonts
) {
231 Maybe
<wr::BlobImageKey
> GetBlobImageKey() { return mBlobKey
; }
232 void SetBlobImageKey(const wr::BlobImageKey
& aKey
);
233 Maybe
<wr::ImageKey
> GetImageKey();
235 /// Create a WebRenderImageData to manage the image we are about to render
237 WebRenderImageData
* PaintIntoImage();
239 gfx::DrawEventRecorderPrivate::ExternalSurfacesHolder mExternalSurfaces
;
240 UniquePtr
<nsDisplayItemGeometry
> mGeometry
;
241 DisplayItemClip mClip
;
243 nsRect mBuildingRect
;
244 gfx::MatrixScales mScale
;
248 void ClearImageKey();
250 std::vector
<RefPtr
<gfx::ScaledFont
>> mFonts
;
251 Maybe
<wr::BlobImageKey
> mBlobKey
;
252 // When rendering into a blob image, mImageData is null. It is non-null only
253 // when we render directly into a texture on the content side.
254 RefPtr
<WebRenderImageData
> mImageData
;
258 class WebRenderAPZAnimationData
: public WebRenderUserData
{
260 WebRenderAPZAnimationData(RenderRootStateManager
* aManager
,
261 nsDisplayItem
* aItem
);
262 virtual ~WebRenderAPZAnimationData() = default;
264 UserDataType
GetType() override
{ return UserDataType::eAPZAnimation
; }
265 static UserDataType
Type() { return UserDataType::eAPZAnimation
; }
266 uint64_t GetAnimationId() { return mAnimationId
; }
269 uint64_t mAnimationId
;
272 class WebRenderAnimationData
: public WebRenderUserData
{
274 WebRenderAnimationData(RenderRootStateManager
* aManager
,
275 nsDisplayItem
* aItem
);
276 virtual ~WebRenderAnimationData();
278 UserDataType
GetType() override
{ return UserDataType::eAnimation
; }
279 static UserDataType
Type() { return UserDataType::eAnimation
; }
280 AnimationInfo
& GetAnimationInfo() { return mAnimationInfo
; }
283 AnimationInfo mAnimationInfo
;
286 class WebRenderCanvasData
: public WebRenderUserData
{
288 WebRenderCanvasData(RenderRootStateManager
* aManager
, nsDisplayItem
* aItem
);
289 virtual ~WebRenderCanvasData();
291 WebRenderCanvasData
* AsCanvasData() override
{ return this; }
292 UserDataType
GetType() override
{ return UserDataType::eCanvas
; }
293 static UserDataType
Type() { return UserDataType::eCanvas
; }
295 void ClearCanvasRenderer();
296 WebRenderCanvasRendererAsync
* GetCanvasRenderer();
297 WebRenderCanvasRendererAsync
* CreateCanvasRenderer();
298 bool SetCanvasRenderer(CanvasRenderer
* aCanvasRenderer
);
300 void SetImageContainer(ImageContainer
* aImageContainer
);
301 ImageContainer
* GetImageContainer();
302 void ClearImageContainer();
305 RefPtr
<WebRenderCanvasRendererAsync
> mCanvasRenderer
;
306 RefPtr
<ImageContainer
> mContainer
;
309 class WebRenderMaskData
: public WebRenderUserData
{
311 explicit WebRenderMaskData(RenderRootStateManager
* aManager
,
312 nsDisplayItem
* aItem
)
313 : WebRenderUserData(aManager
, aItem
),
314 mMaskStyle(nsStyleImageLayers::LayerType::Mask
),
315 mShouldHandleOpacity(false) {
316 MOZ_COUNT_CTOR(WebRenderMaskData
);
318 virtual ~WebRenderMaskData() {
319 MOZ_COUNT_DTOR(WebRenderMaskData
);
323 void ClearImageKey();
326 UserDataType
GetType() override
{ return UserDataType::eMask
; }
327 static UserDataType
Type() { return UserDataType::eMask
; }
329 Maybe
<wr::BlobImageKey
> mBlobKey
;
330 std::vector
<RefPtr
<gfx::ScaledFont
>> mFonts
;
331 gfx::DrawEventRecorderPrivate::ExternalSurfacesHolder mExternalSurfaces
;
332 LayerIntRect mItemRect
;
334 nsStyleImageLayers mMaskStyle
;
335 gfx::MatrixScales mScale
;
336 bool mShouldHandleOpacity
;
339 extern void DestroyWebRenderUserDataTable(WebRenderUserDataTable
* aTable
);
341 struct WebRenderUserDataProperty
{
342 NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(Key
, WebRenderUserDataTable
,
343 DestroyWebRenderUserDataTable
)
347 already_AddRefed
<T
> GetWebRenderUserData(const nsIFrame
* aFrame
,
348 uint32_t aPerFrameKey
) {
350 WebRenderUserDataTable
* userDataTable
=
351 aFrame
->GetProperty(WebRenderUserDataProperty::Key());
352 if (!userDataTable
) {
356 WebRenderUserData
* data
=
357 userDataTable
->GetWeak(WebRenderUserDataKey(aPerFrameKey
, T::Type()));
359 RefPtr
<T
> result
= static_cast<T
*>(data
);
360 return result
.forget();
366 } // namespace layers
367 } // namespace mozilla
369 #endif /* GFX_WEBRENDERUSERDATA_H */