| // Copyright 2024 The Dawn & Tint Authors | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are met: | |
| // | |
| // 1. Redistributions of source code must retain the above copyright notice, this | |
| // list of conditions and the following disclaimer. | |
| // | |
| // 2. Redistributions in binary form must reproduce the above copyright notice, | |
| // this list of conditions and the following disclaimer in the documentation | |
| // and/or other materials provided with the distribution. | |
| // | |
| // 3. Neither the name of the copyright holder nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| #include <array> | |
| #include <utility> | |
| #include "dawn/tests/unittests/wire/WireTest.h" | |
| #include "dawn/wire/WireClient.h" | |
| #include "dawn/wire/WireServer.h" | |
| namespace dawn::wire { | |
| namespace { | |
| using testing::_; | |
| using testing::Mock; | |
| using testing::Return; | |
| using testing::WithArgs; | |
| class WireInjectSurfaceTests : public WireTest { | |
| public: | |
| void SetUp() override { | |
| WireTest::SetUp(); | |
| mCapabilities.usages = mSupportedUsages; | |
| mCapabilities.formatCount = mSupportedFormats.size(); | |
| mCapabilities.formats = mSupportedFormats.data(); | |
| mCapabilities.presentModeCount = mSupportedPresentModes.size(); | |
| mCapabilities.presentModes = mSupportedPresentModes.data(); | |
| mCapabilities.alphaModeCount = mSupportedAlphaModes.size(); | |
| mCapabilities.alphaModes = mSupportedAlphaModes.data(); | |
| mConfiguration.format = wgpu::TextureFormat::RGBA8Unorm; | |
| mConfiguration.alphaMode = wgpu::CompositeAlphaMode::Opaque; | |
| mConfiguration.presentMode = wgpu::PresentMode::Fifo; | |
| mConfiguration.width = 100; | |
| mConfiguration.height = 100; | |
| mConfiguration.usage = wgpu::TextureUsage::RenderAttachment; | |
| mConfiguration.device = device; | |
| mConfiguration.viewFormatCount = 0; | |
| } | |
| void TearDown() override { | |
| mConfiguration.device = nullptr; | |
| WireTest::TearDown(); | |
| } | |
| std::pair<ReservedSurface, wgpu::Surface> ReserveSurface(const WGPUSurfaceCapabilities* caps) { | |
| auto reservation = GetWireClient()->ReserveSurface(instance.Get(), &mCapabilities); | |
| return {reservation, wgpu::Surface::Acquire(reservation.surface)}; | |
| } | |
| WGPUSurfaceCapabilities mCapabilities; | |
| WGPUTextureUsage mSupportedUsages = | |
| WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_CopySrc; | |
| std::array<WGPUTextureFormat, 2> mSupportedFormats = {WGPUTextureFormat_RGBA8Unorm, | |
| WGPUTextureFormat_RGBA8UnormSrgb}; | |
| std::array<WGPUPresentMode, 2> mSupportedPresentModes = {WGPUPresentMode_Fifo, | |
| WGPUPresentMode_Mailbox}; | |
| std::array<WGPUCompositeAlphaMode, 2> mSupportedAlphaModes = {WGPUCompositeAlphaMode_Opaque, | |
| WGPUCompositeAlphaMode_Inherit}; | |
| wgpu::SurfaceConfiguration mConfiguration; | |
| }; | |
| // Test that reserving and injecting a surface makes calls on the client object forward to the | |
| // server object correctly. | |
| TEST_F(WireInjectSurfaceTests, CallAfterReserveInject) { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| WGPUSurface apiSurface = api.GetNewSurface(); | |
| EXPECT_CALL(api, SurfaceAddRef(apiSurface)); | |
| ASSERT_TRUE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| // The client assumes a reserved surface is unconfigured, so it can't present. | |
| EXPECT_EQ(wgpu::Status::Error, surface.Present()); | |
| FlushClient(); | |
| surface.Configure(&mConfiguration); | |
| EXPECT_CALL(api, SurfaceConfigure(apiSurface, _)); | |
| EXPECT_EQ(wgpu::Status::Success, surface.Present()); | |
| EXPECT_CALL(api, SurfacePresent(apiSurface)).WillOnce(Return(WGPUStatus_Success)); | |
| FlushClient(); | |
| } | |
| // Test that reserve correctly returns different IDs each time. | |
| TEST_F(WireInjectSurfaceTests, ReserveDifferentIDs) { | |
| auto [reservation1, surface1] = ReserveSurface(&mCapabilities); | |
| auto [reservation2, surface2] = ReserveSurface(&mCapabilities); | |
| ASSERT_NE(reservation1.handle.id, reservation2.handle.id); | |
| ASSERT_NE(surface1.Get(), surface2.Get()); | |
| } | |
| // Test that injecting the same id without a destroy first fails. | |
| TEST_F(WireInjectSurfaceTests, InjectExistingID) { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| WGPUSurface apiSurface = api.GetNewSurface(); | |
| EXPECT_CALL(api, SurfaceAddRef(apiSurface)); | |
| ASSERT_TRUE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| // ID already in use, call fails. | |
| ASSERT_FALSE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| } | |
| // Test that the server only borrows the surface and does a single addref-release | |
| TEST_F(WireInjectSurfaceTests, InjectedSurfaceLifetime) { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| // Injecting the surface adds a reference | |
| WGPUSurface apiSurface = api.GetNewSurface(); | |
| EXPECT_CALL(api, SurfaceAddRef(apiSurface)); | |
| ASSERT_TRUE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| // Releasing the surface removes a single reference. | |
| surface = nullptr; | |
| EXPECT_CALL(api, SurfaceRelease(apiSurface)); | |
| FlushClient(); | |
| // Deleting the server doesn't release a second reference. | |
| DeleteServer(); | |
| Mock::VerifyAndClearExpectations(&api); | |
| } | |
| // Test that a surface reservation can be reclaimed. This is necessary to | |
| // avoid leaking ObjectIDs for reservations that are never injected. | |
| TEST_F(WireInjectSurfaceTests, ReclaimSurfaceReservation) { | |
| // Test that doing a reservation and full release is an error. | |
| { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| surface = nullptr; | |
| FlushClient(false); | |
| } | |
| // Test that doing a reservation and then reclaiming it recycles the ID. | |
| { | |
| auto [reservation1, surface1] = ReserveSurface(&mCapabilities); | |
| GetWireClient()->ReclaimSurfaceReservation(reservation1); | |
| auto [reservation2, surface2] = ReserveSurface(&mCapabilities); | |
| // The ID is the same, but the generation is still different. | |
| ASSERT_EQ(reservation1.handle.id, reservation2.handle.id); | |
| ASSERT_NE(reservation1.handle.generation, reservation2.handle.generation); | |
| // No errors should occur. | |
| FlushClient(); | |
| } | |
| } | |
| // Test that the surface returns capabilities that were provided during the injection. | |
| TEST_F(WireInjectSurfaceTests, Capabilities) { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| WGPUSurface apiSurface = api.GetNewSurface(); | |
| EXPECT_CALL(api, SurfaceAddRef(apiSurface)); | |
| ASSERT_TRUE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| wgpu::SurfaceCapabilities caps; | |
| wgpu::Status status = surface.GetCapabilities(adapter, &caps); | |
| EXPECT_EQ(status, wgpu::Status::Success); | |
| EXPECT_EQ(caps.formatCount, mCapabilities.formatCount); | |
| for (uint32_t i = 0; i < caps.formatCount; i++) { | |
| EXPECT_EQ(static_cast<WGPUTextureFormat>(caps.formats[i]), mCapabilities.formats[i]); | |
| } | |
| EXPECT_EQ(caps.presentModeCount, mCapabilities.presentModeCount); | |
| for (uint32_t i = 0; i < caps.presentModeCount; i++) { | |
| EXPECT_EQ(static_cast<WGPUPresentMode>(caps.presentModes[i]), | |
| mCapabilities.presentModes[i]); | |
| } | |
| EXPECT_EQ(caps.alphaModeCount, mCapabilities.alphaModeCount); | |
| for (uint32_t i = 0; i < caps.alphaModeCount; i++) { | |
| EXPECT_EQ(static_cast<WGPUCompositeAlphaMode>(caps.alphaModes[i]), | |
| mCapabilities.alphaModes[i]); | |
| } | |
| EXPECT_EQ(static_cast<WGPUTextureUsage>(caps.usages), mCapabilities.usages); | |
| } | |
| // Test that the texture's reflection is correct for injected surface in the wire. | |
| TEST_F(WireInjectSurfaceTests, TextureReflection) { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| WGPUSurface apiSurface = api.GetNewSurface(); | |
| EXPECT_CALL(api, SurfaceAddRef(apiSurface)); | |
| ASSERT_TRUE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| surface.Configure(&mConfiguration); | |
| wgpu::SurfaceTexture texture; | |
| surface.GetCurrentTexture(&texture); | |
| EXPECT_EQ(texture.status, wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal); | |
| EXPECT_EQ(mConfiguration.width, texture.texture.GetWidth()); | |
| EXPECT_EQ(mConfiguration.height, texture.texture.GetHeight()); | |
| EXPECT_EQ(mConfiguration.usage, texture.texture.GetUsage()); | |
| EXPECT_EQ(mConfiguration.format, texture.texture.GetFormat()); | |
| EXPECT_EQ(1u, texture.texture.GetDepthOrArrayLayers()); | |
| EXPECT_EQ(1u, texture.texture.GetMipLevelCount()); | |
| EXPECT_EQ(1u, texture.texture.GetSampleCount()); | |
| EXPECT_EQ(wgpu::TextureDimension::e2D, texture.texture.GetDimension()); | |
| } | |
| // Test a successful call to GetCurrentTexture. | |
| TEST_F(WireInjectSurfaceTests, GetCurrentTextureSuccess) { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| WGPUSurface apiSurface = api.GetNewSurface(); | |
| EXPECT_CALL(api, SurfaceAddRef(apiSurface)); | |
| ASSERT_TRUE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| surface.Configure(&mConfiguration); | |
| EXPECT_CALL(api, SurfaceConfigure(apiSurface, _)); | |
| wgpu::SurfaceTexture texture; | |
| surface.GetCurrentTexture(&texture); | |
| EXPECT_EQ(texture.status, wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal); | |
| WGPUTexture apiTexture = api.GetNewTexture(); | |
| EXPECT_CALL(api, SurfaceGetCurrentTexture(apiSurface, _)) | |
| .WillOnce(WithArgs<1>([&](WGPUSurfaceTexture* out) { | |
| out->texture = apiTexture; | |
| out->status = WGPUSurfaceGetCurrentTextureStatus_SuccessOptimal; | |
| })); | |
| // Check that methods on the returned texture are forwarded to the server correctly. | |
| texture.texture.Destroy(); | |
| EXPECT_CALL(api, TextureDestroy(apiTexture)); | |
| FlushClient(); | |
| } | |
| // Test a valid call to GetCurrentTexture that ends up being an error on the server side. | |
| TEST_F(WireInjectSurfaceTests, GetCurrentTextureErrorServerSide) { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| WGPUSurface apiSurface = api.GetNewSurface(); | |
| EXPECT_CALL(api, SurfaceAddRef(apiSurface)); | |
| ASSERT_TRUE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| surface.Configure(&mConfiguration); | |
| EXPECT_CALL(api, SurfaceConfigure(apiSurface, _)); | |
| wgpu::SurfaceTexture texture; | |
| surface.GetCurrentTexture(&texture); | |
| EXPECT_EQ(texture.status, wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal); | |
| // Oh no, the GetCurrentTexture server-side fails. | |
| WGPUTexture apiTexture = api.GetNewTexture(); | |
| EXPECT_CALL(api, SurfaceGetCurrentTexture(apiSurface, _)) | |
| .WillOnce(WithArgs<1>([&](WGPUSurfaceTexture* out) { | |
| out->texture = nullptr; | |
| out->status = WGPUSurfaceGetCurrentTextureStatus_Error; | |
| EXPECT_CALL(api, DeviceCreateErrorTexture(apiDevice, _)).WillOnce(Return(apiTexture)); | |
| })); | |
| // Check that methods on the returned texture are forwarded to the server correctly. | |
| texture.texture.Destroy(); | |
| EXPECT_CALL(api, TextureDestroy(apiTexture)); | |
| FlushClient(); | |
| } | |
| // Test calling GetCurrentTexture while unconfigured. | |
| TEST_F(WireInjectSurfaceTests, GetCurrentTextureUnconfigured) { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| WGPUSurface apiSurface = api.GetNewSurface(); | |
| EXPECT_CALL(api, SurfaceAddRef(apiSurface)); | |
| ASSERT_TRUE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| // Test while never configured. | |
| wgpu::SurfaceTexture texture; | |
| surface.GetCurrentTexture(&texture); | |
| EXPECT_EQ(texture.status, wgpu::SurfaceGetCurrentTextureStatus::Error); | |
| EXPECT_EQ(texture.texture, nullptr); | |
| // Test after configure/unconfigure. | |
| surface.Configure(&mConfiguration); | |
| EXPECT_CALL(api, SurfaceConfigure(apiSurface, _)); | |
| surface.Unconfigure(); | |
| EXPECT_CALL(api, SurfaceUnconfigure(apiSurface)); | |
| surface.GetCurrentTexture(&texture); | |
| EXPECT_EQ(texture.status, wgpu::SurfaceGetCurrentTextureStatus::Error); | |
| EXPECT_EQ(texture.texture, nullptr); | |
| // The server sees no calls to GetCurrentTexture. | |
| FlushClient(); | |
| } | |
| // Test calling GetCurrentTexture after the device is destroyed. | |
| // Note that this tests the same code path as device loss. | |
| TEST_F(WireInjectSurfaceTests, GetCurrentTextureDeviceDestroyed) { | |
| auto [reservation, surface] = ReserveSurface(&mCapabilities); | |
| WGPUSurface apiSurface = api.GetNewSurface(); | |
| EXPECT_CALL(api, SurfaceAddRef(apiSurface)); | |
| ASSERT_TRUE( | |
| GetWireServer()->InjectSurface(apiSurface, reservation.handle, reservation.instanceHandle)); | |
| surface.Configure(&mConfiguration); | |
| EXPECT_CALL(api, SurfaceConfigure(apiSurface, _)); | |
| device.Destroy(); | |
| EXPECT_CALL(api, DeviceDestroy(apiDevice)); | |
| wgpu::SurfaceTexture texture; | |
| surface.GetCurrentTexture(&texture); | |
| WGPUTexture apiTexture = api.GetNewTexture(); | |
| EXPECT_CALL(api, DeviceCreateErrorTexture(apiDevice, _)).WillOnce(Return(apiTexture)); | |
| EXPECT_EQ(texture.status, wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal); | |
| EXPECT_NE(texture.texture.Get(), nullptr); | |
| FlushClient(); | |
| } | |
| } // anonymous namespace | |
| } // namespace dawn::wire |