Revert "Bug 1979100 - Add infrastructure for importing video frames into wgpu textures. r=webgpu-reviewers,webidl,teoxoy,smaug" for causing build bustages on ExternalTexture.h

This reverts commit 8c62114.

Revert "Bug 1979100 - Move ErrorBuffer declaration to WebGPUParent.h. r=webgpu-reviewers,teoxoy"

This reverts commit 02e5b2a.

Author: CosminSabou

dom/webgpu/ExternalTexture.cpp

@@ -6,28 +6,10 @@
 #ifndef ExternalTexture_H_
 #define ExternalTexture_H_
 
-#include <array>
-
 #include "ObjectModel.h"
-#include "mozilla/Span.h"
-#include "mozilla/gfx/Types.h"
-#include "mozilla/webgpu/WebGPUTypes.h"
 #include "nsIGlobalObject.h"
-#include "nsTArrayForwardDeclare.h"
-
-namespace mozilla {
-namespace dom {
-class OwningHTMLVideoElementOrVideoFrame;
-}
-namespace layers {
-class BufferDescriptor;
-class Image;
-}  // namespace layers
-
-namespace webgpu {
 
-class Device;
-class WebGPUParent;
+namespace mozilla::webgpu {
 
 // NOTE: Incomplete. Follow-up to complete implementation is at
 // <https://bugzilla.mozilla.org/show_bug.cgi?id=1827116>.
@@ -47,96 +29,6 @@ class ExternalTexture : public ObjectBase {
   void Cleanup() {}
 };
 
-// The client side of an imported external texture source. This gets imported
-// from either an HTMLVideoElement or a VideoFrame. ExternalTextures can then
-// be created from a source. It is important to separate the source from the
-// external texture as multiple external textures can be created from the same
-// source.
-// The client side is responsible for creating and destroying the host side.
-// Any external texture created from this source must ensure the source remains
-// alive as long as it is required by the external texture, by holding a strong
-// reference.
-class ExternalTextureSourceClient {
-  NS_INLINE_DECL_REFCOUNTING(ExternalTextureSourceClient)
-
- public:
-  // Creates an ExternalTextureSourceClient from a video element or video frame.
-  // Returns nullptr on failure. Throws security error if the source is not
-  // origin-clean.
-  static already_AddRefed<ExternalTextureSourceClient> Create(
-      Device* aDevice, const dom::OwningHTMLVideoElementOrVideoFrame& aSource,
-      ErrorResult& aRv);
-
-  const RawId mId;
-
-  // External texture sources can consist of up to 3 planes of texture data, but
-  // on the client side we do not know how many planes will actually be
-  // required. We therefore unconditionally make IDs for 3 textures and 3
-  // texture views, and the host side will only use the IDs that it requires.
-  const std::array<RawId, 3> mTextureIds;
-  const std::array<RawId, 3> mViewIds;
-
- private:
-  ExternalTextureSourceClient(WebGPUChild* aBridge, RawId aId,
-                              const std::array<RawId, 3>& aTextureIds,
-                              const std::array<RawId, 3>& aViewIds);
-  ~ExternalTextureSourceClient();
-
-  // Used to free resources on the host side when we are destroyed, if the
-  // bridge is still valid.
-  const WeakPtr<WebGPUChild> mBridge;
-};
-
-// Host side of an external texture source. This is responsible for creating
-// and managing the lifecycle of the wgpu textures and texture views created
-// from the provided SurfaceDescriptor.
-class ExternalTextureSourceHost {
- public:
-  // Creates an external texture source from a descriptor. If this fails it
-  // will create an external texture source in an error state, which will be
-  // propagated to any external textures created from it.
-  static ExternalTextureSourceHost Create(
-      WebGPUParent* aParent, RawId aDeviceId, RawId aQueueId,
-      const ExternalTextureSourceDescriptor& aDesc);
-
-  // Texture and TextureView IDs used by the source. These will be a subset of
-  // the IDs provided by the client in the descriptor.
-  Span<const RawId> TextureIds() const { return mTextureIds; }
-  Span<const RawId> ViewIds() const { return mViewIds; }
-
- private:
-  ExternalTextureSourceHost(Span<const RawId> aTextureIds,
-                            Span<const RawId> aViewIds, gfx::IntSize aSize,
-                            gfx::SurfaceFormat aFormat,
-                            gfx::YUVRangedColorSpace aColorSpace,
-                            const std::array<float, 6>& aSampleTransform,
-                            const std::array<float, 6>& aLoadTransform);
-
-  static ExternalTextureSourceHost CreateFromBufferDesc(
-      WebGPUParent* aParent, RawId aDeviceId, RawId aQueueId,
-      const ExternalTextureSourceDescriptor& aDesc,
-      const layers::BufferDescriptor& aSd, uint8_t* aBuffer);
-
-  // Creates an external texture source in an error state that will be
-  // propagated to any external textures created from it.
-  static ExternalTextureSourceHost CreateError();
-
-  // These should be const but can't be else we wouldn't be move constructible.
-  // While we are always provided with 3 texture IDs and 3 view IDs by the
-  // client, we only store here the IDs that are actually used. For example an
-  // RGBA format source will only require 1 texture and 1 view. NV12 will
-  // require 2 views, and either 1 or 2 textures depending on whether the
-  // platform natively supports NV12 format textures.
-  AutoTArray<RawId, 3> mTextureIds;
-  AutoTArray<RawId, 3> mViewIds;
-  const gfx::IntSize mSize;
-  MOZ_MAYBE_UNUSED const gfx::SurfaceFormat mFormat;
-  MOZ_MAYBE_UNUSED const gfx::YUVRangedColorSpace mColorSpace;
-  MOZ_MAYBE_UNUSED const std::array<float, 6> mSampleTransform;
-  MOZ_MAYBE_UNUSED const std::array<float, 6> mLoadTransform;
-};
-
-}  // namespace webgpu
-}  // namespace mozilla
+}  // namespace mozilla::webgpu
 
 #endif  // GPU_ExternalTexture_H_

