dom/webgpu/CanvasContext.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/dom/WebGPUBinding.h"
   7 #include "CanvasContext.h"
   8 #include "gfxUtils.h"
   9 #include "LayerUserData.h"
  10 #include "nsDisplayList.h"
  11 #include "mozilla/dom/HTMLCanvasElement.h"
  12 #include "mozilla/gfx/CanvasManagerChild.h"
  13 #include "mozilla/layers/CanvasRenderer.h"
  14 #include "mozilla/layers/ImageDataSerializer.h"
  15 #include "mozilla/layers/LayersSurfaces.h"
  16 #include "mozilla/layers/RenderRootStateManager.h"
  17 #include "mozilla/layers/WebRenderCanvasRenderer.h"
  18 #include "mozilla/StaticPrefs_privacy.h"
  19 #include "mozilla/SVGObserverUtils.h"
  20 #include "ipc/WebGPUChild.h"
  21
  22 namespace mozilla {
  23
  24 inline void ImplCycleCollectionTraverse(
  25     nsCycleCollectionTraversalCallback& aCallback,
  26     dom::GPUCanvasConfiguration& aField, const char* aName, uint32_t aFlags) {
  27   aField.TraverseForCC(aCallback, aFlags);
  28 }
  29
  30 inline void ImplCycleCollectionUnlink(dom::GPUCanvasConfiguration& aField) {
  31   aField.UnlinkForCC();
  32 }
  33
  34 // -
  35
  36 template <class T>
  37 inline void ImplCycleCollectionTraverse(
  38     nsCycleCollectionTraversalCallback& aCallback,
  39     const std::unique_ptr<T>& aField, const char* aName, uint32_t aFlags) {
  40   if (aField) {
  41     ImplCycleCollectionTraverse(aCallback, *aField, aName, aFlags);
  42   }
  43 }
  44
  45 template <class T>
  46 inline void ImplCycleCollectionUnlink(std::unique_ptr<T>& aField) {
  47   aField = nullptr;
  48 }
  49
  50 }  // namespace mozilla
  51
  52 // -
  53
  54 namespace mozilla::webgpu {
  55
  56 NS_IMPL_CYCLE_COLLECTING_ADDREF(CanvasContext)
  57 NS_IMPL_CYCLE_COLLECTING_RELEASE(CanvasContext)
  58
  59 GPU_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(CanvasContext, mConfig,
  60                                                 mTexture, mBridge,
  61                                                 mCanvasElement,
  62                                                 mOffscreenCanvas)
  63
  64 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CanvasContext)
  65   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  66   NS_INTERFACE_MAP_ENTRY(nsICanvasRenderingContextInternal)
  67   NS_INTERFACE_MAP_ENTRY(nsISupports)
  68 NS_INTERFACE_MAP_END
  69
  70 // -
  71
  72 CanvasContext::CanvasContext() = default;
  73
  74 CanvasContext::~CanvasContext() {
  75   Cleanup();
  76   RemovePostRefreshObserver();
  77 }
  78
  79 void CanvasContext::Cleanup() { Unconfigure(); }
  80
  81 JSObject* CanvasContext::WrapObject(JSContext* aCx,
  82                                     JS::Handle<JSObject*> aGivenProto) {
  83   return dom::GPUCanvasContext_Binding::Wrap(aCx, this, aGivenProto);
  84 }
  85
  86 // -
  87
  88 void CanvasContext::GetCanvas(
  89     dom::OwningHTMLCanvasElementOrOffscreenCanvas& aRetVal) const {
  90   if (mCanvasElement) {
  91     aRetVal.SetAsHTMLCanvasElement() = mCanvasElement;
  92   } else if (mOffscreenCanvas) {
  93     aRetVal.SetAsOffscreenCanvas() = mOffscreenCanvas;
  94   } else {
  95     MOZ_CRASH(
  96         "This should only happen briefly during CC Unlink, and no JS should "
  97         "happen then.");
  98   }
  99 }
 100
 101 void CanvasContext::Configure(const dom::GPUCanvasConfiguration& aConfig) {
 102   Unconfigure();
 103
 104   // Bug 1864904: Failures in validation should throw a TypeError, per spec.
 105
 106   // these formats are guaranteed by the spec
 107   switch (aConfig.mFormat) {
 108     case dom::GPUTextureFormat::Rgba8unorm:
 109     case dom::GPUTextureFormat::Rgba8unorm_srgb:
 110       mGfxFormat = gfx::SurfaceFormat::R8G8B8A8;
 111       break;
 112     case dom::GPUTextureFormat::Bgra8unorm:
 113     case dom::GPUTextureFormat::Bgra8unorm_srgb:
 114       mGfxFormat = gfx::SurfaceFormat::B8G8R8A8;
 115       break;
 116     default:
 117       NS_WARNING("Specified swap chain format is not supported");
 118       return;
 119   }
 120
 121   mConfig.reset(new dom::GPUCanvasConfiguration(aConfig));
 122   mRemoteTextureOwnerId = Some(layers::RemoteTextureOwnerId::GetNext());
 123   mUseExternalTextureInSwapChain =
 124       wgpu_client_use_external_texture_in_swapChain(
 125           aConfig.mDevice->mId,
 126           WebGPUChild::ConvertTextureFormat(aConfig.mFormat));
 127   mTexture = aConfig.mDevice->InitSwapChain(
 128       mConfig.get(), mRemoteTextureOwnerId.ref(),
 129       mUseExternalTextureInSwapChain, mGfxFormat, mCanvasSize);
 130   if (!mTexture) {
 131     Unconfigure();
 132     return;
 133   }
 134
 135   mTexture->mTargetContext = this;
 136   mBridge = aConfig.mDevice->GetBridge();
 137   if (mCanvasElement) {
 138     mWaitingCanvasRendererInitialized = true;
 139   }
 140
 141   ForceNewFrame();
 142 }
 143
 144 void CanvasContext::Unconfigure() {
 145   if (mBridge && mBridge->IsOpen() && mRemoteTextureOwnerId.isSome()) {
 146     mBridge->SendSwapChainDrop(*mRemoteTextureOwnerId);
 147   }
 148   mRemoteTextureOwnerId = Nothing();
 149   mBridge = nullptr;
 150   mConfig = nullptr;
 151   mTexture = nullptr;
 152   mGfxFormat = gfx::SurfaceFormat::UNKNOWN;
 153 }
 154
 155 NS_IMETHODIMP CanvasContext::SetDimensions(int32_t aWidth, int32_t aHeight) {
 156   aWidth = std::max(1, aWidth);
 157   aHeight = std::max(1, aHeight);
 158   const auto newSize = gfx::IntSize{aWidth, aHeight};
 159   if (newSize == mCanvasSize) return NS_OK;  // No-op no-change resizes.
 160
 161   mCanvasSize = newSize;
 162   if (mConfig) {
 163     const auto copy = dom::GPUCanvasConfiguration{
 164         *mConfig};  // So we can't null it out on ourselves.
 165     Configure(copy);
 166   }
 167   return NS_OK;
 168 }
 169
 170 RefPtr<Texture> CanvasContext::GetCurrentTexture(ErrorResult& aRv) {
 171   if (!mTexture) {
 172     aRv.ThrowOperationError("Canvas not configured");
 173     return nullptr;
 174   }
 175
 176   MOZ_ASSERT(mConfig);
 177   MOZ_ASSERT(mRemoteTextureOwnerId.isSome());
 178
 179   if (mNewTextureRequested) {
 180     mNewTextureRequested = false;
 181
 182     mTexture = mConfig->mDevice->CreateTextureForSwapChain(
 183         mConfig.get(), mCanvasSize, mRemoteTextureOwnerId.ref());
 184     mTexture->mTargetContext = this;
 185   }
 186   return mTexture;
 187 }
 188
 189 void CanvasContext::MaybeQueueSwapChainPresent() {
 190   if (mPendingSwapChainPresent) {
 191     return;
 192   }
 193
 194   mPendingSwapChainPresent = true;
 195
 196   if (mWaitingCanvasRendererInitialized) {
 197     return;
 198   }
 199
 200   InvalidateCanvasContent();
 201 }
 202
 203 Maybe<layers::SurfaceDescriptor> CanvasContext::SwapChainPresent() {
 204   mPendingSwapChainPresent = false;
 205   if (!mBridge || !mBridge->IsOpen() || mRemoteTextureOwnerId.isNothing() ||
 206       !mTexture) {
 207     return Nothing();
 208   }
 209   mLastRemoteTextureId = Some(layers::RemoteTextureId::GetNext());
 210   mBridge->SwapChainPresent(mTexture->mId, *mLastRemoteTextureId,
 211                             *mRemoteTextureOwnerId);
 212   if (mUseExternalTextureInSwapChain) {
 213     mTexture->Destroy();
 214     mNewTextureRequested = true;
 215   }
 216   return Some(layers::SurfaceDescriptorRemoteTexture(*mLastRemoteTextureId,
 217                                                      *mRemoteTextureOwnerId));
 218 }
 219
 220 bool CanvasContext::UpdateWebRenderCanvasData(
 221     mozilla::nsDisplayListBuilder* aBuilder, WebRenderCanvasData* aCanvasData) {
 222   auto* renderer = aCanvasData->GetCanvasRenderer();
 223
 224   if (renderer && mRemoteTextureOwnerId.isSome() &&
 225       renderer->GetRemoteTextureOwnerIdOfPushCallback() ==
 226           mRemoteTextureOwnerId) {
 227     return true;
 228   }
 229
 230   renderer = aCanvasData->CreateCanvasRenderer();
 231   if (!InitializeCanvasRenderer(aBuilder, renderer)) {
 232     // Clear CanvasRenderer of WebRenderCanvasData
 233     aCanvasData->ClearCanvasRenderer();
 234     return false;
 235   }
 236   return true;
 237 }
 238
 239 bool CanvasContext::InitializeCanvasRenderer(
 240     nsDisplayListBuilder* aBuilder, layers::CanvasRenderer* aRenderer) {
 241   if (mRemoteTextureOwnerId.isNothing()) {
 242     return false;
 243   }
 244
 245   layers::CanvasRendererData data;
 246   data.mContext = this;
 247   data.mSize = mCanvasSize;
 248   data.mIsOpaque = false;
 249   data.mRemoteTextureOwnerIdOfPushCallback = mRemoteTextureOwnerId;
 250
 251   aRenderer->Initialize(data);
 252   aRenderer->SetDirty();
 253
 254   if (mWaitingCanvasRendererInitialized) {
 255     InvalidateCanvasContent();
 256   }
 257   mWaitingCanvasRendererInitialized = false;
 258
 259   return true;
 260 }
 261
 262 mozilla::UniquePtr<uint8_t[]> CanvasContext::GetImageBuffer(
 263     int32_t* out_format, gfx::IntSize* out_imageSize) {
 264   *out_format = 0;
 265   *out_imageSize = {};
 266
 267   gfxAlphaType any;
 268   RefPtr<gfx::SourceSurface> snapshot = GetSurfaceSnapshot(&any);
 269   if (!snapshot) {
 270     return nullptr;
 271   }
 272
 273   RefPtr<gfx::DataSourceSurface> dataSurface = snapshot->GetDataSurface();
 274   *out_imageSize = dataSurface->GetSize();
 275
 276   if (ShouldResistFingerprinting(RFPTarget::CanvasRandomization)) {
 277     gfxUtils::GetImageBufferWithRandomNoise(
 278         dataSurface,
 279         /* aIsAlphaPremultiplied */ true, GetCookieJarSettings(), &*out_format);
 280   }
 281
 282   return gfxUtils::GetImageBuffer(dataSurface, /* aIsAlphaPremultiplied */ true,
 283                                   &*out_format);
 284 }
 285
 286 NS_IMETHODIMP CanvasContext::GetInputStream(const char* aMimeType,
 287                                             const nsAString& aEncoderOptions,
 288                                             nsIInputStream** aStream) {
 289   gfxAlphaType any;
 290   RefPtr<gfx::SourceSurface> snapshot = GetSurfaceSnapshot(&any);
 291   if (!snapshot) {
 292     return NS_ERROR_FAILURE;
 293   }
 294
 295   RefPtr<gfx::DataSourceSurface> dataSurface = snapshot->GetDataSurface();
 296
 297   if (ShouldResistFingerprinting(RFPTarget::CanvasRandomization)) {
 298     gfxUtils::GetInputStreamWithRandomNoise(
 299         dataSurface, /* aIsAlphaPremultiplied */ true, aMimeType,
 300         aEncoderOptions, GetCookieJarSettings(), aStream);
 301   }
 302
 303   return gfxUtils::GetInputStream(dataSurface, /* aIsAlphaPremultiplied */ true,
 304                                   aMimeType, aEncoderOptions, aStream);
 305 }
 306
 307 already_AddRefed<mozilla::gfx::SourceSurface> CanvasContext::GetSurfaceSnapshot(
 308     gfxAlphaType* aOutAlphaType) {
 309   if (aOutAlphaType) {
 310     *aOutAlphaType = gfxAlphaType::Premult;
 311   }
 312
 313   auto* const cm = gfx::CanvasManagerChild::Get();
 314   if (!cm) {
 315     return nullptr;
 316   }
 317
 318   if (!mBridge || !mBridge->IsOpen() || mRemoteTextureOwnerId.isNothing()) {
 319     return nullptr;
 320   }
 321
 322   MOZ_ASSERT(mRemoteTextureOwnerId.isSome());
 323   return cm->GetSnapshot(cm->Id(), mBridge->Id(), mRemoteTextureOwnerId,
 324                          mGfxFormat, /* aPremultiply */ false,
 325                          /* aYFlip */ false);
 326 }
 327
 328 Maybe<layers::SurfaceDescriptor> CanvasContext::GetFrontBuffer(
 329     WebGLFramebufferJS*, const bool) {
 330   // With canvas element, remote texture push callback pushes remote texture
 331   // from RemoteTextureMap to WebRenderImageHost. With offscreen canvas, the
 332   // push callback is not used. remote texture is notified from
 333   // ShareableCanvasRenderer to WebRenderImageHost.
 334   if (mPendingSwapChainPresent) {
 335     auto desc = SwapChainPresent();
 336     MOZ_ASSERT(!mPendingSwapChainPresent);
 337     return desc;
 338   }
 339   return Nothing();
 340 }
 341
 342 void CanvasContext::ForceNewFrame() {
 343   if (!mCanvasElement && !mOffscreenCanvas) {
 344     return;
 345   }
 346
 347   // Force a new frame to be built, which will execute the
 348   // `CanvasContextType::WebGPU` switch case in `CreateWebRenderCommands` and
 349   // populate the WR user data.
 350   if (mCanvasElement) {
 351     mCanvasElement->InvalidateCanvas();
 352   } else if (mOffscreenCanvas) {
 353     dom::OffscreenCanvasDisplayData data;
 354     data.mSize = mCanvasSize;
 355     data.mIsOpaque = false;
 356     data.mOwnerId = mRemoteTextureOwnerId;
 357     mOffscreenCanvas->UpdateDisplayData(data);
 358   }
 359 }
 360
 361 void CanvasContext::InvalidateCanvasContent() {
 362   if (!mCanvasElement && !mOffscreenCanvas) {
 363     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 364     return;
 365   }
 366
 367   if (mCanvasElement) {
 368     SVGObserverUtils::InvalidateDirectRenderingObservers(mCanvasElement);
 369     mCanvasElement->InvalidateCanvasContent(nullptr);
 370   } else if (mOffscreenCanvas) {
 371     mOffscreenCanvas->QueueCommitToCompositor();
 372   }
 373 }
 374
 375 }  // namespace mozilla::webgpu