Common: Remove the string parameters from the HookableEvent interface.

27 files changed, 84 insertions, 126 deletions

diff --git a/Source/Core/Common/HookableEvent.h b/Source/Core/Common/HookableEvent.h
index e2145e57e1..58a07c1fe9 100644
--- a/Source/Core/Common/HookableEvent.h
+++ b/Source/Core/Common/HookableEvent.h
@@ -6,14 +6,9 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <string_view>
 #include <vector>
 
-#if defined(_DEBUG)
-#include <string>
-
 #include "Common/Logging/Log.h"
-#endif
 
 namespace Common
 {
@@ -33,12 +28,13 @@ using EventHook = std::unique_ptr<HookBase>;
 //
 // Define Events as:
 //
-//     HookableEvent<std::string, u32> my_lovely_event{"My lovely event"};
+//   HookableEvent<std::string, u32> my_lovely_event;
 //
 // Register listeners anywhere you need them as:
-//    EventHook my_hook = my_lovely_event.Register([](std::string foo, u32 bar) {
+//
+//   EventHook my_hook = my_lovely_event.Register([](std::string foo, u32 bar) {
 //       fmt::print("I've been triggered with {} and {}", foo, bar)
-//   }, "NameOfHook");
+//   });
 //
 // The hook will be automatically unregistered when the EventHook object goes out of scope.
 // Trigger events by calling Trigger as:
@@ -52,19 +48,12 @@ class HookableEvent
 public:
   using CallbackType = std::function<void(CallbackArgs...)>;
 
-  explicit HookableEvent(std::string_view event_name)
-      : m_storage{std::make_shared<Storage>(event_name)}
-  {
-  }
-
   // Returns a handle that will unregister the listener when destroyed.
   // Note: Attempting to add/remove hooks of the event within the callback itself will NOT work.
-  [[nodiscard]] EventHook Register(CallbackType callback, std::string_view name)
+  [[nodiscard]] EventHook Register(CallbackType callback)
   {
-#if defined(_DEBUG)
-    DEBUG_LOG_FMT(COMMON, "Registering {} handler at {} event hook", name, m_storage->event_name);
-#endif
-    auto handle = std::make_unique<HookImpl>(m_storage, std::move(callback), name);
+    DEBUG_LOG_FMT(COMMON, "Registering event hook handler");
+    auto handle = std::make_unique<HookImpl>(m_storage, std::move(callback));
 
     std::lock_guard lg(m_storage->listeners_mutex);
     m_storage->listeners.push_back(handle.get());
@@ -83,29 +72,15 @@ private:
 
   struct Storage
   {
-    explicit Storage(std::string_view name [[maybe_unused]])
-    {
-#if defined(_DEBUG)
-      event_name = std::string(name);
-#endif
-    }
-
     std::mutex listeners_mutex;
     std::vector<HookImpl*> listeners;
-#if defined(_DEBUG)
-    std::string event_name;
-#endif
   };
 
   struct HookImpl final : HookBase
   {
-    HookImpl(const std::shared_ptr<Storage> storage, CallbackType func,
-             std::string_view name [[maybe_unused]])
+    HookImpl(const std::shared_ptr<Storage> storage, CallbackType func)
         : weak_storage{storage}, callback{std::move(func)}
     {
-#if defined(_DEBUG)
-      hook_name = std::string(name);
-#endif
     }
 
     ~HookImpl() override
@@ -113,28 +88,22 @@ private:
       const auto storage = weak_storage.lock();
       if (storage == nullptr)
       {
-#if defined(_DEBUG)
-        DEBUG_LOG_FMT(COMMON, "Handler {} outlived event hook", hook_name);
-#endif
+        DEBUG_LOG_FMT(COMMON, "Handler outlived event hook");
         return;
       }
 
-#if defined(_DEBUG)
-      DEBUG_LOG_FMT(COMMON, "Removing handler {} of event hook {}", hook_name, storage->event_name);
-#endif
+      DEBUG_LOG_FMT(COMMON, "Removing event hook handler");
+
       std::lock_guard lg(storage->listeners_mutex);
       std::erase(storage->listeners, this);
     }
 
     std::weak_ptr<Storage> weak_storage;
     const CallbackType callback;
-#if defined(_DEBUG)
-    std::string hook_name;
-#endif
   };
 
   // shared_ptr storage allows hooks to forget their connection if they outlive the event itself.
-  std::shared_ptr<Storage> m_storage;
+  std::shared_ptr<Storage> m_storage{std::make_shared<Storage>()};
 };
 
 }  // namespace Common
