gfx/layers/wr/WebRenderUserData.h

   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/. */
   6
   7 #ifndef GFX_WEBRENDERUSERDATA_H
   8 #define GFX_WEBRENDERUSERDATA_H
   9
  10 #include <vector>
  11 #include "mozilla/webrender/WebRenderAPI.h"
  12 #include "mozilla/image/WebRenderImageProvider.h"
  13 #include "mozilla/layers/AnimationInfo.h"
  14 #include "mozilla/layers/LayersTypes.h"
  15 #include "mozilla/dom/RemoteBrowser.h"
  16 #include "mozilla/UniquePtr.h"
  17 #include "nsIFrame.h"
  18 #include "nsRefPtrHashtable.h"
  19 #include "nsTHashSet.h"
  20 #include "ImageTypes.h"
  21 #include "ImgDrawResult.h"
  22 #include "DisplayItemClip.h"
  23
  24 namespace mozilla {
  25
  26 class nsDisplayItemGeometry;
  27
  28 namespace webgpu {
  29 class WebGPUChild;
  30 }
  31
  32 namespace wr {
  33 class IpcResourceUpdateQueue;
  34 }
  35
  36 namespace gfx {
  37 class SourceSurface;
  38 }
  39
  40 namespace layers {
  41
  42 class BasicLayerManager;
  43 class CanvasRenderer;
  44 class ImageClient;
  45 class ImageContainer;
  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;
  55
  56 class WebRenderBackgroundData {
  57  public:
  58   WebRenderBackgroundData(wr::LayoutRect aBounds, wr::ColorF aColor)
  59       : mBounds(aBounds), mColor(aColor) {}
  60   void AddWebRenderCommands(wr::DisplayListBuilder& aBuilder);
  61
  62  protected:
  63   wr::LayoutRect mBounds;
  64   wr::ColorF mColor;
  65 };
  66
  67 /// Parent class for arbitrary WebRender-specific data that can be associated
  68 /// to an nsFrame.
  69 class WebRenderUserData {
  70  public:
  71   typedef nsTHashSet<RefPtr<WebRenderUserData>> WebRenderUserDataRefTable;
  72
  73   static bool SupportsAsyncUpdate(nsIFrame* aFrame);
  74
  75   static bool ProcessInvalidateForImage(nsIFrame* aFrame, DisplayItemType aType,
  76                                         image::ImageProviderId aProviderId);
  77
  78   NS_INLINE_DECL_REFCOUNTING(WebRenderUserData)
  79
  80   WebRenderUserData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
  81   WebRenderUserData(RenderRootStateManager* aManager, uint32_t mDisplayItemKey,
  82                     nsIFrame* aFrame);
  83
  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; }
  89
  90   enum class UserDataType {
  91     eImage,
  92     eFallback,
  93     eAPZAnimation,
  94     eAnimation,
  95     eCanvas,
  96     eRemote,
  97     eGroup,
  98     eMask,
  99     eImageProvider,  // ImageLib
 100     eInProcessImage,
 101   };
 102
 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; }
 110
 111  protected:
 112   virtual ~WebRenderUserData();
 113
 114   WebRenderBridgeChild* WrBridge() const;
 115
 116   RefPtr<RenderRootStateManager> mManager;
 117   nsIFrame* mFrame;
 118   uint32_t mDisplayItemKey;
 119   WebRenderUserDataRefTable* mTable;
 120   bool mUsed;
 121 };
 122
 123 struct WebRenderUserDataKey {
 124   WebRenderUserDataKey(uint32_t aFrameKey,
 125                        WebRenderUserData::UserDataType aType)
 126       : mFrameKey(aFrameKey), mType(aType) {}
 127
 128   bool operator==(const WebRenderUserDataKey& other) const {
 129     return mFrameKey == other.mFrameKey && mType == other.mType;
 130   }
 131   PLDHashNumber Hash() const {
 132     return HashGeneric(
 133         mFrameKey,
 134         static_cast<std::underlying_type<decltype(mType)>::type>(mType));
 135   }
 136
 137   uint32_t mFrameKey;
 138   WebRenderUserData::UserDataType mType;
 139 };
 140
 141 typedef nsRefPtrHashtable<
 142     nsGenericHashKey<mozilla::layers::WebRenderUserDataKey>, WebRenderUserData>
 143     WebRenderUserDataTable;
 144
 145 /// Holds some data used to share TextureClient/ImageClient with the parent
 146 /// process.
 147 class WebRenderImageData : public WebRenderUserData {
 148  public:
 149   WebRenderImageData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
 150   WebRenderImageData(RenderRootStateManager* aManager, uint32_t aDisplayItemKey,
 151                      nsIFrame* aFrame);
 152   virtual ~WebRenderImageData();
 153
 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();
 160
 161   Maybe<wr::ImageKey> UpdateImageKey(ImageContainer* aContainer,
 162                                      wr::IpcResourceUpdateQueue& aResources,
 163                                      bool aFallback = false);
 164
 165   void CreateAsyncImageWebRenderCommands(
 166       mozilla::wr::DisplayListBuilder& aBuilder, ImageContainer* aContainer,
 167       const StackingContextHelper& aSc, const LayoutDeviceRect& aBounds,
 168       const LayoutDeviceRect& aSCBounds, VideoInfo::Rotation aRotation,
 169       const wr::ImageRendering& aFilter, const wr::MixBlendMode& aMixBlendMode,
 170       bool aIsBackfaceVisible);
 171
 172   void CreateImageClientIfNeeded();
 173
 174   bool IsAsync() { return mPipelineId.isSome(); }
 175
 176   void ClearImageKey();
 177
 178  protected:
 179   Maybe<wr::ImageKey> mKey;
 180   RefPtr<TextureClient> mTextureOfImage;
 181   RefPtr<ImageClient> mImageClient;
 182   Maybe<wr::PipelineId> mPipelineId;
 183   RefPtr<ImageContainer> mContainer;
 184 };
 185
 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 {
 189  public:
 190   WebRenderImageProviderData(RenderRootStateManager* aManager,
 191                              nsDisplayItem* aItem);
 192   WebRenderImageProviderData(RenderRootStateManager* aManager,
 193                              uint32_t aDisplayItemKey, nsIFrame* aFrame);
 194   ~WebRenderImageProviderData() override;
 195
 196   WebRenderImageProviderData* AsImageProviderData() override { return this; }
 197   UserDataType GetType() override { return UserDataType::eImageProvider; }
 198   static UserDataType Type() { return UserDataType::eImageProvider; }
 199
 200   Maybe<wr::ImageKey> UpdateImageKey(image::WebRenderImageProvider* aProvider,
 201                                      image::ImgDrawResult aDrawResult,
 202                                      wr::IpcResourceUpdateQueue& aResources);
 203
 204   bool Invalidate(image::ImageProviderId aProviderId) const;
 205
 206  protected:
 207   RefPtr<image::WebRenderImageProvider> mProvider;
 208   Maybe<wr::ImageKey> mKey;
 209   image::ImgDrawResult mDrawResult = image::ImgDrawResult::NOT_READY;
 210 };
 211
 212 /// Used for fallback rendering.
 213 ///
 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 {
 217  public:
 218   WebRenderFallbackData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
 219   virtual ~WebRenderFallbackData();
 220
 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(); }
 225
 226   void SetInvalid(bool aInvalid) { mInvalid = aInvalid; }
 227   bool IsInvalid() { return mInvalid; }
 228   void SetFonts(const std::vector<RefPtr<gfx::ScaledFont>>& aFonts) {
 229     mFonts = aFonts;
 230   }
 231   Maybe<wr::BlobImageKey> GetBlobImageKey() { return mBlobKey; }
 232   void SetBlobImageKey(const wr::BlobImageKey& aKey);
 233   Maybe<wr::ImageKey> GetImageKey();
 234
 235   /// Create a WebRenderImageData to manage the image we are about to render
 236   /// into.
 237   WebRenderImageData* PaintIntoImage();
 238
 239   std::vector<RefPtr<gfx::SourceSurface>> mExternalSurfaces;
 240   UniquePtr<nsDisplayItemGeometry> mGeometry;
 241   DisplayItemClip mClip;
 242   nsRect mBounds;
 243   nsRect mBuildingRect;
 244   gfx::MatrixScales mScale;
 245   float mOpacity;
 246
 247  protected:
 248   void ClearImageKey();
 249
 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;
 255   bool mInvalid;
 256 };
 257
 258 class WebRenderAPZAnimationData : public WebRenderUserData {
 259  public:
 260   WebRenderAPZAnimationData(RenderRootStateManager* aManager,
 261                             nsDisplayItem* aItem);
 262   virtual ~WebRenderAPZAnimationData() = default;
 263
 264   UserDataType GetType() override { return UserDataType::eAPZAnimation; }
 265   static UserDataType Type() { return UserDataType::eAPZAnimation; }
 266   uint64_t GetAnimationId() { return mAnimationId; }
 267
 268  private:
 269   uint64_t mAnimationId;
 270 };
 271
 272 class WebRenderAnimationData : public WebRenderUserData {
 273  public:
 274   WebRenderAnimationData(RenderRootStateManager* aManager,
 275                          nsDisplayItem* aItem);
 276   virtual ~WebRenderAnimationData();
 277
 278   UserDataType GetType() override { return UserDataType::eAnimation; }
 279   static UserDataType Type() { return UserDataType::eAnimation; }
 280   AnimationInfo& GetAnimationInfo() { return mAnimationInfo; }
 281
 282  protected:
 283   AnimationInfo mAnimationInfo;
 284 };
 285
 286 class WebRenderCanvasData : public WebRenderUserData {
 287  public:
 288   WebRenderCanvasData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
 289   virtual ~WebRenderCanvasData();
 290
 291   WebRenderCanvasData* AsCanvasData() override { return this; }
 292   UserDataType GetType() override { return UserDataType::eCanvas; }
 293   static UserDataType Type() { return UserDataType::eCanvas; }
 294
 295   void ClearCanvasRenderer();
 296   WebRenderCanvasRendererAsync* GetCanvasRenderer();
 297   WebRenderCanvasRendererAsync* CreateCanvasRenderer();
 298   bool SetCanvasRenderer(CanvasRenderer* aCanvasRenderer);
 299
 300   void SetImageContainer(ImageContainer* aImageContainer);
 301   ImageContainer* GetImageContainer();
 302   void ClearImageContainer();
 303
 304  protected:
 305   RefPtr<WebRenderCanvasRendererAsync> mCanvasRenderer;
 306   RefPtr<ImageContainer> mContainer;
 307 };
 308
 309 class WebRenderRemoteData : public WebRenderUserData {
 310  public:
 311   WebRenderRemoteData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
 312   virtual ~WebRenderRemoteData();
 313
 314   UserDataType GetType() override { return UserDataType::eRemote; }
 315   static UserDataType Type() { return UserDataType::eRemote; }
 316
 317   void SetRemoteBrowser(dom::RemoteBrowser* aBrowser) {
 318     mRemoteBrowser = aBrowser;
 319   }
 320
 321  protected:
 322   RefPtr<dom::RemoteBrowser> mRemoteBrowser;
 323 };
 324
 325 class WebRenderMaskData : public WebRenderUserData {
 326  public:
 327   explicit WebRenderMaskData(RenderRootStateManager* aManager,
 328                              nsDisplayItem* aItem)
 329       : WebRenderUserData(aManager, aItem),
 330         mMaskStyle(nsStyleImageLayers::LayerType::Mask),
 331         mShouldHandleOpacity(false) {
 332     MOZ_COUNT_CTOR(WebRenderMaskData);
 333   }
 334   virtual ~WebRenderMaskData() {
 335     MOZ_COUNT_DTOR(WebRenderMaskData);
 336     ClearImageKey();
 337   }
 338
 339   void ClearImageKey();
 340   void Invalidate();
 341
 342   UserDataType GetType() override { return UserDataType::eMask; }
 343   static UserDataType Type() { return UserDataType::eMask; }
 344
 345   Maybe<wr::BlobImageKey> mBlobKey;
 346   std::vector<RefPtr<gfx::ScaledFont>> mFonts;
 347   std::vector<RefPtr<gfx::SourceSurface>> mExternalSurfaces;
 348   LayerIntRect mItemRect;
 349   nsPoint mMaskOffset;
 350   nsStyleImageLayers mMaskStyle;
 351   gfx::MatrixScales mScale;
 352   bool mShouldHandleOpacity;
 353 };
 354
 355 extern void DestroyWebRenderUserDataTable(WebRenderUserDataTable* aTable);
 356
 357 struct WebRenderUserDataProperty {
 358   NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(Key, WebRenderUserDataTable,
 359                                       DestroyWebRenderUserDataTable)
 360 };
 361
 362 template <class T>
 363 already_AddRefed<T> GetWebRenderUserData(const nsIFrame* aFrame,
 364                                          uint32_t aPerFrameKey) {
 365   MOZ_ASSERT(aFrame);
 366   WebRenderUserDataTable* userDataTable =
 367       aFrame->GetProperty(WebRenderUserDataProperty::Key());
 368   if (!userDataTable) {
 369     return nullptr;
 370   }
 371
 372   WebRenderUserData* data =
 373       userDataTable->GetWeak(WebRenderUserDataKey(aPerFrameKey, T::Type()));
 374   if (data) {
 375     RefPtr<T> result = static_cast<T*>(data);
 376     return result.forget();
 377   }
 378
 379   return nullptr;
 380 }
 381
 382 }  // namespace layers
 383 }  // namespace mozilla
 384
 385 #endif /* GFX_WEBRENDERUSERDATA_H */