gfx/layers/wr/WebRenderUserData.cpp

   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 #include "WebRenderUserData.h"
   8
   9 #include "mozilla/image/WebRenderImageProvider.h"
  10 #include "mozilla/layers/AnimationHelper.h"
  11 #include "mozilla/layers/CompositorBridgeChild.h"
  12 #include "mozilla/layers/ImageClient.h"
  13 #include "mozilla/layers/WebRenderBridgeChild.h"
  14 #include "mozilla/layers/RenderRootStateManager.h"
  15 #include "mozilla/layers/WebRenderMessages.h"
  16 #include "mozilla/layers/IpcResourceUpdateQueue.h"
  17 #include "mozilla/layers/SharedSurfacesChild.h"
  18 #include "mozilla/webgpu/WebGPUChild.h"
  19 #include "nsDisplayListInvalidation.h"
  20 #include "nsIFrame.h"
  21 #include "WebRenderCanvasRenderer.h"
  22
  23 using namespace mozilla::image;
  24
  25 namespace mozilla {
  26 namespace layers {
  27
  28 void WebRenderBackgroundData::AddWebRenderCommands(
  29     wr::DisplayListBuilder& aBuilder) {
  30   aBuilder.PushRect(mBounds, mBounds, true, true, false, mColor);
  31 }
  32
  33 /* static */
  34 bool WebRenderUserData::SupportsAsyncUpdate(nsIFrame* aFrame) {
  35   if (!aFrame) {
  36     return false;
  37   }
  38   RefPtr<WebRenderImageData> data = GetWebRenderUserData<WebRenderImageData>(
  39       aFrame, static_cast<uint32_t>(DisplayItemType::TYPE_VIDEO));
  40   if (data) {
  41     return data->IsAsync();
  42   }
  43
  44   return false;
  45 }
  46
  47 /* static */
  48 bool WebRenderUserData::ProcessInvalidateForImage(nsIFrame* aFrame,
  49                                                   DisplayItemType aType,
  50                                                   ImageProviderId aProviderId) {
  51   MOZ_ASSERT(aFrame);
  52
  53   if (!aFrame->HasProperty(WebRenderUserDataProperty::Key())) {
  54     aFrame->SchedulePaint();
  55     return false;
  56   }
  57
  58   auto type = static_cast<uint32_t>(aType);
  59   RefPtr<WebRenderFallbackData> fallback =
  60       GetWebRenderUserData<WebRenderFallbackData>(aFrame, type);
  61   if (fallback) {
  62     fallback->SetInvalid(true);
  63     aFrame->SchedulePaint();
  64     return true;
  65   }
  66
  67   RefPtr<WebRenderImageProviderData> image =
  68       GetWebRenderUserData<WebRenderImageProviderData>(aFrame, type);
  69   if (image && image->Invalidate(aProviderId)) {
  70     return true;
  71   }
  72
  73   aFrame->SchedulePaint();
  74   return false;
  75 }
  76
  77 WebRenderUserData::WebRenderUserData(RenderRootStateManager* aManager,
  78                                      uint32_t aDisplayItemKey, nsIFrame* aFrame)
  79     : mManager(aManager),
  80       mFrame(aFrame),
  81       mDisplayItemKey(aDisplayItemKey),
  82       mTable(aManager->GetWebRenderUserDataTable()),
  83       mUsed(false) {}
  84
  85 WebRenderUserData::WebRenderUserData(RenderRootStateManager* aManager,
  86                                      nsDisplayItem* aItem)
  87     : mManager(aManager),
  88       mFrame(aItem->Frame()),
  89       mDisplayItemKey(aItem->GetPerFrameKey()),
  90       mTable(aManager->GetWebRenderUserDataTable()),
  91       mUsed(false) {}
  92
  93 WebRenderUserData::~WebRenderUserData() = default;
  94
  95 void WebRenderUserData::RemoveFromTable() { mTable->Remove(this); }
  96
  97 WebRenderBridgeChild* WebRenderUserData::WrBridge() const {
  98   return mManager->WrBridge();
  99 }
 100
 101 WebRenderImageData::WebRenderImageData(RenderRootStateManager* aManager,
 102                                        nsDisplayItem* aItem)
 103     : WebRenderUserData(aManager, aItem) {}
 104
 105 WebRenderImageData::WebRenderImageData(RenderRootStateManager* aManager,
 106                                        uint32_t aDisplayItemKey,
 107                                        nsIFrame* aFrame)
 108     : WebRenderUserData(aManager, aDisplayItemKey, aFrame) {}
 109
 110 WebRenderImageData::~WebRenderImageData() {
 111   ClearImageKey();
 112
 113   if (mPipelineId) {
 114     mManager->RemovePipelineIdForCompositable(mPipelineId.ref());
 115   }
 116 }
 117
 118 void WebRenderImageData::ClearImageKey() {
 119   if (mKey) {
 120     mManager->AddImageKeyForDiscard(mKey.value());
 121     if (mTextureOfImage) {
 122       WrBridge()->ReleaseTextureOfImage(mKey.value());
 123       mTextureOfImage = nullptr;
 124     }
 125     mKey.reset();
 126   }
 127   MOZ_ASSERT(!mTextureOfImage);
 128 }
 129
 130 Maybe<wr::ImageKey> WebRenderImageData::UpdateImageKey(
 131     ImageContainer* aContainer, wr::IpcResourceUpdateQueue& aResources,
 132     bool aFallback) {
 133   MOZ_ASSERT(aContainer);
 134
 135   if (mContainer != aContainer) {
 136     mContainer = aContainer;
 137   }
 138
 139   CreateImageClientIfNeeded();
 140   if (!mImageClient) {
 141     return Nothing();
 142   }
 143
 144   MOZ_ASSERT(mImageClient->AsImageClientSingle());
 145
 146   ImageClientSingle* imageClient = mImageClient->AsImageClientSingle();
 147   uint32_t oldCounter = imageClient->GetLastUpdateGenerationCounter();
 148
 149   bool ret = imageClient->UpdateImage(aContainer);
 150   RefPtr<TextureClient> currentTexture = imageClient->GetForwardedTexture();
 151   if (!ret || !currentTexture) {
 152     // Delete old key
 153     ClearImageKey();
 154     return Nothing();
 155   }
 156
 157   // Reuse old key if generation is not updated.
 158   if (!aFallback &&
 159       oldCounter == imageClient->GetLastUpdateGenerationCounter() && mKey) {
 160     return mKey;
 161   }
 162
 163   // If we already had a texture and the format hasn't changed, better to reuse
 164   // the image keys than create new ones.
 165   bool useUpdate = mKey.isSome() && !!mTextureOfImage && !!currentTexture &&
 166                    mTextureOfImage->GetSize() == currentTexture->GetSize() &&
 167                    mTextureOfImage->GetFormat() == currentTexture->GetFormat();
 168
 169   wr::MaybeExternalImageId extId = currentTexture->GetExternalImageKey();
 170   MOZ_RELEASE_ASSERT(extId.isSome());
 171
 172   if (useUpdate) {
 173     MOZ_ASSERT(mKey.isSome());
 174     MOZ_ASSERT(mTextureOfImage);
 175     aResources.PushExternalImageForTexture(
 176         extId.ref(), mKey.ref(), currentTexture, /* aIsUpdate */ true);
 177   } else {
 178     ClearImageKey();
 179     wr::WrImageKey key = WrBridge()->GetNextImageKey();
 180     aResources.PushExternalImageForTexture(extId.ref(), key, currentTexture,
 181                                            /* aIsUpdate */ false);
 182     mKey = Some(key);
 183   }
 184
 185   mTextureOfImage = currentTexture;
 186   return mKey;
 187 }
 188
 189 already_AddRefed<ImageClient> WebRenderImageData::GetImageClient() {
 190   RefPtr<ImageClient> imageClient = mImageClient;
 191   return imageClient.forget();
 192 }
 193
 194 void WebRenderImageData::CreateAsyncImageWebRenderCommands(
 195     mozilla::wr::DisplayListBuilder& aBuilder, ImageContainer* aContainer,
 196     const StackingContextHelper& aSc, const LayoutDeviceRect& aBounds,
 197     const LayoutDeviceRect& aSCBounds, wr::WrRotation aRotation,
 198     const wr::ImageRendering& aFilter, const wr::MixBlendMode& aMixBlendMode,
 199     bool aIsBackfaceVisible) {
 200   MOZ_ASSERT(aContainer->IsAsync());
 201
 202   if (mPipelineId.isSome() && mContainer != aContainer) {
 203     // In this case, we need to remove the existed pipeline and create new one
 204     // because the ImageContainer is changed.
 205     WrBridge()->RemovePipelineIdForCompositable(mPipelineId.ref());
 206     mPipelineId.reset();
 207   }
 208
 209   if (!mPipelineId) {
 210     // Alloc async image pipeline id.
 211     mPipelineId =
 212         Some(WrBridge()->GetCompositorBridgeChild()->GetNextPipelineId());
 213     WrBridge()->AddPipelineIdForCompositable(
 214         mPipelineId.ref(), aContainer->GetAsyncContainerHandle(),
 215         CompositableHandleOwner::ImageBridge);
 216     mContainer = aContainer;
 217   }
 218   MOZ_ASSERT(!mImageClient);
 219
 220   // Push IFrame for async image pipeline.
 221   //
 222   // We don't push a stacking context for this async image pipeline here.
 223   // Instead, we do it inside the iframe that hosts the image. As a result,
 224   // a bunch of the calculations normally done as part of that stacking
 225   // context need to be done manually and pushed over to the parent side,
 226   // where it will be done when we build the display list for the iframe.
 227   // That happens in AsyncImagePipelineManager.
 228   aBuilder.PushIFrame(aBounds, aIsBackfaceVisible, mPipelineId.ref(),
 229                       /*ignoreMissingPipelines*/ false);
 230
 231   WrBridge()->AddWebRenderParentCommand(OpUpdateAsyncImagePipeline(
 232       mPipelineId.value(), aSCBounds, aRotation, aFilter, aMixBlendMode));
 233 }
 234
 235 void WebRenderImageData::CreateImageClientIfNeeded() {
 236   if (!mImageClient) {
 237     mImageClient = ImageClient::CreateImageClient(
 238         CompositableType::IMAGE, WrBridge(), TextureFlags::DEFAULT);
 239     if (!mImageClient) {
 240       return;
 241     }
 242
 243     mImageClient->Connect();
 244   }
 245 }
 246
 247 WebRenderImageProviderData::WebRenderImageProviderData(
 248     RenderRootStateManager* aManager, nsDisplayItem* aItem)
 249     : WebRenderUserData(aManager, aItem) {}
 250
 251 WebRenderImageProviderData::WebRenderImageProviderData(
 252     RenderRootStateManager* aManager, uint32_t aDisplayItemKey,
 253     nsIFrame* aFrame)
 254     : WebRenderUserData(aManager, aDisplayItemKey, aFrame) {}
 255
 256 WebRenderImageProviderData::~WebRenderImageProviderData() = default;
 257
 258 Maybe<wr::ImageKey> WebRenderImageProviderData::UpdateImageKey(
 259     WebRenderImageProvider* aProvider, ImgDrawResult aDrawResult,
 260     wr::IpcResourceUpdateQueue& aResources) {
 261   if (mProvider != aProvider) {
 262     mProvider = aProvider;
 263   }
 264
 265   wr::ImageKey key = {};
 266   nsresult rv = mProvider ? mProvider->UpdateKey(mManager, aResources, key)
 267                           : NS_ERROR_FAILURE;
 268   mKey = NS_SUCCEEDED(rv) ? Some(key) : Nothing();
 269   mDrawResult = aDrawResult;
 270   return mKey;
 271 }
 272
 273 bool WebRenderImageProviderData::Invalidate(ImageProviderId aProviderId) const {
 274   if (!aProviderId || !mProvider || mProvider->GetProviderId() != aProviderId ||
 275       !mKey) {
 276     return false;
 277   }
 278
 279   if (mDrawResult != ImgDrawResult::SUCCESS &&
 280       mDrawResult != ImgDrawResult::BAD_IMAGE) {
 281     return false;
 282   }
 283
 284   wr::ImageKey key = {};
 285   nsresult rv =
 286       mProvider->UpdateKey(mManager, mManager->AsyncResourceUpdates(), key);
 287   return NS_SUCCEEDED(rv) && mKey.ref() == key;
 288 }
 289
 290 WebRenderFallbackData::WebRenderFallbackData(RenderRootStateManager* aManager,
 291                                              nsDisplayItem* aItem)
 292     : WebRenderUserData(aManager, aItem), mOpacity(1.0f), mInvalid(false) {}
 293
 294 WebRenderFallbackData::~WebRenderFallbackData() { ClearImageKey(); }
 295
 296 void WebRenderFallbackData::SetBlobImageKey(const wr::BlobImageKey& aKey) {
 297   ClearImageKey();
 298   mBlobKey = Some(aKey);
 299 }
 300
 301 Maybe<wr::ImageKey> WebRenderFallbackData::GetImageKey() {
 302   if (mBlobKey) {
 303     return Some(wr::AsImageKey(mBlobKey.value()));
 304   }
 305
 306   if (mImageData) {
 307     return mImageData->GetImageKey();
 308   }
 309
 310   return Nothing();
 311 }
 312
 313 void WebRenderFallbackData::ClearImageKey() {
 314   if (mImageData) {
 315     mImageData->ClearImageKey();
 316     mImageData = nullptr;
 317   }
 318
 319   if (mBlobKey) {
 320     mManager->AddBlobImageKeyForDiscard(mBlobKey.value());
 321     mBlobKey.reset();
 322   }
 323 }
 324
 325 WebRenderImageData* WebRenderFallbackData::PaintIntoImage() {
 326   if (mBlobKey) {
 327     mManager->AddBlobImageKeyForDiscard(mBlobKey.value());
 328     mBlobKey.reset();
 329   }
 330
 331   if (mImageData) {
 332     return mImageData.get();
 333   }
 334
 335   mImageData = MakeAndAddRef<WebRenderImageData>(mManager.get(),
 336                                                  mDisplayItemKey, mFrame);
 337
 338   return mImageData.get();
 339 }
 340
 341 WebRenderAPZAnimationData::WebRenderAPZAnimationData(
 342     RenderRootStateManager* aManager, nsDisplayItem* aItem)
 343     : WebRenderUserData(aManager, aItem),
 344       mAnimationId(AnimationHelper::GetNextCompositorAnimationsId()) {}
 345
 346 WebRenderAnimationData::WebRenderAnimationData(RenderRootStateManager* aManager,
 347                                                nsDisplayItem* aItem)
 348     : WebRenderUserData(aManager, aItem) {}
 349
 350 WebRenderAnimationData::~WebRenderAnimationData() {
 351   // It may be the case that nsDisplayItem that created this WebRenderUserData
 352   // gets destroyed without getting a chance to discard the compositor animation
 353   // id, so we should do it as part of cleanup here.
 354   uint64_t animationId = mAnimationInfo.GetCompositorAnimationsId();
 355   // animationId might be 0 if mAnimationInfo never held any active animations.
 356   if (animationId) {
 357     mManager->AddCompositorAnimationsIdForDiscard(animationId);
 358   }
 359 }
 360
 361 WebRenderCanvasData::WebRenderCanvasData(RenderRootStateManager* aManager,
 362                                          nsDisplayItem* aItem)
 363     : WebRenderUserData(aManager, aItem) {}
 364
 365 WebRenderCanvasData::~WebRenderCanvasData() {
 366   if (mCanvasRenderer) {
 367     mCanvasRenderer->ClearCachedResources();
 368   }
 369 }
 370
 371 void WebRenderCanvasData::ClearCanvasRenderer() { mCanvasRenderer = nullptr; }
 372
 373 WebRenderCanvasRendererAsync* WebRenderCanvasData::GetCanvasRenderer() {
 374   return mCanvasRenderer.get();
 375 }
 376
 377 WebRenderCanvasRendererAsync* WebRenderCanvasData::CreateCanvasRenderer() {
 378   mCanvasRenderer = new WebRenderCanvasRendererAsync(mManager);
 379   return mCanvasRenderer.get();
 380 }
 381
 382 bool WebRenderCanvasData::SetCanvasRenderer(CanvasRenderer* aCanvasRenderer) {
 383   if (!aCanvasRenderer || !aCanvasRenderer->AsWebRenderCanvasRendererAsync()) {
 384     return false;
 385   }
 386
 387   auto* renderer = aCanvasRenderer->AsWebRenderCanvasRendererAsync();
 388   if (mManager != renderer->GetRenderRootStateManager()) {
 389     return false;
 390   }
 391
 392   mCanvasRenderer = renderer;
 393   return true;
 394 }
 395
 396 void WebRenderCanvasData::SetImageContainer(ImageContainer* aImageContainer) {
 397   mContainer = aImageContainer;
 398 }
 399
 400 ImageContainer* WebRenderCanvasData::GetImageContainer() {
 401   if (!mContainer) {
 402     mContainer = MakeAndAddRef<ImageContainer>();
 403   }
 404   return mContainer;
 405 }
 406
 407 void WebRenderCanvasData::ClearImageContainer() { mContainer = nullptr; }
 408
 409 WebRenderRemoteData::WebRenderRemoteData(RenderRootStateManager* aManager,
 410                                          nsDisplayItem* aItem)
 411     : WebRenderUserData(aManager, aItem) {}
 412
 413 WebRenderRemoteData::~WebRenderRemoteData() {
 414   if (mRemoteBrowser) {
 415     mRemoteBrowser->UpdateEffects(mozilla::dom::EffectsInfo::FullyHidden());
 416   }
 417 }
 418
 419 void DestroyWebRenderUserDataTable(WebRenderUserDataTable* aTable) {
 420   for (const auto& value : aTable->Values()) {
 421     value->RemoveFromTable();
 422   }
 423   delete aTable;
 424 }
 425
 426 }  // namespace layers
 427 }  // namespace mozilla