diff --git a/Source/Core/Core/AchievementManager.h b/Source/Core/Core/AchievementManager.h
index c1734cbcd3..225bcb1ddb 100644
--- a/Source/Core/Core/AchievementManager.h
+++ b/Source/Core/Core/AchievementManager.h
@@ -120,7 +120,7 @@ public:
     bool rich_presence = false;
     int failed_login_code = 0;
   };
-  Common::HookableEvent<const UpdatedItems&> update_event{"AchievementManagerUpdate"};
+  Common::HookableEvent<const UpdatedItems&> update_event;
 
   static AchievementManager& GetInstance();
   void Init(void* hwnd);
@@ -174,7 +174,7 @@ public:
   std::vector<std::string> GetActiveLeaderboards() const;
 
 #ifdef RC_CLIENT_SUPPORTS_RAINTEGRATION
-  Common::HookableEvent<> dev_menu_update_event{"AchievementManagerDevMenuUpdate"};
+  Common::HookableEvent<> dev_menu_update_event;
   const rc_client_raintegration_menu_t* GetDevelopmentMenu();
   u32 ActivateDevMenuItem(u32 menu_item_id);
   bool CheckForModifications() { return rc_client_raintegration_has_modifications(m_client); }
diff --git a/Source/Core/Core/Core.cpp b/Source/Core/Core/Core.cpp
index 1892e0b3ea..f026cb939d 100644
--- a/Source/Core/Core/Core.cpp
+++ b/Source/Core/Core/Core.cpp
@@ -658,8 +658,8 @@ static void EmuThread(Core::System& system, std::unique_ptr<BootParameters> boot
   // This adds the SyncGPU handler to CoreTiming, so now CoreTiming::Advance might block.
   system.GetFifo().Prepare();
 
-  const Common::EventHook frame_presented = GetVideoEvents().after_present_event.Register(
-      &Core::Callback_FramePresented, "Core Frame Presented");
+  const Common::EventHook frame_presented =
+      GetVideoEvents().after_present_event.Register(&Core::Callback_FramePresented);
 
   // Setup our core
   if (Config::Get(Config::MAIN_CPU_CORE) != PowerPC::CPUCore::Interpreter)
diff --git a/Source/Core/Core/FifoPlayer/FifoRecorder.cpp b/Source/Core/Core/FifoPlayer/FifoRecorder.cpp
index 7cc22f42be..207e12fb7a 100644
--- a/Source/Core/Core/FifoPlayer/FifoRecorder.cpp
+++ b/Source/Core/Core/FifoPlayer/FifoRecorder.cpp
@@ -250,8 +250,8 @@ void FifoRecorder::StartRecording(s32 numFrames, CallbackFunc finishedCb)
   m_RequestedRecordingEnd = false;
   m_FinishedCb = finishedCb;
 
-  m_end_of_frame_event = m_system.GetVideoEvents().after_frame_event.Register(
-      [this](const Core::System& system) {
+  m_end_of_frame_event =
+      m_system.GetVideoEvents().after_frame_event.Register([this](const Core::System& system) {
         const bool was_recording = OpcodeDecoder::g_record_fifo_data;
         OpcodeDecoder::g_record_fifo_data = IsRecording();
 
@@ -270,8 +270,7 @@ void FifoRecorder::StartRecording(s32 numFrames, CallbackFunc finishedCb)
         const auto& fifo = system.GetCommandProcessor().GetFifo();
         EndFrame(fifo.CPBase.load(std::memory_order_relaxed),
                  fifo.CPEnd.load(std::memory_order_relaxed));
-      },
-      "FifoRecorder::EndFrame");
+      });
 }
 
 void FifoRecorder::RecordInitialVideoMemory()
