diff --git a/generator/templates/api_cpp.h b/generator/templates/api_cpp.h
index 2af158e..9f94756 100644
--- a/generator/templates/api_cpp.h
+++ b/generator/templates/api_cpp.h
@@ -266,6 +266,39 @@
     {{as_cppType(types["callback mode"].name)}} mode, F callback, T userdata) const
 {%- endmacro %}
 
+//* This rendering macro should ONLY be used for callback info type functions.
+{% macro render_cpp_callback_info_lambda_method_declaration(type, method, dfn=False) %}
+    {% set CppType = as_cppType(type.name) %}
+    {% set OriginalMethodName = method.name.CamelCase() %}
+    {% set MethodName = OriginalMethodName[:-1] if method.name.chunks[-1] == "2" else OriginalMethodName %}
+    {% set MethodName = CppType + "::" + MethodName if dfn else MethodName %}
+    //* Stripping the 2 at the end of the callback functions for now until we can deprecate old ones.
+    //* TODO: crbug.com/dawn/2509 - Remove name handling once old APIs are deprecated.
+    {% set CallbackInfoType = (method.arguments|last).type %}
+    {% set CallbackType = (CallbackInfoType.members|first).type %}
+    {% set SfinaeArg = " = std::enable_if_t<std::is_convertible_v<L, Cb>>" if not dfn else "" %}
+    template <typename L,
+              typename Cb
+                {%- if not dfn -%}
+                    {{" "}}= std::function<void(
+                        {%- for arg in CallbackType.arguments -%}
+                            {%- if not loop.first %}, {% endif -%}
+                            {{as_annotated_cppType(arg)}}
+                        {%- endfor -%}
+                    )>
+                {%- endif -%},
+              typename{{SfinaeArg}}>
+    {{as_cppType(method.return_type.name)}} {{MethodName}}(
+        {%- for arg in method.arguments if arg.type.category != "callback info" -%}
+            {%- if arg.type.category == "object" and arg.annotation == "value" -%}
+                {{as_cppType(arg.type.name)}} const& {{as_varName(arg.name)}}{{ ", "}}
+            {%- else -%}
+                {{as_annotated_cppType(arg)}}{{ ", "}}
+            {%- endif -%}
+        {%- endfor -%}
+    {{as_cppType(types["callback mode"].name)}} mode, L callback) const
+{%- endmacro %}
+
 //* This rendering macro should NOT be used for callback info type functions.
 {% macro render_cpp_method_declaration(type, method, dfn=False) %}
     {% set CppType = as_cppType(type.name) %}
@@ -332,10 +365,71 @@
         callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
         callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
         auto result = {{as_cMethod(type.name, method.name)}}(Get(){{", "}}
-            {%- for arg in method.arguments if arg.type.category != "callback info" -%}{{render_c_actual_arg(arg)}}{{", "}}
+            {%- for arg in method.arguments if arg.type.category != "callback info" -%}
+                {{render_c_actual_arg(arg)}}{{", "}}
             {%- endfor -%}
         callbackInfo);
-        return {{convert_cType_to_cppType(method.return_type, 'value', 'result') | indent(8)}};
+        return {{convert_cType_to_cppType(method.return_type, 'value', 'result') | indent(4)}};
+    }
+{%- endmacro %}
+
+{% macro render_cpp_callback_info_lambda_method_impl(type, method) %}
+    {{render_cpp_callback_info_lambda_method_declaration(type, method, dfn=True)}} {
+        {% set CallbackInfoType = (method.arguments|last).type %}
+        {% set CallbackType = (CallbackInfoType.members|first).type %}
+        using F = void (
+            {%- for arg in CallbackType.arguments -%}
+                {%- if not loop.first %}, {% endif -%}
+                {{as_annotated_cppType(arg)}}
+            {%- endfor -%}
+        );
+
+        {{as_cType(CallbackInfoType.name)}} callbackInfo = {};
+        callbackInfo.mode = static_cast<{{as_cType(types["callback mode"].name)}}>(mode);
+        if constexpr (std::is_convertible_v<L, F*>) {
+            callbackInfo.callback = [](
+            {%- for arg in CallbackType.arguments -%}
+                {{as_annotated_cType(arg)}}{{", "}}
+            {%- endfor -%}
+            void* callback, void*) {
+                auto cb = reinterpret_cast<F*>(callback);
+                (*cb)(
+                    {%- for arg in CallbackType.arguments -%}
+                        {%- if not loop.first %}, {% endif -%}
+                        {{convert_cType_to_cppType(arg.type, arg.annotation, as_varName(arg.name))}}
+                    {%- endfor -%});
+            };
+            callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
+            callbackInfo.userdata2 = nullptr;
+            auto result = {{as_cMethod(type.name, method.name)}}(Get(){{", "}}
+            {%- for arg in method.arguments if arg.type.category != "callback info" -%}
+                {{render_c_actual_arg(arg)}}{{", "}}
+            {%- endfor -%}
+            callbackInfo);
+            return {{convert_cType_to_cppType(method.return_type, 'value', 'result') | indent(8)}};
+        } else {
+            auto* lambda = new L(callback);
+            callbackInfo.callback = [](
+                {%- for arg in CallbackType.arguments -%}
+                    {{as_annotated_cType(arg)}}{{", "}}
+                {%- endfor -%}
+            void* callback, void*) {
+                std::unique_ptr<L> lambda(reinterpret_cast<L*>(callback));
+                (*lambda)(
+                    {%- for arg in CallbackType.arguments -%}
+                        {%- if not loop.first %}, {% endif -%}
+                        {{convert_cType_to_cppType(arg.type, arg.annotation, as_varName(arg.name))}}
+                    {%- endfor -%});
+            };
+            callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
+            callbackInfo.userdata2 = nullptr;
+            auto result = {{as_cMethod(type.name, method.name)}}(Get(){{", "}}
+            {%- for arg in method.arguments if arg.type.category != "callback info" -%}
+                {{render_c_actual_arg(arg)}}{{", "}}
+            {%- endfor -%}
+            callbackInfo);
+            return {{convert_cType_to_cppType(method.return_type, 'value', 'result') | indent(8)}};
+        }
     }
 {%- endmacro %}
 
