Use new gmock MOCK_FUNCTION macro.

Bug: None
Change-Id: If436fbf5c2392051caeadfc4a7482544d565b597
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/19720
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
diff --git a/src/dawn_wire/client/ClientMemoryTransferService_mock.h b/src/dawn_wire/client/ClientMemoryTransferService_mock.h
index 54c7f7b..2d5eba4 100644
--- a/src/dawn_wire/client/ClientMemoryTransferService_mock.h
+++ b/src/dawn_wire/client/ClientMemoryTransferService_mock.h
@@ -64,27 +64,30 @@
         MockReadHandle* NewReadHandle();
         MockWriteHandle* NewWriteHandle();
 
-        MOCK_METHOD1(OnCreateReadHandle, ReadHandle*(size_t));
-        MOCK_METHOD1(OnCreateWriteHandle, WriteHandle*(size_t));
+        MOCK_METHOD(ReadHandle*, OnCreateReadHandle, (size_t));
+        MOCK_METHOD(WriteHandle*, OnCreateWriteHandle, (size_t));
 
-        MOCK_METHOD1(OnReadHandleSerializeCreateSize, size_t(const ReadHandle*));
-        MOCK_METHOD2(OnReadHandleSerializeCreate, void(const ReadHandle*, void* serializePointer));
-        MOCK_METHOD5(OnReadHandleDeserializeInitialData,
-                     bool(const ReadHandle*,
-                          const uint32_t* deserializePointer,
-                          size_t deserializeSize,
-                          const void** data,
-                          size_t* dataLength));
-        MOCK_METHOD1(OnReadHandleDestroy, void(const ReadHandle*));
+        MOCK_METHOD(size_t, OnReadHandleSerializeCreateSize, (const ReadHandle*));
+        MOCK_METHOD(void, OnReadHandleSerializeCreate, (const ReadHandle*, void* serializePointer));
+        MOCK_METHOD(bool,
+                    OnReadHandleDeserializeInitialData,
+                    (const ReadHandle*,
+                     const uint32_t* deserializePointer,
+                     size_t deserializeSize,
+                     const void** data,
+                     size_t* dataLength));
+        MOCK_METHOD(void, OnReadHandleDestroy, (const ReadHandle*));
 
-        MOCK_METHOD1(OnWriteHandleSerializeCreateSize, size_t(const void* WriteHandle));
-        MOCK_METHOD2(OnWriteHandleSerializeCreate,
-                     void(const void* WriteHandle, void* serializePointer));
-        MOCK_METHOD1(OnWriteHandleOpen, std::pair<void*, size_t>(const void* WriteHandle));
-        MOCK_METHOD1(OnWriteHandleSerializeFlushSize, size_t(const void* WriteHandle));
-        MOCK_METHOD2(OnWriteHandleSerializeFlush,
-                     void(const void* WriteHandle, void* serializePointer));
-        MOCK_METHOD1(OnWriteHandleDestroy, void(const void* WriteHandle));
+        MOCK_METHOD(size_t, OnWriteHandleSerializeCreateSize, (const void* WriteHandle));
+        MOCK_METHOD(void,
+                    OnWriteHandleSerializeCreate,
+                    (const void* WriteHandle, void* serializePointer));
+        MOCK_METHOD((std::pair<void*, size_t>), OnWriteHandleOpen, (const void* WriteHandle));
+        MOCK_METHOD(size_t, OnWriteHandleSerializeFlushSize, (const void* WriteHandle));
+        MOCK_METHOD(void,
+                    OnWriteHandleSerializeFlush,
+                    (const void* WriteHandle, void* serializePointer));
+        MOCK_METHOD(void, OnWriteHandleDestroy, (const void* WriteHandle));
     };
 
 }}  //  namespace dawn_wire::client
diff --git a/src/dawn_wire/server/ServerMemoryTransferService_mock.h b/src/dawn_wire/server/ServerMemoryTransferService_mock.h
index 4e1e600..f85aa64 100644
--- a/src/dawn_wire/server/ServerMemoryTransferService_mock.h
+++ b/src/dawn_wire/server/ServerMemoryTransferService_mock.h
@@ -65,30 +65,35 @@
         MockReadHandle* NewReadHandle();
         MockWriteHandle* NewWriteHandle();
 
-        MOCK_METHOD3(OnDeserializeReadHandle,
-                     bool(const uint32_t* deserializePointer,
-                          size_t deserializeSize,
-                          ReadHandle** readHandle));
+        MOCK_METHOD(bool,
+                    OnDeserializeReadHandle,
+                    (const uint32_t* deserializePointer,
+                     size_t deserializeSize,
+                     ReadHandle** readHandle));
 