diff --git a/Source/Core/DolphinQt/Achievements/AchievementsWindow.cpp b/Source/Core/DolphinQt/Achievements/AchievementsWindow.cpp
index 43218c47fd..63a15f67e7 100644
--- a/Source/Core/DolphinQt/Achievements/AchievementsWindow.cpp
+++ b/Source/Core/DolphinQt/Achievements/AchievementsWindow.cpp
@@ -36,8 +36,7 @@ AchievementsWindow::AchievementsWindow(QWidget* parent) : QDialog(parent)
         QueueOnObject(this, [this, updated_items = std::move(updated_items)] {
           AchievementsWindow::UpdateData(std::move(updated_items));
         });
-      },
-      "AchievementsWindow");
+      });
   UpdateData(AchievementManager::UpdatedItems{.all = true});
 
   connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
diff --git a/Source/Core/DolphinQt/CheatsManager.cpp b/Source/Core/DolphinQt/CheatsManager.cpp
index e3dd639293..5c77c7fb34 100644
--- a/Source/Core/DolphinQt/CheatsManager.cpp
+++ b/Source/Core/DolphinQt/CheatsManager.cpp
@@ -79,8 +79,8 @@ void CheatsManager::UpdateAllCheatSearchWidgetCurrentValues()
 
 void CheatsManager::RegisterAfterFrameEventCallback()
 {
-  m_VI_end_field_event = m_system.GetVideoEvents().vi_end_field_event.Register(
-      [this] { OnFrameEnd(); }, "CheatsManager");
+  m_VI_end_field_event =
+      m_system.GetVideoEvents().vi_end_field_event.Register([this] { OnFrameEnd(); });
 }
 
 void CheatsManager::RemoveAfterFrameEventCallback()
diff --git a/Source/Core/DolphinQt/Debugger/MemoryWidget.cpp b/Source/Core/DolphinQt/Debugger/MemoryWidget.cpp
index b088eeda02..0872477510 100644
--- a/Source/Core/DolphinQt/Debugger/MemoryWidget.cpp
+++ b/Source/Core/DolphinQt/Debugger/MemoryWidget.cpp
@@ -429,8 +429,8 @@ void MemoryWidget::hideEvent(QHideEvent* event)
 
 void MemoryWidget::RegisterAfterFrameEventCallback()
 {
-  m_vi_end_field_event = m_system.GetVideoEvents().vi_end_field_event.Register(
-      [this] { AutoUpdateTable(); }, "MemoryWidget");
+  m_vi_end_field_event =
+      m_system.GetVideoEvents().vi_end_field_event.Register([this] { AutoUpdateTable(); });
 }
 
 void MemoryWidget::RemoveAfterFrameEventCallback()
diff --git a/Source/Core/DolphinQt/MenuBar.cpp b/Source/Core/DolphinQt/MenuBar.cpp
index f4d69f41ce..d23bcd66e7 100644
--- a/Source/Core/DolphinQt/MenuBar.cpp
+++ b/Source/Core/DolphinQt/MenuBar.cpp
@@ -296,7 +296,7 @@ void MenuBar::AddToolsMenu()
 #ifdef RC_CLIENT_SUPPORTS_RAINTEGRATION
   m_achievements_dev_menu = tools_menu->addMenu(tr("RetroAchievements Development"));
   m_raintegration_event_hook = AchievementManager::GetInstance().dev_menu_update_event.Register(
-      [this] { QueueOnObject(this, [this] { UpdateAchievementDevelopmentMenu(); }); }, "MenuBar");
+      [this] { QueueOnObject(this, [this] { UpdateAchievementDevelopmentMenu(); }); });
   m_achievements_dev_menu->menuAction()->setVisible(false);
 #endif  // RC_CLIENT_SUPPORTS_RAINTEGRATION
   tools_menu->addSeparator();
