Adding upstream version 125.0.1.upstream/125.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 54 insertions, 28 deletions

diff --git a/dom/webgpu/ipc/WebGPUParent.cpp b/dom/webgpu/ipc/WebGPUParent.cpp
index 9b79988245..1c0560d31e 100644
--- a/dom/webgpu/ipc/WebGPUParent.cpp
+++ b/dom/webgpu/ipc/WebGPUParent.cpp
@@ -154,6 +154,12 @@ class ErrorBuffer {
     }
     return Some(Error{*filterType, false, nsCString{mMessageUtf8}});
   }
+
+  void CoerceValidationToInternal() {
+    if (mType == ffi::WGPUErrorBufferType_Validation) {
+      mType = ffi::WGPUErrorBufferType_Internal;
+    }
+  }
 };
 
 struct PendingSwapChainDrop {
@@ -180,10 +186,9 @@ class PresentationData {
   Maybe<PendingSwapChainDrop> mPendingSwapChainDrop;
 
   const uint32_t mSourcePitch;
-  std::vector<RawId> mUnassignedBufferIds MOZ_GUARDED_BY(mBuffersLock);
-  std::vector<RawId> mAvailableBufferIds MOZ_GUARDED_BY(mBuffersLock);
-  std::vector<RawId> mQueuedBufferIds MOZ_GUARDED_BY(mBuffersLock);
-  Mutex mBuffersLock;
+  std::vector<RawId> mUnassignedBufferIds;
+  std::vector<RawId> mAvailableBufferIds;
+  std::vector<RawId> mQueuedBufferIds;
 
   PresentationData(WebGPUParent* aParent, bool aUseExternalTextureInSwapChain,
                    RawId aDeviceId, RawId aQueueId,
@@ -194,8 +199,7 @@ class PresentationData {
         mDeviceId(aDeviceId),
         mQueueId(aQueueId),
         mDesc(aDesc),
-        mSourcePitch(aSourcePitch),
-        mBuffersLock("WebGPU presentation buffers") {
+        mSourcePitch(aSourcePitch) {
     MOZ_COUNT_CTOR(PresentationData);
 
     for (const RawId id : aBufferIds) {
@@ -354,6 +358,11 @@ ipc::IPCResult WebGPUParent::RecvInstanceRequestAdapter(
   nsAutoCString message(aMessage);
   req->mParent->LoseDevice(deviceId, reason, message);
 
+  auto it = req->mParent->mDeviceFenceHandles.find(deviceId);
+  if (it != req->mParent->mDeviceFenceHandles.end()) {
+    req->mParent->mDeviceFenceHandles.erase(it);
+  }
+
   // We're no longer tracking the memory for this callback, so erase
   // it to ensure we don't leak memory.
   req->mParent->mDeviceLostRequests.erase(deviceId);
@@ -394,7 +403,9 @@ ipc::IPCResult WebGPUParent::RecvAdapterRequestDevice(
   HANDLE handle =
       wgpu_server_get_device_fence_handle(mContext.get(), aDeviceId);
   if (handle) {
-    mFenceHandle = new gfx::FileHandleWrapper(UniqueFileHandle(handle));
+    RefPtr<gfx::FileHandleWrapper> fenceHandle =
+        new gfx::FileHandleWrapper(UniqueFileHandle(handle));
+    mDeviceFenceHandles.emplace(aDeviceId, std::move(fenceHandle));
   }
 #endif
 
@@ -970,20 +981,16 @@ static void ReadbackPresentCallback(ffi::WGPUBufferMapAsyncStatus status,
     return;
   }
 
-  PresentationData* data = req->mData.get();
+  RefPtr<PresentationData> data = req->mData;
   // get the buffer ID
   RawId bufferId;
   {
-    MutexAutoLock lock(data->mBuffersLock);
     bufferId = data->mQueuedBufferIds.back();
     data->mQueuedBufferIds.pop_back();
   }
 
   // Ensure we'll make the bufferId available for reuse
-  auto releaseBuffer = MakeScopeExit([data = RefPtr{data}, bufferId] {
-    MutexAutoLock lock(data->mBuffersLock);
-    data->mAvailableBufferIds.push_back(bufferId);
-  });
+  data->mAvailableBufferIds.push_back(bufferId);
 
   MOZ_LOG(sLogger, LogLevel::Info,
           ("ReadbackPresentCallback for buffer %" PRIu64 " status=%d\n",
@@ -994,15 +1001,16 @@ static void ReadbackPresentCallback(ffi::WGPUBufferMapAsyncStatus status,
     ErrorBuffer getRangeError;
     const auto mapped = ffi::wgpu_server_buffer_get_mapped_range(
         req->mContext, bufferId, 0, bufferSize, getRangeError.ToFFI());
+    getRangeError.CoerceValidationToInternal();
     if (req->mData->mParent) {
       req->mData->mParent->ForwardError(data->mDeviceId, getRangeError);
-    } else if (auto innerError = getRangeError.GetError()) {
-      // If an error occured in get_mapped_range, treat it as an internal error
-      // and crash. The error handling story for something unexpected happening
-      // during the present glue needs to befigured out in a more global way.
+    }
+    if (auto innerError = getRangeError.GetError()) {
       MOZ_LOG(sLogger, LogLevel::Info,
-              ("WebGPU present: buffer get_mapped_range failed: %s\n",
+              ("WebGPU present: buffer get_mapped_range for internal "
+               "presentation readback failed: %s\n",
                innerError->message.get()));
+      return;
     }
 
     MOZ_RELEASE_ASSERT(mapped.length >= bufferSize);
@@ -1029,11 +1037,14 @@ static void ReadbackPresentCallback(ffi::WGPUBufferMapAsyncStatus status,
     }
     ErrorBuffer unmapError;
     wgpu_server_buffer_unmap(req->mContext, bufferId, unmapError.ToFFI());
+    unmapError.CoerceValidationToInternal();
     if (req->mData->mParent) {
       req->mData->mParent->ForwardError(data->mDeviceId, unmapError);
-    } else if (auto innerError = unmapError.GetError()) {
+    }
+    if (auto innerError = unmapError.GetError()) {
       MOZ_LOG(sLogger, LogLevel::Info,
-              ("WebGPU present: buffer unmap failed: %s\n",
+              ("WebGPU present: buffer unmap for internal presentation "
+               "readback failed: %s\n",
                innerError->message.get()));
     }
   } else {
@@ -1083,9 +1094,12 @@ void WebGPUParent::PostExternalTexture(
   const auto index = aExternalTexture->GetSubmissionIndex();
   MOZ_ASSERT(index != 0);
 
+  RefPtr<PresentationData> data = lookup->second.get();
+
   Maybe<gfx::FenceInfo> fenceInfo;
-  if (mFenceHandle) {
-    fenceInfo = Some(gfx::FenceInfo(mFenceHandle, index));
+  auto it = mDeviceFenceHandles.find(data->mDeviceId);
+  if (it != mDeviceFenceHandles.end()) {
+    fenceInfo = Some(gfx::FenceInfo(it->second, index));
   }
 
   Maybe<layers::SurfaceDescriptor> desc =
@@ -1098,8 +1112,6 @@ void WebGPUParent::PostExternalTexture(
   mRemoteTextureOwner->PushTexture(aRemoteTextureId, aOwnerId, aExternalTexture,
                                    size, surfaceFormat, *desc);
 
-  RefPtr<PresentationData> data = lookup->second.get();
-
   auto recycledTexture = mRemoteTextureOwner->GetRecycledExternalTexture(
       size, surfaceFormat, desc->type(), aOwnerId);
   if (recycledTexture) {
@@ -1140,7 +1152,6 @@ ipc::IPCResult WebGPUParent::RecvSwapChainPresent(
 
   // step 1: find an available staging buffer, or create one
   {
-    MutexAutoLock lock(data->mBuffersLock);
     if (!data->mAvailableBufferIds.empty()) {
       bufferId = data->mAvailableBufferIds.back();
       data->mAvailableBufferIds.pop_back();
@@ -1285,7 +1296,6 @@ ipc::IPCResult WebGPUParent::RecvSwapChainDrop(
 
   mPresentationDataMap.erase(lookup);
 
-  MutexAutoLock lock(data->mBuffersLock);
   ipc::ByteBuf dropByteBuf;
   for (const auto bid : data->mUnassignedBufferIds) {
     wgpu_server_buffer_free(bid, ToFFI(&dropByteBuf));
@@ -1351,6 +1361,24 @@ ipc::IPCResult WebGPUParent::RecvCommandEncoderAction(
   return IPC_OK();
 }
 
+ipc::IPCResult WebGPUParent::RecvRenderPass(RawId aEncoderId, RawId aDeviceId,
+                                            const ipc::ByteBuf& aByteBuf) {
+  ErrorBuffer error;
+  ffi::wgpu_server_render_pass(mContext.get(), aEncoderId, ToFFI(&aByteBuf),
+                               error.ToFFI());
+  ForwardError(aDeviceId, error);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvComputePass(RawId aEncoderId, RawId aDeviceId,
+                                             const ipc::ByteBuf& aByteBuf) {
+  ErrorBuffer error;
+  ffi::wgpu_server_compute_pass(mContext.get(), aEncoderId, ToFFI(&aByteBuf),
+                                error.ToFFI());
+  ForwardError(aDeviceId, error);
+  return IPC_OK();
+}
+
 ipc::IPCResult WebGPUParent::RecvBumpImplicitBindGroupLayout(RawId aPipelineId,
                                                              bool aIsCompute,
                                                              uint32_t aIndex,
@@ -1426,8 +1454,6 @@ ipc::IPCResult WebGPUParent::RecvDevicePopErrorScope(
         case dom::GPUErrorFilter::Internal:
           ret.resultType = PopErrorScopeResultType::InternalError;
           break;
-        case dom::GPUErrorFilter::EndGuard_:
-          MOZ_CRASH("Bad GPUErrorFilter");
       }
     }
     return ret;