@@ -364,6 +458,7 @@
         {% for method in type.methods %}
             {% if has_callbackInfoStruct(method) %}
                 {{render_cpp_callback_info_template_method_declaration(type, method)|indent}};
+                {{render_cpp_callback_info_lambda_method_declaration(type, method)|indent}};
             {% else %}
                 inline {{render_cpp_method_declaration(type, method)}};
             {% endif %}
@@ -540,6 +635,7 @@
     {% for method in type.methods %}
         {% if has_callbackInfoStruct(method) %}
             {{render_cpp_callback_info_template_method_impl(type, method)}}
+            {{render_cpp_callback_info_lambda_method_impl(type, method)}}
         {% else %}
             {{render_cpp_method_impl(type, method)}}
         {% endif %}
diff --git a/src/dawn/dawn.json b/src/dawn/dawn.json
index 2acb36d..b2208f65 100644
--- a/src/dawn/dawn.json
+++ b/src/dawn/dawn.json
@@ -1491,6 +1491,15 @@
                 ]
             },
             {
+                "name": "pop error scope 2",
+                "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+                "tags": ["dawn", "emscripten"],
+                "returns": "future",
+                "args": [
+                    {"name": "callback info", "type": "pop error scope callback info 2"}
+                ]
+            },
+            {
                 "name": "set label",
                 "returns": "void",
                 "args": [
@@ -1586,6 +1595,14 @@
             {"name": "userdata", "type": "void *"}
         ]
     },
+    "pop error scope callback 2": {
+        "category": "callback function",
+        "args": [
+            {"name": "status", "type": "pop error scope status"},
+            {"name": "type", "type": "error type"},
+            {"name": "message", "type": "char", "annotation": "const*", "length": "strlen"}
+        ]
+    },
     "pop error scope callback info": {
         "category": "structure",
         "extensible": "in",
@@ -1596,6 +1613,12 @@
             {"name": "userdata", "type": "void *", "default": "nullptr"}
         ]
     },