-        MOCK_METHOD3(OnDeserializeWriteHandle,
-                     bool(const uint32_t* deserializePointer,
-                          size_t deserializeSize,
-                          WriteHandle** writeHandle));
+        MOCK_METHOD(bool,
+                    OnDeserializeWriteHandle,
+                    (const uint32_t* deserializePointer,
+                     size_t deserializeSize,
+                     WriteHandle** writeHandle));
 
-        MOCK_METHOD3(OnReadHandleSerializeInitialDataSize,
-                     size_t(const ReadHandle* readHandle, const void* data, size_t dataLength));
-        MOCK_METHOD4(OnReadHandleSerializeInitialData,
-                     void(const ReadHandle* readHandle,
-                          const void* data,
-                          size_t dataLength,
-                          void* serializePointer));
-        MOCK_METHOD1(OnReadHandleDestroy, void(const ReadHandle* readHandle));
+        MOCK_METHOD(size_t,
+                    OnReadHandleSerializeInitialDataSize,
+                    (const ReadHandle* readHandle, const void* data, size_t dataLength));
+        MOCK_METHOD(void,
+                    OnReadHandleSerializeInitialData,
+                    (const ReadHandle* readHandle,
+                     const void* data,
+                     size_t dataLength,
+                     void* serializePointer));
+        MOCK_METHOD(void, OnReadHandleDestroy, (const ReadHandle* readHandle));
 
-        MOCK_METHOD3(OnWriteHandleDeserializeFlush,
-                     bool(const WriteHandle* writeHandle,
-                          const uint32_t* deserializePointer,
-                          size_t deserializeSize));
-        MOCK_METHOD1(OnWriteHandleDestroy, void(const WriteHandle* writeHandle));
+        MOCK_METHOD(bool,
+                    OnWriteHandleDeserializeFlush,
+                    (const WriteHandle* writeHandle,
+                     const uint32_t* deserializePointer,
+                     size_t deserializeSize));
+        MOCK_METHOD(void, OnWriteHandleDestroy, (const WriteHandle* writeHandle));
     };
 
 }}  //  namespace dawn_wire::server
diff --git a/src/tests/end2end/DeviceLostTests.cpp b/src/tests/end2end/DeviceLostTests.cpp
index 6b5ad53..427c7a8 100644
--- a/src/tests/end2end/DeviceLostTests.cpp
+++ b/src/tests/end2end/DeviceLostTests.cpp
@@ -24,7 +24,7 @@
 
 class MockDeviceLostCallback {
   public:
-    MOCK_METHOD2(Call, void(const char* message, void* userdata));
+    MOCK_METHOD(void, Call, (const char* message, void* userdata));
 };
 
 static std::unique_ptr<MockDeviceLostCallback> mockDeviceLostCallback;
@@ -36,7 +36,7 @@
 
 class MockFenceOnCompletionCallback {
   public:
-    MOCK_METHOD2(Call, void(WGPUFenceCompletionStatus status, void* userdata));
+    MOCK_METHOD(void, Call, (WGPUFenceCompletionStatus status, void* userdata));
 };
 
 static std::unique_ptr<MockFenceOnCompletionCallback> mockFenceOnCompletionCallback;
diff --git a/src/tests/end2end/FenceTests.cpp b/src/tests/end2end/FenceTests.cpp
index 8c9a3c6..8822616 100644
--- a/src/tests/end2end/FenceTests.cpp
+++ b/src/tests/end2end/FenceTests.cpp
@@ -22,7 +22,7 @@
 
 class MockFenceOnCompletionCallback {
   public:
-    MOCK_METHOD2(Call, void(WGPUFenceCompletionStatus status, void* userdata));
+    MOCK_METHOD(void, Call, (WGPUFenceCompletionStatus status, void* userdata));
 };
 
 static std::unique_ptr<MockFenceOnCompletionCallback> mockFenceOnCompletionCallback;
@@ -32,7 +32,7 @@
 
 class MockPopErrorScopeCallback {
   public:
-    MOCK_METHOD3(Call, void(WGPUErrorType type, const char* message, void* userdata));
+    MOCK_METHOD(void, Call, (WGPUErrorType type, const char* message, void* userdata));
 };
 
 static std::unique_ptr<MockPopErrorScopeCallback> mockPopErrorScopeCallback;
diff --git a/src/tests/unittests/PlacementAllocatedTests.cpp b/src/tests/unittests/PlacementAllocatedTests.cpp
index d483d6e..9ff7d1d 100644
--- a/src/tests/unittests/PlacementAllocatedTests.cpp
+++ b/src/tests/unittests/PlacementAllocatedTests.cpp
@@ -28,7 +28,7 @@
 
     class MockDestructor {
       public:
-        MOCK_METHOD2(Call, void(void*, DestructedClass));
+        MOCK_METHOD(void, Call, (void*, DestructedClass));
     };
 
     std::unique_ptr<StrictMock<MockDestructor>> mockDestructor;
