tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

WebRenderUserData.h (12579B)

      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/gfx/DrawEventRecorderTypes.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"
     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, wr::WrRotation 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  WebRenderFallbackData(RenderRootStateManager* aManager,
    220                        uint32_t aDisplayItemKey, nsIFrame* aFrame);
    221  virtual ~WebRenderFallbackData();
    222 
    223  WebRenderFallbackData* AsFallbackData() override { return this; }
    224  UserDataType GetType() override { return UserDataType::eFallback; }
    225  static UserDataType Type() { return UserDataType::eFallback; }
    226  nsDisplayItemGeometry* GetGeometry() override { return mGeometry.get(); }
    227 
    228  void SetInvalid(bool aInvalid) { mInvalid = aInvalid; }
    229  bool IsInvalid() { return mInvalid; }
    230  void SetFonts(const std::vector<RefPtr<gfx::ScaledFont>>& aFonts) {
    231    mFonts = aFonts;
    232  }
    233  Maybe<wr::BlobImageKey> GetBlobImageKey() { return mBlobKey; }
    234  void SetBlobImageKey(const wr::BlobImageKey& aKey);
    235  Maybe<wr::ImageKey> GetImageKey();
    236 
    237  /// Create a WebRenderImageData to manage the image we are about to render
    238  /// into.
    239  WebRenderImageData* PaintIntoImage();
    240 
    241  gfx::DrawEventRecorderPrivate_ExternalSurfacesHolder mExternalSurfaces;
    242  UniquePtr<nsDisplayItemGeometry> mGeometry;
    243  DisplayItemClip mClip;
    244  nsRect mBounds;
    245  nsRect mBuildingRect;
    246  gfx::MatrixScales mScale;
    247  float mOpacity;
    248 
    249 protected:
    250  void ClearImageKey();
    251 
    252  std::vector<RefPtr<gfx::ScaledFont>> mFonts;
    253  Maybe<wr::BlobImageKey> mBlobKey;
    254  // When rendering into a blob image, mImageData is null. It is non-null only
    255  // when we render directly into a texture on the content side.
    256  RefPtr<WebRenderImageData> mImageData;
    257  bool mInvalid;
    258 };
    259 
    260 class WebRenderAPZAnimationData : public WebRenderUserData {
    261 public:
    262  WebRenderAPZAnimationData(RenderRootStateManager* aManager,
    263                            nsDisplayItem* aItem);
    264  WebRenderAPZAnimationData(RenderRootStateManager* aManager,
    265                            uint32_t aDisplayItemKey, nsIFrame* aFrame);
    266  virtual ~WebRenderAPZAnimationData() = default;
    267 
    268  UserDataType GetType() override { return UserDataType::eAPZAnimation; }
    269  static UserDataType Type() { return UserDataType::eAPZAnimation; }
    270  uint64_t GetAnimationId() { return mAnimationId; }
    271 
    272 private:
    273  uint64_t mAnimationId;
    274 };
    275 
    276 class WebRenderAnimationData : public WebRenderUserData {
    277 public:
    278  WebRenderAnimationData(RenderRootStateManager* aManager,
    279                         nsDisplayItem* aItem);
    280  WebRenderAnimationData(RenderRootStateManager* aManager,
    281                         uint32_t aDisplayItemKey, nsIFrame* aFrame);
    282  virtual ~WebRenderAnimationData();
    283 
    284  UserDataType GetType() override { return UserDataType::eAnimation; }
    285  static UserDataType Type() { return UserDataType::eAnimation; }
    286  AnimationInfo& GetAnimationInfo() { return mAnimationInfo; }
    287 
    288 protected:
    289  AnimationInfo mAnimationInfo;
    290 };
    291 
    292 class WebRenderCanvasData : public WebRenderUserData {
    293 public:
    294  WebRenderCanvasData(RenderRootStateManager* aManager, nsDisplayItem* aItem);
    295  WebRenderCanvasData(RenderRootStateManager* aManager,
    296                      uint32_t aDisplayItemKey, nsIFrame* aFrame);
    297  virtual ~WebRenderCanvasData();
    298 
    299  WebRenderCanvasData* AsCanvasData() override { return this; }
    300  UserDataType GetType() override { return UserDataType::eCanvas; }
    301  static UserDataType Type() { return UserDataType::eCanvas; }
    302 
    303  void ClearCanvasRenderer();
    304  WebRenderCanvasRendererAsync* GetCanvasRenderer();
    305  WebRenderCanvasRendererAsync* CreateCanvasRenderer();
    306  bool SetCanvasRenderer(CanvasRenderer* aCanvasRenderer);
    307 
    308  void SetImageContainer(ImageContainer* aImageContainer);
    309  ImageContainer* GetImageContainer();
    310  void ClearImageContainer();
    311 
    312 protected:
    313  RefPtr<WebRenderCanvasRendererAsync> mCanvasRenderer;
    314  RefPtr<ImageContainer> mContainer;
    315 };
    316 
    317 class WebRenderMaskData : public WebRenderUserData {
    318 public:
    319  explicit WebRenderMaskData(RenderRootStateManager* aManager,
    320                             nsDisplayItem* aItem);
    321  explicit WebRenderMaskData(RenderRootStateManager* aManager,
    322                             uint32_t aDisplayItemKey, nsIFrame* aFrame);
    323  virtual ~WebRenderMaskData() {
    324    MOZ_COUNT_DTOR(WebRenderMaskData);
    325    ClearImageKey();
    326  }
    327 
    328  void ClearImageKey();
    329  void Invalidate();
    330 
    331  UserDataType GetType() override { return UserDataType::eMask; }
    332  static UserDataType Type() { return UserDataType::eMask; }
    333 
    334  Maybe<wr::BlobImageKey> mBlobKey;
    335  std::vector<RefPtr<gfx::ScaledFont>> mFonts;
    336  gfx::DrawEventRecorderPrivate_ExternalSurfacesHolder mExternalSurfaces;
    337  LayerIntRect mItemRect;
    338  nsPoint mMaskOffset;
    339  nsStyleImageLayers mMaskStyle;
    340  gfx::MatrixScales mScale;
    341  bool mShouldHandleOpacity;
    342 };
    343 
    344 extern void DestroyWebRenderUserDataTable(WebRenderUserDataTable* aTable);
    345 
    346 struct WebRenderUserDataProperty {
    347  NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(Key, WebRenderUserDataTable,
    348                                      DestroyWebRenderUserDataTable)
    349 };
    350 
    351 template <class T>
    352 already_AddRefed<T> GetWebRenderUserData(const nsIFrame* aFrame,
    353                                         uint32_t aPerFrameKey) {
    354  MOZ_ASSERT(aFrame);
    355  WebRenderUserDataTable* userDataTable =
    356      aFrame->GetProperty(WebRenderUserDataProperty::Key());
    357  if (!userDataTable) {
    358    return nullptr;
    359  }
    360 
    361  WebRenderUserData* data =
    362      userDataTable->GetWeak(WebRenderUserDataKey(aPerFrameKey, T::Type()));
    363  if (data) {
    364    RefPtr<T> result = static_cast<T*>(data);
    365    return result.forget();
    366  }
    367 
    368  return nullptr;
    369 }
    370 
    371 }  // namespace layers
    372 }  // namespace mozilla
    373 
    374 #endif /* GFX_WEBRENDERUSERDATA_H */