+    "pop error scope callback info 2": {
+        "category": "callback info",
+        "members": [
+            {"name": "callback", "type": "pop error scope callback 2"}
+        ]
+    },
     "limits": {
         "category": "structure",
         "members": [
diff --git a/src/dawn/dawn_wire.json b/src/dawn/dawn_wire.json
index 62d42bd..d554885 100644
--- a/src/dawn/dawn_wire.json
+++ b/src/dawn/dawn_wire.json
@@ -229,6 +229,7 @@
             "DeviceEnumerateFeatures",
             "DevicePopErrorScope",
             "DevicePopErrorScopeF",
+            "DevicePopErrorScope2",
             "DeviceSetDeviceLostCallback",
             "DeviceSetUncapturedErrorCallback",
             "DeviceSetLoggingCallback",
diff --git a/src/dawn/native/Device.cpp b/src/dawn/native/Device.cpp
index 531996c..e4bdc28 100644
--- a/src/dawn/native/Device.cpp
+++ b/src/dawn/native/Device.cpp
@@ -827,32 +827,42 @@
 void DeviceBase::APIPopErrorScope(wgpu::ErrorCallback callback, void* userdata) {
     static wgpu::ErrorCallback kDefaultCallback = [](WGPUErrorType, char const*, void*) {};
 
-    PopErrorScopeCallbackInfo callbackInfo = {};
-    callbackInfo.mode = wgpu::CallbackMode::AllowProcessEvents;
-    callbackInfo.oldCallback = callback != nullptr ? callback : kDefaultCallback;
-    callbackInfo.userdata = userdata;
-    APIPopErrorScopeF(callbackInfo);
+    APIPopErrorScope2({nullptr, WGPUCallbackMode_AllowProcessEvents,
+                       [](WGPUPopErrorScopeStatus, WGPUErrorType type, char const* message,
+                          void* callback, void* userdata) {
+                           auto cb = reinterpret_cast<wgpu::ErrorCallback>(callback);
+                           cb(type, message, userdata);
+                       },
+                       reinterpret_cast<void*>(callback != nullptr ? callback : kDefaultCallback),
+                       userdata});
 }
 
 Future DeviceBase::APIPopErrorScopeF(const PopErrorScopeCallbackInfo& callbackInfo) {
+    return APIPopErrorScope2({nullptr, ToAPI(callbackInfo.mode),
+                              [](WGPUPopErrorScopeStatus status, WGPUErrorType type,
+                                 char const* message, void* callback, void* userdata) {
+                                  auto cb = reinterpret_cast<WGPUPopErrorScopeCallback>(callback);
+                                  cb(status, type, message, userdata);
+                              },
+                              reinterpret_cast<void*>(callbackInfo.callback),
+                              callbackInfo.userdata});
+}
+
+Future DeviceBase::APIPopErrorScope2(const WGPUPopErrorScopeCallbackInfo2& callbackInfo) {
     struct PopErrorScopeEvent final : public EventManager::TrackedEvent {
-        // TODO(crbug.com/dawn/2021) Remove the old callback type.
-        WGPUPopErrorScopeCallback mCallback;
-        WGPUErrorCallback mOldCallback;
-        void* mUserdata;
+        WGPUPopErrorScopeCallback2 mCallback;
+        raw_ptr<void> mUserdata1;
+        raw_ptr<void> mUserdata2;
         std::optional<ErrorScope> mScope;
 
-        PopErrorScopeEvent(const PopErrorScopeCallbackInfo& callbackInfo,
+        PopErrorScopeEvent(const WGPUPopErrorScopeCallbackInfo2& callbackInfo,
                            std::optional<ErrorScope>&& scope)
-            : TrackedEvent(callbackInfo.mode, TrackedEvent::Completed{}),
+            : TrackedEvent(static_cast<wgpu::CallbackMode>(callbackInfo.mode),
+                           TrackedEvent::Completed{}),
               mCallback(callbackInfo.callback),
-              mOldCallback(callbackInfo.oldCallback),
-              mUserdata(callbackInfo.userdata),
-              mScope(scope) {
-            // Exactly 1 callback should be set.
-            DAWN_ASSERT((mCallback != nullptr && mOldCallback == nullptr) ||
-                        (mCallback == nullptr && mOldCallback != nullptr));
-        }
+              mUserdata1(callbackInfo.userdata1),
+              mUserdata2(callbackInfo.userdata2),
+              mScope(scope) {}
 
         ~PopErrorScopeEvent() override { EnsureComplete(EventCompletionType::Shutdown); }
 
@@ -870,11 +880,8 @@
                 message = "No error scopes to pop";
             }
 
-            if (mCallback) {
-                mCallback(status, type, message, mUserdata);
-            } else {
-                mOldCallback(type, message, mUserdata);
-            }
+            mCallback(status, type, message, mUserdata1.ExtractAsDangling(),
+                      mUserdata2.ExtractAsDangling());
         }
     };
 
diff --git a/src/dawn/native/Device.h b/src/dawn/native/Device.h
index d8b014d..831d0b8 100644
--- a/src/dawn/native/Device.h
+++ b/src/dawn/native/Device.h
@@ -301,6 +301,7 @@
     void APIPushErrorScope(wgpu::ErrorFilter filter);
     void APIPopErrorScope(wgpu::ErrorCallback callback, void* userdata);
     Future APIPopErrorScopeF(const PopErrorScopeCallbackInfo& callbackInfo);
+    Future APIPopErrorScope2(const WGPUPopErrorScopeCallbackInfo2& callbackInfo);
 
     MaybeError ValidateIsAlive() const;
 
diff --git a/src/dawn/tests/MockCallback.h b/src/dawn/tests/MockCallback.h
index 81f484c..1638eb3 100644
--- a/src/dawn/tests/MockCallback.h
+++ b/src/dawn/tests/MockCallback.h
@@ -113,6 +113,23 @@
     std::set<std::unique_ptr<MockAndUserdata>> mUserdatas;
 };
 
+template <typename F>
+class MockCppCallback;
+
+// Helper wrapper class for C++ entry point callbacks.
+// Example Usage:
+//   MockCppCallback<void (*)(wgpu::PopErrorScopeStatus, wgpu::ErrorType, const char*)> mock;
+//
+//   device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mock.Callback());
+//   EXPECT_CALL(mock, Call(wgpu::PopErrorScopeStatus::Success, _, _));
+template <typename R, typename... Args>
+class MockCppCallback<R (*)(Args...)> : public ::testing::MockFunction<R(Args...)> {
+  public:
+    auto Callback() {
+        return [this](Args... args) -> R { return this->Call(args...); };
+    }
+};
+
 }  // namespace testing
 
 #endif  // SRC_DAWN_TESTS_MOCKCALLBACK_H_
