diff --git a/gfx/gl/SharedSurfaceAndroidHardwareBuffer.cpp b/gfx/gl/SharedSurfaceAndroidHardwareBuffer.cpp
index 00f925ce7536..fc8955bffef6 100644
--- a/gfx/gl/SharedSurfaceAndroidHardwareBuffer.cpp
+++ b/gfx/gl/SharedSurfaceAndroidHardwareBuffer.cpp
@@ -111,8 +111,7 @@ void SharedSurface_AndroidHardwareBuffer::ProducerReleaseImpl() {
   MOZ_ASSERT(mSync);
   int rawFd = egl->fDupNativeFenceFDANDROID(mSync);
   if (rawFd >= 0) {
-    auto fenceFd = ipc::FileDescriptor(UniqueFileHandle(rawFd));
-    mAndroidHardwareBuffer->SetAcquireFence(std::move(fenceFd));
+    mAndroidHardwareBuffer->SetAcquireFence(UniqueFileHandle(rawFd));
   }
 
   gl->fFlush();
@@ -126,18 +125,16 @@ SharedSurface_AndroidHardwareBuffer::ToSurfaceDescriptor() {
 }
 
 void SharedSurface_AndroidHardwareBuffer::WaitForBufferOwnership() {
-  ipc::FileDescriptor fenceFd =
-      mAndroidHardwareBuffer->GetAndResetReleaseFence();
-  if (!fenceFd.IsValid()) {
+  UniqueFileHandle fenceFd = mAndroidHardwareBuffer->GetAndResetReleaseFence();
+  if (!fenceFd) {
     return;
   }
 
   const auto& gle = GLContextEGL::Cast(mDesc.gl);
   const auto& egl = gle->mEgl;
 
-  auto rawFD = fenceFd.TakePlatformHandle();
-  const EGLint attribs[] = {LOCAL_EGL_SYNC_NATIVE_FENCE_FD_ANDROID, rawFD.get(),
-                            LOCAL_EGL_NONE};
+  const EGLint attribs[] = {LOCAL_EGL_SYNC_NATIVE_FENCE_FD_ANDROID,
+                            fenceFd.get(), LOCAL_EGL_NONE};
 
   EGLSync sync = egl->fCreateSync(LOCAL_EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
   if (!sync) {
@@ -145,7 +142,7 @@ void SharedSurface_AndroidHardwareBuffer::WaitForBufferOwnership() {
     return;
   }
   // Release fd here, since it is owned by EGLSync
-  Unused << rawFD.release();
+  Unused << fenceFd.release();
 
   egl->fClientWaitSync(sync, 0, LOCAL_EGL_FOREVER);
   egl->fDestroySync(sync);
diff --git a/gfx/layers/AndroidHardwareBuffer.cpp b/gfx/layers/AndroidHardwareBuffer.cpp
index 6c474194aa8c..020dfaf892dd 100644
--- a/gfx/layers/AndroidHardwareBuffer.cpp
+++ b/gfx/layers/AndroidHardwareBuffer.cpp
@@ -210,14 +210,8 @@ AndroidHardwareBuffer::~AndroidHardwareBuffer() {
 
 int AndroidHardwareBuffer::Lock(uint64_t aUsage, const ARect* aRect,
                                 void** aOutVirtualAddress) {
-  ipc::FileDescriptor fd = GetAndResetReleaseFence();
-  int32_t fenceFd = -1;
-  ipc::FileDescriptor::UniquePlatformHandle rawFd;
-  if (fd.IsValid()) {
-    rawFd = fd.TakePlatformHandle();
-    fenceFd = rawFd.get();
-  }
-  return AndroidHardwareBufferApi::Get()->Lock(mNativeBuffer, aUsage, fenceFd,
+  UniqueFileHandle fd = GetAndResetReleaseFence();
+  return AndroidHardwareBufferApi::Get()->Lock(mNativeBuffer, aUsage, fd.get(),
                                                aRect, aOutVirtualAddress);
 }
 
@@ -229,63 +223,43 @@ int AndroidHardwareBuffer::Unlock() {
     return ret;
   }
 
-  ipc::FileDescriptor acquireFenceFd;
-  // The value -1 indicates that unlocking has already completed before
-  // the function returned and no further operations are necessary.
-  if (rawFd >= 0) {
-    acquireFenceFd = ipc::FileDescriptor(UniqueFileHandle(rawFd));
-  }
-
-  if (acquireFenceFd.IsValid()) {
-    SetAcquireFence(std::move(acquireFenceFd));
-  }
+  SetAcquireFence(UniqueFileHandle(rawFd));
   return 0;
 }
 
-void AndroidHardwareBuffer::SetReleaseFence(ipc::FileDescriptor&& aFenceFd) {
+void AndroidHardwareBuffer::SetReleaseFence(UniqueFileHandle&& aFenceFd) {
   MonitorAutoLock lock(AndroidHardwareBufferManager::Get()->GetMonitor());
   SetReleaseFence(std::move(aFenceFd), lock);
 }
 
-void AndroidHardwareBuffer::SetReleaseFence(ipc::FileDescriptor&& aFenceFd,
+void AndroidHardwareBuffer::SetReleaseFence(UniqueFileHandle&& aFenceFd,
                                             const MonitorAutoLock& aAutoLock) {
   mReleaseFenceFd = std::move(aFenceFd);
 }
 
-void AndroidHardwareBuffer::SetAcquireFence(ipc::FileDescriptor&& aFenceFd) {
+void AndroidHardwareBuffer::SetAcquireFence(UniqueFileHandle&& aFenceFd) {
   MonitorAutoLock lock(AndroidHardwareBufferManager::Get()->GetMonitor());
 
   mAcquireFenceFd = std::move(aFenceFd);
 }
 
-ipc::FileDescriptor AndroidHardwareBuffer::GetAndResetReleaseFence() {
+UniqueFileHandle AndroidHardwareBuffer::GetAndResetReleaseFence() {
   MonitorAutoLock lock(AndroidHardwareBufferManager::Get()->GetMonitor());
-
-  if (!mReleaseFenceFd.IsValid()) {
-    return ipc::FileDescriptor();
-  }
-
   return std::move(mReleaseFenceFd);
 }
 
-ipc::FileDescriptor AndroidHardwareBuffer::GetAndResetAcquireFence() {
+UniqueFileHandle AndroidHardwareBuffer::GetAndResetAcquireFence() {
   MonitorAutoLock lock(AndroidHardwareBufferManager::Get()->GetMonitor());
-
-  if (!mAcquireFenceFd.IsValid()) {
-    return ipc::FileDescriptor();
-  }
-
   return std::move(mAcquireFenceFd);
 }
 
-ipc::FileDescriptor AndroidHardwareBuffer::GetAcquireFence() {
+UniqueFileHandle AndroidHardwareBuffer::GetAcquireFence() const {
   MonitorAutoLock lock(AndroidHardwareBufferManager::Get()->GetMonitor());
-
-  if (!mAcquireFenceFd.IsValid()) {
-    return ipc::FileDescriptor();
+  if (!mAcquireFenceFd) {
+    return UniqueFileHandle();
   }
 
-  return mAcquireFenceFd;
+  return DuplicateFileHandle(mAcquireFenceFd);
 }
 
 StaticAutoPtr<AndroidHardwareBufferManager>
diff --git a/gfx/layers/AndroidHardwareBuffer.h b/gfx/layers/AndroidHardwareBuffer.h
index 6b8a66b26fdf..78c6fc5dc97d 100644
--- a/gfx/layers/AndroidHardwareBuffer.h
+++ b/gfx/layers/AndroidHardwareBuffer.h
@@ -18,6 +18,7 @@
 #include "mozilla/RefPtr.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/ThreadSafeWeakPtr.h"
+#include "mozilla/UniquePtrExtensions.h"
 
 namespace mozilla {
 namespace layers {
@@ -99,15 +100,15 @@ class AndroidHardwareBuffer
 
   AHardwareBuffer* GetNativeBuffer() const { return mNativeBuffer; }
 
-  void SetAcquireFence(ipc::FileDescriptor&& aFenceFd);
+  void SetAcquireFence(UniqueFileHandle&& aFenceFd);
 
-  void SetReleaseFence(ipc::FileDescriptor&& aFenceFd);
+  void SetReleaseFence(UniqueFileHandle&& aFenceFd);
 
-  ipc::FileDescriptor GetAndResetReleaseFence();
+  UniqueFileHandle GetAndResetReleaseFence();
 
-  ipc::FileDescriptor GetAndResetAcquireFence();
+  UniqueFileHandle GetAndResetAcquireFence();
 
-  ipc::FileDescriptor GetAcquireFence();
+  UniqueFileHandle GetAcquireFence() const;
 
   const gfx::IntSize mSize;
   const uint32_t mStride;
@@ -119,7 +120,7 @@ class AndroidHardwareBuffer
                         uint32_t aStride, gfx::SurfaceFormat aFormat,
                         uint64_t aId);
 
-  void SetReleaseFence(ipc::FileDescriptor&& aFenceFd,
+  void SetReleaseFence(UniqueFileHandle&& aFenceFd,
                        const MonitorAutoLock& aAutoLock);
 
   AHardwareBuffer* mNativeBuffer;
@@ -133,12 +134,12 @@ class AndroidHardwareBuffer
   // FileDescriptor of release fence.
   // Release fence is a fence that is used for waiting until usage/composite of
   // AHardwareBuffer is ended. The fence is delivered via ImageBridge.
-  ipc::FileDescriptor mReleaseFenceFd;
+  UniqueFileHandle mReleaseFenceFd;
 
   // FileDescriptor of acquire fence.
   // Acquire fence is a fence that is used for waiting until rendering to
   // its AHardwareBuffer is completed.
-  ipc::FileDescriptor mAcquireFenceFd;
+  UniqueFileHandle mAcquireFenceFd;
 
   static uint64_t GetNextId();
 
diff --git a/gfx/layers/client/TextureClient.h b/gfx/layers/client/TextureClient.h
index d25a52e7c84f..be16cd124958 100644
--- a/gfx/layers/client/TextureClient.h
+++ b/gfx/layers/client/TextureClient.h
@@ -24,7 +24,6 @@
 #include "mozilla/gfx/CriticalSection.h"
 #include "mozilla/gfx/Point.h"  // for IntSize
 #include "mozilla/gfx/Types.h"  // for SurfaceFormat
-#include "mozilla/ipc/FileDescriptor.h"
 #include "mozilla/ipc/Shmem.h"  // for Shmem
 #include "mozilla/layers/AtomicRefCountedWithFinalize.h"
 #include "mozilla/layers/CompositorTypes.h"  // for TextureFlags, etc
@@ -32,7 +31,8 @@
 #include "mozilla/layers/LayersSurfaces.h"  // for SurfaceDescriptor
 #include "mozilla/layers/LayersTypes.h"
 #include "mozilla/layers/SyncObject.h"
-#include "mozilla/mozalloc.h"  // for operator delete
+#include "mozilla/mozalloc.h"             // for operator delete
+#include "mozilla/UniquePtrExtensions.h"  // for UniqueFileHandle
 #include "mozilla/webrender/WebRenderTypes.h"
 #include "nsCOMPtr.h"         // for already_AddRefed
 #include "nsISupportsImpl.h"  // for TextureImage::AddRef, etc
@@ -317,9 +317,7 @@ class TextureData {
   // The acquire fence is a fence that is used for waiting until rendering to
   // its AHardwareBuffer is completed.
   // It is used only on android.
-  virtual mozilla::ipc::FileDescriptor GetAcquireFence() {
-    return mozilla::ipc::FileDescriptor();
-  }
+  virtual UniqueFileHandle GetAcquireFence() { return UniqueFileHandle(); }
 
   virtual bool RequiresRefresh() const { return false; }
 
diff --git a/gfx/layers/client/TextureClientSharedSurface.cpp b/gfx/layers/client/TextureClientSharedSurface.cpp
index 63b33335d4fb..e16663bd7a6a 100644
--- a/gfx/layers/client/TextureClientSharedSurface.cpp
+++ b/gfx/layers/client/TextureClientSharedSurface.cpp
@@ -70,7 +70,7 @@ Maybe<uint64_t> SharedSurfaceTextureData::GetBufferId() const {
   return Nothing();
 }
 
-mozilla::ipc::FileDescriptor SharedSurfaceTextureData::GetAcquireFence() {
+UniqueFileHandle SharedSurfaceTextureData::GetAcquireFence() {
 #ifdef MOZ_WIDGET_ANDROID
   if (mDesc.type() ==
       SurfaceDescriptor::TSurfaceDescriptorAndroidHardwareBuffer) {
@@ -79,13 +79,13 @@ mozilla::ipc::FileDescriptor SharedSurfaceTextureData::GetAcquireFence() {
     RefPtr<AndroidHardwareBuffer> buffer =
         AndroidHardwareBufferManager::Get()->GetBuffer(desc.bufferId());
     if (!buffer) {
-      return ipc::FileDescriptor();
+      return UniqueFileHandle();
     }
 
     return buffer->GetAcquireFence();
   }
 #endif
-  return ipc::FileDescriptor();
+  return UniqueFileHandle();
 }
 
 }  // namespace layers
diff --git a/gfx/layers/client/TextureClientSharedSurface.h b/gfx/layers/client/TextureClientSharedSurface.h
index 913afed84857..df0e3466a6fa 100644
--- a/gfx/layers/client/TextureClientSharedSurface.h
+++ b/gfx/layers/client/TextureClientSharedSurface.h
@@ -59,7 +59,7 @@ class SharedSurfaceTextureData : public TextureData {
 
   Maybe<uint64_t> GetBufferId() const override;
 
-  mozilla::ipc::FileDescriptor GetAcquireFence() override;
+  UniqueFileHandle GetAcquireFence() override;
 };
 
 }  // namespace layers
diff --git a/gfx/layers/composite/TextureHost.h b/gfx/layers/composite/TextureHost.h
index f9747c2f4ff6..2c94125b5aea 100644
--- a/gfx/layers/composite/TextureHost.h
+++ b/gfx/layers/composite/TextureHost.h
@@ -17,8 +17,7 @@
 #include "mozilla/gfx/Matrix.h"
 #include "mozilla/gfx/Point.h"  // for IntSize, IntPoint
 #include "mozilla/gfx/Rect.h"
-#include "mozilla/gfx/Types.h"  // for SurfaceFormat, etc
-#include "mozilla/ipc/FileDescriptor.h"
+#include "mozilla/gfx/Types.h"               // for SurfaceFormat, etc
 #include "mozilla/layers/CompositorTypes.h"  // for TextureFlags, etc
 #include "mozilla/layers/LayersTypes.h"      // for LayerRenderState, etc
 #include "mozilla/layers/LayersMessages.h"
@@ -26,7 +25,8 @@
 #include "mozilla/layers/TextureSourceProvider.h"
 #include "mozilla/mozalloc.h"  // for operator delete
 #include "mozilla/Range.h"
-#include "mozilla/UniquePtr.h"  // for UniquePtr
+#include "mozilla/UniquePtr.h"            // for UniquePtr
+#include "mozilla/UniquePtrExtensions.h"  // for UniqueFileHandle
 #include "mozilla/webrender/WebRenderTypes.h"
 #include "nsCOMPtr.h"         // for already_AddRefed
 #include "nsDebug.h"          // for NS_WARNING
@@ -695,12 +695,12 @@ class TextureHost : public AtomicRefCountedWithFinalize<TextureHost> {
 
   virtual bool NeedsYFlip() const;
 
-  virtual void SetAcquireFence(mozilla::ipc::FileDescriptor&& aFenceFd) {}
+  virtual void SetAcquireFence(UniqueFileHandle&& aFenceFd) {}
 
-  virtual void SetReleaseFence(mozilla::ipc::FileDescriptor&& aFenceFd) {}
+  virtual void SetReleaseFence(UniqueFileHandle&& aFenceFd) {}
 
-  virtual mozilla::ipc::FileDescriptor GetAndResetReleaseFence() {
-    return mozilla::ipc::FileDescriptor();
+  virtual UniqueFileHandle GetAndResetReleaseFence() {
+    return UniqueFileHandle();
   }
 
   virtual AndroidHardwareBuffer* GetAndroidHardwareBuffer() const {
diff --git a/gfx/layers/opengl/TextureClientOGL.cpp b/gfx/layers/opengl/TextureClientOGL.cpp
index 6035f0d2bf78..a942a4ee88a9 100644
--- a/gfx/layers/opengl/TextureClientOGL.cpp
+++ b/gfx/layers/opengl/TextureClientOGL.cpp
@@ -316,10 +316,9 @@ Maybe<uint64_t> AndroidHardwareBufferTextureData::GetBufferId() const {
   return Some(mAndroidHardwareBuffer->mId);
 }
 
-mozilla::ipc::FileDescriptor
-AndroidHardwareBufferTextureData::GetAcquireFence() {
+UniqueFileHandle AndroidHardwareBufferTextureData::GetAcquireFence() {
   if (!mAndroidHardwareBuffer) {
-    return ipc::FileDescriptor();
+    return UniqueFileHandle();
   }
 
   return mAndroidHardwareBuffer->GetAcquireFence();
diff --git a/gfx/layers/opengl/TextureClientOGL.h b/gfx/layers/opengl/TextureClientOGL.h
index cb902ab5d214..377e1549411f 100644
--- a/gfx/layers/opengl/TextureClientOGL.h
+++ b/gfx/layers/opengl/TextureClientOGL.h
@@ -137,7 +137,7 @@ class AndroidHardwareBufferTextureData : public TextureData {
 
   Maybe<uint64_t> GetBufferId() const override;
 
-  mozilla::ipc::FileDescriptor GetAcquireFence() override;
+  UniqueFileHandle GetAcquireFence() override;
 
   AndroidHardwareBufferTextureData* AsAndroidHardwareBufferTextureData()
       override {
diff --git a/gfx/layers/opengl/TextureHostOGL.cpp b/gfx/layers/opengl/TextureHostOGL.cpp
index c67d014ae987..3b1adef141af 100644
--- a/gfx/layers/opengl/TextureHostOGL.cpp
+++ b/gfx/layers/opengl/TextureHostOGL.cpp
@@ -662,19 +662,18 @@ bool AndroidHardwareBufferTextureSource::EnsureEGLImage() {
   }
 
   auto fenceFd = mAndroidHardwareBuffer->GetAndResetAcquireFence();
-  if (fenceFd.IsValid()) {
+  if (fenceFd) {
     const auto& gle = gl::GLContextEGL::Cast(mGL);
     const auto& egl = gle->mEgl;
 
-    auto rawFD = fenceFd.TakePlatformHandle();
     const EGLint attribs[] = {LOCAL_EGL_SYNC_NATIVE_FENCE_FD_ANDROID,
-                              rawFD.get(), LOCAL_EGL_NONE};
+                              fenceFd.get(), LOCAL_EGL_NONE};
 
     EGLSync sync =
         egl->fCreateSync(LOCAL_EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
     if (sync) {
       // Release fd here, since it is owned by EGLSync
-      Unused << rawFD.release();
+      Unused << fenceFd.release();
 
       if (egl->IsExtensionSupported(gl::EGLExtension::KHR_wait_sync)) {
         egl->fWaitSync(sync, 0);
@@ -820,7 +819,7 @@ void AndroidHardwareBufferTextureHost::DeallocateDeviceData() {
 }
 
 void AndroidHardwareBufferTextureHost::SetAcquireFence(
-    mozilla::ipc::FileDescriptor&& aFenceFd) {
+    UniqueFileHandle&& aFenceFd) {
   if (!mAndroidHardwareBuffer) {
     return;
   }
@@ -828,17 +827,16 @@ void AndroidHardwareBufferTextureHost::SetAcquireFence(
 }
 
 void AndroidHardwareBufferTextureHost::SetReleaseFence(
-    mozilla::ipc::FileDescriptor&& aFenceFd) {
+    UniqueFileHandle&& aFenceFd) {
   if (!mAndroidHardwareBuffer) {
     return;
   }
   mAndroidHardwareBuffer->SetReleaseFence(std::move(aFenceFd));
 }
 
-mozilla::ipc::FileDescriptor
-AndroidHardwareBufferTextureHost::GetAndResetReleaseFence() {
+UniqueFileHandle AndroidHardwareBufferTextureHost::GetAndResetReleaseFence() {
   if (!mAndroidHardwareBuffer) {
-    return mozilla::ipc::FileDescriptor();
+    return UniqueFileHandle();
   }
   return mAndroidHardwareBuffer->GetAndResetReleaseFence();
 }
diff --git a/gfx/layers/opengl/TextureHostOGL.h b/gfx/layers/opengl/TextureHostOGL.h
index 96d898ac0250..d9690e27d606 100644
--- a/gfx/layers/opengl/TextureHostOGL.h
+++ b/gfx/layers/opengl/TextureHostOGL.h
@@ -541,11 +541,11 @@ class AndroidHardwareBufferTextureHost : public TextureHost {
                         const Range<wr::ImageKey>& aImageKeys,
                         PushDisplayItemFlagSet aFlags) override;
 
-  void SetAcquireFence(mozilla::ipc::FileDescriptor&& aFenceFd) override;
+  void SetAcquireFence(UniqueFileHandle&& aFenceFd) override;
 
-  void SetReleaseFence(mozilla::ipc::FileDescriptor&& aFenceFd) override;
+  void SetReleaseFence(UniqueFileHandle&& aFenceFd) override;
 
-  mozilla::ipc::FileDescriptor GetAndResetReleaseFence() override;
+  UniqueFileHandle GetAndResetReleaseFence() override;
 
   AndroidHardwareBuffer* GetAndroidHardwareBuffer() const override {
     return mAndroidHardwareBuffer;
diff --git a/gfx/layers/wr/AsyncImagePipelineManager.cpp b/gfx/layers/wr/AsyncImagePipelineManager.cpp
index 87383f98ae9e..7b933a16da3a 100644
--- a/gfx/layers/wr/AsyncImagePipelineManager.cpp
+++ b/gfx/layers/wr/AsyncImagePipelineManager.cpp
@@ -658,7 +658,7 @@ void AsyncImagePipelineManager::HoldExternalImage(
 void AsyncImagePipelineManager::NotifyPipelinesUpdated(
     RefPtr<const wr::WebRenderPipelineInfo> aInfo,
     wr::RenderedFrameId aLatestFrameId,
-    wr::RenderedFrameId aLastCompletedFrameId, ipc::FileDescriptor&& aFenceFd) {
+    wr::RenderedFrameId aLastCompletedFrameId, UniqueFileHandle&& aFenceFd) {
   MOZ_ASSERT(wr::RenderThread::IsInRenderThread());
   MOZ_ASSERT(mLastCompletedFrameId <= aLastCompletedFrameId.mId);
   MOZ_ASSERT(aLatestFrameId.IsValid());
@@ -701,7 +701,7 @@ void AsyncImagePipelineManager::ProcessPipelineUpdates() {
 
   // submittedUpdates is a vector of RenderedFrameIds paired with vectors of
   // WebRenderPipelineInfo.
-  for (auto update : submittedUpdates) {
+  for (auto& update : submittedUpdates) {
     auto& holder = update.second;
     const auto& info = holder.mInfo->Raw();
 
@@ -736,10 +736,8 @@ void AsyncImagePipelineManager::ProcessPipelineRendered(
     for (auto it = holder->mTextureHostsUntilRenderSubmitted.begin();
          it != firstSubmittedHostToKeep; ++it) {
       const auto& entry = it;
-      if (entry->mTexture->GetAndroidHardwareBuffer() &&
-          mReleaseFenceFd.IsValid()) {
-        ipc::FileDescriptor fenceFd = mReleaseFenceFd;
-        entry->mTexture->SetReleaseFence(std::move(fenceFd));
+      if (entry->mTexture->GetAndroidHardwareBuffer() && mReleaseFenceFd) {
+        entry->mTexture->SetReleaseFence(DuplicateFileHandle(mReleaseFenceFd));
       }
     }
 #endif
@@ -826,8 +824,8 @@ wr::Epoch AsyncImagePipelineManager::GetNextImageEpoch() {
 
 AsyncImagePipelineManager::WebRenderPipelineInfoHolder::
     WebRenderPipelineInfoHolder(RefPtr<const wr::WebRenderPipelineInfo>&& aInfo,
-                                ipc::FileDescriptor&& aFenceFd)
-    : mInfo(aInfo), mFenceFd(aFenceFd) {}
+                                UniqueFileHandle&& aFenceFd)
+    : mInfo(aInfo), mFenceFd(std::move(aFenceFd)) {}
 
 AsyncImagePipelineManager::WebRenderPipelineInfoHolder::
     ~WebRenderPipelineInfoHolder() = default;
diff --git a/gfx/layers/wr/AsyncImagePipelineManager.h b/gfx/layers/wr/AsyncImagePipelineManager.h
index dbd8233f42a8..179cb8d84e4c 100644
--- a/gfx/layers/wr/AsyncImagePipelineManager.h
+++ b/gfx/layers/wr/AsyncImagePipelineManager.h
@@ -10,8 +10,8 @@
 #include <vector>
 
 #include "CompositableHost.h"
+#include "mozilla/UniquePtrExtensions.h"
 #include "mozilla/gfx/Point.h"
-#include "mozilla/ipc/FileDescriptor.h"
 #include "mozilla/layers/RemoteTextureMap.h"
 #include "mozilla/layers/TextureHost.h"
 #include "mozilla/Maybe.h"
@@ -71,7 +71,7 @@ class AsyncImagePipelineManager final {
   void NotifyPipelinesUpdated(RefPtr<const wr::WebRenderPipelineInfo> aInfo,
                               wr::RenderedFrameId aLatestFrameId,
                               wr::RenderedFrameId aLastCompletedFrameId,
-                              ipc::FileDescriptor&& aFenceFd);
+                              UniqueFileHandle&& aFenceFd);
 
   // This is run on the compositor thread to process mRenderSubmittedUpdates. We
   // make this public because we need to invoke it from other places.
@@ -277,10 +277,11 @@ class AsyncImagePipelineManager final {
 
   struct WebRenderPipelineInfoHolder {
     WebRenderPipelineInfoHolder(RefPtr<const wr::WebRenderPipelineInfo>&& aInfo,
-                                ipc::FileDescriptor&& aFenceFd);
+                                UniqueFileHandle&& aFenceFd);
     ~WebRenderPipelineInfoHolder();
+    WebRenderPipelineInfoHolder(WebRenderPipelineInfoHolder&&) = default;
     RefPtr<const wr::WebRenderPipelineInfo> mInfo;
-    ipc::FileDescriptor mFenceFd;
+    UniqueFileHandle mFenceFd;
   };
 
   std::vector<std::pair<wr::RenderedFrameId, WebRenderPipelineInfoHolder>>
@@ -291,7 +292,7 @@ class AsyncImagePipelineManager final {
   std::vector<std::pair<wr::RenderedFrameId,
                         std::vector<UniquePtr<ForwardingTextureHost>>>>
       mTexturesInUseByGPU;
-  ipc::FileDescriptor mReleaseFenceFd;
+  UniqueFileHandle mReleaseFenceFd;
 };
 
 }  // namespace layers
diff --git a/gfx/layers/wr/WebRenderTextureHost.cpp b/gfx/layers/wr/WebRenderTextureHost.cpp
index 8d17f7ef3dc6..ded58aa8df05 100644
--- a/gfx/layers/wr/WebRenderTextureHost.cpp
+++ b/gfx/layers/wr/WebRenderTextureHost.cpp
@@ -195,17 +195,15 @@ bool WebRenderTextureHost::SupportsExternalCompositing(
   return mWrappedTextureHost->SupportsExternalCompositing(aBackend);
 }
 
-void WebRenderTextureHost::SetAcquireFence(
-    mozilla::ipc::FileDescriptor&& aFenceFd) {
+void WebRenderTextureHost::SetAcquireFence(UniqueFileHandle&& aFenceFd) {
   mWrappedTextureHost->SetAcquireFence(std::move(aFenceFd));
 }
 
-void WebRenderTextureHost::SetReleaseFence(
-    mozilla::ipc::FileDescriptor&& aFenceFd) {
+void WebRenderTextureHost::SetReleaseFence(UniqueFileHandle&& aFenceFd) {
   mWrappedTextureHost->SetReleaseFence(std::move(aFenceFd));
 }
 
-mozilla::ipc::FileDescriptor WebRenderTextureHost::GetAndResetReleaseFence() {
+UniqueFileHandle WebRenderTextureHost::GetAndResetReleaseFence() {
   return mWrappedTextureHost->GetAndResetReleaseFence();
 }
 
diff --git a/gfx/layers/wr/WebRenderTextureHost.h b/gfx/layers/wr/WebRenderTextureHost.h
index 680c23d28b30..5d2be63ff1e2 100644
--- a/gfx/layers/wr/WebRenderTextureHost.h
+++ b/gfx/layers/wr/WebRenderTextureHost.h
@@ -97,11 +97,11 @@ class WebRenderTextureHost : public TextureHost {
 
   bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
 
-  void SetAcquireFence(mozilla::ipc::FileDescriptor&& aFenceFd) override;
+  void SetAcquireFence(UniqueFileHandle&& aFenceFd) override;
 
-  void SetReleaseFence(mozilla::ipc::FileDescriptor&& aFenceFd) override;
+  void SetReleaseFence(UniqueFileHandle&& aFenceFd) override;
 
-  mozilla::ipc::FileDescriptor GetAndResetReleaseFence() override;
+  UniqueFileHandle GetAndResetReleaseFence() override;
 
   AndroidHardwareBuffer* GetAndroidHardwareBuffer() const override;
 
diff --git a/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp
index 144c8817da5a..e96d241bb57e 100644
--- a/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp
+++ b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp
@@ -49,19 +49,18 @@ bool RenderAndroidHardwareBufferTextureHost::EnsureLockable() {
   }
 
   auto fenceFd = mAndroidHardwareBuffer->GetAndResetAcquireFence();
-  if (fenceFd.IsValid()) {
+  if (fenceFd) {
     const auto& gle = gl::GLContextEGL::Cast(mGL);
     const auto& egl = gle->mEgl;
 
-    auto rawFD = fenceFd.TakePlatformHandle();
     const EGLint attribs[] = {LOCAL_EGL_SYNC_NATIVE_FENCE_FD_ANDROID,
-                              rawFD.get(), LOCAL_EGL_NONE};
+                              fenceFd.get(), LOCAL_EGL_NONE};
 
     EGLSync sync =
         egl->fCreateSync(LOCAL_EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
     if (sync) {
       // Release fd here, since it is owned by EGLSync
-      Unused << rawFD.release();
+      Unused << fenceFd.release();
 
       if (egl->IsExtensionSupported(gl::EGLExtension::KHR_wait_sync)) {
         egl->fWaitSync(sync, 0);
diff --git a/gfx/webrender_bindings/RenderCompositor.h b/gfx/webrender_bindings/RenderCompositor.h
index d5ca6ee0f8a7..c6ecc15c5c6b 100644
--- a/gfx/webrender_bindings/RenderCompositor.h
+++ b/gfx/webrender_bindings/RenderCompositor.h
@@ -7,9 +7,9 @@
 #ifndef MOZILLA_GFX_RENDERCOMPOSITOR_H
 #define MOZILLA_GFX_RENDERCOMPOSITOR_H
 
-#include "mozilla/ipc/FileDescriptor.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/UniquePtr.h"
+#include "mozilla/UniquePtrExtensions.h"
 #include "mozilla/webrender/WebRenderTypes.h"
 #include "Units.h"
 
@@ -206,8 +206,8 @@ class RenderCompositor {
   // Release fence is a fence that is used for waiting until usage/composite of
   // AHardwareBuffer is ended. The fence is delivered to client side via
   // ImageBridge. It is used only on android.
-  virtual ipc::FileDescriptor GetAndResetReleaseFence() {
-    return ipc::FileDescriptor();
+  virtual UniqueFileHandle GetAndResetReleaseFence() {
+    return UniqueFileHandle();
   }
 
   virtual bool IsPaused() { return false; }
diff --git a/gfx/webrender_bindings/RenderCompositorEGL.cpp b/gfx/webrender_bindings/RenderCompositorEGL.cpp
index 47ce9d549d9f..e352be6293b6 100644
--- a/gfx/webrender_bindings/RenderCompositorEGL.cpp
+++ b/gfx/webrender_bindings/RenderCompositorEGL.cpp
@@ -123,7 +123,7 @@ RenderedFrameId RenderCompositorEGL::EndFrame(
   if (sync) {
     int fenceFd = egl->fDupNativeFenceFDANDROID(sync);
     if (fenceFd >= 0) {
-      mReleaseFenceFd = ipc::FileDescriptor(UniqueFileHandle(fenceFd));
+      mReleaseFenceFd = UniqueFileHandle(fenceFd);
     }
     egl->fDestroySync(sync);
     sync = nullptr;
@@ -259,13 +259,12 @@ void RenderCompositorEGL::DestroyEGLSurface() {
   }
 }
 
-ipc::FileDescriptor RenderCompositorEGL::GetAndResetReleaseFence() {
+UniqueFileHandle RenderCompositorEGL::GetAndResetReleaseFence() {
 #ifdef MOZ_WIDGET_ANDROID
-  MOZ_ASSERT(!layers::AndroidHardwareBufferApi::Get() ||
-             mReleaseFenceFd.IsValid());
+  MOZ_ASSERT(!layers::AndroidHardwareBufferApi::Get() || mReleaseFenceFd);
   return std::move(mReleaseFenceFd);
 #else
-  return ipc::FileDescriptor();
+  return UniqueFileHandle();
 #endif
 }
 
diff --git a/gfx/webrender_bindings/RenderCompositorEGL.h b/gfx/webrender_bindings/RenderCompositorEGL.h
index 8e851b2fc0df..dcd0e03ded69 100644
--- a/gfx/webrender_bindings/RenderCompositorEGL.h
+++ b/gfx/webrender_bindings/RenderCompositorEGL.h
@@ -46,7 +46,7 @@ class RenderCompositorEGL : public RenderCompositor {
   void SetBufferDamageRegion(const wr::DeviceIntRect* aRects,
                              size_t aNumRects) override;
 
-  ipc::FileDescriptor GetAndResetReleaseFence() override;
+  UniqueFileHandle GetAndResetReleaseFence() override;
 
  protected:
   EGLSurface CreateEGLSurface();
@@ -66,7 +66,7 @@ class RenderCompositorEGL : public RenderCompositor {
   // Release fence is a fence that is used for waiting until usage/composite of
   // AHardwareBuffer is ended. The fence is delivered to client side via
   // ImageBridge. It is used only on android.
-  ipc::FileDescriptor mReleaseFenceFd;
+  UniqueFileHandle mReleaseFenceFd;
 };
 
 }  // namespace wr
diff --git a/gfx/webrender_bindings/RenderThread.cpp b/gfx/webrender_bindings/RenderThread.cpp
index 8d20e96f2605..62377f3739ca 100644
--- a/gfx/webrender_bindings/RenderThread.cpp
+++ b/gfx/webrender_bindings/RenderThread.cpp
@@ -866,7 +866,7 @@ void RenderThread::UpdateAndRender(
                           renderer->GetCompositorBridge(), info, aStartId,
                           aStartTime, start, end, aRender, *aStats));
 
-  ipc::FileDescriptor fenceFd;
+  UniqueFileHandle fenceFd;
 
   if (latestFrameId.IsValid()) {
     fenceFd = renderer->GetAndResetReleaseFence();
diff --git a/gfx/webrender_bindings/RendererOGL.cpp b/gfx/webrender_bindings/RendererOGL.cpp
index ed590ff95667..f1ed01468afc 100644
--- a/gfx/webrender_bindings/RendererOGL.cpp
+++ b/gfx/webrender_bindings/RendererOGL.cpp
@@ -280,7 +280,7 @@ void RendererOGL::WaitForGPU() {
   }
 }
 
-ipc::FileDescriptor RendererOGL::GetAndResetReleaseFence() {
+UniqueFileHandle RendererOGL::GetAndResetReleaseFence() {
   return mCompositor->GetAndResetReleaseFence();
 }
 
diff --git a/gfx/webrender_bindings/RendererOGL.h b/gfx/webrender_bindings/RendererOGL.h
index 60f7ac372107..cba22a6b44ed 100644
--- a/gfx/webrender_bindings/RendererOGL.h
+++ b/gfx/webrender_bindings/RendererOGL.h
@@ -7,7 +7,7 @@
 #ifndef MOZILLA_LAYERS_RENDEREROGL_H
 #define MOZILLA_LAYERS_RENDEREROGL_H
 
-#include "mozilla/ipc/FileDescriptor.h"
+#include "mozilla/UniquePtrExtensions.h"
 #include "mozilla/layers/CompositorTypes.h"
 #include "mozilla/gfx/Point.h"
 #include "mozilla/webrender/RenderThread.h"
@@ -70,7 +70,7 @@ class RendererOGL {
   void WaitForGPU();
 
   /// This can be called on the render thread only.
-  ipc::FileDescriptor GetAndResetReleaseFence();
+  UniqueFileHandle GetAndResetReleaseFence();
 
   /// This can be called on the render thread only.
   RenderedFrameId GetLastCompletedFrameId();