src/dawn/tests/unittests/wire/WireInjectSurfaceTests.cpp - dawn.git - Git at Google

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