diff --git a/Source/Core/DolphinQt/Settings.cpp b/Source/Core/DolphinQt/Settings.cpp
index 13260f7134..2767badbec 100644
--- a/Source/Core/DolphinQt/Settings.cpp
+++ b/Source/Core/DolphinQt/Settings.cpp
@@ -75,7 +75,7 @@ Settings::Settings()
     }
   });
 
-  m_hotplug_event_hook = g_controller_interface.RegisterDevicesChangedCallback("Settings", [this] {
+  m_hotplug_event_hook = g_controller_interface.RegisterDevicesChangedCallback([this] {
     if (Core::IsHostThread())
     {
       emit DevicesChanged();
diff --git a/Source/Core/InputCommon/ControllerInterface/Android/Android.cpp b/Source/Core/InputCommon/ControllerInterface/Android/Android.cpp
index a11241d4f8..48eebbb7f6 100644
--- a/Source/Core/InputCommon/ControllerInterface/Android/Android.cpp
+++ b/Source/Core/InputCommon/ControllerInterface/Android/Android.cpp
@@ -455,7 +455,7 @@ void RegisterDevicesChangedCallbackIfNeeded(JNIEnv* env, jclass controller_inter
       env->GetStaticMethodID(global_controller_interface_class, "onDevicesChanged", "()V");
 
   static Common::EventHook event_hook = g_controller_interface.RegisterDevicesChangedCallback(
-      "Android", [global_controller_interface_class, controller_interface_on_devices_changed] {
+      [global_controller_interface_class, controller_interface_on_devices_changed] {
         IDCache::GetEnvForThread()->CallStaticVoidMethod(global_controller_interface_class,
                                                          controller_interface_on_devices_changed);
       });
diff --git a/Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp b/Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp
index 19ac7d3690..7393de9950 100644
--- a/Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp
+++ b/Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp
@@ -415,10 +415,9 @@ bool ControllerInterface::IsMouseCenteringRequested() const
 // Returns a handle for later removing the callback.
 
 Common::EventHook
-ControllerInterface::RegisterDevicesChangedCallback(std::string_view name,
-                                                    Common::HookableEvent<>::CallbackType callback)
+ControllerInterface::RegisterDevicesChangedCallback(Common::HookableEvent<>::CallbackType callback)
 {
-  return m_devices_changed_event.Register(std::move(callback), name);
+  return m_devices_changed_event.Register(std::move(callback));
 }
 
 // Invoke all callbacks that were registered
diff --git a/Source/Core/InputCommon/ControllerInterface/ControllerInterface.h b/Source/Core/InputCommon/ControllerInterface/ControllerInterface.h
index 806c6b4b2a..05a3a99a05 100644
--- a/Source/Core/InputCommon/ControllerInterface/ControllerInterface.h
+++ b/Source/Core/InputCommon/ControllerInterface/ControllerInterface.h
@@ -115,8 +115,7 @@ public:
   bool IsMouseCenteringRequested() const;
 
   [[nodiscard]] Common::EventHook
-  RegisterDevicesChangedCallback(std::string_view name,
-                                 Common::HookableEvent<>::CallbackType callback);
+  RegisterDevicesChangedCallback(Common::HookableEvent<>::CallbackType callback);
 
   static void SetCurrentInputChannel(ciface::InputChannel);
   static ciface::InputChannel GetCurrentInputChannel();
@@ -128,7 +127,7 @@ private:
 
   void InvokeDevicesChangedCallbacks();
 
-  Common::HookableEvent<> m_devices_changed_event{"Devices Changed"};
+  Common::HookableEvent<> m_devices_changed_event;
 
   mutable std::recursive_mutex m_devices_population_mutex;
   std::atomic<bool> m_is_init;
diff --git a/Source/Core/InputCommon/InputConfig.cpp b/Source/Core/InputCommon/InputConfig.cpp
index 0e56adf378..6a6495c29c 100644
--- a/Source/Core/InputCommon/InputConfig.cpp
+++ b/Source/Core/InputCommon/InputConfig.cpp
@@ -172,11 +172,10 @@ void InputConfig::RegisterHotplugCallback()
 {
   // Update control references on all controllers
   // as configured devices may have been added or removed.
-  m_hotplug_event_hook =
-      g_controller_interface.RegisterDevicesChangedCallback("InputConfig", [this] {
-        for (auto& controller : m_controllers)
-          controller->UpdateReferences(g_controller_interface);
-      });
+  m_hotplug_event_hook = g_controller_interface.RegisterDevicesChangedCallback([this] {
+    for (auto& controller : m_controllers)
+      controller->UpdateReferences(g_controller_interface);
+  });
 }
 
 void InputConfig::UnregisterHotplugCallback()
diff --git a/Source/Core/VideoCommon/AbstractGfx.cpp b/Source/Core/VideoCommon/AbstractGfx.cpp
index ca6ad881b1..0e7e05e0f0 100644
--- a/Source/Core/VideoCommon/AbstractGfx.cpp
+++ b/Source/Core/VideoCommon/AbstractGfx.cpp
@@ -18,8 +18,8 @@ std::unique_ptr<AbstractGfx> g_gfx;
 
 AbstractGfx::AbstractGfx()
 {
-  m_config_changed = GetVideoEvents().config_changed_event.Register(
-      [this](u32 bits) { OnConfigChanged(bits); }, "AbstractGfx");
+  m_config_changed =
+      GetVideoEvents().config_changed_event.Register([this](u32 bits) { OnConfigChanged(bits); });
 }
 
 bool AbstractGfx::IsHeadless() const
diff --git a/Source/Core/VideoCommon/Assets/CustomResourceManager.cpp b/Source/Core/VideoCommon/Assets/CustomResourceManager.cpp
index ac8199ef86..6f8d3557bb 100644
--- a/Source/Core/VideoCommon/Assets/CustomResourceManager.cpp
+++ b/Source/Core/VideoCommon/Assets/CustomResourceManager.cpp
@@ -29,8 +29,8 @@ void CustomResourceManager::Initialize()
 
   m_asset_loader.Initialize();
 
-  m_xfb_event = GetVideoEvents().after_frame_event.Register(
-      [this](Core::System&) { XFBTriggered(); }, "CustomResourceManager");
+  m_xfb_event =
+      GetVideoEvents().after_frame_event.Register([this](Core::System&) { XFBTriggered(); });
 }
 
 void CustomResourceManager::Shutdown()
diff --git a/Source/Core/VideoCommon/FrameDumper.cpp b/Source/Core/VideoCommon/FrameDumper.cpp
index f39424805c..8bb98833f2 100644
--- a/Source/Core/VideoCommon/FrameDumper.cpp
+++ b/Source/Core/VideoCommon/FrameDumper.cpp
@@ -29,8 +29,8 @@ static bool DumpFrameToPNG(const FrameData& frame, const std::string& file_name)
 
 FrameDumper::FrameDumper()
 {
-  m_frame_end_handle = GetVideoEvents().after_frame_event.Register(
-      [this](Core::System&) { FlushFrameDump(); }, "FrameDumper");
+  m_frame_end_handle =
+      GetVideoEvents().after_frame_event.Register([this](Core::System&) { FlushFrameDump(); });
 }
 
 FrameDumper::~FrameDumper()
diff --git a/Source/Core/VideoCommon/FramebufferManager.cpp b/Source/Core/VideoCommon/FramebufferManager.cpp
index fc514811d5..8872f551c1 100644
--- a/Source/Core/VideoCommon/FramebufferManager.cpp
+++ b/Source/Core/VideoCommon/FramebufferManager.cpp
@@ -84,8 +84,8 @@ bool FramebufferManager::Initialize()
     return false;
   }
 
-  m_end_of_frame_event = GetVideoEvents().after_frame_event.Register(
-      [this](Core::System&) { EndOfFrame(); }, "FramebufferManager");
+  m_end_of_frame_event =
+      GetVideoEvents().after_frame_event.Register([this](Core::System&) { EndOfFrame(); });
 
   return true;
 }
diff --git a/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp
index 0bf8e844ec..a3c98ee9d7 100644
--- a/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp
+++ b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp
@@ -18,7 +18,7 @@ CustomShaderCache::CustomShaderCache()
   m_async_uber_shader_compiler->StartWorkerThreads(1);  // TODO
 
   m_frame_end_handler = GetVideoEvents().after_frame_event.Register(
-      [this](Core::System&) { RetrieveAsyncShaders(); }, "RetrieveAsyncShaders");
+      [this](Core::System&) { RetrieveAsyncShaders(); });
 }
 
 CustomShaderCache::~CustomShaderCache()
diff --git a/Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModManager.cpp b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModManager.cpp
index 6a523c61a2..3caaa999fd 100644
--- a/Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModManager.cpp
+++ b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModManager.cpp
@@ -95,8 +95,8 @@ bool GraphicsModManager::Initialize()
     g_ActiveConfig.graphics_mod_config->SetChangeCount(old_game_mod_changes);
     g_graphics_mod_manager->Load(*g_ActiveConfig.graphics_mod_config);
 
-    m_end_of_frame_event = GetVideoEvents().after_frame_event.Register(
-        [this](Core::System&) { EndOfFrame(); }, "ModManager");
+    m_end_of_frame_event =
+        GetVideoEvents().after_frame_event.Register([this](Core::System&) { EndOfFrame(); });
   }
 
   return true;
diff --git a/Source/Core/VideoCommon/Present.cpp b/Source/Core/VideoCommon/Present.cpp
index 24c767cc69..a8266a18a7 100644
--- a/Source/Core/VideoCommon/Present.cpp
+++ b/Source/Core/VideoCommon/Present.cpp
@@ -94,8 +94,8 @@ static void TryToSnapToXFBSize(int& width, int& height, int xfb_width, int xfb_h
 
 Presenter::Presenter()
 {
-  m_config_changed = GetVideoEvents().config_changed_event.Register(
-      [this](u32 bits) { ConfigChanged(bits); }, "Presenter");
+  m_config_changed =
+      GetVideoEvents().config_changed_event.Register([this](u32 bits) { ConfigChanged(bits); });
 }
 
 Presenter::~Presenter()
diff --git a/Source/Core/VideoCommon/ShaderCache.cpp b/Source/Core/VideoCommon/ShaderCache.cpp
index fbed022aa5..a3d07368f6 100644
--- a/Source/Core/VideoCommon/ShaderCache.cpp
+++ b/Source/Core/VideoCommon/ShaderCache.cpp
@@ -47,7 +47,7 @@ bool ShaderCache::Initialize()
 
   m_async_shader_compiler = g_gfx->CreateAsyncShaderCompiler();
   m_frame_end_handler = GetVideoEvents().after_frame_event.Register(
-      [this](Core::System&) { RetrieveAsyncShaders(); }, "RetrieveAsyncShaders");
+      [this](Core::System&) { RetrieveAsyncShaders(); });
   return true;
 }
 