diff --git a/src/dawn/tests/end2end/DeviceLifetimeTests.cpp b/src/dawn/tests/end2end/DeviceLifetimeTests.cpp
index 170c42b..4fc14e2 100644
--- a/src/dawn/tests/end2end/DeviceLifetimeTests.cpp
+++ b/src/dawn/tests/end2end/DeviceLifetimeTests.cpp
@@ -102,9 +102,11 @@
     bool done = false;
 
     device.PopErrorScope(
-        [](WGPUErrorType type, const char*, void* userdata) {
-            *static_cast<bool*>(userdata) = true;
-            EXPECT_EQ(type, WGPUErrorType_NoError);
+        wgpu::CallbackMode::AllowProcessEvents,
+        [](wgpu::PopErrorScopeStatus status, wgpu::ErrorType type, const char*, bool* done) {
+            *done = true;
+            EXPECT_EQ(status, wgpu::PopErrorScopeStatus::Success);
+            EXPECT_EQ(type, wgpu::ErrorType::NoError);
         },
         &done);
     device = nullptr;
@@ -125,10 +127,13 @@
     // Ask for a popErrorScope callback and drop the device inside the callback.
     Userdata data = Userdata{std::move(device), false};
     data.device.PopErrorScope(
-        [](WGPUErrorType type, const char*, void* userdata) {
-            EXPECT_EQ(type, WGPUErrorType_NoError);
-            static_cast<Userdata*>(userdata)->device = nullptr;
-            static_cast<Userdata*>(userdata)->done = true;
+        wgpu::CallbackMode::AllowProcessEvents,
+        [](wgpu::PopErrorScopeStatus status, wgpu::ErrorType type, const char*,
+           Userdata* userdata) {
+            EXPECT_EQ(status, wgpu::PopErrorScopeStatus::Success);
+            EXPECT_EQ(type, wgpu::ErrorType::NoError);
+            userdata->device = nullptr;
+            userdata->done = true;
         },
         &data);
 
@@ -555,9 +560,9 @@
     // The following callback will drop the 2nd device. It won't be triggered until
     // instance.ProcessEvents() is called.
     device.PopErrorScope(
-        [](WGPUErrorType type, const char*, void* userdataPtr) {
-            auto userdata = static_cast<UserData*>(userdataPtr);
-
+        wgpu::CallbackMode::AllowProcessEvents,
+        [](wgpu::PopErrorScopeStatus status, wgpu::ErrorType type, const char*,
+           UserData* userdata) {
             userdata->device2 = nullptr;
             userdata->done = true;
         },
diff --git a/src/dawn/tests/end2end/EventTests.cpp b/src/dawn/tests/end2end/EventTests.cpp
index 4f8e15a..a84f5fc 100644
--- a/src/dawn/tests/end2end/EventTests.cpp
+++ b/src/dawn/tests/end2end/EventTests.cpp
@@ -647,9 +647,8 @@
 
     // PopErrorScope is implemented via a signal.
     device.PushErrorScope(wgpu::ErrorFilter::Validation);
-    device.PopErrorScope({nullptr, wgpu::CallbackMode::AllowProcessEvents,
-                          [](WGPUPopErrorScopeStatus, WGPUErrorType, char const*, void*) {},
-                          nullptr, nullptr});
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents,
+                         [](wgpu::PopErrorScopeStatus, wgpu::ErrorType, const char*) {});
 
     instance.ProcessEvents();
 }
diff --git a/src/dawn/tests/end2end/MaxLimitTests.cpp b/src/dawn/tests/end2end/MaxLimitTests.cpp
index 742be91..928452d 100644
--- a/src/dawn/tests/end2end/MaxLimitTests.cpp
+++ b/src/dawn/tests/end2end/MaxLimitTests.cpp
@@ -220,14 +220,14 @@
         bufDesc.usage = usage | wgpu::BufferUsage::CopyDst;
         wgpu::Buffer buffer = device.CreateBuffer(&bufDesc);
 
-        WGPUErrorType oomResult;
-        device.PopErrorScope([](WGPUErrorType type, const char*,
-                                void* userdata) { *static_cast<WGPUErrorType*>(userdata) = type; },
-                             &oomResult);
-        instance.ProcessEvents();
+        wgpu::ErrorType oomResult;
+        device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents,
+                             [&oomResult](wgpu::PopErrorScopeStatus, wgpu::ErrorType type,
+                                          const char*) { oomResult = type; });
         FlushWire();
+        instance.ProcessEvents();
         // Max buffer size is smaller than the max buffer binding size.
-        DAWN_TEST_UNSUPPORTED_IF(oomResult == WGPUErrorType_OutOfMemory);
+        DAWN_TEST_UNSUPPORTED_IF(oomResult == wgpu::ErrorType::OutOfMemory);
 
         wgpu::BufferDescriptor resultBufDesc;
         resultBufDesc.size = 8;
diff --git a/src/dawn/tests/end2end/MultithreadTests.cpp b/src/dawn/tests/end2end/MultithreadTests.cpp
index cddcb36..29d18d1 100644
--- a/src/dawn/tests/end2end/MultithreadTests.cpp
+++ b/src/dawn/tests/end2end/MultithreadTests.cpp
@@ -168,30 +168,25 @@
     // Create threads
     utils::RunInParallel(static_cast<uint32_t>(devices.size()), [&devices, this](uint32_t index) {
         auto additionalDevice = std::move(devices[index]);
-        struct UserData {
-            wgpu::Device device2ndRef;
-            std::atomic_bool isCompleted{false};
-        } userData;
-
-        userData.device2ndRef = additionalDevice;
+        wgpu::Device device2ndRef = additionalDevice;
+        std::atomic_bool isCompleted{false};
 
         // Drop the last ref inside a callback.
         additionalDevice.PushErrorScope(wgpu::ErrorFilter::Validation);
         additionalDevice.PopErrorScope(
-            [](WGPUErrorType type, const char*, void* userdataPtr) {
-                auto userdata = static_cast<UserData*>(userdataPtr);
-                userdata->device2ndRef = nullptr;
-                userdata->isCompleted = true;
-            },
-            &userData);
+            wgpu::CallbackMode::AllowProcessEvents,
+            [&device2ndRef, &isCompleted](wgpu::PopErrorScopeStatus, wgpu::ErrorType, const char*) {
+                device2ndRef = nullptr;
+                isCompleted = true;
+            });
         // main ref dropped.
         additionalDevice = nullptr;
 
         do {
             WaitABit();
-        } while (!userData.isCompleted.load());
+        } while (!isCompleted.load());
 
-        EXPECT_EQ(userData.device2ndRef, nullptr);
+        EXPECT_EQ(device2ndRef, nullptr);
     });
 }
 
@@ -1330,12 +1325,12 @@
 
         std::atomic<bool> errorThrown(false);
         device.PopErrorScope(
-            [](WGPUErrorType type, char const* message, void* userdata) {
-                EXPECT_EQ(type, WGPUErrorType_Validation);
-                auto error = static_cast<std::atomic<bool>*>(userdata);
-                *error = true;
-            },
-            &errorThrown);
+            wgpu::CallbackMode::AllowProcessEvents,
+            [&errorThrown](wgpu::PopErrorScopeStatus status, wgpu::ErrorType type, char const*) {
+                EXPECT_EQ(status, wgpu::PopErrorScopeStatus::Success);
+                EXPECT_EQ(type, wgpu::ErrorType::Validation);
+                errorThrown = true;
+            });
         instance.ProcessEvents();
         EXPECT_TRUE(errorThrown.load());
 
