/work/obj-fuzz/dist/include/mozilla/dom/WebGPUBinding.h

Source (jump to first uncovered line)
/* THIS FILE IS AUTOGENERATED FROM WebGPU.webidl BY Codegen.py - DO NOT EDIT */

#ifndef mozilla_dom_WebGPUBinding_h
#define mozilla_dom_WebGPUBinding_h

#include "GeckoProfiler.h"
#include "WebGPUBinding.h"
#include "WebGPUExtrasBinding.h"
#include "js/RootingAPI.h"
#include "jspubtd.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/CallbackFunction.h"
#include "mozilla/dom/FakeString.h"
#include "mozilla/dom/Nullable.h"
#include "mozilla/dom/PrototypeList.h"
#include "mozilla/dom/ToJSValue.h"
#include "mozilla/dom/TypedArray.h"
#include "mozilla/dom/UnionMember.h"
#include "mozilla/webgpu/AttachmentState.h"
#include "mozilla/webgpu/BindGroupLayout.h"
#include "mozilla/webgpu/BlendState.h"
#include "mozilla/webgpu/DepthStencilState.h"
#include "mozilla/webgpu/InputState.h"
#include "mozilla/webgpu/PipelineLayout.h"
#include "mozilla/webgpu/ShaderModule.h"
#include "mozilla/webgpu/TextureView.h"

namespace mozilla {

namespace dom {

struct NativePropertyHooks;
class OwningWebGPUBufferOrWebGPUTexture;
class OwningWebGPUComputePipelineOrWebGPURenderPipeline;
class OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding;
class ProtoAndIfaceCache;
struct WebGPUAdapterDescriptorAtoms;
struct WebGPUAttachmentStateDescriptorAtoms;
struct WebGPUBindGroupBinding;
struct WebGPUBindGroupBindingAtoms;
struct WebGPUBindGroupDescriptorAtoms;
struct WebGPUBindGroupLayoutDescriptorAtoms;
struct WebGPUBinding;
struct WebGPUBindingAtoms;
class WebGPUBindingType;
struct WebGPUBindingTypeAtoms;
struct WebGPUBlendDescriptor;
struct WebGPUBlendDescriptorAtoms;
class WebGPUBlendFactor;
struct WebGPUBlendFactorAtoms;
class WebGPUBlendOperation;
struct WebGPUBlendOperationAtoms;
struct WebGPUBlendStateDescriptorAtoms;
struct WebGPUBufferDescriptorAtoms;
class WebGPUBufferUsage;
struct WebGPUBufferUsageAtoms;
class WebGPUColorWriteBits;
struct WebGPUColorWriteBitsAtoms;
class WebGPUCompareFunction;
struct WebGPUCompareFunctionAtoms;
struct WebGPUDepthStencilStateDescriptorAtoms;
struct WebGPUDeviceDescriptorAtoms;
struct WebGPUExtensions;
struct WebGPUExtensionsAtoms;
class WebGPUFilterMode;
struct WebGPUFilterModeAtoms;
class WebGPUIndexFormat;
struct WebGPUIndexFormatAtoms;
struct WebGPUInputStateDescriptorAtoms;
class WebGPUInputStepMode;
struct WebGPUInputStepModeAtoms;
struct WebGPULimitsAtoms;
class WebGPULoadOp;
struct WebGPULoadOpAtoms;
class WebGPULogCallback;
struct WebGPUPipelineDescriptorBaseAtoms;
struct WebGPUPipelineLayoutDescriptorAtoms;
struct WebGPUPipelineStageDescriptor;
struct WebGPUPipelineStageDescriptorAtoms;
class WebGPUPrimitiveTopology;
struct WebGPUPrimitiveTopologyAtoms;
struct WebGPURenderPassAttachmentDescriptor;
struct WebGPURenderPassAttachmentDescriptorAtoms;
struct WebGPURenderPassDescriptorAtoms;
struct WebGPURenderPipelineDescriptorAtoms;
struct WebGPUSamplerDescriptorAtoms;
class WebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding;
struct WebGPUShaderModuleDescriptorAtoms;
class WebGPUShaderStage;
struct WebGPUShaderStageAtoms;
class WebGPUShaderStageBit;
struct WebGPUShaderStageBitAtoms;
class WebGPUStencilOperation;
struct WebGPUStencilOperationAtoms;
struct WebGPUStencilStateFaceDescriptor;
struct WebGPUStencilStateFaceDescriptorAtoms;
class WebGPUStoreOp;
struct WebGPUStoreOpAtoms;
struct WebGPUSwapChainDescriptorAtoms;
struct WebGPUTextureDescriptorAtoms;
class WebGPUTextureDimension;
struct WebGPUTextureDimensionAtoms;
class WebGPUTextureFormat;
struct WebGPUTextureFormatAtoms;
class WebGPUTextureUsage;
struct WebGPUTextureUsageAtoms;
struct WebGPUVertexAttributeDescriptor;
struct WebGPUVertexAttributeDescriptorAtoms;
class WebGPUVertexFormat;
struct WebGPUVertexFormatAtoms;
struct WebGPUVertexInputDescriptor;
struct WebGPUVertexInputDescriptorAtoms;

} // namespace dom

namespace webgpu {

class Adapter;
struct AdapterAtoms;
class AttachmentState;
struct AttachmentStateAtoms;
class BindGroup;
struct BindGroupAtoms;
class BindGroupLayout;
struct BindGroupLayoutAtoms;
class BlendState;
struct BlendStateAtoms;
class Buffer;
struct BufferAtoms;
class CommandBuffer;
struct CommandBufferAtoms;
class CommandEncoder;
struct CommandEncoderAtoms;
class ComputePipeline;
struct ComputePipelineAtoms;
class DepthStencilState;
struct DepthStencilStateAtoms;
class Device;
struct DeviceAtoms;
class Fence;
struct FenceAtoms;
class InputState;
struct InputStateAtoms;
class Instance;
struct InstanceAtoms;
class LogEntry;
struct LogEntryAtoms;
class PipelineLayout;
struct PipelineLayoutAtoms;
class Queue;
struct QueueAtoms;
class RenderPipeline;
struct RenderPipelineAtoms;
class Sampler;
struct SamplerAtoms;
class ShaderModule;
struct ShaderModuleAtoms;
class SwapChain;
struct SwapChainAtoms;
class Texture;
struct TextureAtoms;
class TextureView;
struct TextureViewAtoms;

} // namespace webgpu

} // namespace mozilla

namespace mozilla {
namespace dom {

enum class WebGPULogEntryType : uint8_t {
  Device_lost,
  Validation_error,
  Recoverable_out_of_memory,
  EndGuard_
};

namespace WebGPULogEntryTypeValues {
extern const EnumEntry strings[4];
} // namespace WebGPULogEntryTypeValues

bool
ToJSValue(JSContext* aCx, WebGPULogEntryType aArgument, JS::MutableHandle<JS::Value> aValue);


enum class WebGPUObjectStatus : uint8_t {
  Valid,
  Out_of_memory,
  Invalid,
  EndGuard_
};

namespace WebGPUObjectStatusValues {
extern const EnumEntry strings[4];
} // namespace WebGPUObjectStatusValues

bool
ToJSValue(JSContext* aCx, WebGPUObjectStatus aArgument, JS::MutableHandle<JS::Value> aValue);


enum class WebGPUPowerPreference : uint8_t {
  Default,
  Low_power,
  High_performance,
  EndGuard_
};

namespace WebGPUPowerPreferenceValues {
extern const EnumEntry strings[4];
} // namespace WebGPUPowerPreferenceValues

bool
ToJSValue(JSContext* aCx, WebGPUPowerPreference aArgument, JS::MutableHandle<JS::Value> aValue);


void
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, OwningWebGPUBufferOrWebGPUTexture& aUnion, const char* aName, uint32_t aFlags = 0);


void
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, OwningWebGPUComputePipelineOrWebGPURenderPipeline& aUnion, const char* aName, uint32_t aFlags = 0);


void
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding& aUnion, const char* aName, uint32_t aFlags = 0);


void
ImplCycleCollectionUnlink(OwningWebGPUBufferOrWebGPUTexture& aUnion);


void
ImplCycleCollectionUnlink(OwningWebGPUComputePipelineOrWebGPURenderPipeline& aUnion);


void
ImplCycleCollectionUnlink(OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding& aUnion);


