tor-browser

commit 247e62fe6fdc16da1eb805015414453ff0c38858
parent 89031bf98f809ffe571fc7dea84e73083b02cab6
Author: Cosmin Sabou <csabou@mozilla.com>
Date:   Sat, 27 Dec 2025 03:45:25 +0200

Revert "Bug 2007768 - Clean up Fence handling around AsyncImagePipelineManager r=gfx-reviewers,lsalzman" for causing build bustages on TextureHostOGL

This reverts commit ec62de7f10822149665b3741b77263acbcf51686.

Diffstat:
M
gfx/layers/composite/TextureHost.h
 | 
8
++++++++
M
gfx/layers/opengl/TextureHostOGL.cpp
 | 
26
+++++++++++++++++---------
M
gfx/layers/opengl/TextureHostOGL.h
 | 
6
+++++-
M
gfx/layers/wr/AsyncImagePipelineManager.cpp
 | 
21
++++++++++++++++-----
M
gfx/layers/wr/WebRenderTextureHost.cpp
 | 
12
++++++++++++
M
gfx/layers/wr/WebRenderTextureHost.h
 | 
6
++++++

6 files changed, 64 insertions(+), 15 deletions(-)
diff --git a/gfx/layers/composite/TextureHost.h b/gfx/layers/composite/TextureHost.h
@@ -701,6 +701,14 @@ class TextureHost : public AtomicRefCountedWithFinalize<TextureHost> {
 
   virtual bool NeedsYFlip() const;
 
+  virtual void SetAcquireFence(UniqueFileHandle&& aFenceFd) {}
+
+  virtual void SetReleaseFence(UniqueFileHandle&& aFenceFd) {}
+
+  virtual UniqueFileHandle GetAndResetReleaseFence() {
+    return UniqueFileHandle();
+  }
+
   virtual AndroidHardwareBuffer* GetAndroidHardwareBuffer() const {
     return nullptr;
   }
diff --git a/gfx/layers/opengl/TextureHostOGL.cpp b/gfx/layers/opengl/TextureHostOGL.cpp
@@ -818,19 +818,27 @@ void AndroidHardwareBufferTextureHost::DeallocateDeviceData() {
   mAndroidHardwareBuffer = nullptr;
 }
 
-void AndroidHardwareBufferTextureHost::SetReadFence(Fence* aReadFence) {
-  MOZ_ASSERT(aReadFence);
-  MOZ_ASSERT(mReadFence->AsFenceFileHandle());
-  MOZ_ASSERT(mAndroidHardwareBuffer);
+void AndroidHardwareBufferTextureHost::SetAcquireFence(
+    UniqueFileHandle&& aFenceFd) {
+  if (!mAndroidHardwareBuffer) {
+    return;
+  }
+  mAndroidHardwareBuffer->SetAcquireFence(std::move(aFenceFd));
+}
 
-  if (!aReadFence || !mReadFence->AsFenceFileHandle() ||
-      !mAndroidHardwareBuffer) {
+void AndroidHardwareBufferTextureHost::SetReleaseFence(
+    UniqueFileHandle&& aFenceFd) {
+  if (!mAndroidHardwareBuffer) {
     return;
   }
+  mAndroidHardwareBuffer->SetReleaseFence(std::move(aFenceFd));
+}
 
-  UniqueFileHandle handle =
-      aReadFence->AsFenceFileHandle()->DuplicateFileHandle();
-  mAndroidHardwareBuffer->SetReleaseFence(std::move(handle));
+UniqueFileHandle AndroidHardwareBufferTextureHost::GetAndResetReleaseFence() {
+  if (!mAndroidHardwareBuffer) {
+    return UniqueFileHandle();
+  }
+  return mAndroidHardwareBuffer->GetAndResetReleaseFence();
 }
 
 void AndroidHardwareBufferTextureHost::CreateRenderTexture(
diff --git a/gfx/layers/opengl/TextureHostOGL.h b/gfx/layers/opengl/TextureHostOGL.h
@@ -540,7 +540,11 @@ class AndroidHardwareBufferTextureHost : public TextureHost {
                         const Range<wr::ImageKey>& aImageKeys,
                         PushDisplayItemFlagSet aFlags) override;
 
-  void SetReadFence(Fence* aReadFence) override;
+  void SetAcquireFence(UniqueFileHandle&& aFenceFd) override;
+
+  void SetReleaseFence(UniqueFileHandle&& aFenceFd) override;
+
+  UniqueFileHandle GetAndResetReleaseFence() override;
 
   AndroidHardwareBuffer* GetAndroidHardwareBuffer() const override {
     return mAndroidHardwareBuffer;
diff --git a/gfx/layers/wr/AsyncImagePipelineManager.cpp b/gfx/layers/wr/AsyncImagePipelineManager.cpp
@@ -24,6 +24,15 @@
 #include "mozilla/webrender/WebRenderAPI.h"
 #include "mozilla/webrender/WebRenderTypes.h"
 
+#ifdef MOZ_WIDGET_ANDROID
+#  include "mozilla/layers/TextureHostOGL.h"
+#endif
+
+#ifdef XP_WIN
+#  include "mozilla/layers/FenceD3D11.h"
+#  include "mozilla/layers/TextureD3D11.h"
+#endif
+
 namespace mozilla {
 namespace layers {
 
@@ -725,19 +734,21 @@ void AsyncImagePipelineManager::ProcessPipelineRendered(
         holder->mTextureHostsUntilRenderSubmitted.begin(),
         holder->mTextureHostsUntilRenderSubmitted.end(),
         [&aEpoch](const auto& entry) { return aEpoch <= entry.mEpoch; });
-
-    // Set read fence if TextureHost owns AndroidHardwareBuffer.
+#ifdef MOZ_WIDGET_ANDROID
+    // Set release fence if TextureHost owns AndroidHardwareBuffer.
     // The TextureHost handled by mTextureHostsUntilRenderSubmitted instead of
     // mTextureHostsUntilRenderCompleted, since android fence could be used
     // to wait until its end of usage by GPU.
     for (auto it = holder->mTextureHostsUntilRenderSubmitted.begin();
          it != firstSubmittedHostToKeep; ++it) {
       const auto& entry = it;
-      if (entry->mTexture->GetAndroidHardwareBuffer() && mReadFence) {
-        entry->mTexture->SetReadFence(mReadFence);
+      if (entry->mTexture->GetAndroidHardwareBuffer() && mReadFence &&
+          mReadFence->AsFenceFileHandle()) {
+        entry->mTexture->SetReleaseFence(
+            mReadFence->AsFenceFileHandle()->DuplicateFileHandle());
       }
     }
-
+#endif
     holder->mTextureHostsUntilRenderSubmitted.erase(
         holder->mTextureHostsUntilRenderSubmitted.begin(),
         firstSubmittedHostToKeep);
diff --git a/gfx/layers/wr/WebRenderTextureHost.cpp b/gfx/layers/wr/WebRenderTextureHost.cpp
@@ -200,6 +200,18 @@ bool WebRenderTextureHost::SupportsExternalCompositing(
   return mWrappedTextureHost->SupportsExternalCompositing(aBackend);
 }
 
+void WebRenderTextureHost::SetAcquireFence(UniqueFileHandle&& aFenceFd) {
+  mWrappedTextureHost->SetAcquireFence(std::move(aFenceFd));
+}
+
+void WebRenderTextureHost::SetReleaseFence(UniqueFileHandle&& aFenceFd) {
+  mWrappedTextureHost->SetReleaseFence(std::move(aFenceFd));
+}
+
+UniqueFileHandle WebRenderTextureHost::GetAndResetReleaseFence() {
+  return mWrappedTextureHost->GetAndResetReleaseFence();
+}
+
 void WebRenderTextureHost::SetReadFence(Fence* aReadFence) {
   return mWrappedTextureHost->SetReadFence(aReadFence);
 }
diff --git a/gfx/layers/wr/WebRenderTextureHost.h b/gfx/layers/wr/WebRenderTextureHost.h
@@ -103,8 +103,14 @@ class WebRenderTextureHost final : public TextureHost {
 
   bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
 
+  void SetAcquireFence(UniqueFileHandle&& aFenceFd) override;
+
+  void SetReleaseFence(UniqueFileHandle&& aFenceFd) override;
+
   void SetReadFence(Fence* aReadFence) override;
 
+  UniqueFileHandle GetAndResetReleaseFence() override;
+
   AndroidHardwareBuffer* GetAndroidHardwareBuffer() const override;
 
   void MaybeNotifyForUse(wr::TransactionBuilder& aTxn);