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


            
            // Copyright 2020 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 <memory>


            #include "dawn/dawn_proc.h"

            
            #include "dawn/native/DawnNative.h"

            
            #include "dawn/tests/unittests/wire/WireFutureTest.h"

            
            #include "dawn/tests/unittests/wire/WireTest.h"

            
            #include "dawn/utils/TerribleCommandBuffer.h"

            
            #include "dawn/wire/WireClient.h"

            
            #include "dawn/wire/WireServer.h"


            namespace dawn::wire {

            
            namespace {


            using testing::_;

            
            using testing::InvokeWithoutArgs;

            
            using testing::NotNull;

            
            using testing::Return;

            
            using testing::StrEq;


            using WireCreateComputePipelineAsyncTestBase =

            
                WireFutureTest<WGPUCreateComputePipelineAsyncCallback,

            
                               WGPUCreateComputePipelineAsyncCallbackInfo,

            
                               wgpuDeviceCreateComputePipelineAsync,

            
                               wgpuDeviceCreateComputePipelineAsyncF>;

            
            using WireCreateRenderPipelineAsyncTestBase =

            
                WireFutureTest<WGPUCreateRenderPipelineAsyncCallback,

            
                               WGPUCreateRenderPipelineAsyncCallbackInfo,

            
                               wgpuDeviceCreateRenderPipelineAsync,

            
                               wgpuDeviceCreateRenderPipelineAsyncF>;


            class WireCreateComputePipelineAsyncTest : public WireCreateComputePipelineAsyncTestBase {

            
              protected:

            
                // Overridden version of wgpuDeviceCreateComputePipelineAsync that defers to the API call based

            
                // on the test callback mode.

            
                void DeviceCreateComputePipelineAsync(WGPUDevice d,

            
                                                      WGPUComputePipelineDescriptor const* desc,

            
                                                      void* userdata = nullptr) {

            
                    CallImpl(userdata, d, desc);

            
                }


                // Sets up default descriptors to use in the tests.

            
                void SetUp() override {

            
                    WireCreateComputePipelineAsyncTestBase::SetUp();


                    WGPUShaderModuleDescriptor shaderDesc = {};

            
                    mShader = wgpuDeviceCreateShaderModule(device, &shaderDesc);

            
                    mApiShader = api.GetNewShaderModule();

            
                    EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(mApiShader));

            
                    FlushClient();


                    mDescriptor.compute.module = mShader;

            
                }


                WGPUShaderModule mShader;

            
                WGPUShaderModule mApiShader;

            
                WGPUComputePipelineDescriptor mDescriptor = {};

            
            };

            
            class WireCreateRenderPipelineAsyncTest : public WireCreateRenderPipelineAsyncTestBase {

            
              protected:

            
                // Overriden version of wgpuDeviceCreateRenderPipelineAsync that defers to the API call based on

            
                // the test callback mode.

            
                void DeviceCreateRenderPipelineAsync(WGPUDevice d,

            
                                                     WGPURenderPipelineDescriptor const* desc,

            
                                                     void* userdata = nullptr) {

            
                    CallImpl(userdata, d, desc);

            
                }


                // Sets up default descriptors to use in the tests.

            
                void SetUp() override {

            
                    WireCreateRenderPipelineAsyncTestBase::SetUp();


                    WGPUShaderModuleDescriptor shaderDesc = {};

            
                    mShader = wgpuDeviceCreateShaderModule(device, &shaderDesc);

            
                    mApiShader = api.GetNewShaderModule();

            
                    EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(mApiShader));

            
                    FlushClient();


                    mDescriptor.vertex.module = mShader;

            
                    mFragment.module = mShader;

            
                    mDescriptor.fragment = &mFragment;

            
                }


                WGPUShaderModule mShader;

            
                WGPUShaderModule mApiShader;

            
                WGPUFragmentState mFragment = {};

            
                WGPURenderPipelineDescriptor mDescriptor = {};

            
            };

            
            DAWN_INSTANTIATE_WIRE_FUTURE_TEST_P(WireCreateComputePipelineAsyncTest);

            
            DAWN_INSTANTIATE_WIRE_FUTURE_TEST_P(WireCreateRenderPipelineAsyncTest);


            // Test when creating a compute pipeline with CreateComputePipelineAsync() successfully.

            
            TEST_P(WireCreateComputePipelineAsyncTest, CreateSuccess) {

            
                DeviceCreateComputePipelineAsync(device, &mDescriptor, this);


                EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _))

            
                    .WillOnce(InvokeWithoutArgs([&] {

            
                        api.CallDeviceCreateComputePipelineAsyncCallback(

            
                            apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");

            
                    }));


                FlushClient();

            
                FlushFutures();

            
                ExpectWireCallbacksWhen([&](auto& mockCb) {

            
                    EXPECT_CALL(mockCb, Call(WGPUCreatePipelineAsyncStatus_Success, NotNull(), StrEq(""), this))

            
                        .Times(1);


                    FlushCallbacks();

            
                });

            
            }


            // Test when creating a compute pipeline with CreateComputePipelineAsync() results in an error.

            
            TEST_P(WireCreateComputePipelineAsyncTest, CreateError) {

            
                DeviceCreateComputePipelineAsync(device, &mDescriptor, this);


                EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _))

            
                    .WillOnce(InvokeWithoutArgs([&] {

            
                        api.CallDeviceCreateComputePipelineAsyncCallback(

            
                            apiDevice, WGPUCreatePipelineAsyncStatus_ValidationError, nullptr,

            
                            "Some error message");

            
                    }));


                FlushClient();

            
                FlushFutures();

            
                ExpectWireCallbacksWhen([&](auto& mockCb) {

            
                    EXPECT_CALL(mockCb, Call(WGPUCreatePipelineAsyncStatus_ValidationError, _,

            
                                             StrEq("Some error message"), this))

            
                        .Times(1);


                    FlushCallbacks();

            
                });

            
            }


            // Test when creating a render pipeline with CreateRenderPipelineAsync() successfully.

            
            TEST_P(WireCreateRenderPipelineAsyncTest, CreateSuccess) {

            
                DeviceCreateRenderPipelineAsync(device, &mDescriptor, this);


                EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _))

            
                    .WillOnce(InvokeWithoutArgs([&] {

            
                        api.CallDeviceCreateRenderPipelineAsyncCallback(

            
                            apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");

            
                    }));


                FlushClient();

            
                FlushFutures();

            
                ExpectWireCallbacksWhen([&](auto& mockCb) {

            
                    EXPECT_CALL(mockCb, Call(WGPUCreatePipelineAsyncStatus_Success, NotNull(), StrEq(""), this))

            
                        .Times(1);


                    FlushCallbacks();

            
                });

            
            }


            // Test when creating a render pipeline with CreateRenderPipelineAsync() results in an error.

            
            TEST_P(WireCreateRenderPipelineAsyncTest, CreateError) {

            
                DeviceCreateRenderPipelineAsync(device, &mDescriptor, this);


                EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _))

            
                    .WillOnce(InvokeWithoutArgs([&] {

            
                        api.CallDeviceCreateRenderPipelineAsyncCallback(

            
                            apiDevice, WGPUCreatePipelineAsyncStatus_ValidationError, nullptr,

            
                            "Some error message");

            
                    }));


                FlushClient();

            
                FlushFutures();

            
                ExpectWireCallbacksWhen([&](auto& mockCb) {

            
                    EXPECT_CALL(mockCb, Call(WGPUCreatePipelineAsyncStatus_ValidationError, _,

            
                                             StrEq("Some error message"), this))

            
                        .Times(1);


                    FlushCallbacks();

            
                });

            
            }


            // Test that registering a callback then wire disconnect calls the callback with

            
            // Success.

            
            TEST_P(WireCreateRenderPipelineAsyncTest, CreateThenDisconnect) {

            
                DeviceCreateRenderPipelineAsync(device, &mDescriptor, this);


                EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _))

            
                    .WillOnce(InvokeWithoutArgs([&] {

            
                        api.CallDeviceCreateRenderPipelineAsyncCallback(

            
                            apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");

            
                    }));


                FlushClient();

            
                ExpectWireCallbacksWhen([&](auto& mockCb) {

            
                    EXPECT_CALL(mockCb,

            
                                Call(WGPUCreatePipelineAsyncStatus_InstanceDropped, nullptr, NotNull(), this))

            
                        .Times(1);


                    GetWireClient()->Disconnect();

            
                });

            
            }


            // Test that registering a callback then wire disconnect calls the callback with

            
            // Success.

            
            TEST_P(WireCreateComputePipelineAsyncTest, CreateThenDisconnect) {

            
                DeviceCreateComputePipelineAsync(device, &mDescriptor, this);


                EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _))

            
                    .WillOnce(InvokeWithoutArgs([&] {

            
                        api.CallDeviceCreateComputePipelineAsyncCallback(

            
                            apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");

            
                    }));


                FlushClient();

            
                ExpectWireCallbacksWhen([&](auto& mockCb) {

            
                    EXPECT_CALL(mockCb,

            
                                Call(WGPUCreatePipelineAsyncStatus_InstanceDropped, nullptr, NotNull(), this))

            
                        .Times(1);


                    GetWireClient()->Disconnect();

            
                });

            
            }


            // Test that registering a callback after wire disconnect calls the callback with

            
            // Success.

            
            TEST_P(WireCreateRenderPipelineAsyncTest, CreateAfterDisconnect) {

            
                GetWireClient()->Disconnect();


                ExpectWireCallbacksWhen([&](auto& mockCb) {

            
                    EXPECT_CALL(mockCb,

            
                                Call(WGPUCreatePipelineAsyncStatus_InstanceDropped, nullptr, NotNull(), this))

            
                        .Times(1);


                    DeviceCreateRenderPipelineAsync(device, &mDescriptor, this);

            
                });

            
            }


            // Test that registering a callback after wire disconnect calls the callback with

            
            // Success.

            
            TEST_P(WireCreateComputePipelineAsyncTest, CreateAfterDisconnect) {

            
                GetWireClient()->Disconnect();


                ExpectWireCallbacksWhen([&](auto& mockCb) {

            
                    EXPECT_CALL(mockCb,

            
                                Call(WGPUCreatePipelineAsyncStatus_InstanceDropped, nullptr, NotNull(), this))

            
                        .Times(1);


                    DeviceCreateComputePipelineAsync(device, &mDescriptor, this);

            
                });

            
            }


            // TODO(dawn:2298) Add tests for callbacks when the Instance is released.


            // Test that if the server is deleted before the callback, it forces the

            
            // callback to complete.

            
            TEST(WireCreatePipelineAsyncTestNullBackend, ServerDeletedBeforeCallback) {

            
                // This test sets up its own wire facilities, because unlike the other

            
                // tests which use mocks, this test needs the null backend and the

            
                // threadpool which automatically pushes async pipeline compilation

            
                // to completion. With mocks, we need to explicitly trigger callbacks,

            
                // but this test depends on triggering the async compilation from

            
                // *within* the wire server destructor.

            
                auto c2sBuf = std::make_unique<dawn::utils::TerribleCommandBuffer>();

            
                auto s2cBuf = std::make_unique<dawn::utils::TerribleCommandBuffer>();


                dawn::wire::WireServerDescriptor serverDesc = {};

            
                serverDesc.procs = &dawn::native::GetProcs();

            
                serverDesc.serializer = s2cBuf.get();


                auto wireServer = std::make_unique<dawn::wire::WireServer>(serverDesc);

            
                c2sBuf->SetHandler(wireServer.get());


                dawn::wire::WireClientDescriptor clientDesc = {};

            
                clientDesc.serializer = c2sBuf.get();


                auto wireClient = std::make_unique<dawn::wire::WireClient>(clientDesc);

            
                s2cBuf->SetHandler(wireClient.get());


                dawnProcSetProcs(&dawn::wire::client::GetProcs());


                auto reserved = wireClient->ReserveInstance();

            
                WGPUInstance instance = reserved.instance;

            
                wireServer->InjectInstance(dawn::native::GetProcs().createInstance(nullptr), reserved.handle);


                WGPURequestAdapterOptions adapterOptions = {};

            
                adapterOptions.backendType = WGPUBackendType_Null;


                WGPUAdapter adapter;

            
                wgpuInstanceRequestAdapter(

            
                    instance, &adapterOptions,

            
                    [](WGPURequestAdapterStatus status, WGPUAdapter adapter, const char*, void* userdata) {

            
                        *static_cast<WGPUAdapter*>(userdata) = adapter;

            
                    },

            
                    &adapter);

            
                ASSERT_TRUE(c2sBuf->Flush());

            
                ASSERT_TRUE(s2cBuf->Flush());


                WGPUDeviceDescriptor deviceDesc = {};

            
                WGPUDevice device;

            
                wgpuAdapterRequestDevice(

            
                    adapter, &deviceDesc,

            
                    [](WGPURequestDeviceStatus status, WGPUDevice device, const char*, void* userdata) {

            
                        *static_cast<WGPUDevice*>(userdata) = device;

            
                    },

            
                    &device);

            
                ASSERT_TRUE(c2sBuf->Flush());

            
                ASSERT_TRUE(s2cBuf->Flush());


                WGPUShaderModuleWGSLDescriptor wgslDesc = {};

            
                wgslDesc.chain.sType = WGPUSType_ShaderModuleWGSLDescriptor;

            
                wgslDesc.code = "@compute @workgroup_size(64) fn main() {}";


                WGPUShaderModuleDescriptor smDesc = {};

            
                smDesc.nextInChain = &wgslDesc.chain;


                WGPUShaderModule sm = wgpuDeviceCreateShaderModule(device, &smDesc);


                WGPUComputePipelineDescriptor computeDesc = {};

            
                computeDesc.compute.module = sm;


                WGPUComputePipeline pipeline = nullptr;

            
                wgpuDeviceCreateComputePipelineAsync(

            
                    device, &computeDesc,

            
                    [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, const char* message,

            
                       void* userdata) { *static_cast<WGPUComputePipeline*>(userdata) = pipeline; },

            
                    &pipeline);


                ASSERT_TRUE(c2sBuf->Flush());


                // Delete the server. It should force async work to complete.

            
                wireServer.reset();


                ASSERT_TRUE(s2cBuf->Flush());

            
                ASSERT_NE(pipeline, nullptr);


                wgpuComputePipelineRelease(pipeline);

            
                wgpuShaderModuleRelease(sm);

            
                wgpuDeviceRelease(device);

            
                wgpuAdapterRelease(adapter);

            
                wgpuInstanceRelease(instance);

            
            }


            }  // anonymous namespace

            
            }  // namespace dawn::wire
	// Copyright 2020 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 <memory>

	#include "dawn/dawn_proc.h"
	#include "dawn/native/DawnNative.h"
	#include "dawn/tests/unittests/wire/WireFutureTest.h"
	#include "dawn/tests/unittests/wire/WireTest.h"
	#include "dawn/utils/TerribleCommandBuffer.h"
	#include "dawn/wire/WireClient.h"
	#include "dawn/wire/WireServer.h"

	namespace dawn::wire {
	namespace {

	using testing::_;
	using testing::InvokeWithoutArgs;
	using testing::NotNull;
	using testing::Return;
	using testing::StrEq;

	using WireCreateComputePipelineAsyncTestBase =
	WireFutureTest<WGPUCreateComputePipelineAsyncCallback,
	WGPUCreateComputePipelineAsyncCallbackInfo,
	wgpuDeviceCreateComputePipelineAsync,
	wgpuDeviceCreateComputePipelineAsyncF>;
	using WireCreateRenderPipelineAsyncTestBase =
	WireFutureTest<WGPUCreateRenderPipelineAsyncCallback,
	WGPUCreateRenderPipelineAsyncCallbackInfo,
	wgpuDeviceCreateRenderPipelineAsync,
	wgpuDeviceCreateRenderPipelineAsyncF>;

	class WireCreateComputePipelineAsyncTest : public WireCreateComputePipelineAsyncTestBase {
	protected:
	// Overridden version of wgpuDeviceCreateComputePipelineAsync that defers to the API call based
	// on the test callback mode.
	void DeviceCreateComputePipelineAsync(WGPUDevice d,
	WGPUComputePipelineDescriptor const* desc,
	void* userdata = nullptr) {
	CallImpl(userdata, d, desc);
	}

	// Sets up default descriptors to use in the tests.
	void SetUp() override {
	WireCreateComputePipelineAsyncTestBase::SetUp();

	WGPUShaderModuleDescriptor shaderDesc = {};
	mShader = wgpuDeviceCreateShaderModule(device, &shaderDesc);
	mApiShader = api.GetNewShaderModule();
	EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(mApiShader));
	FlushClient();

	mDescriptor.compute.module = mShader;
	}

	WGPUShaderModule mShader;
	WGPUShaderModule mApiShader;
	WGPUComputePipelineDescriptor mDescriptor = {};
	};
	class WireCreateRenderPipelineAsyncTest : public WireCreateRenderPipelineAsyncTestBase {
	protected:
	// Overriden version of wgpuDeviceCreateRenderPipelineAsync that defers to the API call based on
	// the test callback mode.
	void DeviceCreateRenderPipelineAsync(WGPUDevice d,
	WGPURenderPipelineDescriptor const* desc,
	void* userdata = nullptr) {
	CallImpl(userdata, d, desc);
	}

	// Sets up default descriptors to use in the tests.
	void SetUp() override {
	WireCreateRenderPipelineAsyncTestBase::SetUp();

	WGPUShaderModuleDescriptor shaderDesc = {};
	mShader = wgpuDeviceCreateShaderModule(device, &shaderDesc);
	mApiShader = api.GetNewShaderModule();
	EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(mApiShader));
	FlushClient();

	mDescriptor.vertex.module = mShader;
	mFragment.module = mShader;
	mDescriptor.fragment = &mFragment;
	}

	WGPUShaderModule mShader;
	WGPUShaderModule mApiShader;
	WGPUFragmentState mFragment = {};
	WGPURenderPipelineDescriptor mDescriptor = {};
	};
	DAWN_INSTANTIATE_WIRE_FUTURE_TEST_P(WireCreateComputePipelineAsyncTest);
	DAWN_INSTANTIATE_WIRE_FUTURE_TEST_P(WireCreateRenderPipelineAsyncTest);

	// Test when creating a compute pipeline with CreateComputePipelineAsync() successfully.
	TEST_P(WireCreateComputePipelineAsyncTest, CreateSuccess) {
	DeviceCreateComputePipelineAsync(device, &mDescriptor, this);

	EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _))
	.WillOnce(InvokeWithoutArgs([&] {
	api.CallDeviceCreateComputePipelineAsyncCallback(
	apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");
	}));

	FlushClient();
	FlushFutures();
	ExpectWireCallbacksWhen([&](auto& mockCb) {
	EXPECT_CALL(mockCb, Call(WGPUCreatePipelineAsyncStatus_Success, NotNull(), StrEq(""), this))
	.Times(1);

	FlushCallbacks();
	});
	}

	// Test when creating a compute pipeline with CreateComputePipelineAsync() results in an error.
	TEST_P(WireCreateComputePipelineAsyncTest, CreateError) {
	DeviceCreateComputePipelineAsync(device, &mDescriptor, this);

	EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _))
	.WillOnce(InvokeWithoutArgs([&] {
	api.CallDeviceCreateComputePipelineAsyncCallback(
	apiDevice, WGPUCreatePipelineAsyncStatus_ValidationError, nullptr,
	"Some error message");
	}));

	FlushClient();
	FlushFutures();
	ExpectWireCallbacksWhen([&](auto& mockCb) {
	EXPECT_CALL(mockCb, Call(WGPUCreatePipelineAsyncStatus_ValidationError, _,
	StrEq("Some error message"), this))
	.Times(1);

	FlushCallbacks();
	});
	}

	// Test when creating a render pipeline with CreateRenderPipelineAsync() successfully.
	TEST_P(WireCreateRenderPipelineAsyncTest, CreateSuccess) {
	DeviceCreateRenderPipelineAsync(device, &mDescriptor, this);

	EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _))
	.WillOnce(InvokeWithoutArgs([&] {
	api.CallDeviceCreateRenderPipelineAsyncCallback(
	apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");
	}));

	FlushClient();
	FlushFutures();
	ExpectWireCallbacksWhen([&](auto& mockCb) {
	EXPECT_CALL(mockCb, Call(WGPUCreatePipelineAsyncStatus_Success, NotNull(), StrEq(""), this))
	.Times(1);

	FlushCallbacks();
	});
	}

	// Test when creating a render pipeline with CreateRenderPipelineAsync() results in an error.
	TEST_P(WireCreateRenderPipelineAsyncTest, CreateError) {
	DeviceCreateRenderPipelineAsync(device, &mDescriptor, this);

	EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _))
	.WillOnce(InvokeWithoutArgs([&] {
	api.CallDeviceCreateRenderPipelineAsyncCallback(
	apiDevice, WGPUCreatePipelineAsyncStatus_ValidationError, nullptr,
	"Some error message");
	}));

	FlushClient();
	FlushFutures();
	ExpectWireCallbacksWhen([&](auto& mockCb) {
	EXPECT_CALL(mockCb, Call(WGPUCreatePipelineAsyncStatus_ValidationError, _,
	StrEq("Some error message"), this))
	.Times(1);

	FlushCallbacks();
	});
	}

	// Test that registering a callback then wire disconnect calls the callback with
	// Success.
	TEST_P(WireCreateRenderPipelineAsyncTest, CreateThenDisconnect) {
	DeviceCreateRenderPipelineAsync(device, &mDescriptor, this);

	EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _))
	.WillOnce(InvokeWithoutArgs([&] {
	api.CallDeviceCreateRenderPipelineAsyncCallback(
	apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");
	}));

	FlushClient();
	ExpectWireCallbacksWhen([&](auto& mockCb) {
	EXPECT_CALL(mockCb,
	Call(WGPUCreatePipelineAsyncStatus_InstanceDropped, nullptr, NotNull(), this))
	.Times(1);

	GetWireClient()->Disconnect();
	});
	}

	// Test that registering a callback then wire disconnect calls the callback with
	// Success.
	TEST_P(WireCreateComputePipelineAsyncTest, CreateThenDisconnect) {
	DeviceCreateComputePipelineAsync(device, &mDescriptor, this);

	EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _))
	.WillOnce(InvokeWithoutArgs([&] {
	api.CallDeviceCreateComputePipelineAsyncCallback(
	apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");
	}));

	FlushClient();
	ExpectWireCallbacksWhen([&](auto& mockCb) {
	EXPECT_CALL(mockCb,
	Call(WGPUCreatePipelineAsyncStatus_InstanceDropped, nullptr, NotNull(), this))
	.Times(1);

	GetWireClient()->Disconnect();
	});
	}

	// Test that registering a callback after wire disconnect calls the callback with
	// Success.
	TEST_P(WireCreateRenderPipelineAsyncTest, CreateAfterDisconnect) {
	GetWireClient()->Disconnect();

	ExpectWireCallbacksWhen([&](auto& mockCb) {
	EXPECT_CALL(mockCb,
	Call(WGPUCreatePipelineAsyncStatus_InstanceDropped, nullptr, NotNull(), this))
	.Times(1);

	DeviceCreateRenderPipelineAsync(device, &mDescriptor, this);
	});
	}

	// Test that registering a callback after wire disconnect calls the callback with
	// Success.
	TEST_P(WireCreateComputePipelineAsyncTest, CreateAfterDisconnect) {
	GetWireClient()->Disconnect();

	ExpectWireCallbacksWhen([&](auto& mockCb) {
	EXPECT_CALL(mockCb,
	Call(WGPUCreatePipelineAsyncStatus_InstanceDropped, nullptr, NotNull(), this))
	.Times(1);

	DeviceCreateComputePipelineAsync(device, &mDescriptor, this);
	});
	}

	// TODO(dawn:2298) Add tests for callbacks when the Instance is released.

	// Test that if the server is deleted before the callback, it forces the
	// callback to complete.
	TEST(WireCreatePipelineAsyncTestNullBackend, ServerDeletedBeforeCallback) {
	// This test sets up its own wire facilities, because unlike the other
	// tests which use mocks, this test needs the null backend and the
	// threadpool which automatically pushes async pipeline compilation
	// to completion. With mocks, we need to explicitly trigger callbacks,
	// but this test depends on triggering the async compilation from
	// within the wire server destructor.
	auto c2sBuf = std::make_unique<dawn::utils::TerribleCommandBuffer>();
	auto s2cBuf = std::make_unique<dawn::utils::TerribleCommandBuffer>();

	dawn::wire::WireServerDescriptor serverDesc = {};
	serverDesc.procs = &dawn::native::GetProcs();
	serverDesc.serializer = s2cBuf.get();

	auto wireServer = std::make_unique<dawn::wire::WireServer>(serverDesc);
	c2sBuf->SetHandler(wireServer.get());

	dawn::wire::WireClientDescriptor clientDesc = {};
	clientDesc.serializer = c2sBuf.get();

	auto wireClient = std::make_unique<dawn::wire::WireClient>(clientDesc);
	s2cBuf->SetHandler(wireClient.get());

	dawnProcSetProcs(&dawn::wire::client::GetProcs());

	auto reserved = wireClient->ReserveInstance();
	WGPUInstance instance = reserved.instance;
	wireServer->InjectInstance(dawn::native::GetProcs().createInstance(nullptr), reserved.handle);

	WGPURequestAdapterOptions adapterOptions = {};
	adapterOptions.backendType = WGPUBackendType_Null;

	WGPUAdapter adapter;
	wgpuInstanceRequestAdapter(
	instance, &adapterOptions,
	[](WGPURequestAdapterStatus status, WGPUAdapter adapter, const char, void userdata) {
	static_cast<WGPUAdapter>(userdata) = adapter;
	},
	&adapter);
	ASSERT_TRUE(c2sBuf->Flush());
	ASSERT_TRUE(s2cBuf->Flush());

	WGPUDeviceDescriptor deviceDesc = {};
	WGPUDevice device;
	wgpuAdapterRequestDevice(
	adapter, &deviceDesc,
	[](WGPURequestDeviceStatus status, WGPUDevice device, const char, void userdata) {
	static_cast<WGPUDevice>(userdata) = device;
	},
	&device);
	ASSERT_TRUE(c2sBuf->Flush());
	ASSERT_TRUE(s2cBuf->Flush());

	WGPUShaderModuleWGSLDescriptor wgslDesc = {};
	wgslDesc.chain.sType = WGPUSType_ShaderModuleWGSLDescriptor;
	wgslDesc.code = "@compute @workgroup_size(64) fn main() {}";

	WGPUShaderModuleDescriptor smDesc = {};
	smDesc.nextInChain = &wgslDesc.chain;

	WGPUShaderModule sm = wgpuDeviceCreateShaderModule(device, &smDesc);

	WGPUComputePipelineDescriptor computeDesc = {};
	computeDesc.compute.module = sm;

	WGPUComputePipeline pipeline = nullptr;
	wgpuDeviceCreateComputePipelineAsync(
	device, &computeDesc,
	[](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, const char* message,
	void* userdata) { static_cast<WGPUComputePipeline>(userdata) = pipeline; },
	&pipeline);

	ASSERT_TRUE(c2sBuf->Flush());

	// Delete the server. It should force async work to complete.
	wireServer.reset();

	ASSERT_TRUE(s2cBuf->Flush());
	ASSERT_NE(pipeline, nullptr);

	wgpuComputePipelineRelease(pipeline);
	wgpuShaderModuleRelease(sm);
	wgpuDeviceRelease(device);
	wgpuAdapterRelease(adapter);
	wgpuInstanceRelease(instance);
	}

	} // anonymous namespace
	} // namespace dawn::wire