diff --git a/src/dawn/tests/unittests/validation/ErrorScopeValidationTests.cpp b/src/dawn/tests/unittests/validation/ErrorScopeValidationTests.cpp
index f4ae097..60ad2ac 100644
--- a/src/dawn/tests/unittests/validation/ErrorScopeValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/ErrorScopeValidationTests.cpp
@@ -33,30 +33,8 @@
 #include "gmock/gmock.h"
 
 using testing::_;
-using testing::MockCallback;
-using testing::Sequence;
-
-class MockDevicePopErrorScopeCallback {
-  public:
-    MOCK_METHOD(void, Call, (WGPUErrorType type, const char* message, void* userdata));
-};
-
-static std::unique_ptr<MockDevicePopErrorScopeCallback> mockDevicePopErrorScopeCallback;
-static void ToMockDevicePopErrorScopeCallback(WGPUErrorType type,
-                                              const char* message,
-                                              void* userdata) {
-    mockDevicePopErrorScopeCallback->Call(type, message, userdata);
-}
-
-class MockQueueWorkDoneCallback {
-  public:
-    MOCK_METHOD(void, Call, (WGPUQueueWorkDoneStatus status, void* userdata));
-};
-
-static std::unique_ptr<MockQueueWorkDoneCallback> mockQueueWorkDoneCallback;
-static void ToMockQueueWorkDone(WGPUQueueWorkDoneStatus status, void* userdata) {
-    mockQueueWorkDoneCallback->Call(status, userdata);
-}
+using testing::MockCppCallback;
+using testing::NotNull;
 
 class ErrorScopeValidationTest : public ValidationTest {
   protected:
@@ -65,40 +43,18 @@
         instance.ProcessEvents();
     }
 
-    // Generate new void* pointer for use as `userdata` in callback. The pointer
-    // is valid for the whole duration of the test. This avoids dangling
-    // pointers checks to trigger.
-    void* CreateUserData() {
-        mUserData.push_back(std::make_unique<bool>());
-        return reinterpret_cast<void*>(mUserData.back().get());
-    }
-
-  private:
-    void SetUp() override {
-        ValidationTest::SetUp();
-        mockDevicePopErrorScopeCallback = std::make_unique<MockDevicePopErrorScopeCallback>();
-        mockQueueWorkDoneCallback = std::make_unique<MockQueueWorkDoneCallback>();
-    }
-
-    void TearDown() override {
-        ValidationTest::TearDown();
-
-        // Delete mocks so that expectations are checked
-        mockDevicePopErrorScopeCallback = nullptr;
-        mockQueueWorkDoneCallback = nullptr;
-    }
-
-    std::vector<std::unique_ptr<bool>> mUserData;
+    MockCppCallback<void (*)(wgpu::PopErrorScopeStatus, wgpu::ErrorType, const char*)>
+        mPopErrorScopeCb;
 };
 
 // Test the simple success case.
 TEST_F(ErrorScopeValidationTest, Success) {
     device.PushErrorScope(wgpu::ErrorFilter::Validation);
 
-    void* userdata = CreateUserData();
-    EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, userdata))
+    EXPECT_CALL(mPopErrorScopeCb,
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::NoError, _))
         .Times(1);
-    device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata);
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
     FlushWireAndProcessEvents();
 }
 
@@ -110,10 +66,10 @@
     desc.usage = static_cast<wgpu::BufferUsage>(WGPUBufferUsage_Force32);
     device.CreateBuffer(&desc);
 
-    void* userdata = CreateUserData();
-    EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_Validation, _, userdata))
+    EXPECT_CALL(mPopErrorScopeCb,
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::Validation, _))
         .Times(1);
-    device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata);
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
     FlushWireAndProcessEvents();
 }
 
@@ -127,17 +83,17 @@
     device.CreateBuffer(&desc);
 
     // OutOfMemory does not match Validation error.
-    void* userdata_1 = CreateUserData();
-    EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, userdata_1))
+    EXPECT_CALL(mPopErrorScopeCb,
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::NoError, _))
         .Times(1);
-    device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata_1);
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
     FlushWireAndProcessEvents();
 
     // Parent validation error scope captures the error.
-    void* userdata_2 = CreateUserData();
-    EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_Validation, _, userdata_2))
+    EXPECT_CALL(mPopErrorScopeCb,
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::Validation, _))
         .Times(1);
-    device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata_2);
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
     FlushWireAndProcessEvents();
 }
 
@@ -151,17 +107,17 @@
     device.CreateBuffer(&desc);
 
     // Inner scope catches the error.
-    void* userdata_1 = CreateUserData();
-    EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_Validation, _, userdata_1))
+    EXPECT_CALL(mPopErrorScopeCb,
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::Validation, _))
         .Times(1);
-    device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata_1);
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
     FlushWireAndProcessEvents();
 
     // Parent scope does not see the error.
-    void* userdata_2 = CreateUserData();
-    EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, userdata_2))
+    EXPECT_CALL(mPopErrorScopeCb,
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::NoError, _))
         .Times(1);
-    device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata_2);
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
     FlushWireAndProcessEvents();
 }
 
@@ -173,10 +129,10 @@
     desc.usage = static_cast<wgpu::BufferUsage>(WGPUBufferUsage_Force32);
     ASSERT_DEVICE_ERROR(device.CreateBuffer(&desc));
 