diff --git a/Source/Core/VideoCommon/Statistics.cpp b/Source/Core/VideoCommon/Statistics.cpp
index 97c9264d18..642df5694a 100644
--- a/Source/Core/VideoCommon/Statistics.cpp
+++ b/Source/Core/VideoCommon/Statistics.cpp
@@ -500,18 +500,15 @@ void Statistics::DisplayScissor()
 
 void Statistics::Init()
 {
-  s_before_frame_event = GetVideoEvents().before_frame_event.Register([] { g_stats.ResetFrame(); },
-                                                                      "Statistics::ResetFrame");
-
-  s_after_frame_event = GetVideoEvents().after_frame_event.Register(
-      [](const Core::System& system) {
-        DolphinAnalytics::Instance().ReportPerformanceInfo({
-            .speed_ratio = system.GetSystemTimers().GetEstimatedEmulationPerformance(),
-            .num_prims = g_stats.this_frame.num_prims + g_stats.this_frame.num_dl_prims,
-            .num_draw_calls = g_stats.this_frame.num_draw_calls,
-        });
-      },
-      "Statistics::PerformanceSample");
+  s_before_frame_event = GetVideoEvents().before_frame_event.Register([] { g_stats.ResetFrame(); });
+
+  s_after_frame_event = GetVideoEvents().after_frame_event.Register([](const Core::System& system) {
+    DolphinAnalytics::Instance().ReportPerformanceInfo({
+        .speed_ratio = system.GetSystemTimers().GetEstimatedEmulationPerformance(),
+        .num_prims = g_stats.this_frame.num_prims + g_stats.this_frame.num_dl_prims,
+        .num_draw_calls = g_stats.this_frame.num_draw_calls,
+    });
+  });
 }
 
 void Statistics::Shutdown()