diff --git a/src/tests/unittests/validation/BufferValidationTests.cpp b/src/tests/unittests/validation/BufferValidationTests.cpp
index 6326630..d9342d3 100644
--- a/src/tests/unittests/validation/BufferValidationTests.cpp
+++ b/src/tests/unittests/validation/BufferValidationTests.cpp
@@ -22,11 +22,12 @@
 
 class MockBufferMapReadCallback {
     public:
-      MOCK_METHOD4(Call,
-                   void(WGPUBufferMapAsyncStatus status,
-                        const uint32_t* ptr,
-                        uint64_t dataLength,
-                        void* userdata));
+      MOCK_METHOD(void,
+                  Call,
+                  (WGPUBufferMapAsyncStatus status,
+                   const uint32_t* ptr,
+                   uint64_t dataLength,
+                   void* userdata));
 };
 
 static std::unique_ptr<MockBufferMapReadCallback> mockBufferMapReadCallback;
@@ -41,11 +42,10 @@
 
 class MockBufferMapWriteCallback {
     public:
-      MOCK_METHOD4(Call,
-                   void(WGPUBufferMapAsyncStatus status,
-                        uint32_t* ptr,
-                        uint64_t dataLength,
-                        void* userdata));
+      MOCK_METHOD(
+          void,
+          Call,
+          (WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata));
 };
 
 static std::unique_ptr<MockBufferMapWriteCallback> mockBufferMapWriteCallback;
diff --git a/src/tests/unittests/validation/ErrorScopeValidationTests.cpp b/src/tests/unittests/validation/ErrorScopeValidationTests.cpp
index e8dfb68..414e073 100644
--- a/src/tests/unittests/validation/ErrorScopeValidationTests.cpp
+++ b/src/tests/unittests/validation/ErrorScopeValidationTests.cpp
@@ -20,7 +20,7 @@
 
 class MockDevicePopErrorScopeCallback {
   public:
-    MOCK_METHOD3(Call, void(WGPUErrorType type, const char* message, void* userdata));
+    MOCK_METHOD(void, Call, (WGPUErrorType type, const char* message, void* userdata));
 };
 
 static std::unique_ptr<MockDevicePopErrorScopeCallback> mockDevicePopErrorScopeCallback;
diff --git a/src/tests/unittests/validation/FenceValidationTests.cpp b/src/tests/unittests/validation/FenceValidationTests.cpp
index 4a24cf0..dfb9693 100644
--- a/src/tests/unittests/validation/FenceValidationTests.cpp
+++ b/src/tests/unittests/validation/FenceValidationTests.cpp
@@ -20,7 +20,7 @@
 
 class MockFenceOnCompletionCallback {
   public:
-    MOCK_METHOD2(Call, void(WGPUFenceCompletionStatus status, void* userdata));
+    MOCK_METHOD(void, Call, (WGPUFenceCompletionStatus status, void* userdata));
 };
 
 struct FenceOnCompletionExpectation {
diff --git a/src/tests/unittests/wire/WireBufferMappingTests.cpp b/src/tests/unittests/wire/WireBufferMappingTests.cpp
index a8cbc20..1307b95 100644
--- a/src/tests/unittests/wire/WireBufferMappingTests.cpp
+++ b/src/tests/unittests/wire/WireBufferMappingTests.cpp
@@ -22,11 +22,12 @@
     // Mock classes to add expectations on the wire calling callbacks
     class MockBufferMapReadCallback {
       public:
-        MOCK_METHOD4(Call,
-                     void(WGPUBufferMapAsyncStatus status,
-                          const uint32_t* ptr,
-                          uint64_t dataLength,
-                          void* userdata));
+        MOCK_METHOD(void,
+                    Call,
+                    (WGPUBufferMapAsyncStatus status,
+                     const uint32_t* ptr,
+                     uint64_t dataLength,
+                     void* userdata));
     };
 
     std::unique_ptr<StrictMock<MockBufferMapReadCallback>> mockBufferMapReadCallback;
@@ -41,11 +42,10 @@
 
     class MockBufferMapWriteCallback {
       public:
-        MOCK_METHOD4(Call,
-                     void(WGPUBufferMapAsyncStatus status,
-                          uint32_t* ptr,
-                          uint64_t dataLength,
-                          void* userdata));
+        MOCK_METHOD(
+            void,
+            Call,
+            (WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata));
     };
 
     std::unique_ptr<StrictMock<MockBufferMapWriteCallback>> mockBufferMapWriteCallback;
@@ -61,12 +61,13 @@
 
     class MockBufferCreateMappedCallback {
       public:
-        MOCK_METHOD5(Call,
-                     void(WGPUBufferMapAsyncStatus status,
-                          WGPUBuffer buffer,
-                          uint32_t* ptr,
-                          uint64_t dataLength,
-                          void* userdata));
+        MOCK_METHOD(void,
+                    Call,
+                    (WGPUBufferMapAsyncStatus status,
+                     WGPUBuffer buffer,
+                     uint32_t* ptr,
+                     uint64_t dataLength,
+                     void* userdata));
     };
 
 }  // anonymous namespace