-    void* userdata = CreateUserData();
-    EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, userdata))
+    EXPECT_CALL(mPopErrorScopeCb,
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::NoError, _))
         .Times(1);
-    device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata);
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
     FlushWireAndProcessEvents();
 }
 
@@ -184,63 +140,31 @@
 TEST_F(ErrorScopeValidationTest, PushPopBalanced) {
     // No error scopes to pop.
     {
-        void* userdata = CreateUserData();
-        EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_Unknown, _, userdata))
+        EXPECT_CALL(mPopErrorScopeCb,
+                    Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::Unknown, NotNull()))
             .Times(1);
-        device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata);
+        device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
         FlushWireAndProcessEvents();
     }
     // Too many pops
     {
         device.PushErrorScope(wgpu::ErrorFilter::Validation);
 
-        void* userdata_1 = CreateUserData();
-        EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, userdata_1))
+        EXPECT_CALL(mPopErrorScopeCb,
+                    Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::NoError, _))
             .Times(1);
-        device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata_1);
+        device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
         FlushWireAndProcessEvents();
 
-        void* userdata_2 = CreateUserData();
-        EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_Unknown, _, userdata_2))
+        EXPECT_CALL(mPopErrorScopeCb,
+                    Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::Unknown, NotNull()))
             .Times(1);
-        device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata_2);
+        device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
         FlushWireAndProcessEvents();
     }
 }
 
-// Test that parent error scopes also call their callbacks before an enclosed Queue::Submit
-// completes
-TEST_F(ErrorScopeValidationTest, EnclosedQueueSubmitNested) {
-    wgpu::Queue queue = device.GetQueue();
-
-    device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory);
-    device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory);
-
-    void* userdata_1 = CreateUserData();
-    queue.Submit(0, nullptr);
-    queue.OnSubmittedWorkDone(ToMockQueueWorkDone, userdata_1);
-
-    Sequence seq;
-
-    MockCallback<WGPUErrorCallback> errorScopeCallback2;
-    void* userdata_2 = CreateUserData();
-    EXPECT_CALL(errorScopeCallback2, Call(WGPUErrorType_NoError, _, userdata_2)).InSequence(seq);
-    device.PopErrorScope(errorScopeCallback2.Callback(),
-                         errorScopeCallback2.MakeUserdata(userdata_2));
-
-    MockCallback<WGPUErrorCallback> errorScopeCallback1;
-    void* userdata_3 = CreateUserData();
-    EXPECT_CALL(errorScopeCallback1, Call(WGPUErrorType_NoError, _, userdata_3)).InSequence(seq);
-    device.PopErrorScope(errorScopeCallback1.Callback(),
-                         errorScopeCallback1.MakeUserdata(userdata_3));
-
-    EXPECT_CALL(*mockQueueWorkDoneCallback, Call(WGPUQueueWorkDoneStatus_Success, userdata_1));
-    WaitForAllOperations(device);
-}
-
-// Test that if the device is destroyed before the callback occurs, it is called with NoError
-// in dawn_native, but Unknown in dawn_wire because the device is destroyed before the callback
-// message happens.
+// Test that if the device is destroyed before the callback occurs, it is called with NoError.
 TEST_F(ErrorScopeValidationTest, DeviceDestroyedBeforeCallback) {
     device.PushErrorScope(wgpu::ErrorFilter::OutOfMemory);
     {
@@ -249,10 +173,10 @@
         queue.Submit(0, nullptr);
     }
 
-    void* userdata = CreateUserData();
-    EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_NoError, _, userdata))
+    EXPECT_CALL(mPopErrorScopeCb,
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::NoError, _))
         .Times(1);
-    device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata);
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
     ExpectDeviceDestruction();
     device = nullptr;
 
@@ -266,10 +190,10 @@
     device.Destroy();
     FlushWireAndProcessEvents();
 
-    void* userdata = CreateUserData();
-    EXPECT_CALL(*mockDevicePopErrorScopeCallback, Call(WGPUErrorType_DeviceLost, _, userdata))
+    EXPECT_CALL(mPopErrorScopeCb,
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::DeviceLost, NotNull()))
         .Times(1);
-    device.PopErrorScope(ToMockDevicePopErrorScopeCallback, userdata);
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, mPopErrorScopeCb.Callback());
     FlushWireAndProcessEvents();
 }
 
diff --git a/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp b/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp
index 2a91393..7fad752 100644
--- a/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp
@@ -213,17 +213,6 @@
         }
     }
 