struct WebGPUAdapterDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<WebGPUPowerPreference> mPowerPreference;

  WebGPUAdapterDescriptor();

  explicit inline WebGPUAdapterDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUAdapterDescriptor(const WebGPUAdapterDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUAdapterDescriptor&
  operator=(const WebGPUAdapterDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUAdapterDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUAdapterDescriptor : public WebGPUAdapterDescriptor
{
  inline FastWebGPUAdapterDescriptor()
    : WebGPUAdapterDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUAttachmentStateDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<uint32_t>> mFormats;

  WebGPUAttachmentStateDescriptor();

  explicit inline WebGPUAttachmentStateDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUAttachmentStateDescriptor(const WebGPUAttachmentStateDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUAttachmentStateDescriptor&
  operator=(const WebGPUAttachmentStateDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUAttachmentStateDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUAttachmentStateDescriptor : public WebGPUAttachmentStateDescriptor
{
  inline FastWebGPUAttachmentStateDescriptor()
    : WebGPUAttachmentStateDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUBindGroupBinding : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mCount;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mStart;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mType;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mVisibility;

  WebGPUBindGroupBinding();

  explicit inline WebGPUBindGroupBinding(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUBindGroupBinding(const WebGPUBindGroupBinding& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUBindGroupBinding&
  operator=(const WebGPUBindGroupBinding& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUBindGroupBindingAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUBindGroupBinding : public WebGPUBindGroupBinding
{
  inline FastWebGPUBindGroupBinding()
    : WebGPUBindGroupBinding(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUBlendDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mDstFactor;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mOperation;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mSrcFactor;

  WebGPUBlendDescriptor();

  explicit inline WebGPUBlendDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUBlendDescriptor(const WebGPUBlendDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUBlendDescriptor&
  operator=(const WebGPUBlendDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUBlendDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUBlendDescriptor : public WebGPUBlendDescriptor
{
  inline FastWebGPUBlendDescriptor()
    : WebGPUBlendDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUBufferDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mSize;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mUsage;

  WebGPUBufferDescriptor();

  explicit inline WebGPUBufferDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUBufferDescriptor(const WebGPUBufferDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUBufferDescriptor&
  operator=(const WebGPUBufferDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUBufferDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUBufferDescriptor : public WebGPUBufferDescriptor
{
  inline FastWebGPUBufferDescriptor()
    : WebGPUBufferDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


class WebGPUBufferOrWebGPUTexture
{
  friend class WebGPUBufferOrWebGPUTextureArgument;
  enum Type
  {
    eUninitialized,
    eWebGPUBuffer,
    eWebGPUTexture
  };

  union Value
  {
    UnionMember<NonNull<mozilla::webgpu::Buffer> > mWebGPUBuffer;
    UnionMember<NonNull<mozilla::webgpu::Texture> > mWebGPUTexture;

  };

  Type mType;
  Value mValue;

  WebGPUBufferOrWebGPUTexture(const WebGPUBufferOrWebGPUTexture&) = delete;
  WebGPUBufferOrWebGPUTexture& operator=(const WebGPUBufferOrWebGPUTexture&) = delete;
public:
  explicit inline WebGPUBufferOrWebGPUTexture()
    : mType(eUninitialized)
  {
  }

  inline ~WebGPUBufferOrWebGPUTexture()
  {
    Uninit();
  }

  inline NonNull<mozilla::webgpu::Buffer>&
  RawSetAsWebGPUBuffer()
  {
    if (mType == eWebGPUBuffer) {
      return mValue.mWebGPUBuffer.Value();
    }
    MOZ_ASSERT(mType == eUninitialized);
    mType = eWebGPUBuffer;
    return mValue.mWebGPUBuffer.SetValue();
  }

  inline NonNull<mozilla::webgpu::Buffer>&
  SetAsWebGPUBuffer()
  {
    if (mType == eWebGPUBuffer) {
      return mValue.mWebGPUBuffer.Value();
    }
    Uninit();
    mType = eWebGPUBuffer;
    return mValue.mWebGPUBuffer.SetValue();
  }

  inline bool
  IsWebGPUBuffer() const
  {
    return mType == eWebGPUBuffer;
  }

  inline NonNull<mozilla::webgpu::Buffer>&
  GetAsWebGPUBuffer()
  {
    MOZ_ASSERT(IsWebGPUBuffer(), "Wrong type!");
    return mValue.mWebGPUBuffer.Value();
  }

  inline mozilla::webgpu::Buffer&
  GetAsWebGPUBuffer() const
  {
    MOZ_ASSERT(IsWebGPUBuffer(), "Wrong type!");
    return mValue.mWebGPUBuffer.Value();
  }

  inline NonNull<mozilla::webgpu::Texture>&
  RawSetAsWebGPUTexture()
  {
    if (mType == eWebGPUTexture) {
      return mValue.mWebGPUTexture.Value();
    }
    MOZ_ASSERT(mType == eUninitialized);
    mType = eWebGPUTexture;
    return mValue.mWebGPUTexture.SetValue();
  }

  inline NonNull<mozilla::webgpu::Texture>&
  SetAsWebGPUTexture()
  {
    if (mType == eWebGPUTexture) {
      return mValue.mWebGPUTexture.Value();
    }
    Uninit();
    mType = eWebGPUTexture;
    return mValue.mWebGPUTexture.SetValue();
  }

  inline bool
  IsWebGPUTexture() const
  {
    return mType == eWebGPUTexture;
  }

  inline NonNull<mozilla::webgpu::Texture>&
  GetAsWebGPUTexture()
  {
    MOZ_ASSERT(IsWebGPUTexture(), "Wrong type!");
    return mValue.mWebGPUTexture.Value();
  }

  inline mozilla::webgpu::Texture&
  GetAsWebGPUTexture() const
  {
    MOZ_ASSERT(IsWebGPUTexture(), "Wrong type!");
    return mValue.mWebGPUTexture.Value();
  }

  inline void
  Uninit()
  {
    switch (mType) {
      case eUninitialized: {
        break;
      }
      case eWebGPUBuffer: {
        DestroyWebGPUBuffer();
        break;
      }
      case eWebGPUTexture: {
        DestroyWebGPUTexture();
        break;
      }
    }
  }

  bool
  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;

private:
  inline void
  DestroyWebGPUBuffer()
  {
    MOZ_ASSERT(IsWebGPUBuffer(), "Wrong type!");
    mValue.mWebGPUBuffer.Destroy();
    mType = eUninitialized;
  }

  inline void
  DestroyWebGPUTexture()
  {
    MOZ_ASSERT(IsWebGPUTexture(), "Wrong type!");
    mValue.mWebGPUTexture.Destroy();
    mType = eUninitialized;
  }
};


class OwningWebGPUBufferOrWebGPUTexture : public AllOwningUnionBase
{
  friend void ImplCycleCollectionUnlink(OwningWebGPUBufferOrWebGPUTexture& aUnion);
  enum Type
  {
    eUninitialized,
    eWebGPUBuffer,
    eWebGPUTexture
  };

  union Value
  {
    UnionMember<OwningNonNull<mozilla::webgpu::Buffer> > mWebGPUBuffer;
    UnionMember<OwningNonNull<mozilla::webgpu::Texture> > mWebGPUTexture;

  };

  Type mType;
  Value mValue;

public:
  explicit inline OwningWebGPUBufferOrWebGPUTexture()
    : mType(eUninitialized)
  {
  }

  explicit inline OwningWebGPUBufferOrWebGPUTexture(const OwningWebGPUBufferOrWebGPUTexture& aOther)
    : mType(eUninitialized)
  {
    *this = aOther;
  }

  inline ~OwningWebGPUBufferOrWebGPUTexture()
  {
    Uninit();
  }

  OwningNonNull<mozilla::webgpu::Buffer>&
  RawSetAsWebGPUBuffer();

  OwningNonNull<mozilla::webgpu::Buffer>&
  SetAsWebGPUBuffer();

  bool
  TrySetToWebGPUBuffer(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);

  inline bool
  IsWebGPUBuffer() const
  {
    return mType == eWebGPUBuffer;
  }

  inline OwningNonNull<mozilla::webgpu::Buffer>&
  GetAsWebGPUBuffer()
  {
    MOZ_ASSERT(IsWebGPUBuffer(), "Wrong type!");
    return mValue.mWebGPUBuffer.Value();
  }

  inline OwningNonNull<mozilla::webgpu::Buffer> const &
  GetAsWebGPUBuffer() const
  {
    MOZ_ASSERT(IsWebGPUBuffer(), "Wrong type!");
    return mValue.mWebGPUBuffer.Value();
  }

  OwningNonNull<mozilla::webgpu::Texture>&
  RawSetAsWebGPUTexture();

  OwningNonNull<mozilla::webgpu::Texture>&
  SetAsWebGPUTexture();

  bool
  TrySetToWebGPUTexture(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);

  inline bool
  IsWebGPUTexture() const
  {
    return mType == eWebGPUTexture;
  }

  inline OwningNonNull<mozilla::webgpu::Texture>&
  GetAsWebGPUTexture()
  {
    MOZ_ASSERT(IsWebGPUTexture(), "Wrong type!");
    return mValue.mWebGPUTexture.Value();
  }

  inline OwningNonNull<mozilla::webgpu::Texture> const &
  GetAsWebGPUTexture() const
  {
    MOZ_ASSERT(IsWebGPUTexture(), "Wrong type!");
    return mValue.mWebGPUTexture.Value();
  }

  void
  Uninit();

  bool
  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceUnion(JSTracer* trc);

  OwningWebGPUBufferOrWebGPUTexture&
  operator=(const OwningWebGPUBufferOrWebGPUTexture& aOther);

private:
  void
  DestroyWebGPUBuffer();

  void
  DestroyWebGPUTexture();
};


struct WebGPUCommandEncoderDescriptor : public DictionaryBase
{
  WebGPUCommandEncoderDescriptor();

  explicit inline WebGPUCommandEncoderDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUCommandEncoderDescriptor(const WebGPUCommandEncoderDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUCommandEncoderDescriptor&
  operator=(const WebGPUCommandEncoderDescriptor& aOther);
};

namespace binding_detail {
struct FastWebGPUCommandEncoderDescriptor : public WebGPUCommandEncoderDescriptor
{
  inline FastWebGPUCommandEncoderDescriptor()
    : WebGPUCommandEncoderDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


class WebGPUComputePipelineOrWebGPURenderPipeline
{
  friend class WebGPUComputePipelineOrWebGPURenderPipelineArgument;
  enum Type
  {
    eUninitialized,
    eWebGPUComputePipeline,
    eWebGPURenderPipeline
  };

  union Value
  {
    UnionMember<NonNull<mozilla::webgpu::ComputePipeline> > mWebGPUComputePipeline;
    UnionMember<NonNull<mozilla::webgpu::RenderPipeline> > mWebGPURenderPipeline;

  };

  Type mType;
  Value mValue;

  WebGPUComputePipelineOrWebGPURenderPipeline(const WebGPUComputePipelineOrWebGPURenderPipeline&) = delete;
  WebGPUComputePipelineOrWebGPURenderPipeline& operator=(const WebGPUComputePipelineOrWebGPURenderPipeline&) = delete;
public:
  explicit inline WebGPUComputePipelineOrWebGPURenderPipeline()
    : mType(eUninitialized)
  {
  }

  inline ~WebGPUComputePipelineOrWebGPURenderPipeline()
  {
    Uninit();
  }

  inline NonNull<mozilla::webgpu::ComputePipeline>&
  RawSetAsWebGPUComputePipeline()
  {
    if (mType == eWebGPUComputePipeline) {
      return mValue.mWebGPUComputePipeline.Value();
    }
    MOZ_ASSERT(mType == eUninitialized);
    mType = eWebGPUComputePipeline;
    return mValue.mWebGPUComputePipeline.SetValue();
  }

  inline NonNull<mozilla::webgpu::ComputePipeline>&
  SetAsWebGPUComputePipeline()
  {
    if (mType == eWebGPUComputePipeline) {
      return mValue.mWebGPUComputePipeline.Value();
    }
    Uninit();
    mType = eWebGPUComputePipeline;
    return mValue.mWebGPUComputePipeline.SetValue();
  }

  inline bool
  IsWebGPUComputePipeline() const
  {
    return mType == eWebGPUComputePipeline;
  }

  inline NonNull<mozilla::webgpu::ComputePipeline>&
  GetAsWebGPUComputePipeline()
  {
    MOZ_ASSERT(IsWebGPUComputePipeline(), "Wrong type!");
    return mValue.mWebGPUComputePipeline.Value();
  }

  inline mozilla::webgpu::ComputePipeline&
  GetAsWebGPUComputePipeline() const
  {
    MOZ_ASSERT(IsWebGPUComputePipeline(), "Wrong type!");
    return mValue.mWebGPUComputePipeline.Value();
  }

  inline NonNull<mozilla::webgpu::RenderPipeline>&
  RawSetAsWebGPURenderPipeline()
  {
    if (mType == eWebGPURenderPipeline) {
      return mValue.mWebGPURenderPipeline.Value();
    }
    MOZ_ASSERT(mType == eUninitialized);
    mType = eWebGPURenderPipeline;
    return mValue.mWebGPURenderPipeline.SetValue();
  }

  inline NonNull<mozilla::webgpu::RenderPipeline>&
  SetAsWebGPURenderPipeline()
  {
    if (mType == eWebGPURenderPipeline) {
      return mValue.mWebGPURenderPipeline.Value();
    }
    Uninit();
    mType = eWebGPURenderPipeline;
    return mValue.mWebGPURenderPipeline.SetValue();
  }

  inline bool
  IsWebGPURenderPipeline() const
  {
    return mType == eWebGPURenderPipeline;
  }

  inline NonNull<mozilla::webgpu::RenderPipeline>&
  GetAsWebGPURenderPipeline()
  {
    MOZ_ASSERT(IsWebGPURenderPipeline(), "Wrong type!");
    return mValue.mWebGPURenderPipeline.Value();
  }

  inline mozilla::webgpu::RenderPipeline&
  GetAsWebGPURenderPipeline() const
  {
    MOZ_ASSERT(IsWebGPURenderPipeline(), "Wrong type!");
    return mValue.mWebGPURenderPipeline.Value();
  }

  inline void
  Uninit()
  {
    switch (mType) {
      case eUninitialized: {
        break;
      }
      case eWebGPUComputePipeline: {
        DestroyWebGPUComputePipeline();
        break;
      }
      case eWebGPURenderPipeline: {
        DestroyWebGPURenderPipeline();
        break;
      }
    }
  }

  bool
  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;

private:
  inline void
  DestroyWebGPUComputePipeline()
  {
    MOZ_ASSERT(IsWebGPUComputePipeline(), "Wrong type!");
    mValue.mWebGPUComputePipeline.Destroy();
    mType = eUninitialized;
  }

  inline void
  DestroyWebGPURenderPipeline()
  {
    MOZ_ASSERT(IsWebGPURenderPipeline(), "Wrong type!");
    mValue.mWebGPURenderPipeline.Destroy();
    mType = eUninitialized;
  }
};


class OwningWebGPUComputePipelineOrWebGPURenderPipeline : public AllOwningUnionBase
{
  friend void ImplCycleCollectionUnlink(OwningWebGPUComputePipelineOrWebGPURenderPipeline& aUnion);
  enum Type
  {
    eUninitialized,
    eWebGPUComputePipeline,
    eWebGPURenderPipeline
  };

  union Value
  {
    UnionMember<OwningNonNull<mozilla::webgpu::ComputePipeline> > mWebGPUComputePipeline;
    UnionMember<OwningNonNull<mozilla::webgpu::RenderPipeline> > mWebGPURenderPipeline;

  };

  Type mType;
  Value mValue;

public:
  explicit inline OwningWebGPUComputePipelineOrWebGPURenderPipeline()
    : mType(eUninitialized)
  {
  }

  explicit inline OwningWebGPUComputePipelineOrWebGPURenderPipeline(const OwningWebGPUComputePipelineOrWebGPURenderPipeline& aOther)
    : mType(eUninitialized)
  {
    *this = aOther;
  }

  inline ~OwningWebGPUComputePipelineOrWebGPURenderPipeline()
  {
    Uninit();
  }

  OwningNonNull<mozilla::webgpu::ComputePipeline>&
  RawSetAsWebGPUComputePipeline();

  OwningNonNull<mozilla::webgpu::ComputePipeline>&
  SetAsWebGPUComputePipeline();

  bool
  TrySetToWebGPUComputePipeline(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);

  inline bool
  IsWebGPUComputePipeline() const
  {
    return mType == eWebGPUComputePipeline;
  }

  inline OwningNonNull<mozilla::webgpu::ComputePipeline>&
  GetAsWebGPUComputePipeline()
  {
    MOZ_ASSERT(IsWebGPUComputePipeline(), "Wrong type!");
    return mValue.mWebGPUComputePipeline.Value();
  }

  inline OwningNonNull<mozilla::webgpu::ComputePipeline> const &
  GetAsWebGPUComputePipeline() const
  {
    MOZ_ASSERT(IsWebGPUComputePipeline(), "Wrong type!");
    return mValue.mWebGPUComputePipeline.Value();
  }

  OwningNonNull<mozilla::webgpu::RenderPipeline>&
  RawSetAsWebGPURenderPipeline();

  OwningNonNull<mozilla::webgpu::RenderPipeline>&
  SetAsWebGPURenderPipeline();

  bool
  TrySetToWebGPURenderPipeline(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);

  inline bool
  IsWebGPURenderPipeline() const
  {
    return mType == eWebGPURenderPipeline;
  }

  inline OwningNonNull<mozilla::webgpu::RenderPipeline>&
  GetAsWebGPURenderPipeline()
  {
    MOZ_ASSERT(IsWebGPURenderPipeline(), "Wrong type!");
    return mValue.mWebGPURenderPipeline.Value();
  }

  inline OwningNonNull<mozilla::webgpu::RenderPipeline> const &
  GetAsWebGPURenderPipeline() const
  {
    MOZ_ASSERT(IsWebGPURenderPipeline(), "Wrong type!");
    return mValue.mWebGPURenderPipeline.Value();
  }

  void
  Uninit();

  bool
  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceUnion(JSTracer* trc);

  OwningWebGPUComputePipelineOrWebGPURenderPipeline&
  operator=(const OwningWebGPUComputePipelineOrWebGPURenderPipeline& aOther);

private:
  void
  DestroyWebGPUComputePipeline();

  void
  DestroyWebGPURenderPipeline();
};


struct WebGPUExtensions : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<bool> mAnisotropicFiltering;
  MOZ_INIT_OUTSIDE_CTOR Optional<bool> mLogicOp;

  WebGPUExtensions();

  explicit inline WebGPUExtensions(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUExtensions(const WebGPUExtensions& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUExtensions&
  operator=(const WebGPUExtensions& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUExtensionsAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUExtensions : public WebGPUExtensions
{
  inline FastWebGPUExtensions()
    : WebGPUExtensions(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPULimits : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mMaxBindGroups;

  WebGPULimits();

  explicit inline WebGPULimits(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPULimits(const WebGPULimits& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPULimits&
  operator=(const WebGPULimits& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPULimitsAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPULimits : public WebGPULimits
{
  inline FastWebGPULimits()
    : WebGPULimits(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUPipelineLayoutDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<OwningNonNull<mozilla::webgpu::BindGroupLayout>>> mBindGroupLayouts;

  WebGPUPipelineLayoutDescriptor();

  explicit inline WebGPUPipelineLayoutDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUPipelineLayoutDescriptor(const WebGPUPipelineLayoutDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  inline void
  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)
  {
    ImplCycleCollectionTraverse(aCallback, mBindGroupLayouts, "mBindGroupLayouts", aFlags);
  }

  inline void
  UnlinkForCC()
  {
    ImplCycleCollectionUnlink(mBindGroupLayouts);
  }

  WebGPUPipelineLayoutDescriptor&
  operator=(const WebGPUPipelineLayoutDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUPipelineLayoutDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUPipelineLayoutDescriptor : public WebGPUPipelineLayoutDescriptor
{
  inline FastWebGPUPipelineLayoutDescriptor()
    : WebGPUPipelineLayoutDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUPipelineStageDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR nsString mEntryPoint;
  MOZ_INIT_OUTSIDE_CTOR OwningNonNull<mozilla::webgpu::ShaderModule> mShaderModule;
  MOZ_INIT_OUTSIDE_CTOR uint32_t mStage;

  WebGPUPipelineStageDescriptor();

  explicit inline WebGPUPipelineStageDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUPipelineStageDescriptor(const WebGPUPipelineStageDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  inline void
  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)
  {
    ImplCycleCollectionTraverse(aCallback, mShaderModule, "mShaderModule", aFlags);
  }

  inline void
  UnlinkForCC()
  {
    ImplCycleCollectionUnlink(mShaderModule);
  }

  WebGPUPipelineStageDescriptor&
  operator=(const WebGPUPipelineStageDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUPipelineStageDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUPipelineStageDescriptor : public WebGPUPipelineStageDescriptor
{
  inline FastWebGPUPipelineStageDescriptor()
    : WebGPUPipelineStageDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPURenderPassAttachmentDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<OwningNonNull<mozilla::webgpu::TextureView>> mAttachment;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mLoadOp;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mStoreOp;

  WebGPURenderPassAttachmentDescriptor();

  explicit inline WebGPURenderPassAttachmentDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPURenderPassAttachmentDescriptor(const WebGPURenderPassAttachmentDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  inline void
  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)
  {
    ImplCycleCollectionTraverse(aCallback, mAttachment, "mAttachment", aFlags);
  }

  inline void
  UnlinkForCC()
  {
    ImplCycleCollectionUnlink(mAttachment);
  }

  WebGPURenderPassAttachmentDescriptor&
  operator=(const WebGPURenderPassAttachmentDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPURenderPassAttachmentDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPURenderPassAttachmentDescriptor : public WebGPURenderPassAttachmentDescriptor
{
  inline FastWebGPURenderPassAttachmentDescriptor()
    : WebGPURenderPassAttachmentDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUSamplerDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mMagFilter;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mMinFilter;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mMipmapFilter;

  WebGPUSamplerDescriptor();

  explicit inline WebGPUSamplerDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUSamplerDescriptor(const WebGPUSamplerDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUSamplerDescriptor&
  operator=(const WebGPUSamplerDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUSamplerDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUSamplerDescriptor : public WebGPUSamplerDescriptor
{
  inline FastWebGPUSamplerDescriptor()
    : WebGPUSamplerDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


class WebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding
{
  friend class WebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBindingArgument;
  enum Type
  {
    eUninitialized,
    eWebGPUSampler,
    eWebGPUTextureView,
    eWebGPUBufferBinding
  };

  union Value
  {
    UnionMember<NonNull<mozilla::webgpu::Sampler> > mWebGPUSampler;
    UnionMember<NonNull<mozilla::webgpu::TextureView> > mWebGPUTextureView;
    UnionMember<binding_detail::FastWebGPUBufferBinding > mWebGPUBufferBinding;

  };

  Type mType;
  Value mValue;

  WebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding(const WebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding&) = delete;
  WebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding& operator=(const WebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding&) = delete;
public:
  explicit inline WebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding()
    : mType(eUninitialized)
  {
  }

  inline ~WebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding()
  {
    Uninit();
  }

  inline NonNull<mozilla::webgpu::Sampler>&
  RawSetAsWebGPUSampler()
  {
    if (mType == eWebGPUSampler) {
      return mValue.mWebGPUSampler.Value();
    }
    MOZ_ASSERT(mType == eUninitialized);
    mType = eWebGPUSampler;
    return mValue.mWebGPUSampler.SetValue();
  }

  inline NonNull<mozilla::webgpu::Sampler>&
  SetAsWebGPUSampler()
  {
    if (mType == eWebGPUSampler) {
      return mValue.mWebGPUSampler.Value();
    }
    Uninit();
    mType = eWebGPUSampler;
    return mValue.mWebGPUSampler.SetValue();
  }

  inline bool
  IsWebGPUSampler() const
  {
    return mType == eWebGPUSampler;
  }

  inline NonNull<mozilla::webgpu::Sampler>&
  GetAsWebGPUSampler()
  {
    MOZ_ASSERT(IsWebGPUSampler(), "Wrong type!");
    return mValue.mWebGPUSampler.Value();
  }

  inline mozilla::webgpu::Sampler&
  GetAsWebGPUSampler() const
  {
    MOZ_ASSERT(IsWebGPUSampler(), "Wrong type!");
    return mValue.mWebGPUSampler.Value();
  }

  inline NonNull<mozilla::webgpu::TextureView>&
  RawSetAsWebGPUTextureView()
  {
    if (mType == eWebGPUTextureView) {
      return mValue.mWebGPUTextureView.Value();
    }
    MOZ_ASSERT(mType == eUninitialized);
    mType = eWebGPUTextureView;
    return mValue.mWebGPUTextureView.SetValue();
  }

  inline NonNull<mozilla::webgpu::TextureView>&
  SetAsWebGPUTextureView()
  {
    if (mType == eWebGPUTextureView) {
      return mValue.mWebGPUTextureView.Value();
    }
    Uninit();
    mType = eWebGPUTextureView;
    return mValue.mWebGPUTextureView.SetValue();
  }

  inline bool
  IsWebGPUTextureView() const
  {
    return mType == eWebGPUTextureView;
  }

  inline NonNull<mozilla::webgpu::TextureView>&
  GetAsWebGPUTextureView()
  {
    MOZ_ASSERT(IsWebGPUTextureView(), "Wrong type!");
    return mValue.mWebGPUTextureView.Value();
  }

  inline mozilla::webgpu::TextureView&
  GetAsWebGPUTextureView() const
  {
    MOZ_ASSERT(IsWebGPUTextureView(), "Wrong type!");
    return mValue.mWebGPUTextureView.Value();
  }

  inline binding_detail::FastWebGPUBufferBinding&
  RawSetAsWebGPUBufferBinding()
  {
    if (mType == eWebGPUBufferBinding) {
      return mValue.mWebGPUBufferBinding.Value();
    }
    MOZ_ASSERT(mType == eUninitialized);
    mType = eWebGPUBufferBinding;
    return mValue.mWebGPUBufferBinding.SetValue();
  }

  inline binding_detail::FastWebGPUBufferBinding&
  SetAsWebGPUBufferBinding()
  {
    if (mType == eWebGPUBufferBinding) {
      return mValue.mWebGPUBufferBinding.Value();
    }
    Uninit();
    mType = eWebGPUBufferBinding;
    return mValue.mWebGPUBufferBinding.SetValue();
  }

  inline bool
  IsWebGPUBufferBinding() const
  {
    return mType == eWebGPUBufferBinding;
  }

  inline binding_detail::FastWebGPUBufferBinding&
  GetAsWebGPUBufferBinding()
  {
    MOZ_ASSERT(IsWebGPUBufferBinding(), "Wrong type!");
    return mValue.mWebGPUBufferBinding.Value();
  }

  inline const WebGPUBufferBinding&
  GetAsWebGPUBufferBinding() const
  {
    MOZ_ASSERT(IsWebGPUBufferBinding(), "Wrong type!");
    return mValue.mWebGPUBufferBinding.Value();
  }

  inline void
  Uninit()
  {
    switch (mType) {
      case eUninitialized: {
        break;
      }
      case eWebGPUSampler: {
        DestroyWebGPUSampler();
        break;
      }
      case eWebGPUTextureView: {
        DestroyWebGPUTextureView();
        break;
      }
      case eWebGPUBufferBinding: {
        DestroyWebGPUBufferBinding();
        break;
      }
    }
  }

  bool
  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;

private:
  inline void
  DestroyWebGPUSampler()
  {
    MOZ_ASSERT(IsWebGPUSampler(), "Wrong type!");
    mValue.mWebGPUSampler.Destroy();
    mType = eUninitialized;
  }

  inline void
  DestroyWebGPUTextureView()
  {
    MOZ_ASSERT(IsWebGPUTextureView(), "Wrong type!");
    mValue.mWebGPUTextureView.Destroy();
    mType = eUninitialized;
  }

  inline void
  DestroyWebGPUBufferBinding()
  {
    MOZ_ASSERT(IsWebGPUBufferBinding(), "Wrong type!");
    mValue.mWebGPUBufferBinding.Destroy();
    mType = eUninitialized;
  }
};


class OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding : public AllOwningUnionBase
{
  friend void ImplCycleCollectionUnlink(OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding& aUnion);
  enum Type
  {
    eUninitialized,
    eWebGPUSampler,
    eWebGPUTextureView,
    eWebGPUBufferBinding
  };

  union Value
  {
    UnionMember<OwningNonNull<mozilla::webgpu::Sampler> > mWebGPUSampler;
    UnionMember<OwningNonNull<mozilla::webgpu::TextureView> > mWebGPUTextureView;
    UnionMember<WebGPUBufferBinding > mWebGPUBufferBinding;

  };

  Type mType;
  Value mValue;

public:
  explicit inline OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding()
    : mType(eUninitialized)
  {
  }

  explicit inline OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding(const OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding& aOther)
    : mType(eUninitialized)
  {
    *this = aOther;
  }

  inline ~OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding()
  {
    Uninit();
  }

  OwningNonNull<mozilla::webgpu::Sampler>&
  RawSetAsWebGPUSampler();

  OwningNonNull<mozilla::webgpu::Sampler>&
  SetAsWebGPUSampler();

  bool
  TrySetToWebGPUSampler(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);

  inline bool
  IsWebGPUSampler() const
  {
    return mType == eWebGPUSampler;
  }

  inline OwningNonNull<mozilla::webgpu::Sampler>&
  GetAsWebGPUSampler()
  {
    MOZ_ASSERT(IsWebGPUSampler(), "Wrong type!");
    return mValue.mWebGPUSampler.Value();
  }

  inline OwningNonNull<mozilla::webgpu::Sampler> const &
  GetAsWebGPUSampler() const
  {
    MOZ_ASSERT(IsWebGPUSampler(), "Wrong type!");
    return mValue.mWebGPUSampler.Value();
  }

  OwningNonNull<mozilla::webgpu::TextureView>&
  RawSetAsWebGPUTextureView();

  OwningNonNull<mozilla::webgpu::TextureView>&
  SetAsWebGPUTextureView();

  bool
  TrySetToWebGPUTextureView(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);

  inline bool
  IsWebGPUTextureView() const
  {
    return mType == eWebGPUTextureView;
  }

  inline OwningNonNull<mozilla::webgpu::TextureView>&
  GetAsWebGPUTextureView()
  {
    MOZ_ASSERT(IsWebGPUTextureView(), "Wrong type!");
    return mValue.mWebGPUTextureView.Value();
  }

  inline OwningNonNull<mozilla::webgpu::TextureView> const &
  GetAsWebGPUTextureView() const
  {
    MOZ_ASSERT(IsWebGPUTextureView(), "Wrong type!");
    return mValue.mWebGPUTextureView.Value();
  }

  WebGPUBufferBinding&
  RawSetAsWebGPUBufferBinding();

  WebGPUBufferBinding&
  SetAsWebGPUBufferBinding();

  bool
  TrySetToWebGPUBufferBinding(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);

  inline bool
  IsWebGPUBufferBinding() const
  {
    return mType == eWebGPUBufferBinding;
  }

  inline WebGPUBufferBinding&
  GetAsWebGPUBufferBinding()
  {
    MOZ_ASSERT(IsWebGPUBufferBinding(), "Wrong type!");
    return mValue.mWebGPUBufferBinding.Value();
  }

  inline WebGPUBufferBinding const &
  GetAsWebGPUBufferBinding() const
  {
    MOZ_ASSERT(IsWebGPUBufferBinding(), "Wrong type!");
    return mValue.mWebGPUBufferBinding.Value();
  }

  void
  Uninit();

  bool
  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceUnion(JSTracer* trc);

  OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding&
  operator=(const OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding& aOther);

private:
  void
  DestroyWebGPUSampler();

  void
  DestroyWebGPUTextureView();

  void
  DestroyWebGPUBufferBinding();
};


struct WebGPUShaderModuleDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR ArrayBuffer mCode;

  WebGPUShaderModuleDescriptor();

  explicit inline WebGPUShaderModuleDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

private:
  WebGPUShaderModuleDescriptor(const WebGPUShaderModuleDescriptor&) = delete;
  WebGPUShaderModuleDescriptor& operator=(const WebGPUShaderModuleDescriptor&) = delete;

  static bool
  InitIds(JSContext* cx, WebGPUShaderModuleDescriptorAtoms* atomsCache);

public:
  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);
};

namespace binding_detail {
struct FastWebGPUShaderModuleDescriptor : public WebGPUShaderModuleDescriptor
{
  inline FastWebGPUShaderModuleDescriptor()
    : WebGPUShaderModuleDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUStencilStateFaceDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mCompare;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mDepthFailOp;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mPassOp;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mStencilFailOp;

  WebGPUStencilStateFaceDescriptor();

  explicit inline WebGPUStencilStateFaceDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUStencilStateFaceDescriptor(const WebGPUStencilStateFaceDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUStencilStateFaceDescriptor&
  operator=(const WebGPUStencilStateFaceDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUStencilStateFaceDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUStencilStateFaceDescriptor : public WebGPUStencilStateFaceDescriptor
{
  inline FastWebGPUStencilStateFaceDescriptor()
    : WebGPUStencilStateFaceDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUSwapChainDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mFormat;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mHeight;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mUsage;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mWidth;

  WebGPUSwapChainDescriptor();

  explicit inline WebGPUSwapChainDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUSwapChainDescriptor(const WebGPUSwapChainDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUSwapChainDescriptor&
  operator=(const WebGPUSwapChainDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUSwapChainDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUSwapChainDescriptor : public WebGPUSwapChainDescriptor
{
  inline FastWebGPUSwapChainDescriptor()
    : WebGPUSwapChainDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUTextureDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mArraySize;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mDepth;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mDimension;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mFormat;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mHeight;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mUsage;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mWidth;

  WebGPUTextureDescriptor();

  explicit inline WebGPUTextureDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUTextureDescriptor(const WebGPUTextureDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUTextureDescriptor&
  operator=(const WebGPUTextureDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUTextureDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUTextureDescriptor : public WebGPUTextureDescriptor
{
  inline FastWebGPUTextureDescriptor()
    : WebGPUTextureDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUTextureViewDescriptor : public DictionaryBase
{
  WebGPUTextureViewDescriptor();

  explicit inline WebGPUTextureViewDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUTextureViewDescriptor(const WebGPUTextureViewDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUTextureViewDescriptor&
  operator=(const WebGPUTextureViewDescriptor& aOther);
};

namespace binding_detail {
struct FastWebGPUTextureViewDescriptor : public WebGPUTextureViewDescriptor
{
  inline FastWebGPUTextureViewDescriptor()
    : WebGPUTextureViewDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUVertexAttributeDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mFormat;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mInputSlot;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mOffset;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mShaderLocation;

  WebGPUVertexAttributeDescriptor();

  explicit inline WebGPUVertexAttributeDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUVertexAttributeDescriptor(const WebGPUVertexAttributeDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUVertexAttributeDescriptor&
  operator=(const WebGPUVertexAttributeDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUVertexAttributeDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUVertexAttributeDescriptor : public WebGPUVertexAttributeDescriptor
{
  inline FastWebGPUVertexAttributeDescriptor()
    : WebGPUVertexAttributeDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUVertexInputDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mInputSlot;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mStepMode;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mStride;

  WebGPUVertexInputDescriptor();

  explicit inline WebGPUVertexInputDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUVertexInputDescriptor(const WebGPUVertexInputDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUVertexInputDescriptor&
  operator=(const WebGPUVertexInputDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUVertexInputDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUVertexInputDescriptor : public WebGPUVertexInputDescriptor
{
  inline FastWebGPUVertexInputDescriptor()
    : WebGPUVertexInputDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUBindGroupLayoutDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<WebGPUBindGroupBinding>> mBindingTypes;

  WebGPUBindGroupLayoutDescriptor();

  explicit inline WebGPUBindGroupLayoutDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUBindGroupLayoutDescriptor(const WebGPUBindGroupLayoutDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUBindGroupLayoutDescriptor&
  operator=(const WebGPUBindGroupLayoutDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUBindGroupLayoutDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUBindGroupLayoutDescriptor : public WebGPUBindGroupLayoutDescriptor
{
  inline FastWebGPUBindGroupLayoutDescriptor()
    : WebGPUBindGroupLayoutDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUBinding : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mCount;
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<OwningWebGPUSamplerOrWebGPUTextureViewOrWebGPUBufferBinding>> mResources;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mStart;

  WebGPUBinding();

  explicit inline WebGPUBinding(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUBinding(const WebGPUBinding& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  inline void
  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)
  {
    ImplCycleCollectionTraverse(aCallback, mResources, "mResources", aFlags);
  }

  inline void
  UnlinkForCC()
  {
    ImplCycleCollectionUnlink(mResources);
  }

  WebGPUBinding&
  operator=(const WebGPUBinding& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUBindingAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUBinding : public WebGPUBinding
{
  inline FastWebGPUBinding()
    : WebGPUBinding(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUBlendStateDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR WebGPUBlendDescriptor mAlpha;
  MOZ_INIT_OUTSIDE_CTOR Optional<bool> mBlendEnabled;
  MOZ_INIT_OUTSIDE_CTOR WebGPUBlendDescriptor mColor;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mWriteMask;

  WebGPUBlendStateDescriptor();

  explicit inline WebGPUBlendStateDescriptor(const FastDictionaryInitializer& )
    : mAlpha(FastDictionaryInitializer()),
      mColor(FastDictionaryInitializer())
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUBlendStateDescriptor(const WebGPUBlendStateDescriptor& aOther)
    : mAlpha(FastDictionaryInitializer()),
      mColor(FastDictionaryInitializer())
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUBlendStateDescriptor&
  operator=(const WebGPUBlendStateDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUBlendStateDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUBlendStateDescriptor : public WebGPUBlendStateDescriptor
{
  inline FastWebGPUBlendStateDescriptor()
    : WebGPUBlendStateDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUDepthStencilStateDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR WebGPUStencilStateFaceDescriptor mBack;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mDepthCompare;
  MOZ_INIT_OUTSIDE_CTOR Optional<bool> mDepthWriteEnabled;
  MOZ_INIT_OUTSIDE_CTOR WebGPUStencilStateFaceDescriptor mFront;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mStencilReadMask;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mStencilWriteMask;

  WebGPUDepthStencilStateDescriptor();

  explicit inline WebGPUDepthStencilStateDescriptor(const FastDictionaryInitializer& )
    : mBack(FastDictionaryInitializer()),
      mFront(FastDictionaryInitializer())
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUDepthStencilStateDescriptor(const WebGPUDepthStencilStateDescriptor& aOther)
    : mBack(FastDictionaryInitializer()),
      mFront(FastDictionaryInitializer())
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUDepthStencilStateDescriptor&
  operator=(const WebGPUDepthStencilStateDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUDepthStencilStateDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUDepthStencilStateDescriptor : public WebGPUDepthStencilStateDescriptor
{
  inline FastWebGPUDepthStencilStateDescriptor()
    : WebGPUDepthStencilStateDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUDeviceDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR WebGPUExtensions mExtensions;

  WebGPUDeviceDescriptor();

  explicit inline WebGPUDeviceDescriptor(const FastDictionaryInitializer& )
    : mExtensions(FastDictionaryInitializer())
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUDeviceDescriptor(const WebGPUDeviceDescriptor& aOther)
    : mExtensions(FastDictionaryInitializer())
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUDeviceDescriptor&
  operator=(const WebGPUDeviceDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUDeviceDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUDeviceDescriptor : public WebGPUDeviceDescriptor
{
  inline FastWebGPUDeviceDescriptor()
    : WebGPUDeviceDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUInputStateDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<WebGPUVertexAttributeDescriptor>> mAttributes;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mIndexFormat;
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<WebGPUVertexInputDescriptor>> mInputs;

  WebGPUInputStateDescriptor();

  explicit inline WebGPUInputStateDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUInputStateDescriptor(const WebGPUInputStateDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  WebGPUInputStateDescriptor&
  operator=(const WebGPUInputStateDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUInputStateDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUInputStateDescriptor : public WebGPUInputStateDescriptor
{
  inline FastWebGPUInputStateDescriptor()
    : WebGPUInputStateDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUPipelineDescriptorBase : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR OwningNonNull<mozilla::webgpu::PipelineLayout> mLayout;
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<WebGPUPipelineStageDescriptor>> mStages;

  WebGPUPipelineDescriptorBase();

  explicit inline WebGPUPipelineDescriptorBase(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUPipelineDescriptorBase(const WebGPUPipelineDescriptorBase& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  inline void
  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)
  {
    ImplCycleCollectionTraverse(aCallback, mLayout, "mLayout", aFlags);
    ImplCycleCollectionTraverse(aCallback, mStages, "mStages", aFlags);
  }

  inline void
  UnlinkForCC()
  {
    ImplCycleCollectionUnlink(mLayout);
    ImplCycleCollectionUnlink(mStages);
  }

  WebGPUPipelineDescriptorBase&
  operator=(const WebGPUPipelineDescriptorBase& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUPipelineDescriptorBaseAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUPipelineDescriptorBase : public WebGPUPipelineDescriptorBase
{
  inline FastWebGPUPipelineDescriptorBase()
    : WebGPUPipelineDescriptorBase(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPURenderPassDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<WebGPURenderPassAttachmentDescriptor>> mColorAttachments;
  MOZ_INIT_OUTSIDE_CTOR WebGPURenderPassAttachmentDescriptor mDepthStencilAttachment;

  WebGPURenderPassDescriptor();

  explicit inline WebGPURenderPassDescriptor(const FastDictionaryInitializer& )
    : mDepthStencilAttachment(FastDictionaryInitializer())
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPURenderPassDescriptor(const WebGPURenderPassDescriptor& aOther)
    : mDepthStencilAttachment(FastDictionaryInitializer())
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  inline void
  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)
  {
    ImplCycleCollectionTraverse(aCallback, mColorAttachments, "mColorAttachments", aFlags);
    ImplCycleCollectionTraverse(aCallback, mDepthStencilAttachment, "mDepthStencilAttachment", aFlags);
  }

  inline void
  UnlinkForCC()
  {
    ImplCycleCollectionUnlink(mColorAttachments);
    ImplCycleCollectionUnlink(mDepthStencilAttachment);
  }

  WebGPURenderPassDescriptor&
  operator=(const WebGPURenderPassDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPURenderPassDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPURenderPassDescriptor : public WebGPURenderPassDescriptor
{
  inline FastWebGPURenderPassDescriptor()
    : WebGPURenderPassDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUBindGroupDescriptor : public DictionaryBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<WebGPUBinding>> mBindings;
  MOZ_INIT_OUTSIDE_CTOR Optional<OwningNonNull<mozilla::webgpu::BindGroupLayout>> mLayout;

  WebGPUBindGroupDescriptor();

  explicit inline WebGPUBindGroupDescriptor(const FastDictionaryInitializer& )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUBindGroupDescriptor(const WebGPUBindGroupDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  inline void
  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)
  {
    ImplCycleCollectionTraverse(aCallback, mBindings, "mBindings", aFlags);
    ImplCycleCollectionTraverse(aCallback, mLayout, "mLayout", aFlags);
  }

  inline void
  UnlinkForCC()
  {
    ImplCycleCollectionUnlink(mBindings);
    ImplCycleCollectionUnlink(mLayout);
  }

  WebGPUBindGroupDescriptor&
  operator=(const WebGPUBindGroupDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPUBindGroupDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPUBindGroupDescriptor : public WebGPUBindGroupDescriptor
{
  inline FastWebGPUBindGroupDescriptor()
    : WebGPUBindGroupDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPUComputePipelineDescriptor : public WebGPUPipelineDescriptorBase
{
  WebGPUComputePipelineDescriptor();

  explicit inline WebGPUComputePipelineDescriptor(const FastDictionaryInitializer& )
    : WebGPUPipelineDescriptorBase(FastDictionaryInitializer())
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPUComputePipelineDescriptor(const WebGPUComputePipelineDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  Init(const nsAString& aJSON);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool
  ToJSON(nsAString& aJSON) const;

  void
  TraceDictionary(JSTracer* trc);

  inline void
  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)
  {
    WebGPUPipelineDescriptorBase::TraverseForCC(aCallback, aFlags);
  }

  inline void
  UnlinkForCC()
  {
    WebGPUPipelineDescriptorBase::UnlinkForCC();
  }

  WebGPUComputePipelineDescriptor&
  operator=(const WebGPUComputePipelineDescriptor& aOther);
};

namespace binding_detail {
struct FastWebGPUComputePipelineDescriptor : public WebGPUComputePipelineDescriptor
{
  inline FastWebGPUComputePipelineDescriptor()
    : WebGPUComputePipelineDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


struct WebGPURenderPipelineDescriptor : public WebGPUPipelineDescriptorBase
{
  MOZ_INIT_OUTSIDE_CTOR Optional<OwningNonNull<mozilla::webgpu::AttachmentState>> mAttachmentState;
  MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<OwningNonNull<mozilla::webgpu::BlendState>>> mBlendState;
  MOZ_INIT_OUTSIDE_CTOR Optional<OwningNonNull<mozilla::webgpu::DepthStencilState>> mDepthStencilState;
  MOZ_INIT_OUTSIDE_CTOR Optional<OwningNonNull<mozilla::webgpu::InputState>> mInputState;
  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mPrimitiveTopology;

  WebGPURenderPipelineDescriptor();

  explicit inline WebGPURenderPipelineDescriptor(const FastDictionaryInitializer& )
    : WebGPUPipelineDescriptorBase(FastDictionaryInitializer())
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

  explicit inline WebGPURenderPipelineDescriptor(const WebGPURenderPipelineDescriptor& aOther)
  {
    *this = aOther;
  }

  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool
  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  inline void
  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)
  {
    WebGPUPipelineDescriptorBase::TraverseForCC(aCallback, aFlags);
    ImplCycleCollectionTraverse(aCallback, mAttachmentState, "mAttachmentState", aFlags);
    ImplCycleCollectionTraverse(aCallback, mBlendState, "mBlendState", aFlags);
    ImplCycleCollectionTraverse(aCallback, mDepthStencilState, "mDepthStencilState", aFlags);
    ImplCycleCollectionTraverse(aCallback, mInputState, "mInputState", aFlags);
  }

  inline void
  UnlinkForCC()
  {
    WebGPUPipelineDescriptorBase::UnlinkForCC();
    ImplCycleCollectionUnlink(mAttachmentState);
    ImplCycleCollectionUnlink(mBlendState);
    ImplCycleCollectionUnlink(mDepthStencilState);
    ImplCycleCollectionUnlink(mInputState);
  }

  WebGPURenderPipelineDescriptor&
  operator=(const WebGPURenderPipelineDescriptor& aOther);

private:
  static bool
  InitIds(JSContext* cx, WebGPURenderPipelineDescriptorAtoms* atomsCache);
};

namespace binding_detail {
struct FastWebGPURenderPipelineDescriptor : public WebGPURenderPipelineDescriptor
{
  inline FastWebGPURenderPipelineDescriptor()
    : WebGPURenderPipelineDescriptor(FastDictionaryInitializer())
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace binding_detail


class WebGPULogCallback : public CallbackFunction
{
public:
  explicit inline WebGPULogCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aCallbackGlobal, nsIGlobalObject* aIncumbentGlobal)
    : CallbackFunction(aCx, aCallback, aCallbackGlobal, aIncumbentGlobal)
  {
    MOZ_ASSERT(JS::IsCallable(mCallback));
  }

  explicit inline WebGPULogCallback(JSObject* aCallback, JSObject* aCallbackGlobal, const FastCallbackConstructor& )
    : CallbackFunction(aCallback, aCallbackGlobal, FastCallbackConstructor())
  {
    MOZ_ASSERT(JS::IsCallable(mCallback));
  }

  explicit inline WebGPULogCallback(JSObject* aCallback, JSObject* aCallbackGlobal, JSObject* aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
    : CallbackFunction(aCallback, aCallbackGlobal, aAsyncStack, aIncumbentGlobal)
  {
    MOZ_ASSERT(JS::IsCallable(mCallback));
  }

  explicit inline WebGPULogCallback(CallbackFunction* aOther)
    : CallbackFunction(aOther)
  {
  }

  template <typename T>
  inline void
  Call(const T& thisVal, webgpu::LogEntry& error, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JS::Realm* aRealm = nullptr)
  {
    MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
    if (!aExecutionReason) {
      aExecutionReason = "WebGPULogCallback";
    }
    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aRealm);
    if (!s.GetContext()) {
      MOZ_ASSERT(aRv.Failed());
      return;
    }
    JS::Rooted<JS::Value> thisValJS(s.GetContext());
    if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
      aRv.Throw(NS_ERROR_FAILURE);
      return;
    }
    return Call(s.GetContext(), thisValJS, error, aRv);
  }

  inline void
  Call(webgpu::LogEntry& error, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JS::Realm* aRealm = nullptr)
  {
    MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
    if (!aExecutionReason) {
      aExecutionReason = "WebGPULogCallback";
    }
    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aRealm);
    if (!s.GetContext()) {
      MOZ_ASSERT(aRv.Failed());
      return;
    }
    return Call(s.GetContext(), JS::UndefinedHandleValue, error, aRv);
  }

  template <typename T>
  inline void
  Call(const T& thisVal, webgpu::LogEntry& error, const char* aExecutionReason = nullptr)
  {
    return Call(thisVal, error, IgnoreErrors(), aExecutionReason);
  }

  inline void
  Call(webgpu::LogEntry& error, const char* aExecutionReason = nullptr)
  {
    return Call(error, IgnoreErrors(), aExecutionReason, eReportExceptions, nullptr);
  }

  inline bool
  operator==(const WebGPULogCallback& aOther) const
  {
    return CallbackFunction::operator==(aOther);
  }

private:
  void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, webgpu::LogEntry& error, ErrorResult& aRv);
};


namespace binding_detail {
class FastWebGPULogCallback : public WebGPULogCallback
{
public:
  explicit inline FastWebGPULogCallback(JSObject* aCallback, JSObject* aCallbackGlobal)
    : WebGPULogCallback(aCallback, aCallbackGlobal, FastCallbackConstructor())
  {
  }

  inline void
  Trace(JSTracer* aTracer)
  {
    WebGPULogCallback::Trace(aTracer);
  }

  inline void
  FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
  {
    WebGPULogCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
  }
};
} // namespace binding_detail


namespace WebGPU_Binding {

  typedef mozilla::webgpu::Instance NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::Instance* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPU,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPU,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPU_Binding



namespace WebGPUAdapter_Binding {

  typedef mozilla::webgpu::Adapter NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::Adapter* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUAdapter,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUAdapter,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUAdapter_Binding



namespace WebGPUAttachmentState_Binding {

  typedef mozilla::webgpu::AttachmentState NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::AttachmentState* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUAttachmentState,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUAttachmentState,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUAttachmentState_Binding



namespace WebGPUBindGroup_Binding {

  typedef mozilla::webgpu::BindGroup NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::BindGroup* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUBindGroup,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUBindGroup,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUBindGroup_Binding



namespace WebGPUBindGroupLayout_Binding {

  typedef mozilla::webgpu::BindGroupLayout NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::BindGroupLayout* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUBindGroupLayout,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUBindGroupLayout,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUBindGroupLayout_Binding



namespace WebGPUBindingType_Binding {

  typedef mozilla::dom::WebGPUBindingType NativeType;

  static const uint32_t UNIFORM_BUFFER = 0;
  static const uint32_t SAMPLER = 1;
  static const uint32_t SAMPLED_TEXTURE = 2;
  static const uint32_t STORAGE_BUFFER = 3;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUBindingType,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUBindingType_Binding



namespace WebGPUBlendFactor_Binding {

  typedef mozilla::dom::WebGPUBlendFactor NativeType;

  static const uint32_t ZERO = 0;
  static const uint32_t ONE = 1;
  static const uint32_t SRC_COLOR = 2;
  static const uint32_t ONE_MINUS_SRC_COLOR = 3;
  static const uint32_t SRC_ALPHA = 4;
  static const uint32_t ONE_MINUS_SRC_ALPHA = 5;
  static const uint32_t DST_COLOR = 6;
  static const uint32_t ONE_MINUS_DST_COLOR = 7;
  static const uint32_t DST_ALPHA = 8;
  static const uint32_t ONE_MINUS_DST_ALPHA = 9;
  static const uint32_t SRC_ALPHA_SATURATED = 10;
  static const uint32_t BLEND_COLOR = 11;
  static const uint32_t ONE_MINUS_BLEND_COLOR = 12;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUBlendFactor,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUBlendFactor_Binding



namespace WebGPUBlendOperation_Binding {

  typedef mozilla::dom::WebGPUBlendOperation NativeType;

  static const uint32_t ADD = 0;
  static const uint32_t SUBTRACT = 1;
  static const uint32_t REVERSE_SUBTRACT = 2;
  static const uint32_t MIN = 3;
  static const uint32_t MAX = 4;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUBlendOperation,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUBlendOperation_Binding



namespace WebGPUBlendState_Binding {

  typedef mozilla::webgpu::BlendState NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::BlendState* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUBlendState,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUBlendState,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUBlendState_Binding



namespace WebGPUBuffer_Binding {

  typedef mozilla::webgpu::Buffer NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::Buffer* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUBuffer,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUBuffer,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUBuffer_Binding



namespace WebGPUBufferUsage_Binding {

  typedef mozilla::dom::WebGPUBufferUsage NativeType;

  static const uint32_t NONE = 0;
  static const uint32_t MAP_READ = 1;
  static const uint32_t MAP_WRITE = 2;
  static const uint32_t TRANSFER_SRC = 4;
  static const uint32_t TRANSFER_DST = 8;
  static const uint32_t INDEX = 16;
  static const uint32_t VERTEX = 32;
  static const uint32_t UNIFORM = 64;
  static const uint32_t STORAGE = 128;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUBufferUsage,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUBufferUsage_Binding



namespace WebGPUColorWriteBits_Binding {

  typedef mozilla::dom::WebGPUColorWriteBits NativeType;

  static const uint32_t NONE = 0;
  static const uint32_t RED = 1;
  static const uint32_t GREEN = 2;
  static const uint32_t BLUE = 4;
  static const uint32_t ALPHA = 8;
  static const uint32_t ALL = 15;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUColorWriteBits,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUColorWriteBits_Binding



namespace WebGPUCommandBuffer_Binding {

  typedef mozilla::webgpu::CommandBuffer NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::CommandBuffer* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUCommandBuffer,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUCommandBuffer,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUCommandBuffer_Binding



namespace WebGPUCommandEncoder_Binding {

  typedef mozilla::webgpu::CommandEncoder NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::CommandEncoder* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUCommandEncoder,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUCommandEncoder,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUCommandEncoder_Binding



namespace WebGPUCompareFunction_Binding {

  typedef mozilla::dom::WebGPUCompareFunction NativeType;

  static const uint32_t NEVER = 0;
  static const uint32_t LESS = 1;
  static const uint32_t LESS_EQUAL = 2;
  static const uint32_t GREATER = 3;
  static const uint32_t GREATER_EQUAL = 4;
  static const uint32_t EQUAL = 5;
  static const uint32_t NOT_EQUAL = 6;
  static const uint32_t ALWAYS = 7;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUCompareFunction,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUCompareFunction_Binding



namespace WebGPUComputePipeline_Binding {

  typedef mozilla::webgpu::ComputePipeline NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::ComputePipeline* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUComputePipeline,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUComputePipeline,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUComputePipeline_Binding



namespace WebGPUDepthStencilState_Binding {

  typedef mozilla::webgpu::DepthStencilState NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::DepthStencilState* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUDepthStencilState,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUDepthStencilState,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUDepthStencilState_Binding



namespace WebGPUDevice_Binding {

  typedef mozilla::webgpu::Device NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::Device* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUDevice,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUDevice,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUDevice_Binding



namespace WebGPUFence_Binding {

  typedef mozilla::webgpu::Fence NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::Fence* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUFence,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUFence,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUFence_Binding



namespace WebGPUFilterMode_Binding {

  typedef mozilla::dom::WebGPUFilterMode NativeType;

  static const uint32_t NEAREST = 0;
  static const uint32_t LINEAR = 1;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUFilterMode,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUFilterMode_Binding



namespace WebGPUIndexFormat_Binding {

  typedef mozilla::dom::WebGPUIndexFormat NativeType;

  static const uint32_t UINT16 = 0;
  static const uint32_t UINT32 = 1;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUIndexFormat,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUIndexFormat_Binding



namespace WebGPUInputState_Binding {

  typedef mozilla::webgpu::InputState NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::InputState* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUInputState,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUInputState,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUInputState_Binding



namespace WebGPUInputStepMode_Binding {

  typedef mozilla::dom::WebGPUInputStepMode NativeType;

  static const uint32_t VERTEX = 0;
  static const uint32_t INSTANCE = 1;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUInputStepMode,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUInputStepMode_Binding



namespace WebGPULoadOp_Binding {

  typedef mozilla::dom::WebGPULoadOp NativeType;

  static const uint32_t CLEAR = 0;
  static const uint32_t LOAD = 1;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPULoadOp,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPULoadOp_Binding



namespace WebGPULogEntry_Binding {

  typedef mozilla::webgpu::LogEntry NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::LogEntry* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPULogEntry,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPULogEntry,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPULogEntry_Binding



namespace WebGPUPipelineLayout_Binding {

  typedef mozilla::webgpu::PipelineLayout NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::PipelineLayout* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUPipelineLayout,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUPipelineLayout,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUPipelineLayout_Binding



namespace WebGPUPrimitiveTopology_Binding {

  typedef mozilla::dom::WebGPUPrimitiveTopology NativeType;

  static const uint32_t POINT_LIST = 0;
  static const uint32_t LINE_LIST = 1;
  static const uint32_t LINE_STRIP = 2;
  static const uint32_t TRIANGLE_LIST = 3;
  static const uint32_t TRIANGLE_STRIP = 4;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUPrimitiveTopology,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUPrimitiveTopology_Binding



namespace WebGPUQueue_Binding {

  typedef mozilla::webgpu::Queue NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::Queue* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUQueue,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUQueue,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUQueue_Binding



namespace WebGPURenderPipeline_Binding {

  typedef mozilla::webgpu::RenderPipeline NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::RenderPipeline* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPURenderPipeline,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPURenderPipeline,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPURenderPipeline_Binding



namespace WebGPUSampler_Binding {

  typedef mozilla::webgpu::Sampler NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::Sampler* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUSampler,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUSampler,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUSampler_Binding



namespace WebGPUShaderModule_Binding {

  typedef mozilla::webgpu::ShaderModule NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::ShaderModule* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUShaderModule,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUShaderModule,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUShaderModule_Binding



namespace WebGPUShaderStage_Binding {

  typedef mozilla::dom::WebGPUShaderStage NativeType;

  static const uint32_t VERTEX = 0;
  static const uint32_t FRAGMENT = 1;
  static const uint32_t COMPUTE = 2;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUShaderStage,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUShaderStage_Binding



namespace WebGPUShaderStageBit_Binding {

  typedef mozilla::dom::WebGPUShaderStageBit NativeType;

  static const uint32_t NONE = 0;
  static const uint32_t VERTEX = 1;
  static const uint32_t FRAGMENT = 2;
  static const uint32_t COMPUTE = 4;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUShaderStageBit,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUShaderStageBit_Binding



namespace WebGPUStencilOperation_Binding {

  typedef mozilla::dom::WebGPUStencilOperation NativeType;

  static const uint32_t KEEP = 0;
  static const uint32_t ZERO = 1;
  static const uint32_t REPLACE = 2;
  static const uint32_t INVERT = 3;
  static const uint32_t INCREMENT_CLAMP = 4;
  static const uint32_t DECREMENT_CLAMP = 5;
  static const uint32_t INCREMENT_WRAP = 6;
  static const uint32_t DECREMENT_WRAP = 7;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUStencilOperation,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUStencilOperation_Binding



namespace WebGPUStoreOp_Binding {

  typedef mozilla::dom::WebGPUStoreOp NativeType;

  static const uint32_t STORE = 0;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUStoreOp,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUStoreOp_Binding



namespace WebGPUSwapChain_Binding {

  typedef mozilla::webgpu::SwapChain NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::SwapChain* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUSwapChain,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUSwapChain,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUSwapChain_Binding



namespace WebGPUTexture_Binding {

  typedef mozilla::webgpu::Texture NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::Texture* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUTexture,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUTexture,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUTexture_Binding



namespace WebGPUTextureDimension_Binding {

  typedef mozilla::dom::WebGPUTextureDimension NativeType;

  static const uint32_t e1D = 0;
  static const uint32_t e2D = 1;
  static const uint32_t e3D = 2;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUTextureDimension,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUTextureDimension_Binding



namespace WebGPUTextureFormat_Binding {

  typedef mozilla::dom::WebGPUTextureFormat NativeType;

  static const uint32_t R8_G8_B8_A8_UNORM = 0;
  static const uint32_t R8_G8_B8_A8_UINT = 1;
  static const uint32_t B8_G8_R8_A8_UNORM = 2;
  static const uint32_t D32_FLOAT_S8_UINT = 3;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUTextureFormat,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUTextureFormat_Binding



namespace WebGPUTextureUsage_Binding {

  typedef mozilla::dom::WebGPUTextureUsage NativeType;

  static const uint32_t NONE = 0;
  static const uint32_t TRANSFER_SRC = 1;
  static const uint32_t TRANSFER_DST = 2;
  static const uint32_t SAMPLED = 4;
  static const uint32_t STORAGE = 8;
  static const uint32_t OUTPUT_ATTACHMENT = 16;
  static const uint32_t PRESENT = 32;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUTextureUsage,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUTextureUsage_Binding



namespace WebGPUTextureView_Binding {

  typedef mozilla::webgpu::TextureView NativeType;

  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*
  GetJSClass();

  bool
  Wrap(JSContext* aCx, mozilla::webgpu::TextureView* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>
  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
  {
    JS::Rooted<JSObject*> reflector(aCx);
    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
  }

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
  {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
    return GetPerInterfaceObjectHandle(aCx, prototypes::id::WebGPUTextureView,
                                       &CreateInterfaceObjects,
                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUTextureView,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUTextureView_Binding



namespace WebGPUVertexFormat_Binding {

  typedef mozilla::dom::WebGPUVertexFormat NativeType;

  static const uint32_t FLOAT_R32_G32_B32_A32 = 0;
  static const uint32_t FLOAT_R32_G32_B32 = 1;
  static const uint32_t FLOAT_R32_G32 = 2;
  static const uint32_t FLOAT_R32 = 3;
  bool
  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  // We declare this as an array so that retrieving a pointer to this
  // binding's property hooks only requires compile/link-time resolvable
  // address arithmetic.  Declaring it as a pointer instead would require
  // doing a run-time load to fetch a pointer to this binding's property
  // hooks.  And then structures which embedded a pointer to this structure
  // would require a run-time load for proper initialization, which would
  // then induce static constructors.  Lots of static constructors.
  extern const NativePropertyHooks sNativePropertyHooks[];

  void
  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
  {
    /* Get the interface object for this class.  This will create the object as
       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::WebGPUVertexFormat,
                                       &CreateInterfaceObjects,
                                       aDefineOnGlobal);
  }

  JSObject*
  GetConstructorObject(JSContext* aCx);

} // namespace WebGPUVertexFormat_Binding



} // namespace dom
} // namespace mozilla

#endif // mozilla_dom_WebGPUBinding_h

Coverage Report

Created: 2018-09-25 14:53