dom/webgpu/ExternalTexture.h

@@ -15,7 +15,6 @@ using mozilla::dom::GPUErrorFilter from "mozilla/dom/WebGPUBinding.h";
 using mozilla::dom::GPURequestAdapterOptions from "mozilla/dom/WebGPUBinding.h";
 using mozilla::dom::GPUCommandBufferDescriptor from "mozilla/dom/WebGPUBinding.h";
 using mozilla::dom::GPUBufferDescriptor from "mozilla/dom/WebGPUBinding.h";
-using mozilla::webgpu::ExternalTextureSourceDescriptor from "mozilla/webgpu/WebGPUTypes.h";
 using mozilla::webgpu::PopErrorScopeResult from "mozilla/webgpu/WebGPUTypes.h";
 using mozilla::webgpu::WebGPUCompilationMessage from "mozilla/webgpu/WebGPUTypes.h";
 [MoveOnly] using mozilla::ipc::MutableSharedMemoryHandle from "mozilla/ipc/SharedMemoryHandle.h";
@@ -43,16 +42,6 @@ async protocol PWebGPU
 parent:
   async Messages(uint32_t nrOfMessages, ByteBuf serializedMessages, ByteBuf[] dataBuffers, MutableSharedMemoryHandle[] shmems);
 
-  // Ideally this would be sent in Messages(), but we need to implement
-  // SurfaceDescriptor serialization first.
-  async CreateExternalTextureSource(
-    RawId deviceId,
-    RawId queueId,
-    RawId externalTextureSourceId,
-    ExternalTextureSourceDescriptor aDesc
-  );
-
-
 child:
   async ServerMessage(ByteBuf buf);
 

dom/webgpu/ipc/PWebGPU.ipdl

@@ -7,7 +7,6 @@
 
 #include <unordered_set>
 
-#include "ExternalTexture.h"
 #include "mozilla/PodOperations.h"
 #include "mozilla/ScopeExit.h"
 #include "mozilla/dom/WebGPUBinding.h"
@@ -172,18 +171,6 @@ extern void wgpu_server_remove_shared_texture(WGPUWebGPUParentPtr aParent,
   parent->RemoveSharedTexture(aId);
 }
 