-    // Overridden version of api.CallDevicePopErrorScopeCallback to defer to the correct callback
-    // depending on the test callback mode. Note that currently, the ServerDevice calls the native
-    // procs using the old-non-future signature. Once that changes, we can probably just inline
-    // api.CallDevicePopErrorScopeCallback calls in place of this function.
-    void CallDevicePopErrorScopeCallback(WGPUDevice d,
-                                         WGPUPopErrorScopeStatus status,
-                                         WGPUErrorType type,
-                                         char const* message) {
-        api.CallDevicePopErrorScopeOldCallback(d, type, message);
-    }
-
     void PushErrorScope(WGPUErrorFilter filter) {
         EXPECT_CALL(api, DevicePushErrorScope(apiDevice, filter)).Times(1);
         wgpuDevicePushErrorScope(device, filter);
@@ -259,9 +248,9 @@
         PushErrorScope(filter);
 
         DevicePopErrorScope(device, this);
-        EXPECT_CALL(api, OnDevicePopErrorScope(apiDevice, _)).WillOnce([&] {
-            CallDevicePopErrorScopeCallback(apiDevice, WGPUPopErrorScopeStatus_Success, type,
-                                            "Some error message");
+        EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).WillOnce([&] {
+            api.CallDevicePopErrorScope2Callback(apiDevice, WGPUPopErrorScopeStatus_Success, type,
+                                                 "Some error message");
         });
 
         FlushClient();
@@ -288,7 +277,7 @@
     PushErrorScope(WGPUErrorFilter_Validation);
 
     DevicePopErrorScope(device, this);
-    EXPECT_CALL(api, OnDevicePopErrorScope(apiDevice, _)).Times(1);
+    EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).Times(1);
 
     FlushClient();
     FlushFutures();
@@ -316,9 +305,9 @@
     PushErrorScope(WGPUErrorFilter_Validation);
 
     DevicePopErrorScope(device, this);
-    EXPECT_CALL(api, OnDevicePopErrorScope(apiDevice, _)).WillOnce(InvokeWithoutArgs([&] {
-        CallDevicePopErrorScopeCallback(apiDevice, WGPUPopErrorScopeStatus_Success,
-                                        WGPUErrorType_Validation, "Some error message");
+    EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).WillOnce(InvokeWithoutArgs([&] {
+        api.CallDevicePopErrorScope2Callback(apiDevice, WGPUPopErrorScopeStatus_Success,
+                                             WGPUErrorType_Validation, "Some error message");
     }));
 
     FlushClient();
@@ -341,9 +330,9 @@
 // Empty stack (We are emulating the errors that would be callback-ed from native).
 TEST_P(WirePopErrorScopeCallbackTests, EmptyStack) {
     DevicePopErrorScope(device, this);
-    EXPECT_CALL(api, OnDevicePopErrorScope(apiDevice, _)).WillOnce(InvokeWithoutArgs([&] {
-        CallDevicePopErrorScopeCallback(apiDevice, WGPUPopErrorScopeStatus_Success,
-                                        WGPUErrorType_Validation, "No error scopes to pop");
+    EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).WillOnce(InvokeWithoutArgs([&] {
+        api.CallDevicePopErrorScope2Callback(apiDevice, WGPUPopErrorScopeStatus_Success,
+                                             WGPUErrorType_Validation, "No error scopes to pop");
     }));
 
     FlushClient();
diff --git a/src/dawn/tests/white_box/SharedTextureMemoryTests.cpp b/src/dawn/tests/white_box/SharedTextureMemoryTests.cpp
index 7951b51..534487c 100644
--- a/src/dawn/tests/white_box/SharedTextureMemoryTests.cpp
+++ b/src/dawn/tests/white_box/SharedTextureMemoryTests.cpp
@@ -772,7 +772,7 @@
 namespace {
 
 using testing::HasSubstr;
-using testing::MockCallback;
+using testing::MockCppCallback;
 
 template <typename T>
 T& AsNonConst(const T& rhs) {
@@ -788,12 +788,13 @@
     const auto& memories =
         GetParam().mBackend->CreateSharedTextureMemories(device, GetParam().mLayerCount);
 
-    MockCallback<WGPUErrorCallback> popErrorScopeCallback;
+    MockCppCallback<void (*)(wgpu::PopErrorScopeStatus, wgpu::ErrorType, const char*)>
+        popErrorScopeCallback;
     EXPECT_CALL(popErrorScopeCallback,
-                Call(WGPUErrorType_Validation, HasSubstr("is not enabled"), this));
+                Call(wgpu::PopErrorScopeStatus::Success, wgpu::ErrorType::Validation,
+                     HasSubstr("is not enabled")));
 
-    device.PopErrorScope(popErrorScopeCallback.Callback(),
-                         popErrorScopeCallback.MakeUserdata(this));
+    device.PopErrorScope(wgpu::CallbackMode::AllowProcessEvents, popErrorScopeCallback.Callback());
 
     for (wgpu::SharedTextureMemory memory : memories) {
         ASSERT_DEVICE_ERROR_MSG(wgpu::Texture texture = memory.CreateTexture(),
diff --git a/src/dawn/wire/client/Device.cpp b/src/dawn/wire/client/Device.cpp
index 459d7a2..6e132f3 100644
--- a/src/dawn/wire/client/Device.cpp
+++ b/src/dawn/wire/client/Device.cpp
@@ -45,15 +45,11 @@
   public:
     static constexpr EventType kType = EventType::PopErrorScope;
 
-    explicit PopErrorScopeEvent(const WGPUPopErrorScopeCallbackInfo& callbackInfo)
+    explicit PopErrorScopeEvent(const WGPUPopErrorScopeCallbackInfo2& callbackInfo)
         : TrackedEvent(callbackInfo.mode),
           mCallback(callbackInfo.callback),
-          mOldCallback(callbackInfo.oldCallback),
-          mUserdata(callbackInfo.userdata) {
-        // Exactly 1 callback should be set.
-        DAWN_ASSERT((mCallback != nullptr && mOldCallback == nullptr) ||
-                    (mCallback == nullptr && mOldCallback != nullptr));
-    }
+          mUserdata1(callbackInfo.userdata1),
+          mUserdata2(callbackInfo.userdata2) {}
 
     EventType GetType() override { return kType; }
 
@@ -71,19 +67,16 @@
             mStatus = WGPUPopErrorScopeStatus_InstanceDropped;
             mMessage = std::nullopt;
         }
-        void* userdata = mUserdata.ExtractAsDangling();
-        if (mOldCallback) {
-            mOldCallback(mType, mMessage ? mMessage->c_str() : nullptr, userdata);
-        }
+        void* userdata1 = mUserdata1.ExtractAsDangling();
+        void* userdata2 = mUserdata2.ExtractAsDangling();
         if (mCallback) {
-            mCallback(mStatus, mType, mMessage ? mMessage->c_str() : nullptr, userdata);
+            mCallback(mStatus, mType, mMessage ? mMessage->c_str() : nullptr, userdata1, userdata2);
         }
     }
 
-    // TODO(crbug.com/dawn/2021) Remove the old callback type.
-    WGPUPopErrorScopeCallback mCallback;
-    WGPUErrorCallback mOldCallback;
-    raw_ptr<void> mUserdata;
+    WGPUPopErrorScopeCallback2 mCallback;
+    raw_ptr<void> mUserdata1;
+    raw_ptr<void> mUserdata2;
 
     WGPUPopErrorScopeStatus mStatus = WGPUPopErrorScopeStatus_Success;
     WGPUErrorType mType = WGPUErrorType_Unknown;
@@ -385,14 +378,29 @@
 }
 
 void Device::PopErrorScope(WGPUErrorCallback callback, void* userdata) {
-    WGPUPopErrorScopeCallbackInfo callbackInfo = {};
-    callbackInfo.mode = WGPUCallbackMode_AllowSpontaneous;
-    callbackInfo.oldCallback = callback;
-    callbackInfo.userdata = userdata;
-    PopErrorScopeF(callbackInfo);
+    static WGPUErrorCallback kDefaultCallback = [](WGPUErrorType, char const*, void*) {};
+
+    PopErrorScope2({nullptr, WGPUCallbackMode_AllowSpontaneous,
+                    [](WGPUPopErrorScopeStatus, WGPUErrorType type, char const* message,
+                       void* callback, void* userdata) {
+                        auto cb = reinterpret_cast<WGPUErrorCallback>(callback);
+                        cb(type, message, userdata);
+                    },
+                    reinterpret_cast<void*>(callback != nullptr ? callback : kDefaultCallback),
+                    userdata});
 }
 
 WGPUFuture Device::PopErrorScopeF(const WGPUPopErrorScopeCallbackInfo& callbackInfo) {
+    return PopErrorScope2({nullptr, callbackInfo.mode,
+                           [](WGPUPopErrorScopeStatus status, WGPUErrorType type,
+                              char const* message, void* callback, void* userdata) {
+                               auto cb = reinterpret_cast<WGPUPopErrorScopeCallback>(callback);
+                               cb(status, type, message, userdata);
+                           },
+                           reinterpret_cast<void*>(callbackInfo.callback), callbackInfo.userdata});
+}
+
+WGPUFuture Device::PopErrorScope2(const WGPUPopErrorScopeCallbackInfo2& callbackInfo) {
     Client* client = GetClient();
     auto [futureIDInternal, tracked] =
         GetEventManager().TrackEvent(std::make_unique<PopErrorScopeEvent>(callbackInfo));
diff --git a/src/dawn/wire/client/Device.h b/src/dawn/wire/client/Device.h
index ab07cc70..28418ba 100644
--- a/src/dawn/wire/client/Device.h
+++ b/src/dawn/wire/client/Device.h
@@ -61,6 +61,7 @@
     void InjectError(WGPUErrorType type, const char* message);
     void PopErrorScope(WGPUErrorCallback callback, void* userdata);
     WGPUFuture PopErrorScopeF(const WGPUPopErrorScopeCallbackInfo& callbackInfo);
+    WGPUFuture PopErrorScope2(const WGPUPopErrorScopeCallbackInfo2& callbackInfo);
     WGPUBuffer CreateBuffer(const WGPUBufferDescriptor* descriptor);
     void CreateComputePipelineAsync(WGPUComputePipelineDescriptor const* descriptor,
                                     WGPUCreateComputePipelineAsyncCallback callback,
diff --git a/src/dawn/wire/server/Server.h b/src/dawn/wire/server/Server.h
index a64d59f..a244b9d 100644
--- a/src/dawn/wire/server/Server.h
+++ b/src/dawn/wire/server/Server.h
@@ -250,6 +250,7 @@
                       WGPUDeviceLostReason reason,
                       const char* message);
     void OnDevicePopErrorScope(ErrorScopeUserdata* userdata,
+                               WGPUPopErrorScopeStatus status,
                                WGPUErrorType type,
                                const char* message);
     void OnBufferMapAsyncCallback(MapUserdata* userdata, WGPUBufferMapAsyncStatus status);
diff --git a/src/dawn/wire/server/ServerDevice.cpp b/src/dawn/wire/server/ServerDevice.cpp
index e974431..1c191b7 100644
--- a/src/dawn/wire/server/ServerDevice.cpp
+++ b/src/dawn/wire/server/ServerDevice.cpp
@@ -71,12 +71,14 @@
     userdata->eventManager = eventManager;
     userdata->future = future;
 
-    mProcs.devicePopErrorScope(device->handle, ForwardToServer<&Server::OnDevicePopErrorScope>,
-                               userdata.release());
+    mProcs.devicePopErrorScope2(device->handle, {nullptr, WGPUCallbackMode_AllowProcessEvents,
+                                                 ForwardToServer2<&Server::OnDevicePopErrorScope>,
+                                                 userdata.release(), nullptr});
     return WireResult::Success;
 }
 
 void Server::OnDevicePopErrorScope(ErrorScopeUserdata* userdata,
+                                   WGPUPopErrorScopeStatus status,
                                    WGPUErrorType type,
                                    const char* message) {
     ReturnDevicePopErrorScopeCallbackCmd cmd;