diff --git a/Source/Core/VideoCommon/TextureCacheBase.h b/Source/Core/VideoCommon/TextureCacheBase.h
index ee27c3e80b..9a95400679 100644
--- a/Source/Core/VideoCommon/TextureCacheBase.h
+++ b/Source/Core/VideoCommon/TextureCacheBase.h
@@ -463,8 +463,8 @@ private:
 
   void OnFrameEnd();
 
-  Common::EventHook m_frame_event = GetVideoEvents().after_frame_event.Register(
-      [this](Core::System&) { OnFrameEnd(); }, "TextureCache");
+  Common::EventHook m_frame_event =
+      GetVideoEvents().after_frame_event.Register([this](Core::System&) { OnFrameEnd(); });
 
   VideoCommon::TextureUtils::TextureDumper m_texture_dumper;
 };
diff --git a/Source/Core/VideoCommon/VertexManagerBase.cpp b/Source/Core/VideoCommon/VertexManagerBase.cpp
index 1af9ad8eb4..ce6c07ddb1 100644
--- a/Source/Core/VideoCommon/VertexManagerBase.cpp
+++ b/Source/Core/VideoCommon/VertexManagerBase.cpp
@@ -120,11 +120,10 @@ bool VertexManagerBase::Initialize()
 {
   auto& video_events = GetVideoEvents();
 
-  m_frame_end_event = video_events.after_frame_event.Register(
-      [this](Core::System&) { OnEndFrame(); }, "VertexManagerBase");
+  m_frame_end_event =
+      video_events.after_frame_event.Register([this](Core::System&) { OnEndFrame(); });
   m_after_present_event = video_events.after_present_event.Register(
-      [this](const PresentInfo& pi) { m_ticks_elapsed = pi.emulated_timestamp; },
-      "VertexManagerBase");
+      [this](const PresentInfo& pi) { m_ticks_elapsed = pi.emulated_timestamp; });
   m_index_generator.Init();
   m_custom_shader_cache = std::make_unique<CustomShaderCache>();
   m_cpu_cull.Init();
