Bug 1873503 - Replace Scoped with std::unique_ptr in dom/webgpu. r=webgpu-reviewers,ErichDonGubler

marco-c · marco-c · commit 4b540710faf7 · 2024-01-19T16:15:16.000Z
Differential Revision: https://phabricator.services.mozilla.com/D198088 UltraBlame original commit: e838d654d7b583da5a04bd39314c5c700cc4d47c
diff --git a/dom/webgpu/ComputePassEncoder.cpp b/dom/webgpu/ComputePassEncoder.cpp
@@ -17,9 +17,7 @@ GPU_IMPL_CYCLE_COLLECTION(ComputePassEncoder, mParent, mUsedBindGroups,
                           mUsedPipelines)
 GPU_IMPL_JS_WRAP(ComputePassEncoder)
 
-ffi::WGPUComputePass* ScopedFfiComputeTraits::empty() { return nullptr; }
-
-void ScopedFfiComputeTraits::release(ffi::WGPUComputePass* raw) {
+void ffiWGPUComputePassDeleter::operator()(ffi::WGPUComputePass* raw) {
   if (raw) {
     ffi::wgpu_compute_pass_destroy(raw);
   }
@@ -51,7 +49,7 @@ void ComputePassEncoder::SetBindGroup(
     const dom::Sequence<uint32_t>& aDynamicOffsets) {
   if (mValid) {
     mUsedBindGroups.AppendElement(&aBindGroup);
-    ffi::wgpu_compute_pass_set_bind_group(mPass, aSlot, aBindGroup.mId,
+    ffi::wgpu_compute_pass_set_bind_group(mPass.get(), aSlot, aBindGroup.mId,
                                           aDynamicOffsets.Elements(),
                                           aDynamicOffsets.Length());
   }
@@ -60,7 +58,7 @@ void ComputePassEncoder::SetBindGroup(
 void ComputePassEncoder::SetPipeline(const ComputePipeline& aPipeline) {
   if (mValid) {
     mUsedPipelines.AppendElement(&aPipeline);
-    ffi::wgpu_compute_pass_set_pipeline(mPass, aPipeline.mId);
+    ffi::wgpu_compute_pass_set_pipeline(mPass.get(), aPipeline.mId);
   }
 }
 
@@ -69,40 +67,40 @@ void ComputePassEncoder::DispatchWorkgroups(uint32_t workgroupCountX,
                                             uint32_t workgroupCountZ) {
   if (mValid) {
     ffi::wgpu_compute_pass_dispatch_workgroups(
-        mPass, workgroupCountX, workgroupCountY, workgroupCountZ);
+        mPass.get(), workgroupCountX, workgroupCountY, workgroupCountZ);
   }
 }
 
 void ComputePassEncoder::DispatchWorkgroupsIndirect(
     const Buffer& aIndirectBuffer, uint64_t aIndirectOffset) {
   if (mValid) {
     ffi::wgpu_compute_pass_dispatch_workgroups_indirect(
-        mPass, aIndirectBuffer.mId, aIndirectOffset);
+        mPass.get(), aIndirectBuffer.mId, aIndirectOffset);
   }
 }
 
 void ComputePassEncoder::PushDebugGroup(const nsAString& aString) {
   if (mValid) {
     const NS_ConvertUTF16toUTF8 utf8(aString);
-    ffi::wgpu_compute_pass_push_debug_group(mPass, utf8.get(), 0);
+    ffi::wgpu_compute_pass_push_debug_group(mPass.get(), utf8.get(), 0);
   }
 }
 void ComputePassEncoder::PopDebugGroup() {
   if (mValid) {
-    ffi::wgpu_compute_pass_pop_debug_group(mPass);
+    ffi::wgpu_compute_pass_pop_debug_group(mPass.get());
   }
 }
 void ComputePassEncoder::InsertDebugMarker(const nsAString& aString) {
   if (mValid) {
     const NS_ConvertUTF16toUTF8 utf8(aString);
-    ffi::wgpu_compute_pass_insert_debug_marker(mPass, utf8.get(), 0);
+    ffi::wgpu_compute_pass_insert_debug_marker(mPass.get(), utf8.get(), 0);
   }
 }
 
 void ComputePassEncoder::End() {
   if (mValid) {
     mValid = false;
-    auto* pass = mPass.forget();
+    auto* pass = mPass.release();
     MOZ_ASSERT(pass);
     mParent->EndComputePass(*pass);
   }
diff --git a/dom/webgpu/ComputePassEncoder.h b/dom/webgpu/ComputePassEncoder.h
@@ -6,7 +6,6 @@
 #ifndef GPU_ComputePassEncoder_H_
 #define GPU_ComputePassEncoder_H_
 
-#include "mozilla/Scoped.h"
 #include "mozilla/dom/TypedArray.h"
 #include "ObjectModel.h"
 
@@ -27,10 +26,8 @@ class Buffer;
 class CommandEncoder;
 class ComputePipeline;
 
-struct ScopedFfiComputeTraits {
-  using type = ffi::WGPUComputePass*;
-  static type empty();
-  static void release(type raw);
+struct ffiWGPUComputePassDeleter {
+  void operator()(ffi::WGPUComputePass*);
 };
 
 class ComputePassEncoder final : public ObjectBase,
@@ -46,7 +43,7 @@ class ComputePassEncoder final : public ObjectBase,
   virtual ~ComputePassEncoder();
   void Cleanup() {}
 
-  Scoped<ScopedFfiComputeTraits> mPass;
+  std::unique_ptr<ffi::WGPUComputePass, ffiWGPUComputePassDeleter> mPass;
   
   nsTArray<RefPtr<const BindGroup>> mUsedBindGroups;
   nsTArray<RefPtr<const ComputePipeline>> mUsedPipelines;
diff --git a/dom/webgpu/RenderBundleEncoder.cpp b/dom/webgpu/RenderBundleEncoder.cpp
@@ -19,9 +19,7 @@ GPU_IMPL_CYCLE_COLLECTION(RenderBundleEncoder, mParent, mUsedBindGroups,
                           mUsedBuffers, mUsedPipelines, mUsedTextureViews)
 GPU_IMPL_JS_WRAP(RenderBundleEncoder)
 
-ffi::WGPURenderBundleEncoder* ScopedFfiBundleTraits::empty() { return nullptr; }
-
-void ScopedFfiBundleTraits::release(ffi::WGPURenderBundleEncoder* raw) {
+void ffiWGPURenderBundleEncoderDeleter::operator()(ffi::WGPURenderBundleEncoder* raw) {
   if (raw) {
     ffi::wgpu_render_bundle_encoder_destroy(raw);
   }
@@ -89,7 +87,7 @@ void RenderBundleEncoder::SetBindGroup(
     const dom::Sequence<uint32_t>& aDynamicOffsets) {
   if (mValid) {
     mUsedBindGroups.AppendElement(&aBindGroup);
-    ffi::wgpu_render_bundle_set_bind_group(mEncoder, aSlot, aBindGroup.mId,
+    ffi::wgpu_render_bundle_set_bind_group(mEncoder.get(), aSlot, aBindGroup.mId,
                                            aDynamicOffsets.Elements(),
                                            aDynamicOffsets.Length());
   }
@@ -98,7 +96,7 @@ void RenderBundleEncoder::SetBindGroup(
 void RenderBundleEncoder::SetPipeline(const RenderPipeline& aPipeline) {
   if (mValid) {
     mUsedPipelines.AppendElement(&aPipeline);
-    ffi::wgpu_render_bundle_set_pipeline(mEncoder, aPipeline.mId);
+    ffi::wgpu_render_bundle_set_pipeline(mEncoder.get(), aPipeline.mId);
   }
 }
 
@@ -110,7 +108,7 @@ void RenderBundleEncoder::SetIndexBuffer(
     const auto iformat = aIndexFormat == dom::GPUIndexFormat::Uint32
                              ? ffi::WGPUIndexFormat_Uint32
                              : ffi::WGPUIndexFormat_Uint16;
-    ffi::wgpu_render_bundle_set_index_buffer(mEncoder, aBuffer.mId, iformat,
+    ffi::wgpu_render_bundle_set_index_buffer(mEncoder.get(), aBuffer.mId, iformat,
                                              aOffset, aSize);
   }
 }
@@ -119,15 +117,15 @@ void RenderBundleEncoder::SetVertexBuffer(uint32_t aSlot, const Buffer& aBuffer,
                                           uint64_t aOffset, uint64_t aSize) {
   if (mValid) {
     mUsedBuffers.AppendElement(&aBuffer);
-    ffi::wgpu_render_bundle_set_vertex_buffer(mEncoder, aSlot, aBuffer.mId,
+    ffi::wgpu_render_bundle_set_vertex_buffer(mEncoder.get(), aSlot, aBuffer.mId,
                                               aOffset, aSize);
   }
 }
 
 void RenderBundleEncoder::Draw(uint32_t aVertexCount, uint32_t aInstanceCount,
                                uint32_t aFirstVertex, uint32_t aFirstInstance) {
   if (mValid) {
-    ffi::wgpu_render_bundle_draw(mEncoder, aVertexCount, aInstanceCount,
+    ffi::wgpu_render_bundle_draw(mEncoder.get(), aVertexCount, aInstanceCount,
                                  aFirstVertex, aFirstInstance);
   }
 }
@@ -137,7 +135,7 @@ void RenderBundleEncoder::DrawIndexed(uint32_t aIndexCount,
                                       uint32_t aFirstIndex, int32_t aBaseVertex,
                                       uint32_t aFirstInstance) {
   if (mValid) {
-    ffi::wgpu_render_bundle_draw_indexed(mEncoder, aIndexCount, aInstanceCount,
+    ffi::wgpu_render_bundle_draw_indexed(mEncoder.get(), aIndexCount, aInstanceCount,
                                          aFirstIndex, aBaseVertex,
                                          aFirstInstance);
   }
@@ -146,34 +144,34 @@ void RenderBundleEncoder::DrawIndexed(uint32_t aIndexCount,
 void RenderBundleEncoder::DrawIndirect(const Buffer& aIndirectBuffer,
                                        uint64_t aIndirectOffset) {
   if (mValid) {
-    ffi::wgpu_render_bundle_draw_indirect(mEncoder, aIndirectBuffer.mId,
+    ffi::wgpu_render_bundle_draw_indirect(mEncoder.get(), aIndirectBuffer.mId,
                                           aIndirectOffset);
   }
 }
 
 void RenderBundleEncoder::DrawIndexedIndirect(const Buffer& aIndirectBuffer,
                                               uint64_t aIndirectOffset) {
   if (mValid) {
-    ffi::wgpu_render_bundle_draw_indexed_indirect(mEncoder, aIndirectBuffer.mId,
+    ffi::wgpu_render_bundle_draw_indexed_indirect(mEncoder.get(), aIndirectBuffer.mId,
                                                   aIndirectOffset);
   }
 }
 
 void RenderBundleEncoder::PushDebugGroup(const nsAString& aString) {
   if (mValid) {
     const NS_ConvertUTF16toUTF8 utf8(aString);
-    ffi::wgpu_render_bundle_push_debug_group(mEncoder, utf8.get());
+    ffi::wgpu_render_bundle_push_debug_group(mEncoder.get(), utf8.get());
   }
 }
 void RenderBundleEncoder::PopDebugGroup() {
   if (mValid) {
-    ffi::wgpu_render_bundle_pop_debug_group(mEncoder);
+    ffi::wgpu_render_bundle_pop_debug_group(mEncoder.get());
   }
 }
 void RenderBundleEncoder::InsertDebugMarker(const nsAString& aString) {
   if (mValid) {
     const NS_ConvertUTF16toUTF8 utf8(aString);
-    ffi::wgpu_render_bundle_insert_debug_marker(mEncoder, utf8.get());
+    ffi::wgpu_render_bundle_insert_debug_marker(mEncoder.get(), utf8.get());
   }
 }
 
@@ -184,7 +182,7 @@ already_AddRefed<RenderBundle> RenderBundleEncoder::Finish(
     mValid = false;
     auto bridge = mParent->GetBridge();
     if (bridge && bridge->CanSend()) {
-      auto* encoder = mEncoder.forget();
+      auto* encoder = mEncoder.release();
       MOZ_ASSERT(encoder);
       id = bridge->RenderBundleEncoderFinish(*encoder, mParent->mId, aDesc);
     }
diff --git a/dom/webgpu/RenderBundleEncoder.h b/dom/webgpu/RenderBundleEncoder.h
@@ -6,7 +6,6 @@
 #ifndef GPU_RenderBundleEncoder_H_
 #define GPU_RenderBundleEncoder_H_
 
-#include "mozilla/Scoped.h"
 #include "mozilla/dom/TypedArray.h"
 #include "ObjectModel.h"
 
@@ -18,10 +17,8 @@ struct WGPURenderBundleEncoder;
 class Device;
 class RenderBundle;
 
-struct ScopedFfiBundleTraits {
-  using type = ffi::WGPURenderBundleEncoder*;
-  static type empty();
-  static void release(type raw);
+struct ffiWGPURenderBundleEncoderDeleter {
+  void operator()(ffi::WGPURenderBundleEncoder*);
 };
 
 class RenderBundleEncoder final : public ObjectBase, public ChildOf<Device> {
@@ -36,7 +33,7 @@ class RenderBundleEncoder final : public ObjectBase, public ChildOf<Device> {
   ~RenderBundleEncoder();
   void Cleanup();
 
-  Scoped<ScopedFfiBundleTraits> mEncoder;
+  std::unique_ptr<ffi::WGPURenderBundleEncoder, ffiWGPURenderBundleEncoderDeleter> mEncoder;
   
   nsTArray<RefPtr<const BindGroup>> mUsedBindGroups;
   nsTArray<RefPtr<const Buffer>> mUsedBuffers;
diff --git a/dom/webgpu/RenderPassEncoder.cpp b/dom/webgpu/RenderPassEncoder.cpp
diff --git a/dom/webgpu/RenderPassEncoder.h b/dom/webgpu/RenderPassEncoder.h

Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,7 @@ GPU_IMPL_CYCLE_COLLECTION(ComputePassEncoder, mParent, mUsedBindGroups,`
`17`	`17`	`mUsedPipelines)`
`18`	`18`	`GPU_IMPL_JS_WRAP(ComputePassEncoder)`
`19`	`19`
`20`		`-ffi::WGPUComputePass* ScopedFfiComputeTraits::empty() { return nullptr; }`
`21`		`-`
`22`		`-void ScopedFfiComputeTraits::release(ffi::WGPUComputePass* raw) {`
	`20`	`+void ffiWGPUComputePassDeleter::operator()(ffi::WGPUComputePass* raw) {`
`23`	`21`	`if (raw) {`
`24`	`22`	`ffi::wgpu_compute_pass_destroy(raw);`
`25`	`23`	`}`
`@@ -51,7 +49,7 @@ void ComputePassEncoder::SetBindGroup(`
`51`	`49`	`const dom::Sequence<uint32_t>& aDynamicOffsets) {`
`52`	`50`	`if (mValid) {`
`53`	`51`	`mUsedBindGroups.AppendElement(&aBindGroup);`
`54`		`- ffi::wgpu_compute_pass_set_bind_group(mPass, aSlot, aBindGroup.mId,`
	`52`	`+ ffi::wgpu_compute_pass_set_bind_group(mPass.get(), aSlot, aBindGroup.mId,`
`55`	`53`	`aDynamicOffsets.Elements(),`
`56`	`54`	`aDynamicOffsets.Length());`
`57`	`55`	`}`
`@@ -60,7 +58,7 @@ void ComputePassEncoder::SetBindGroup(`
`60`	`58`	`void ComputePassEncoder::SetPipeline(const ComputePipeline& aPipeline) {`
`61`	`59`	`if (mValid) {`
`62`	`60`	`mUsedPipelines.AppendElement(&aPipeline);`
`63`		`- ffi::wgpu_compute_pass_set_pipeline(mPass, aPipeline.mId);`
	`61`	`+ ffi::wgpu_compute_pass_set_pipeline(mPass.get(), aPipeline.mId);`
`64`	`62`	`}`
`65`	`63`	`}`
`66`	`64`
`@@ -69,40 +67,40 @@ void ComputePassEncoder::DispatchWorkgroups(uint32_t workgroupCountX,`
`69`	`67`	`uint32_t workgroupCountZ) {`
`70`	`68`	`if (mValid) {`
`71`	`69`	`ffi::wgpu_compute_pass_dispatch_workgroups(`
`72`		`- mPass, workgroupCountX, workgroupCountY, workgroupCountZ);`
	`70`	`+ mPass.get(), workgroupCountX, workgroupCountY, workgroupCountZ);`
`73`	`71`	`}`
`74`	`72`	`}`
`75`	`73`
`76`	`74`	`void ComputePassEncoder::DispatchWorkgroupsIndirect(`
`77`	`75`	`const Buffer& aIndirectBuffer, uint64_t aIndirectOffset) {`
`78`	`76`	`if (mValid) {`
`79`	`77`	`ffi::wgpu_compute_pass_dispatch_workgroups_indirect(`
`80`		`- mPass, aIndirectBuffer.mId, aIndirectOffset);`
	`78`	`+ mPass.get(), aIndirectBuffer.mId, aIndirectOffset);`
`81`	`79`	`}`
`82`	`80`	`}`
`83`	`81`
`84`	`82`	`void ComputePassEncoder::PushDebugGroup(const nsAString& aString) {`
`85`	`83`	`if (mValid) {`
`86`	`84`	`const NS_ConvertUTF16toUTF8 utf8(aString);`
`87`		`- ffi::wgpu_compute_pass_push_debug_group(mPass, utf8.get(), 0);`
	`85`	`+ ffi::wgpu_compute_pass_push_debug_group(mPass.get(), utf8.get(), 0);`
`88`	`86`	`}`
`89`	`87`	`}`
`90`	`88`	`void ComputePassEncoder::PopDebugGroup() {`
`91`	`89`	`if (mValid) {`
`92`		`- ffi::wgpu_compute_pass_pop_debug_group(mPass);`
	`90`	`+ ffi::wgpu_compute_pass_pop_debug_group(mPass.get());`
`93`	`91`	`}`
`94`	`92`	`}`
`95`	`93`	`void ComputePassEncoder::InsertDebugMarker(const nsAString& aString) {`
`96`	`94`	`if (mValid) {`
`97`	`95`	`const NS_ConvertUTF16toUTF8 utf8(aString);`
`98`		`- ffi::wgpu_compute_pass_insert_debug_marker(mPass, utf8.get(), 0);`
	`96`	`+ ffi::wgpu_compute_pass_insert_debug_marker(mPass.get(), utf8.get(), 0);`
`99`	`97`	`}`
`100`	`98`	`}`
`101`	`99`
`102`	`100`	`void ComputePassEncoder::End() {`
`103`	`101`	`if (mValid) {`
`104`	`102`	`mValid = false;`
`105`		`- auto* pass = mPass.forget();`
	`103`	`+ auto* pass = mPass.release();`
`106`	`104`	`MOZ_ASSERT(pass);`
`107`	`105`	`mParent->EndComputePass(*pass);`
`108`	`106`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,9 +19,7 @@ GPU_IMPL_CYCLE_COLLECTION(RenderBundleEncoder, mParent, mUsedBindGroups,`
`19`	`19`	`mUsedBuffers, mUsedPipelines, mUsedTextureViews)`
`20`	`20`	`GPU_IMPL_JS_WRAP(RenderBundleEncoder)`
`21`	`21`
`22`		`-ffi::WGPURenderBundleEncoder* ScopedFfiBundleTraits::empty() { return nullptr; }`
`23`		`-`
`24`		`-void ScopedFfiBundleTraits::release(ffi::WGPURenderBundleEncoder* raw) {`
	`22`	`+void ffiWGPURenderBundleEncoderDeleter::operator()(ffi::WGPURenderBundleEncoder* raw) {`
`25`	`23`	`if (raw) {`
`26`	`24`	`ffi::wgpu_render_bundle_encoder_destroy(raw);`
`27`	`25`	`}`
`@@ -89,7 +87,7 @@ void RenderBundleEncoder::SetBindGroup(`
`89`	`87`	`const dom::Sequence<uint32_t>& aDynamicOffsets) {`
`90`	`88`	`if (mValid) {`
`91`	`89`	`mUsedBindGroups.AppendElement(&aBindGroup);`
`92`		`- ffi::wgpu_render_bundle_set_bind_group(mEncoder, aSlot, aBindGroup.mId,`
	`90`	`+ ffi::wgpu_render_bundle_set_bind_group(mEncoder.get(), aSlot, aBindGroup.mId,`
`93`	`91`	`aDynamicOffsets.Elements(),`
`94`	`92`	`aDynamicOffsets.Length());`
`95`	`93`	`}`
`@@ -98,7 +96,7 @@ void RenderBundleEncoder::SetBindGroup(`
`98`	`96`	`void RenderBundleEncoder::SetPipeline(const RenderPipeline& aPipeline) {`
`99`	`97`	`if (mValid) {`
`100`	`98`	`mUsedPipelines.AppendElement(&aPipeline);`
`101`		`- ffi::wgpu_render_bundle_set_pipeline(mEncoder, aPipeline.mId);`
	`99`	`+ ffi::wgpu_render_bundle_set_pipeline(mEncoder.get(), aPipeline.mId);`
`102`	`100`	`}`
`103`	`101`	`}`
`104`	`102`
`@@ -110,7 +108,7 @@ void RenderBundleEncoder::SetIndexBuffer(`
`110`	`108`	`const auto iformat = aIndexFormat == dom::GPUIndexFormat::Uint32`
`111`	`109`	`? ffi::WGPUIndexFormat_Uint32`
`112`	`110`	`: ffi::WGPUIndexFormat_Uint16;`
`113`		`- ffi::wgpu_render_bundle_set_index_buffer(mEncoder, aBuffer.mId, iformat,`
	`111`	`+ ffi::wgpu_render_bundle_set_index_buffer(mEncoder.get(), aBuffer.mId, iformat,`
`114`	`112`	`aOffset, aSize);`
`115`	`113`	`}`
`116`	`114`	`}`
`@@ -119,15 +117,15 @@ void RenderBundleEncoder::SetVertexBuffer(uint32_t aSlot, const Buffer& aBuffer,`
`119`	`117`	`uint64_t aOffset, uint64_t aSize) {`
`120`	`118`	`if (mValid) {`
`121`	`119`	`mUsedBuffers.AppendElement(&aBuffer);`
`122`		`- ffi::wgpu_render_bundle_set_vertex_buffer(mEncoder, aSlot, aBuffer.mId,`
	`120`	`+ ffi::wgpu_render_bundle_set_vertex_buffer(mEncoder.get(), aSlot, aBuffer.mId,`
`123`	`121`	`aOffset, aSize);`
`124`	`122`	`}`
`125`	`123`	`}`
`126`	`124`
`127`	`125`	`void RenderBundleEncoder::Draw(uint32_t aVertexCount, uint32_t aInstanceCount,`
`128`	`126`	`uint32_t aFirstVertex, uint32_t aFirstInstance) {`
`129`	`127`	`if (mValid) {`
`130`		`- ffi::wgpu_render_bundle_draw(mEncoder, aVertexCount, aInstanceCount,`
	`128`	`+ ffi::wgpu_render_bundle_draw(mEncoder.get(), aVertexCount, aInstanceCount,`
`131`	`129`	`aFirstVertex, aFirstInstance);`
`132`	`130`	`}`
`133`	`131`	`}`
`@@ -137,7 +135,7 @@ void RenderBundleEncoder::DrawIndexed(uint32_t aIndexCount,`
`137`	`135`	`uint32_t aFirstIndex, int32_t aBaseVertex,`
`138`	`136`	`uint32_t aFirstInstance) {`
`139`	`137`	`if (mValid) {`
`140`		`- ffi::wgpu_render_bundle_draw_indexed(mEncoder, aIndexCount, aInstanceCount,`
	`138`	`+ ffi::wgpu_render_bundle_draw_indexed(mEncoder.get(), aIndexCount, aInstanceCount,`
`141`	`139`	`aFirstIndex, aBaseVertex,`
`142`	`140`	`aFirstInstance);`
`143`	`141`	`}`
`@@ -146,34 +144,34 @@ void RenderBundleEncoder::DrawIndexed(uint32_t aIndexCount,`
`146`	`144`	`void RenderBundleEncoder::DrawIndirect(const Buffer& aIndirectBuffer,`
`147`	`145`	`uint64_t aIndirectOffset) {`
`148`	`146`	`if (mValid) {`
`149`		`- ffi::wgpu_render_bundle_draw_indirect(mEncoder, aIndirectBuffer.mId,`
	`147`	`+ ffi::wgpu_render_bundle_draw_indirect(mEncoder.get(), aIndirectBuffer.mId,`
`150`	`148`	`aIndirectOffset);`
`151`	`149`	`}`
`152`	`150`	`}`
`153`	`151`
`154`	`152`	`void RenderBundleEncoder::DrawIndexedIndirect(const Buffer& aIndirectBuffer,`
`155`	`153`	`uint64_t aIndirectOffset) {`
`156`	`154`	`if (mValid) {`
`157`		`- ffi::wgpu_render_bundle_draw_indexed_indirect(mEncoder, aIndirectBuffer.mId,`
	`155`	`+ ffi::wgpu_render_bundle_draw_indexed_indirect(mEncoder.get(), aIndirectBuffer.mId,`
`158`	`156`	`aIndirectOffset);`
`159`	`157`	`}`
`160`	`158`	`}`
`161`	`159`
`162`	`160`	`void RenderBundleEncoder::PushDebugGroup(const nsAString& aString) {`
`163`	`161`	`if (mValid) {`
`164`	`162`	`const NS_ConvertUTF16toUTF8 utf8(aString);`
`165`		`- ffi::wgpu_render_bundle_push_debug_group(mEncoder, utf8.get());`
	`163`	`+ ffi::wgpu_render_bundle_push_debug_group(mEncoder.get(), utf8.get());`
`166`	`164`	`}`
`167`	`165`	`}`
`168`	`166`	`void RenderBundleEncoder::PopDebugGroup() {`
`169`	`167`	`if (mValid) {`
`170`		`- ffi::wgpu_render_bundle_pop_debug_group(mEncoder);`
	`168`	`+ ffi::wgpu_render_bundle_pop_debug_group(mEncoder.get());`
`171`	`169`	`}`
`172`	`170`	`}`
`173`	`171`	`void RenderBundleEncoder::InsertDebugMarker(const nsAString& aString) {`
`174`	`172`	`if (mValid) {`
`175`	`173`	`const NS_ConvertUTF16toUTF8 utf8(aString);`
`176`		`- ffi::wgpu_render_bundle_insert_debug_marker(mEncoder, utf8.get());`
	`174`	`+ ffi::wgpu_render_bundle_insert_debug_marker(mEncoder.get(), utf8.get());`
`177`	`175`	`}`
`178`	`176`	`}`
`179`	`177`
`@@ -184,7 +182,7 @@ already_AddRefed<RenderBundle> RenderBundleEncoder::Finish(`
`184`	`182`	`mValid = false;`
`185`	`183`	`auto bridge = mParent->GetBridge();`
`186`	`184`	`if (bridge && bridge->CanSend()) {`
`187`		`- auto* encoder = mEncoder.forget();`
	`185`	`+ auto* encoder = mEncoder.release();`
`188`	`186`	`MOZ_ASSERT(encoder);`
`189`	`187`	`id = bridge->RenderBundleEncoderFinish(*encoder, mParent->mId, aDesc);`
`190`	`188`	`}`