Move DynamicLinkLibrary to common and use it in more places

rafalh · rafalh · commit 8ed434b83a98 · 2024-09-15T17:16:12.000+02:00
diff --git a/common/include/common/DynamicLinkLibrary.h b/common/include/common/DynamicLinkLibrary.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <utility>
+
+class DynamicLinkLibrary
+{
+public:
+    DynamicLinkLibrary(const wchar_t* filename)
+    {
+        handle_ = LoadLibraryW(filename);
+    }
+
+    DynamicLinkLibrary(const DynamicLinkLibrary& other) = delete;
+
+    DynamicLinkLibrary(DynamicLinkLibrary&& other) noexcept
+        : handle_(std::exchange(other.handle_, nullptr))
+    {}
+
+    ~DynamicLinkLibrary()
+    {
+        if (handle_) {
+            FreeLibrary(handle_);
+        }
+    }
+
+    DynamicLinkLibrary& operator=(const DynamicLinkLibrary& other) = delete;
+
+    DynamicLinkLibrary& operator=(DynamicLinkLibrary&& other) noexcept
+    {
+        std::swap(handle_, other.handle_);
+        return *this;
+    }
+
+    operator bool() const
+    {
+        return handle_ != nullptr;
+    }
+
+    template<typename T>
+    T get_proc_address(const char* name) const
+    {
+        static_assert(std::is_pointer_v<T>);
+        // Note: double cast is needed to fix cast-function-type GCC warning
+        return reinterpret_cast<T>(reinterpret_cast<void(*)()>(GetProcAddress(handle_, name)));
+    }
+
+private:
+    HMODULE handle_;
+};
diff --git a/crash_handler/MiniDumpHelper.cpp b/crash_handler/MiniDumpHelper.cpp
@@ -128,18 +128,15 @@ bool MiniDumpHelper::write_dump(const char* path, PEXCEPTION_POINTERS exception_
     return result != FALSE;
 }
 
-MiniDumpHelper::MiniDumpHelper()
+MiniDumpHelper::MiniDumpHelper() :
+    m_dbghelp_lib{L"Dbghelp.dll"}
 {
-    m_dbghelp_lib = LoadLibraryW(L"Dbghelp.dll");
     if (m_dbghelp_lib) {
-        // Note: double cast is needed to fix cast-function-type GCC warning
-        m_MiniDumpWriteDump = reinterpret_cast<MiniDumpWriteDump_Type>(reinterpret_cast<void(*)()>(
-            GetProcAddress(m_dbghelp_lib, "MiniDumpWriteDump")));
+        m_MiniDumpWriteDump = m_dbghelp_lib.get_proc_address<MiniDumpWriteDump_Type>("MiniDumpWriteDump");
     }
 }
 
 MiniDumpHelper::~MiniDumpHelper()
 {
-    FreeLibrary(m_dbghelp_lib);
     m_MiniDumpWriteDump = nullptr;
 }
diff --git a/crash_handler/MiniDumpHelper.h b/crash_handler/MiniDumpHelper.h
@@ -3,6 +3,7 @@
 #include <string>
 #include <vector>
 #include <windows.h>
