Special-case GetDefaultQueue in the wire

This makes it so calling GetDefaultQueue always returns the same
object. It required updating various WireTests to account for the
additional wire calls.

Bug: dawn:22

Change-Id: I8c74374b7c732b8bb7d0490bbc740dee0d2dface
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/19726
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>

src/tests/end2end/QueueTests.cpp

@@ -25,7 +25,7 @@ class QueueTests : public DawnTest {};
 TEST_P(QueueTests, GetDefaultQueueSameObject) {
     wgpu::Queue q1 = device.GetDefaultQueue();
     wgpu::Queue q2 = device.GetDefaultQueue();
-    EXPECT_EQ(q1.Get() == q2.Get(), !UsesWire());
+    EXPECT_EQ(q1.Get(), q2.Get());
 }
 
 DAWN_INSTANTIATE_TEST(QueueTests,

src/tests/unittests/wire/WireArgumentTests.cpp

@@ -232,11 +232,6 @@ TEST_F(WireArgumentTests, ObjectsAsPointerArgument) {
             .WillOnce(Return(apiCmdBufs[i]));
     }
 
-    // Create queue
-    WGPUQueue queue = wgpuDeviceGetDefaultQueue(device);
-    WGPUQueue apiQueue = api.GetNewQueue();
-    EXPECT_CALL(api, DeviceGetDefaultQueue(apiDevice)).WillOnce(Return(apiQueue));
-
     // Submit command buffer and check we got a call with both API-side command buffers
     wgpuQueueSubmit(queue, 2, cmdBufs);
 

src/tests/unittests/wire/WireFenceTests.cpp

@@ -43,12 +43,6 @@ class WireFenceTests : public WireTest {
         mockFenceOnCompletionCallback =
             std::make_unique<StrictMock<MockFenceOnCompletionCallback>>();
 
-        {
-            queue = wgpuDeviceGetDefaultQueue(device);
-            apiQueue = api.GetNewQueue();
-            EXPECT_CALL(api, DeviceGetDefaultQueue(apiDevice)).WillOnce(Return(apiQueue));
-            FlushClient();
-        }
         {
             WGPUFenceDescriptor descriptor = {};
             descriptor.initialValue = 1;
@@ -89,9 +83,6 @@ class WireFenceTests : public WireTest {
     // A successfully created fence
     WGPUFence fence;
     WGPUFence apiFence;
-
-    WGPUQueue queue;
-    WGPUQueue apiQueue;
 };
 
 // Check that signaling a fence succeeds
@@ -227,7 +218,8 @@ TEST_F(WireFenceTests, DestroyBeforeOnCompletionEnd) {
 }
 
 // Test that signaling a fence on a wrong queue is invalid
-TEST_F(WireFenceTests, SignalWrongQueue) {
+// DISABLED until we have support for multiple queues.
+TEST_F(WireFenceTests, DISABLED_SignalWrongQueue) {
     WGPUQueue queue2 = wgpuDeviceGetDefaultQueue(device);
     WGPUQueue apiQueue2 = api.GetNewQueue();
     EXPECT_CALL(api, DeviceGetDefaultQueue(apiDevice)).WillOnce(Return(apiQueue2));
@@ -240,7 +232,8 @@ TEST_F(WireFenceTests, SignalWrongQueue) {
 }
 
 // Test that signaling a fence on a wrong queue does not update fence signaled value
-TEST_F(WireFenceTests, SignalWrongQueueDoesNotUpdateValue) {
+// DISABLED until we have support for multiple queues.
+TEST_F(WireFenceTests, DISABLED_SignalWrongQueueDoesNotUpdateValue) {
     WGPUQueue queue2 = wgpuDeviceGetDefaultQueue(device);
     WGPUQueue apiQueue2 = api.GetNewQueue();
     EXPECT_CALL(api, DeviceGetDefaultQueue(apiDevice)).WillOnce(Return(apiQueue2));

src/tests/unittests/wire/WireMultipleDeviceTests.cpp

@@ -69,6 +69,12 @@ class WireMultipleDeviceTests : public testing::Test {
             mS2cBuf->SetHandler(mWireClient.get());
 
             mClientDevice = mWireClient->GetDevice();
+
+            // The GetDefaultQueue is done on WireClient startup so we expect it now.
+            mClientQueue = wgpuDeviceGetDefaultQueue(mClientDevice);
+            mServerQueue = mApi.GetNewQueue();
+            EXPECT_CALL(mApi, DeviceGetDefaultQueue(mServerDevice)).WillOnce(Return(mServerQueue));
+            FlushClient();
         }
 
         ~WireHolder() {
@@ -97,6 +103,14 @@ class WireMultipleDeviceTests : public testing::Test {
             return mServerDevice;
         }
 
+        WGPUQueue ClientQueue() {
+            return mClientQueue;
+        }
+
+        WGPUQueue ServerQueue() {
+            return mServerQueue;
+        }
+
       private:
         testing::StrictMock<MockProcTable> mApi;
         std::unique_ptr<dawn_wire::WireServer> mWireServer;
@@ -105,6 +119,8 @@ class WireMultipleDeviceTests : public testing::Test {
         std::unique_ptr<utils::TerribleCommandBuffer> mC2sBuf;
         WGPUDevice mServerDevice;
         WGPUDevice mClientDevice;
+        WGPUQueue mServerQueue;
+        WGPUQueue mClientQueue;
     };
 
     void ExpectInjectedError(WireHolder* wire) {
@@ -134,20 +150,12 @@ TEST_F(WireMultipleDeviceTests, ValidatesSameDevice) {
     WireHolder wireA;
     WireHolder wireB;
 
-    // Create the objects
-    WGPUQueue queueA = wgpuDeviceGetDefaultQueue(wireA.ClientDevice());
-    WGPUQueue queueB = wgpuDeviceGetDefaultQueue(wireB.ClientDevice());
-
+    // Create the fence
     WGPUFenceDescriptor desc = {};
-    WGPUFence fenceA = wgpuQueueCreateFence(queueA, &desc);
-
-    // Flush on wire B. We should see the queue created.
-    EXPECT_CALL(*wireB.Api(), DeviceGetDefaultQueue(wireB.ServerDevice()))
-        .WillOnce(Return(wireB.Api()->GetNewQueue()));
-    wireB.FlushClient();
+    WGPUFence fenceA = wgpuQueueCreateFence(wireA.ClientQueue(), &desc);
 
     // Signal with a fence from a different wire.
-    wgpuQueueSignal(queueB, fenceA, 1u);
+    wgpuQueueSignal(wireB.ClientQueue(), fenceA, 1u);
 
     // We should inject an error into the server.
     ExpectInjectedError(&wireB);

src/tests/unittests/wire/WireTest.cpp

@@ -70,6 +70,12 @@ void WireTest::SetUp() {
     dawnProcSetProcs(&clientProcs);
 
     apiDevice = mockDevice;
+
+    // The GetDefaultQueue is done on WireClient startup so we expect it now.
+    queue = wgpuDeviceGetDefaultQueue(device);
+    apiQueue = api.GetNewQueue();
+    EXPECT_CALL(api, DeviceGetDefaultQueue(apiDevice)).WillOnce(Return(apiQueue));
+    FlushClient();
 }
 
 void WireTest::TearDown() {
@@ -104,6 +110,7 @@ dawn_wire::WireClient* WireTest::GetWireClient() {
 }
 
 void WireTest::DeleteServer() {
+    EXPECT_CALL(api, QueueRelease(apiQueue)).Times(1);
     mWireServer = nullptr;
 }
 

src/tests/unittests/wire/WireTest.h

@@ -123,7 +123,9 @@ class WireTest : public testing::Test {
 
     testing::StrictMock<MockProcTable> api;
     WGPUDevice apiDevice;
+    WGPUQueue apiQueue;
     WGPUDevice device;
+    WGPUQueue queue;
 
     dawn_wire::WireServer* GetWireServer();
     dawn_wire::WireClient* GetWireClient();