diff --git a/Source/Core/VideoCommon/VideoConfig.cpp b/Source/Core/VideoCommon/VideoConfig.cpp
index 63d061e684..c4d764176c 100644
--- a/Source/Core/VideoCommon/VideoConfig.cpp
+++ b/Source/Core/VideoCommon/VideoConfig.cpp
@@ -221,8 +221,8 @@ void VideoConfig::VerifyValidity()
 
 void VideoConfig::Init()
 {
-  s_check_config_event = GetVideoEvents().after_frame_event.Register(
-      [](Core::System&) { CheckForConfigChanges(); }, "CheckForConfigChanges");
+  s_check_config_event =
+      GetVideoEvents().after_frame_event.Register([](Core::System&) { CheckForConfigChanges(); });
 }
 
 void VideoConfig::Shutdown()
diff --git a/Source/Core/VideoCommon/VideoEvents.h b/Source/Core/VideoCommon/VideoEvents.h
index f8f29db589..ccee5bc3bd 100644
--- a/Source/Core/VideoCommon/VideoEvents.h
+++ b/Source/Core/VideoCommon/VideoEvents.h
@@ -69,17 +69,17 @@ struct PresentInfo
 struct VideoEvents
 {
   // Called when certain video config setting are changed
-  Common::HookableEvent<u32> config_changed_event{"ConfigChanged"};
+  Common::HookableEvent<u32> config_changed_event;
 
   // An event called just before the first draw call of a frame
-  Common::HookableEvent<> before_frame_event{"BeforeFrame"};
+  Common::HookableEvent<> before_frame_event;
 
   // An event called after the frame XFB copy begins processing on the host GPU.
   // Useful for "once per frame" usecases.
   // Note: In a few rare cases, games do multiple XFB copies per frame and join them while
   // presenting.
   //       If this matters to your usecase, you should use BeforePresent instead.
-  Common::HookableEvent<Core::System&> after_frame_event{"AfterFrame"};
+  Common::HookableEvent<Core::System&> after_frame_event;
 
   // An event called just as a frame is queued for presentation.
   // The exact timing of this event depends on the "Immediately Present XFB" option.
@@ -89,14 +89,14 @@ struct VideoEvents
   // frame.
   //
   // frame_count: The number of frames
-  Common::HookableEvent<PresentInfo&> before_present_event{"BeforePresent"};
+  Common::HookableEvent<PresentInfo&> before_present_event;
 
   // An event that is triggered after a frame is presented.
   // The exact timing of this event depends on backend/driver support.
-  Common::HookableEvent<PresentInfo&> after_present_event{"AfterPresent"};
+  Common::HookableEvent<PresentInfo&> after_present_event;
 
   // An end of frame event that runs on the CPU thread
-  Common::HookableEvent<> vi_end_field_event{"VIEndField"};
+  Common::HookableEvent<> vi_end_field_event;
 };
 
 VideoEvents& GetVideoEvents();
