corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1948890 - Use UniqueFileHandle for Android HardwareBuffer fences. r=gfx-reviewers,aosmond

Browse Source 
We currently use ipc::FileDescriptor which is implicitly copyable, and
as a result we end up inadvertently duping the file descriptors in a few
places. This patch switches to UniqueFileHandle which makes cloning
explicit. This uncovers a few places where we were accidentally copying
the file descriptor, which this patch also fixes.

Differential Revision: https://phabricator.services.mozilla.com/D238595
This commit is contained in:
Jamie Nicol
2025-02-18 15:01:27 +00:00
parent d2d17b6243
commit 04e3dfee76
22 changed files with 88 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
gfx/gl/SharedSurfaceAndroidHardwareBuffer.cpp
View File

@@ -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);

50
gfx/layers/AndroidHardwareBuffer.cpp
View File

@@ -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>

17
gfx/layers/AndroidHardwareBuffer.h
View File

@@ -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();

6
gfx/layers/client/TextureClient.h
View File

@@ -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
@@ -33,6 +32,7 @@
#include "mozilla/layers/LayersTypes.h"
#include "mozilla/layers/SyncObject.h"
#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; }

6
gfx/layers/client/TextureClientSharedSurface.cpp
View File

@@ -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

2
gfx/layers/client/TextureClientSharedSurface.h
View File

@@ -59,7 +59,7 @@ class SharedSurfaceTextureData : public TextureData {
Maybe<uint64_t> GetBufferId() const override;
mozilla::ipc::FileDescriptor GetAcquireFence() override;
UniqueFileHandle GetAcquireFence() override;
};
} // namespace layers

10
gfx/layers/composite/TextureHost.h
View File

@@ -18,7 +18,6 @@
#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/layers/CompositorTypes.h" // for TextureFlags, etc
#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc
#include "mozilla/layers/LayersMessages.h"
@@ -27,6 +26,7 @@
#include "mozilla/mozalloc.h" // for operator delete
#include "mozilla/Range.h"
#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 {

5
gfx/layers/opengl/TextureClientOGL.cpp
View File

@@ -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();

2
gfx/layers/opengl/TextureClientOGL.h
View File

@@ -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 {

16
gfx/layers/opengl/TextureHostOGL.cpp
View File

@@ -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();
}

6
gfx/layers/opengl/TextureHostOGL.h
View File

@@ -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;

14
gfx/layers/wr/AsyncImagePipelineManager.cpp
View File

@@ -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;

11
gfx/layers/wr/AsyncImagePipelineManager.h
View File

@@ -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

8
gfx/layers/wr/WebRenderTextureHost.cpp
View File

@@ -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();
}

6
gfx/layers/wr/WebRenderTextureHost.h
View File

@@ -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;

7
gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp
View File

@@ -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);

6
gfx/webrender_bindings/RenderCompositor.h
View File

@@ -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; }

9
gfx/webrender_bindings/RenderCompositorEGL.cpp
View File

@@ -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
}

4
gfx/webrender_bindings/RenderCompositorEGL.h
View File

@@ -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

2
gfx/webrender_bindings/RenderThread.cpp
View File

@@ -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();

2
gfx/webrender_bindings/RendererOGL.cpp
View File

@@ -280,7 +280,7 @@ void RendererOGL::WaitForGPU() {
}
}
ipc::FileDescriptor RendererOGL::GetAndResetReleaseFence() {
UniqueFileHandle RendererOGL::GetAndResetReleaseFence() {
return mCompositor->GetAndResetReleaseFence();
}

4
gfx/webrender_bindings/RendererOGL.h
View File

@@ -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();