-extern void wgpu_parent_destroy_external_texture_source(
-    WGPUWebGPUParentPtr aParent, WGPUExternalTextureSourceId aId) {
-  auto* const parent = static_cast<WebGPUParent*>(aParent);
-  parent->DestroyExternalTextureSource(aId);
-}
-
-extern void wgpu_parent_drop_external_texture_source(
-    WGPUWebGPUParentPtr aParent, WGPUExternalTextureSourceId aId) {
-  auto* const parent = static_cast<WebGPUParent*>(aParent);
-  parent->DropExternalTextureSource(aId);
-}
-
 extern void wgpu_server_dealloc_buffer_shmem(WGPUWebGPUParentPtr aParent,
                                              WGPUBufferId aId) {
   auto* parent = static_cast<WebGPUParent*>(aParent);
@@ -371,60 +358,95 @@ extern void wgpu_parent_send_server_message(WGPUWebGPUParentPtr aParent,
 
 }  // namespace ffi
 
-ErrorBuffer::ErrorBuffer() { mMessageUtf8[0] = 0; }
+// A fixed-capacity buffer for receiving textual error messages from
+// `wgpu_bindings`.
+//
+// The `ToFFI` method returns an `ffi::WGPUErrorBuffer` pointing to our
+// buffer, for you to pass to fallible FFI-visible `wgpu_bindings`
+// functions. These indicate failure by storing an error message in the
+// buffer, which you can retrieve by calling `GetError`.
+//
+// If you call `ToFFI` on this type, you must also call `GetError` to check for
+// an error. Otherwise, the destructor asserts.
+//
+// TODO: refactor this to avoid stack-allocating the buffer all the time.
+class ErrorBuffer {
+  // if the message doesn't fit, it will be truncated
+  static constexpr unsigned BUFFER_SIZE = 512;
+  ffi::WGPUErrorBufferType mType = ffi::WGPUErrorBufferType_None;
+  char mMessageUtf8[BUFFER_SIZE] = {};
+  bool mAwaitingGetError = false;
+  RawId mDeviceId = 0;
 
-ErrorBuffer::~ErrorBuffer() { MOZ_ASSERT(!mAwaitingGetError); }
+ public:
+  ErrorBuffer() { mMessageUtf8[0] = 0; }
+  ErrorBuffer(const ErrorBuffer&) = delete;
+  ~ErrorBuffer() { MOZ_ASSERT(!mAwaitingGetError); }
+
+  ffi::WGPUErrorBuffer ToFFI() {
+    mAwaitingGetError = true;
+    ffi::WGPUErrorBuffer errorBuf = {&mType, mMessageUtf8, BUFFER_SIZE,
+                                     &mDeviceId};
+    return errorBuf;
+  }
+
+  ffi::WGPUErrorBufferType GetType() { return mType; }
+
+  static Maybe<dom::GPUErrorFilter> ErrorTypeToFilterType(
+      ffi::WGPUErrorBufferType aType) {
+    switch (aType) {
+      case ffi::WGPUErrorBufferType_None:
+      case ffi::WGPUErrorBufferType_DeviceLost:
+        return {};
+      case ffi::WGPUErrorBufferType_Internal:
+        return Some(dom::GPUErrorFilter::Internal);
+      case ffi::WGPUErrorBufferType_Validation:
+        return Some(dom::GPUErrorFilter::Validation);
+      case ffi::WGPUErrorBufferType_OutOfMemory:
+        return Some(dom::GPUErrorFilter::Out_of_memory);
+      case ffi::WGPUErrorBufferType_Sentinel:
+        break;
+    }
 
-ffi::WGPUErrorBuffer ErrorBuffer::ToFFI() {
-  mAwaitingGetError = true;
-  ffi::WGPUErrorBuffer errorBuf = {&mType, mMessageUtf8, BUFFER_SIZE,
-                                   &mDeviceId};
-  return errorBuf;
-}
+    MOZ_CRASH("invalid `ErrorBufferType`");
+  }
 
-ffi::WGPUErrorBufferType ErrorBuffer::GetType() { return mType; }
+  struct Error {
+    dom::GPUErrorFilter type;
+    bool isDeviceLost;
+    nsCString message;
+    RawId deviceId;
+  };
 
-Maybe<dom::GPUErrorFilter> ErrorBuffer::ErrorTypeToFilterType(
-    ffi::WGPUErrorBufferType aType) {
-  switch (aType) {
-    case ffi::WGPUErrorBufferType_None:
-    case ffi::WGPUErrorBufferType_DeviceLost:
+  // Retrieve the error message was stored in this buffer. Asserts that
+  // this instance actually contains an error (viz., that `GetType() !=
+  // ffi::WGPUErrorBufferType_None`).
+  //
+  // Mark this `ErrorBuffer` as having been handled, so its destructor
+  // won't assert.
+  Maybe<Error> GetError() {
+    mAwaitingGetError = false;
+    if (mType == ffi::WGPUErrorBufferType_DeviceLost) {
+      // This error is for a lost device, so we return an Error struct
+      // with the isDeviceLost bool set to true. It doesn't matter what
+      // GPUErrorFilter type we use, so we just use Validation. The error
+      // will not be reported.
+      return Some(Error{dom::GPUErrorFilter::Validation, true,
+                        nsCString{mMessageUtf8}, mDeviceId});
+    }
+    auto filterType = ErrorTypeToFilterType(mType);
+    if (!filterType) {
       return {};
-    case ffi::WGPUErrorBufferType_Internal:
-      return Some(dom::GPUErrorFilter::Internal);
-    case ffi::WGPUErrorBufferType_Validation:
-      return Some(dom::GPUErrorFilter::Validation);
-    case ffi::WGPUErrorBufferType_OutOfMemory:
-      return Some(dom::GPUErrorFilter::Out_of_memory);
-    case ffi::WGPUErrorBufferType_Sentinel:
-      break;
+    }
+    return Some(Error{*filterType, false, nsCString{mMessageUtf8}, mDeviceId});
   }
 
-  MOZ_CRASH("invalid `ErrorBufferType`");
-}
-
-Maybe<ErrorBuffer::Error> ErrorBuffer::GetError() {
-  mAwaitingGetError = false;
-  if (mType == ffi::WGPUErrorBufferType_DeviceLost) {
-    // This error is for a lost device, so we return an Error struct
-    // with the isDeviceLost bool set to true. It doesn't matter what
-    // GPUErrorFilter type we use, so we just use Validation. The error
-    // will not be reported.
-    return Some(Error{dom::GPUErrorFilter::Validation, true,
-                      nsCString{mMessageUtf8}, mDeviceId});
-  }
-  auto filterType = ErrorTypeToFilterType(mType);
-  if (!filterType) {
-    return {};
-  }
-  return Some(Error{*filterType, false, nsCString{mMessageUtf8}, mDeviceId});
-}
-
-void ErrorBuffer::CoerceValidationToInternal() {
-  if (mType == ffi::WGPUErrorBufferType_Validation) {
-    mType = ffi::WGPUErrorBufferType_Internal;
+  void CoerceValidationToInternal() {
+    if (mType == ffi::WGPUErrorBufferType_Validation) {
+      mType = ffi::WGPUErrorBufferType_Internal;
+    }
   }
-}
+};
 
 struct PendingSwapChainDrop {
   layers::RemoteTextureTxnType mTxnType;
@@ -792,28 +814,6 @@ void WebGPUParent::RemoveSharedTexture(RawId aTextureId) {
   }
 }
 
-void WebGPUParent::DestroyExternalTextureSource(RawId aSourceId) {
-  auto it = mExternalTextureSources.find(aSourceId);
-  if (it != mExternalTextureSources.end()) {
-    for (const auto textureId : it->second.TextureIds()) {
-      ffi::wgpu_server_texture_destroy(mContext.get(), textureId);
-    }
-  }
-}
-
-void WebGPUParent::DropExternalTextureSource(RawId aSourceId) {
-  auto it = mExternalTextureSources.find(aSourceId);
-  if (it != mExternalTextureSources.end()) {
-    for (const auto viewId : it->second.ViewIds()) {
-      ffi::wgpu_server_texture_view_drop(mContext.get(), viewId);
-    }
-    for (const auto textureId : it->second.TextureIds()) {
-      ffi::wgpu_server_texture_drop(mContext.get(), textureId);
-    }
-    mExternalTextureSources.erase(it);
-  }
-}
-
 void WebGPUParent::QueueSubmit(RawId aQueueId, RawId aDeviceId,
                                Span<const RawId> aCommandBuffers,
                                Span<const RawId> aTextureIds) {
@@ -1564,18 +1564,6 @@ ipc::IPCResult WebGPUParent::RecvMessages(
   return IPC_OK();
 }
 
-ipc::IPCResult WebGPUParent::RecvCreateExternalTextureSource(
-    RawId aDeviceId, RawId aQueueId, RawId aExternalTextureSourceId,
-    const ExternalTextureSourceDescriptor& aDesc) {
-  MOZ_RELEASE_ASSERT(mExternalTextureSources.find(aExternalTextureSourceId) ==
-                     mExternalTextureSources.end());
-  mExternalTextureSources.emplace(
-      aExternalTextureSourceId,
-      ExternalTextureSourceHost::Create(this, aDeviceId, aQueueId, aDesc));
-
-  return IPC_OK();
-}
-
 void WebGPUParent::DevicePushErrorScope(RawId aDeviceId,
                                         const dom::GPUErrorFilter aFilter) {
   const auto& itr = mErrorScopeStackByDevice.find(aDeviceId);