diff --git a/src/tests/unittests/wire/WireErrorCallbackTests.cpp b/src/tests/unittests/wire/WireErrorCallbackTests.cpp
index 93b5342..6f31977 100644
--- a/src/tests/unittests/wire/WireErrorCallbackTests.cpp
+++ b/src/tests/unittests/wire/WireErrorCallbackTests.cpp
@@ -22,7 +22,7 @@
     // Mock classes to add expectations on the wire calling callbacks
     class MockDeviceErrorCallback {
       public:
-        MOCK_METHOD3(Call, void(WGPUErrorType type, const char* message, void* userdata));
+        MOCK_METHOD(void, Call, (WGPUErrorType type, const char* message, void* userdata));
     };
 
     std::unique_ptr<StrictMock<MockDeviceErrorCallback>> mockDeviceErrorCallback;
@@ -32,7 +32,7 @@
 
     class MockDevicePopErrorScopeCallback {
       public:
-        MOCK_METHOD3(Call, void(WGPUErrorType type, const char* message, void* userdata));
+        MOCK_METHOD(void, Call, (WGPUErrorType type, const char* message, void* userdata));
     };
 
     std::unique_ptr<StrictMock<MockDevicePopErrorScopeCallback>> mockDevicePopErrorScopeCallback;
@@ -44,7 +44,7 @@
 
     class MockDeviceLostCallback {
       public:
-        MOCK_METHOD2(Call, void(const char* message, void* userdata));
+        MOCK_METHOD(void, Call, (const char* message, void* userdata));
     };
 
     std::unique_ptr<StrictMock<MockDeviceLostCallback>> mockDeviceLostCallback;
diff --git a/src/tests/unittests/wire/WireFenceTests.cpp b/src/tests/unittests/wire/WireFenceTests.cpp
index 0f186c5..eb33df9 100644
--- a/src/tests/unittests/wire/WireFenceTests.cpp
+++ b/src/tests/unittests/wire/WireFenceTests.cpp
@@ -21,7 +21,7 @@
 
     class MockFenceOnCompletionCallback {
       public:
-        MOCK_METHOD2(Call, void(WGPUFenceCompletionStatus status, void* userdata));
+        MOCK_METHOD(void, Call, (WGPUFenceCompletionStatus status, void* userdata));
     };
 
     std::unique_ptr<StrictMock<MockFenceOnCompletionCallback>> mockFenceOnCompletionCallback;
diff --git a/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp b/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
index 121a050..1d7d828 100644
--- a/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
+++ b/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
@@ -25,11 +25,12 @@
     // Mock classes to add expectations on the wire calling callbacks
     class MockBufferMapReadCallback {
       public:
-        MOCK_METHOD4(Call,
-                     void(WGPUBufferMapAsyncStatus status,
-                          const uint32_t* ptr,
-                          uint64_t dataLength,
-                          void* userdata));
+        MOCK_METHOD(void,
+                    Call,
+                    (WGPUBufferMapAsyncStatus status,
+                     const uint32_t* ptr,
+                     uint64_t dataLength,
+                     void* userdata));
     };
 
     std::unique_ptr<StrictMock<MockBufferMapReadCallback>> mockBufferMapReadCallback;
@@ -44,11 +45,10 @@
 
     class MockBufferMapWriteCallback {
       public:
-        MOCK_METHOD4(Call,
-                     void(WGPUBufferMapAsyncStatus status,
-                          uint32_t* ptr,
-                          uint64_t dataLength,
-                          void* userdata));
+        MOCK_METHOD(
+            void,
+            Call,
+            (WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata));
     };
 
     std::unique_ptr<StrictMock<MockBufferMapWriteCallback>> mockBufferMapWriteCallback;
@@ -62,12 +62,13 @@
 
     class MockBufferCreateMappedCallback {
       public:
-        MOCK_METHOD5(Call,
-                     void(WGPUBufferMapAsyncStatus status,
-                          WGPUBuffer buffer,
-                          uint32_t* ptr,
-                          uint64_t dataLength,
-                          void* userdata));
+        MOCK_METHOD(void,
+                    Call,
+                    (WGPUBufferMapAsyncStatus status,
+                     WGPUBuffer buffer,
+                     uint32_t* ptr,
+                     uint64_t dataLength,
+                     void* userdata));
     };
 
 }  // anonymous namespace