Replace RenderEngineResult with FenceResult
Bug: b/232535621
Test: atest librenderengine_test
Test: atest SurfaceFlinger_test
Change-Id: If036ab847024751b8da97d6ed856db447db19f6f
diff --git a/libs/renderengine/RenderEngine.cpp b/libs/renderengine/RenderEngine.cpp
index c7ad058..9d9cb6b 100644
--- a/libs/renderengine/RenderEngine.cpp
+++ b/libs/renderengine/RenderEngine.cpp
@@ -63,12 +63,13 @@
"output buffer not gpu writeable");
}
-std::future<RenderEngineResult> RenderEngine::drawLayers(
- const DisplaySettings& display, const std::vector<LayerSettings>& layers,
- const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
- base::unique_fd&& bufferFence) {
- const auto resultPromise = std::make_shared<std::promise<RenderEngineResult>>();
- std::future<RenderEngineResult> resultFuture = resultPromise->get_future();
+ftl::Future<FenceResult> RenderEngine::drawLayers(const DisplaySettings& display,
+ const std::vector<LayerSettings>& layers,
+ const std::shared_ptr<ExternalTexture>& buffer,
+ const bool useFramebufferCache,
+ base::unique_fd&& bufferFence) {
+ const auto resultPromise = std::make_shared<std::promise<FenceResult>>();
+ std::future<FenceResult> resultFuture = resultPromise->get_future();
drawLayersInternal(std::move(resultPromise), display, layers, buffer, useFramebufferCache,
std::move(bufferFence));
return resultFuture;
diff --git a/libs/renderengine/benchmark/RenderEngineBench.cpp b/libs/renderengine/benchmark/RenderEngineBench.cpp
index 7bcfff5..739f3fa 100644
--- a/libs/renderengine/benchmark/RenderEngineBench.cpp
+++ b/libs/renderengine/benchmark/RenderEngineBench.cpp
@@ -159,9 +159,10 @@
};
auto layers = std::vector<LayerSettings>{layer};
- auto [status, drawFence] =
- re.drawLayers(display, layers, texture, kUseFrameBufferCache, base::unique_fd()).get();
- sp<Fence> waitFence = sp<Fence>::make(std::move(drawFence));
+ sp<Fence> waitFence =
+ re.drawLayers(display, layers, texture, kUseFrameBufferCache, base::unique_fd())
+ .get()
+ .value();
waitFence->waitForever(LOG_TAG);
return texture;
}
@@ -190,10 +191,10 @@
// This loop starts and stops the timer.
for (auto _ : benchState) {
- auto [status, drawFence] = re.drawLayers(display, layers, outputBuffer,
- kUseFrameBufferCache, base::unique_fd())
- .get();
- sp<Fence> waitFence = sp<Fence>::make(std::move(drawFence));
+ sp<Fence> waitFence = re.drawLayers(display, layers, outputBuffer, kUseFrameBufferCache,
+ base::unique_fd())
+ .get()
+ .value();
waitFence->waitForever(LOG_TAG);
}
diff --git a/libs/renderengine/gl/GLESRenderEngine.cpp b/libs/renderengine/gl/GLESRenderEngine.cpp
index 9a5ff54..13f766c 100644
--- a/libs/renderengine/gl/GLESRenderEngine.cpp
+++ b/libs/renderengine/gl/GLESRenderEngine.cpp
@@ -1081,14 +1081,14 @@
}
void GLESRenderEngine::drawLayersInternal(
- const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
+ const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
const DisplaySettings& display, const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
base::unique_fd&& bufferFence) {
ATRACE_CALL();
if (layers.empty()) {
ALOGV("Drawing empty layer stack");
- resultPromise->set_value({NO_ERROR, base::unique_fd()});
+ resultPromise->set_value(Fence::NO_FENCE);
return;
}
@@ -1103,7 +1103,7 @@
if (buffer == nullptr) {
ALOGE("No output buffer provided. Aborting GPU composition.");
- resultPromise->set_value({BAD_VALUE, base::unique_fd()});
+ resultPromise->set_value(base::unexpected(BAD_VALUE));
return;
}
@@ -1132,7 +1132,7 @@
ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",
buffer->getBuffer()->handle);
checkErrors();
- resultPromise->set_value({fbo->getStatus(), base::unique_fd()});
+ resultPromise->set_value(base::unexpected(fbo->getStatus()));
return;
}
setViewportAndProjection(display.physicalDisplay, display.clip);
@@ -1144,7 +1144,7 @@
ALOGE("Failed to prepare blur filter! Aborting GPU composition for buffer (%p).",
buffer->getBuffer()->handle);
checkErrors();
- resultPromise->set_value({status, base::unique_fd()});
+ resultPromise->set_value(base::unexpected(status));
return;
}
}
@@ -1178,7 +1178,7 @@
ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",
buffer->getBuffer()->handle);
checkErrors("Can't render first blur pass");
- resultPromise->set_value({status, base::unique_fd()});
+ resultPromise->set_value(base::unexpected(status));
return;
}
@@ -1201,7 +1201,7 @@
ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",
buffer->getBuffer()->handle);
checkErrors("Can't bind native framebuffer");
- resultPromise->set_value({status, base::unique_fd()});
+ resultPromise->set_value(base::unexpected(status));
return;
}
@@ -1210,7 +1210,7 @@
ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",
buffer->getBuffer()->handle);
checkErrors("Can't render blur filter");
- resultPromise->set_value({status, base::unique_fd()});
+ resultPromise->set_value(base::unexpected(status));
return;
}
}
@@ -1310,7 +1310,7 @@
checkErrors();
// Chances are, something illegal happened (either the caller passed
// us bad parameters, or we messed up our shader generation).
- resultPromise->set_value({INVALID_OPERATION, std::move(drawFence)});
+ resultPromise->set_value(base::unexpected(INVALID_OPERATION));
return;
}
mLastDrawFence = nullptr;
@@ -1322,8 +1322,7 @@
mPriorResourcesCleaned = false;
checkErrors();
- resultPromise->set_value({NO_ERROR, std::move(drawFence)});
- return;
+ resultPromise->set_value(sp<Fence>::make(std::move(drawFence)));
}
void GLESRenderEngine::setViewportAndProjection(Rect viewport, Rect clip) {
diff --git a/libs/renderengine/gl/GLESRenderEngine.h b/libs/renderengine/gl/GLESRenderEngine.h
index 1d7c2ca..1ee5cba 100644
--- a/libs/renderengine/gl/GLESRenderEngine.h
+++ b/libs/renderengine/gl/GLESRenderEngine.h
@@ -31,6 +31,7 @@
#include <renderengine/RenderEngine.h>
#include <renderengine/private/Description.h>
#include <sys/types.h>
+#include <ui/FenceResult.h>
#include "GLShadowTexture.h"
#include "ImageManager.h"
@@ -102,7 +103,7 @@
EXCLUDES(mRenderingMutex);
void unmapExternalTextureBuffer(const sp<GraphicBuffer>& buffer) EXCLUDES(mRenderingMutex);
bool canSkipPostRenderCleanup() const override;
- void drawLayersInternal(const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
+ void drawLayersInternal(const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
const DisplaySettings& display,
const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer,
diff --git a/libs/renderengine/include/renderengine/RenderEngine.h b/libs/renderengine/include/renderengine/RenderEngine.h
index 3e7f69c..199392c 100644
--- a/libs/renderengine/include/renderengine/RenderEngine.h
+++ b/libs/renderengine/include/renderengine/RenderEngine.h
@@ -18,6 +18,7 @@
#define SF_RENDERENGINE_H_
#include <android-base/unique_fd.h>
+#include <ftl/future.h>
#include <math/mat4.h>
#include <renderengine/DisplaySettings.h>
#include <renderengine/ExternalTexture.h>
@@ -26,6 +27,7 @@
#include <renderengine/LayerSettings.h>
#include <stdint.h>
#include <sys/types.h>
+#include <ui/FenceResult.h>
#include <ui/GraphicTypes.h>
#include <ui/Transform.h>
@@ -68,7 +70,6 @@
class Mesh;
class Texture;
struct RenderEngineCreationArgs;
-struct RenderEngineResult;
namespace threaded {
class RenderEngineThreaded;
@@ -158,12 +159,13 @@
// parameter does nothing.
// @param bufferFence Fence signalling that the buffer is ready to be drawn
// to.
- // @return A future object of RenderEngineResult struct indicating whether
- // drawing was successful in async mode.
- virtual std::future<RenderEngineResult> drawLayers(
- const DisplaySettings& display, const std::vector<LayerSettings>& layers,
- const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
- base::unique_fd&& bufferFence);
+ // @return A future object of FenceResult indicating whether drawing was
+ // successful in async mode.
+ virtual ftl::Future<FenceResult> drawLayers(const DisplaySettings& display,
+ const std::vector<LayerSettings>& layers,
+ const std::shared_ptr<ExternalTexture>& buffer,
+ const bool useFramebufferCache,
+ base::unique_fd&& bufferFence);
// Clean-up method that should be called on the main thread after the
// drawFence returned by drawLayers fires. This method will free up
@@ -237,7 +239,7 @@
const RenderEngineType mRenderEngineType;
virtual void drawLayersInternal(
- const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
+ const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
const DisplaySettings& display, const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
base::unique_fd&& bufferFence) = 0;
@@ -327,13 +329,6 @@
RenderEngine::RenderEngineType::SKIA_GL_THREADED;
};
-struct RenderEngineResult {
- // status indicates if drawing is successful
- status_t status;
- // drawFence will fire when the buffer has been drawn to and is ready to be examined.
- base::unique_fd drawFence;
-};
-
} // namespace renderengine
} // namespace android
diff --git a/libs/renderengine/include/renderengine/mock/RenderEngine.h b/libs/renderengine/include/renderengine/mock/RenderEngine.h
index 248bd65..e3ce85d 100644
--- a/libs/renderengine/include/renderengine/mock/RenderEngine.h
+++ b/libs/renderengine/include/renderengine/mock/RenderEngine.h
@@ -48,14 +48,13 @@
MOCK_METHOD0(cleanupPostRender, void());
MOCK_CONST_METHOD0(canSkipPostRenderCleanup, bool());
MOCK_METHOD5(drawLayers,
- std::future<RenderEngineResult>(const DisplaySettings&,
- const std::vector<LayerSettings>&,
- const std::shared_ptr<ExternalTexture>&,
- const bool, base::unique_fd&&));
+ ftl::Future<FenceResult>(const DisplaySettings&, const std::vector<LayerSettings>&,
+ const std::shared_ptr<ExternalTexture>&, const bool,
+ base::unique_fd&&));
MOCK_METHOD6(drawLayersInternal,
- void(const std::shared_ptr<std::promise<RenderEngineResult>>&&,
- const DisplaySettings&, const std::vector<LayerSettings>&,
- const std::shared_ptr<ExternalTexture>&, const bool, base::unique_fd&&));
+ void(const std::shared_ptr<std::promise<FenceResult>>&&, const DisplaySettings&,
+ const std::vector<LayerSettings>&, const std::shared_ptr<ExternalTexture>&,
+ const bool, base::unique_fd&&));
MOCK_METHOD0(cleanFramebufferCache, void());
MOCK_METHOD0(getContextPriority, int());
MOCK_METHOD0(supportsBackgroundBlur, bool());
diff --git a/libs/renderengine/skia/SkiaRenderEngine.cpp b/libs/renderengine/skia/SkiaRenderEngine.cpp
index db983a8..b9aa5ac 100644
--- a/libs/renderengine/skia/SkiaRenderEngine.cpp
+++ b/libs/renderengine/skia/SkiaRenderEngine.cpp
@@ -632,7 +632,7 @@
};
void SkiaRenderEngine::drawLayersInternal(
- const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
+ const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
const DisplaySettings& display, const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer, const bool /*useFramebufferCache*/,
base::unique_fd&& bufferFence) {
@@ -642,7 +642,7 @@
if (buffer == nullptr) {
ALOGE("No output buffer provided. Aborting GPU composition.");
- resultPromise->set_value({BAD_VALUE, base::unique_fd()});
+ resultPromise->set_value(base::unexpected(BAD_VALUE));
return;
}
@@ -675,7 +675,7 @@
SkCanvas* dstCanvas = mCapture->tryCapture(dstSurface.get());
if (dstCanvas == nullptr) {
ALOGE("Cannot acquire canvas from Skia.");
- resultPromise->set_value({BAD_VALUE, base::unique_fd()});
+ resultPromise->set_value(base::unexpected(BAD_VALUE));
return;
}
@@ -1126,8 +1126,7 @@
}
base::unique_fd drawFence = flushAndSubmit(grContext);
- resultPromise->set_value({NO_ERROR, std::move(drawFence)});
- return;
+ resultPromise->set_value(sp<Fence>::make(std::move(drawFence)));
}
size_t SkiaRenderEngine::getMaxTextureSize() const {
diff --git a/libs/renderengine/skia/SkiaRenderEngine.h b/libs/renderengine/skia/SkiaRenderEngine.h
index a5cd278..e7c5b8f 100644
--- a/libs/renderengine/skia/SkiaRenderEngine.h
+++ b/libs/renderengine/skia/SkiaRenderEngine.h
@@ -135,7 +135,7 @@
void initCanvas(SkCanvas* canvas, const DisplaySettings& display);
void drawShadow(SkCanvas* canvas, const SkRRect& casterRRect,
const ShadowSettings& shadowSettings);
- void drawLayersInternal(const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
+ void drawLayersInternal(const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
const DisplaySettings& display,
const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer,
diff --git a/libs/renderengine/tests/RenderEngineTest.cpp b/libs/renderengine/tests/RenderEngineTest.cpp
index d23063c..9d8b2df 100644
--- a/libs/renderengine/tests/RenderEngineTest.cpp
+++ b/libs/renderengine/tests/RenderEngineTest.cpp
@@ -528,16 +528,15 @@
void invokeDraw(const renderengine::DisplaySettings& settings,
const std::vector<renderengine::LayerSettings>& layers) {
- std::future<renderengine::RenderEngineResult> result =
+ ftl::Future<FenceResult> future =
mRE->drawLayers(settings, layers, mBuffer, true, base::unique_fd());
+ ASSERT_TRUE(future.valid());
- ASSERT_TRUE(result.valid());
- auto [status, fence] = result.get();
+ auto result = future.get();
+ ASSERT_TRUE(result.ok());
- ASSERT_EQ(NO_ERROR, status);
- if (fence.ok()) {
- sync_wait(fence.get(), -1);
- }
+ auto fence = result.value();
+ fence->waitForever(LOG_TAG);
if (layers.size() > 0 && mGLESRE != nullptr) {
ASSERT_TRUE(mGLESRE->isFramebufferImageCachedForTesting(mBuffer->getBuffer()->getId()));
@@ -1681,13 +1680,13 @@
layer.geometry.boundaries = fullscreenRect().toFloatRect();
BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
layers.push_back(layer);
- std::future<renderengine::RenderEngineResult> result =
+ ftl::Future<FenceResult> future =
mRE->drawLayers(settings, layers, nullptr, true, base::unique_fd());
- ASSERT_TRUE(result.valid());
- auto [status, fence] = result.get();
- ASSERT_EQ(BAD_VALUE, status);
- ASSERT_FALSE(fence.ok());
+ ASSERT_TRUE(future.valid());
+ auto result = future.get();
+ ASSERT_FALSE(result.ok());
+ ASSERT_EQ(BAD_VALUE, result.error());
}
TEST_P(RenderEngineTest, drawLayers_doesNotCacheFramebuffer) {
@@ -1712,15 +1711,14 @@
layer.alpha = 1.0;
layers.push_back(layer);
- std::future<renderengine::RenderEngineResult> result =
+ ftl::Future<FenceResult> future =
mRE->drawLayers(settings, layers, mBuffer, false, base::unique_fd());
- ASSERT_TRUE(result.valid());
- auto [status, fence] = result.get();
+ ASSERT_TRUE(future.valid());
+ auto result = future.get();
- ASSERT_EQ(NO_ERROR, status);
- if (fence.ok()) {
- sync_wait(fence.get(), -1);
- }
+ ASSERT_TRUE(result.ok());
+ auto fence = result.value();
+ fence->waitForever(LOG_TAG);
ASSERT_FALSE(mGLESRE->isFramebufferImageCachedForTesting(mBuffer->getBuffer()->getId()));
expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
@@ -2219,20 +2217,20 @@
layer.alpha = 1.0;
layers.push_back(layer);
- std::future<renderengine::RenderEngineResult> resultOne =
+ ftl::Future<FenceResult> futureOne =
mRE->drawLayers(settings, layers, mBuffer, true, base::unique_fd());
- ASSERT_TRUE(resultOne.valid());
- auto [statusOne, fenceOne] = resultOne.get();
- ASSERT_EQ(NO_ERROR, statusOne);
+ ASSERT_TRUE(futureOne.valid());
+ auto resultOne = futureOne.get();
+ ASSERT_TRUE(resultOne.ok());
+ auto fenceOne = resultOne.value();
- std::future<renderengine::RenderEngineResult> resultTwo =
- mRE->drawLayers(settings, layers, mBuffer, true, std::move(fenceOne));
- ASSERT_TRUE(resultTwo.valid());
- auto [statusTwo, fenceTwo] = resultTwo.get();
- ASSERT_EQ(NO_ERROR, statusTwo);
- if (fenceTwo.ok()) {
- sync_wait(fenceTwo.get(), -1);
- }
+ ftl::Future<FenceResult> futureTwo =
+ mRE->drawLayers(settings, layers, mBuffer, true, base::unique_fd(fenceOne->dup()));
+ ASSERT_TRUE(futureTwo.valid());
+ auto resultTwo = futureTwo.get();
+ ASSERT_TRUE(resultTwo.ok());
+ auto fenceTwo = resultTwo.value();
+ fenceTwo->waitForever(LOG_TAG);
// Only cleanup the first time.
EXPECT_FALSE(mRE->canSkipPostRenderCleanup());
diff --git a/libs/renderengine/tests/RenderEngineThreadedTest.cpp b/libs/renderengine/tests/RenderEngineThreadedTest.cpp
index 909ded3..1a96289 100644
--- a/libs/renderengine/tests/RenderEngineThreadedTest.cpp
+++ b/libs/renderengine/tests/RenderEngineThreadedTest.cpp
@@ -183,20 +183,17 @@
base::unique_fd bufferFence;
EXPECT_CALL(*mRenderEngine, drawLayersInternal)
- .WillOnce([&](const std::shared_ptr<std::promise<renderengine::RenderEngineResult>>&&
- resultPromise,
+ .WillOnce([&](const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
const renderengine::DisplaySettings&,
const std::vector<renderengine::LayerSettings>&,
const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
- base::unique_fd&&) -> void {
- resultPromise->set_value({NO_ERROR, base::unique_fd()});
- });
+ base::unique_fd&&) { resultPromise->set_value(Fence::NO_FENCE); });
- std::future<renderengine::RenderEngineResult> result =
+ ftl::Future<FenceResult> future =
mThreadedRE->drawLayers(settings, layers, buffer, false, std::move(bufferFence));
- ASSERT_TRUE(result.valid());
- auto [status, _] = result.get();
- ASSERT_EQ(NO_ERROR, status);
+ ASSERT_TRUE(future.valid());
+ auto result = future.get();
+ ASSERT_TRUE(result.ok());
}
} // namespace android
diff --git a/libs/renderengine/threaded/RenderEngineThreaded.cpp b/libs/renderengine/threaded/RenderEngineThreaded.cpp
index 203bb54..b41e843 100644
--- a/libs/renderengine/threaded/RenderEngineThreaded.cpp
+++ b/libs/renderengine/threaded/RenderEngineThreaded.cpp
@@ -313,21 +313,21 @@
}
void RenderEngineThreaded::drawLayersInternal(
- const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
+ const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
const DisplaySettings& display, const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
base::unique_fd&& bufferFence) {
- resultPromise->set_value({NO_ERROR, base::unique_fd()});
+ resultPromise->set_value(Fence::NO_FENCE);
return;
}
-std::future<RenderEngineResult> RenderEngineThreaded::drawLayers(
+ftl::Future<FenceResult> RenderEngineThreaded::drawLayers(
const DisplaySettings& display, const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
base::unique_fd&& bufferFence) {
ATRACE_CALL();
- const auto resultPromise = std::make_shared<std::promise<RenderEngineResult>>();
- std::future<RenderEngineResult> resultFuture = resultPromise->get_future();
+ const auto resultPromise = std::make_shared<std::promise<FenceResult>>();
+ std::future<FenceResult> resultFuture = resultPromise->get_future();
int fd = bufferFence.release();
{
std::lock_guard lock(mThreadMutex);
diff --git a/libs/renderengine/threaded/RenderEngineThreaded.h b/libs/renderengine/threaded/RenderEngineThreaded.h
index 1340902..bf2ebea 100644
--- a/libs/renderengine/threaded/RenderEngineThreaded.h
+++ b/libs/renderengine/threaded/RenderEngineThreaded.h
@@ -56,11 +56,11 @@
void useProtectedContext(bool useProtectedContext) override;
void cleanupPostRender() override;
- std::future<RenderEngineResult> drawLayers(const DisplaySettings& display,
- const std::vector<LayerSettings>& layers,
- const std::shared_ptr<ExternalTexture>& buffer,
- const bool useFramebufferCache,
- base::unique_fd&& bufferFence) override;
+ ftl::Future<FenceResult> drawLayers(const DisplaySettings& display,
+ const std::vector<LayerSettings>& layers,
+ const std::shared_ptr<ExternalTexture>& buffer,
+ const bool useFramebufferCache,
+ base::unique_fd&& bufferFence) override;
void cleanFramebufferCache() override;
int getContextPriority() override;
@@ -73,7 +73,7 @@
void mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer, bool isRenderable) override;
void unmapExternalTextureBuffer(const sp<GraphicBuffer>& buffer) override;
bool canSkipPostRenderCleanup() const override;
- void drawLayersInternal(const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
+ void drawLayersInternal(const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
const DisplaySettings& display,
const std::vector<LayerSettings>& layers,
const std::shared_ptr<ExternalTexture>& buffer,
diff --git a/libs/ui/include/ui/FenceResult.h b/libs/ui/include/ui/FenceResult.h
new file mode 100644
index 0000000..6d63fc9
--- /dev/null
+++ b/libs/ui/include/ui/FenceResult.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <android-base/expected.h>
+#include <utils/Errors.h>
+#include <utils/StrongPointer.h>
+
+namespace android {
+
+class Fence;
+
+using FenceResult = base::expected<sp<Fence>, status_t>;
+
+inline status_t fenceStatus(const FenceResult& fenceResult) {
+ return fenceResult.ok() ? NO_ERROR : fenceResult.error();
+}
+
+} // namespace android