diff --git a/Source/Core/VideoCommon/Widescreen.cpp b/Source/Core/VideoCommon/Widescreen.cpp
index e980d24d57..987e733555 100644
--- a/Source/Core/VideoCommon/Widescreen.cpp
+++ b/Source/Core/VideoCommon/Widescreen.cpp
@@ -32,26 +32,24 @@ WidescreenManager::WidescreenManager()
   auto& system = Core::System::GetInstance();
   auto& video_events = system.GetVideoEvents();
 
-  m_config_changed = video_events.config_changed_event.Register(
-      [this](u32 bits) {
-        if (bits & (CONFIG_CHANGE_BIT_ASPECT_RATIO))
-        {
-          // If the widescreen flag isn't being overridden by any settings,
-          // reset it to default if heuristic aren't running or to the last
-          // heuristic value if they were running.
-          if (std::optional<bool> is_game_widescreen = GetWidescreenOverride())
-            m_is_game_widescreen = *is_game_widescreen;
-          else
-            m_is_game_widescreen = (m_heuristic_state == HeuristicState::Active_Found_Anamorphic);
-        }
-      },
-      "Widescreen");
+  m_config_changed = video_events.config_changed_event.Register([this](u32 bits) {
+    if (bits & (CONFIG_CHANGE_BIT_ASPECT_RATIO))
+    {
+      // If the widescreen flag isn't being overridden by any settings,
+      // reset it to default if heuristic aren't running or to the last
+      // heuristic value if they were running.
+      if (std::optional<bool> is_game_widescreen = GetWidescreenOverride())
+        m_is_game_widescreen = *is_game_widescreen;
+      else
+        m_is_game_widescreen = (m_heuristic_state == HeuristicState::Active_Found_Anamorphic);
+    }
+  });
 
   // VertexManager doesn't maintain statistics in Wii mode.
   if (!system.IsWii())
   {
     m_update_widescreen = video_events.after_frame_event.Register(
-        [this](Core::System&) { UpdateWidescreenHeuristic(); }, "WideScreen Heuristic");
+        [this](Core::System&) { UpdateWidescreenHeuristic(); });
   }
 }