+#include <common/DynamicLinkLibrary.h>
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -18,7 +19,7 @@ typedef decltype(&MiniDumpWriteDump) MiniDumpWriteDump_Type;
 class MiniDumpHelper
 {
 private:
-    HMODULE m_dbghelp_lib = nullptr;
+    DynamicLinkLibrary m_dbghelp_lib;
     MiniDumpWriteDump_Type m_MiniDumpWriteDump = nullptr;
     std::vector<std::wstring> m_known_modules;
     int m_info_level = 0;
diff --git a/game_patch/graphics/d3d11/gr_d3d11.h b/game_patch/graphics/d3d11/gr_d3d11.h
@@ -1,9 +1,9 @@
 #pragma once
 
 #include <unordered_map>
-#include <utility>
 #include <d3d11.h>
 #include <common/ComPtr.h>
+#include <common/DynamicLinkLibrary.h>
 #include <xlog/xlog.h>
 #include "../../rf/gr/gr.h"
 #include "../../rf/os/os.h"
@@ -34,51 +34,6 @@ namespace df::gr::d3d11
     class SolidRenderer;
     class MeshRenderer;
 
-    class DynamicLinkLibrary
-    {
-    public:
-        DynamicLinkLibrary(const wchar_t* filename)
-        {
-            handle_ = LoadLibraryW(filename);
-        }
-
-        DynamicLinkLibrary(const DynamicLinkLibrary& other) = delete;
-
-        DynamicLinkLibrary(DynamicLinkLibrary&& other) noexcept
-            : handle_(std::exchange(other.handle_, nullptr))
-        {}
-
-        ~DynamicLinkLibrary()
-        {
-            if (handle_) {
-                FreeLibrary(handle_);
-            }
-        }
-
-        DynamicLinkLibrary& operator=(const DynamicLinkLibrary& other) = delete;
-
-        DynamicLinkLibrary& operator=(DynamicLinkLibrary&& other) noexcept
-        {
-            std::swap(handle_, other.handle_);
-            return *this;
-        }
-
-        operator bool() const
-        {
-            return handle_ != nullptr;
-        }
-
-        template<typename T>
-        T get_proc_address(const char* name) const
-        {
-            static_assert(std::is_pointer_v<T>);
-            return reinterpret_cast<T>(reinterpret_cast<void(*)()>(GetProcAddress(handle_, name)));
-        }
-
-    private:
-        HMODULE handle_;
-    };
-
     class Renderer
     {
     public:
diff --git a/launcher_common/VideoDeviceInfoProviderD3D11.cpp b/launcher_common/VideoDeviceInfoProviderD3D11.cpp
@@ -3,6 +3,7 @@
 #include "VideoDeviceInfoProvider.h"
 #include <common/error/Exception.h>
 #include <common/error/Win32Error.h>
+#include <common/DynamicLinkLibrary.h>
 #include <common/ComPtr.h>
 #include <xlog/xlog.h>
 #include <dxgi.h>
@@ -11,7 +12,7 @@ class VideoDeviceInfoProviderD3D11 : public VideoDeviceInfoProvider
 {
 public:
     VideoDeviceInfoProviderD3D11();
-    ~VideoDeviceInfoProviderD3D11() override;
+    ~VideoDeviceInfoProviderD3D11() override = default;
     std::vector<std::string> get_adapters() override;
     std::set<Resolution> get_resolutions(unsigned adapter, unsigned format) override;
     std::set<unsigned> get_multisample_types(unsigned adapter, unsigned format, bool windowed) override;
@@ -27,46 +28,34 @@ class VideoDeviceInfoProviderD3D11 : public VideoDeviceInfoProvider
     }
 
 private:
-    IDXGIFactory* m_factory;
-    HMODULE m_dxgi_lib;
-    HMODULE m_d3d11_lib;
+    DynamicLinkLibrary m_dxgi_lib;
+    DynamicLinkLibrary m_d3d11_lib;
+    ComPtr<IDXGIFactory> m_factory;
     decltype(D3D11CreateDevice)* m_D3D11CreateDevice;
 };
 
-VideoDeviceInfoProviderD3D11::VideoDeviceInfoProviderD3D11()
+VideoDeviceInfoProviderD3D11::VideoDeviceInfoProviderD3D11() :
+    m_dxgi_lib{L"dxgi.dll"}, m_d3d11_lib{L"d3d11.dll"}
 {
-    m_dxgi_lib = LoadLibraryA("dxgi.dll");
     if (!m_dxgi_lib)
         THROW_WIN32_ERROR("Failed to load dxgi.dll");
 
-    // Note: double cast is needed to fix cast-function-type GCC warning
-    auto pCreateDXGIFactory = reinterpret_cast<decltype(CreateDXGIFactory)*>(reinterpret_cast<void(*)()>(
-        GetProcAddress(m_dxgi_lib, "CreateDXGIFactory")));
+    auto pCreateDXGIFactory = m_dxgi_lib.get_proc_address<decltype(CreateDXGIFactory)*>("CreateDXGIFactory");
     if (!pCreateDXGIFactory)
         THROW_WIN32_ERROR("Failed to load get CreateDXGIFactory function address");
 
     HRESULT hr = pCreateDXGIFactory(IID_IDXGIFactory, reinterpret_cast<void**>(&m_factory));
     if (FAILED(hr))
         THROW_EXCEPTION("CreateDXGIFactory failed");
 
-    m_d3d11_lib = LoadLibraryA("d3d11.dll");
     if (!m_d3d11_lib)
         THROW_WIN32_ERROR("Failed to load d3d11.dll");
 
-    // Note: double cast is needed to fix cast-function-type GCC warning
-    m_D3D11CreateDevice = reinterpret_cast<decltype(D3D11CreateDevice)*>(reinterpret_cast<void(*)()>(
-        GetProcAddress(m_d3d11_lib, "D3D11CreateDevice")));
+    m_D3D11CreateDevice = m_d3d11_lib.get_proc_address<decltype(D3D11CreateDevice)*>("D3D11CreateDevice");
     if (!m_D3D11CreateDevice)
         THROW_WIN32_ERROR("Failed to load get D3D11CreateDevice function address");
 }
 
-VideoDeviceInfoProviderD3D11::~VideoDeviceInfoProviderD3D11()
-{
-    m_factory->Release();
-    FreeLibrary(m_d3d11_lib);
-    FreeLibrary(m_dxgi_lib);
-}
-
 std::vector<std::string> VideoDeviceInfoProviderD3D11::get_adapters()
 {
     std::vector<std::string> adapters;
@@ -138,14 +127,14 @@ std::set<unsigned> VideoDeviceInfoProviderD3D11::get_multisample_types(
     unsigned adapter, unsigned format, [[maybe_unused]] bool windowed
 ) {
 
-    ComPtr<IDXGIAdapter> dxgi_adapter = nullptr;
+    ComPtr<IDXGIAdapter> dxgi_adapter;
     HRESULT hr = m_factory->EnumAdapters(adapter, &dxgi_adapter);
     if (FAILED(hr)) {
         xlog::error("EnumAdapters failed: %lx", hr);
         return {};
     }
 
-    ComPtr<ID3D11Device> d3d11_device = nullptr;
+    ComPtr<ID3D11Device> d3d11_device;
     hr = m_D3D11CreateDevice(dxgi_adapter, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, nullptr, 0, D3D11_SDK_VERSION, &d3d11_device, nullptr, nullptr);
     if (FAILED(hr)) {
         xlog::error("D3D11CreateDevice failed: %lx", hr);
diff --git a/launcher_common/VideoDeviceInfoProviderD3D8.cpp b/launcher_common/VideoDeviceInfoProviderD3D8.cpp
@@ -3,13 +3,15 @@
 #include "VideoDeviceInfoProvider.h"
 #include <common/error/Exception.h>
 #include <common/error/Win32Error.h>
+#include <common/DynamicLinkLibrary.h>
+#include <common/ComPtr.h>
 #include <xlog/xlog.h>
 
 class VideoDeviceInfoProviderD3D8 : public VideoDeviceInfoProvider
 {
 public:
     VideoDeviceInfoProviderD3D8();
-    ~VideoDeviceInfoProviderD3D8() override;
+    ~VideoDeviceInfoProviderD3D8() override = default;
     std::vector<std::string> get_adapters() override;
     std::set<Resolution> get_resolutions(unsigned adapter, unsigned format) override;
     std::set<unsigned> get_multisample_types(unsigned adapter, unsigned format, bool windowed) override;
@@ -24,19 +26,17 @@ class VideoDeviceInfoProviderD3D8 : public VideoDeviceInfoProvider
     }
 
 private:
-    IDirect3D8* m_d3d;
-    HMODULE m_lib;
+    DynamicLinkLibrary m_lib;
+    ComPtr<IDirect3D8> m_d3d;
 };
 
-VideoDeviceInfoProviderD3D8::VideoDeviceInfoProviderD3D8()
+VideoDeviceInfoProviderD3D8::VideoDeviceInfoProviderD3D8() :
+    m_lib{L"d3d8.dll"}
 {
-    m_lib = LoadLibraryA("d3d8.dll");
     if (!m_lib)
         THROW_WIN32_ERROR("Failed to load d3d8.dll");
 
-    // Note: double cast is needed to fix cast-function-type GCC warning
-    auto pDirect3DCreate8 = reinterpret_cast<decltype(Direct3DCreate8)*>(reinterpret_cast<void(*)()>(
-        GetProcAddress(m_lib, "Direct3DCreate8")));
+    auto pDirect3DCreate8 = m_lib.get_proc_address<decltype(Direct3DCreate8)*>("Direct3DCreate8");
     if (!pDirect3DCreate8)
         THROW_WIN32_ERROR("Failed to load get Direct3DCreate8 function address");
 
@@ -45,12 +45,6 @@ VideoDeviceInfoProviderD3D8::VideoDeviceInfoProviderD3D8()
         THROW_EXCEPTION("Direct3DCreate8 failed");
 }
 
-VideoDeviceInfoProviderD3D8::~VideoDeviceInfoProviderD3D8()
-{
-    m_d3d->Release();
-    FreeLibrary(m_lib);
-}
-
 std::vector<std::string> VideoDeviceInfoProviderD3D8::get_adapters()
 {
     std::vector<std::string> adapters;
diff --git a/launcher_common/VideoDeviceInfoProviderD3D9.cpp b/launcher_common/VideoDeviceInfoProviderD3D9.cpp
@@ -3,13 +3,15 @@
 #include "VideoDeviceInfoProvider.h"
 #include <common/error/Exception.h>
 #include <common/error/Win32Error.h>
+#include <common/DynamicLinkLibrary.h>
+#include <common/ComPtr.h>
 #include <xlog/xlog.h>
 
 class VideoDeviceInfoProviderD3D9 : public VideoDeviceInfoProvider
 {
 public:
     VideoDeviceInfoProviderD3D9();
-    ~VideoDeviceInfoProviderD3D9() override;
+    ~VideoDeviceInfoProviderD3D9() override = default;
     std::vector<std::string> get_adapters() override;
     std::set<Resolution> get_resolutions(unsigned adapter, unsigned format) override;
     std::set<unsigned> get_multisample_types(unsigned adapter, unsigned format, bool windowed) override;
@@ -24,19 +26,17 @@ class VideoDeviceInfoProviderD3D9 : public VideoDeviceInfoProvider
     }
 
 private:
-    IDirect3D9* m_d3d;
-    HMODULE m_lib;
+    DynamicLinkLibrary m_lib;
+    ComPtr<IDirect3D9> m_d3d;
 };
 
-VideoDeviceInfoProviderD3D9::VideoDeviceInfoProviderD3D9()
+VideoDeviceInfoProviderD3D9::VideoDeviceInfoProviderD3D9() :
+    m_lib{L"d3d9.dll"}
 {
-    m_lib = LoadLibraryA("d3d9.dll");
     if (!m_lib)
         THROW_WIN32_ERROR("Failed to load d3d9.dll");
 
-    // Note: double cast is needed to fix cast-function-type GCC warning
-    auto pDirect3DCreate9 = reinterpret_cast<decltype(Direct3DCreate9)*>(reinterpret_cast<void(*)()>(
-        GetProcAddress(m_lib, "Direct3DCreate9")));
+    auto pDirect3DCreate9 = m_lib.get_proc_address<decltype(Direct3DCreate9)*>("Direct3DCreate9");
     if (!pDirect3DCreate9)
         THROW_WIN32_ERROR("Failed to load get Direct3DCreate9 function address");
 
@@ -45,12 +45,6 @@ VideoDeviceInfoProviderD3D9::VideoDeviceInfoProviderD3D9()
         THROW_EXCEPTION("Direct3DCreate9 failed");
 }
 
-VideoDeviceInfoProviderD3D9::~VideoDeviceInfoProviderD3D9()
-{
-    m_d3d->Release();
-    FreeLibrary(m_lib);
-}
-
 std::vector<std::string> VideoDeviceInfoProviderD3D9::get_adapters()
 {
     std::vector<std::string> adapters;

Original file line number	Diff line number	Diff line change
`@@ -128,18 +128,15 @@ bool MiniDumpHelper::write_dump(const char* path, PEXCEPTION_POINTERS exception_`
`128`	`128`	`return result != FALSE;`
`129`	`129`	`}`
`130`	`130`
`131`		`-MiniDumpHelper::MiniDumpHelper()`
	`131`	`+MiniDumpHelper::MiniDumpHelper() :`
	`132`	`+ m_dbghelp_lib{L"Dbghelp.dll"}`
`132`	`133`	`{`
`133`		`- m_dbghelp_lib = LoadLibraryW(L"Dbghelp.dll");`
`134`	`134`	`if (m_dbghelp_lib) {`
`135`		`- // Note: double cast is needed to fix cast-function-type GCC warning`
`136`		`- m_MiniDumpWriteDump = reinterpret_cast<MiniDumpWriteDump_Type>(reinterpret_cast<void(*)()>(`
`137`		`- GetProcAddress(m_dbghelp_lib, "MiniDumpWriteDump")));`
	`135`	`+ m_MiniDumpWriteDump = m_dbghelp_lib.get_proc_address<MiniDumpWriteDump_Type>("MiniDumpWriteDump");`
`138`	`136`	`}`
`139`	`137`	`}`
`140`	`138`
`141`	`139`	`MiniDumpHelper::~MiniDumpHelper()`
`142`	`140`	`{`
`143`		`- FreeLibrary(m_dbghelp_lib);`
`144`	`141`	`m_MiniDumpWriteDump = nullptr;`
`145`	`142`	`}`