CEF reworks #3: Miscellaneous and refactors

Dutchman101 · Dutchman101 · commit 045bde9b6ca2 · 2025-11-14T18:46:21.000+08:00
diff --git a/Client/ceflauncher/Main.cpp b/Client/ceflauncher/Main.cpp
@@ -27,7 +27,7 @@ struct HINSTANCE__;
 using HINSTANCE = HINSTANCE__*;
 using LPSTR = char*;
 
-[[nodiscard("InitCEF return value must be used")]] __declspec(dllimport) auto InitCEF() -> int;
+extern "C" [[nodiscard("InitCEF return value must be used")]] __declspec(dllimport) int __cdecl InitCEF();
 
 // Users are faced with vague crashes in CEFLauncher.exe, so rather than over-engineering all this is intended
 // Do note that CEFLauncher.exe ends up hosting any GPU rendering processes of CEF
diff --git a/Client/ceflauncher_DLL/Main.cpp b/Client/ceflauncher_DLL/Main.cpp
@@ -9,111 +9,170 @@
  *
  *****************************************************************************/
 
+// #define CEF_ENABLE_SANDBOX
+
+#include <atomic>
+
 #define WIN32_NO_STATUS
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
+
 #undef WIN32_NO_STATUS
 #include <ntstatus.h>
-#include <winnt.h>
 #include <winternl.h>
 #include <delayimp.h>
+
 #include "CCefApp.h"
-#include <string>
-#include <cef3/cef/include/cef_sandbox_win.h>
-#include <SharedUtil.h>
+#include "SharedUtil.h"
 
-// #define CEF_ENABLE_SANDBOX
 #ifdef CEF_ENABLE_SANDBOX
-    #pragma comment(lib, "cef_sandbox.lib")
+#include <cef3/cef/include/cef_sandbox_win.h>
+#pragma comment(lib, "cef_sandbox.lib")
 #endif
 
-DWORD WINAPI CheckParentProcessAliveness(LPVOID);
+// Return codes
+inline constexpr int CEF_INIT_SUCCESS                = 0;
+inline constexpr int CEF_INIT_ERROR_NO_BASE_DIR      = -1;
+inline constexpr int CEF_INIT_ERROR_DLL_LOAD_FAILED  = -2;
 
-int _declspec(dllexport) InitCEF()
-{
-    // Get MTA base directory and set DLL directory to MTA folder
-    const SString strBaseDir = SharedUtil::GetMTAProcessBaseDir();
-    
-    if (strBaseDir.empty())
-    {
-        // Unable to determine base directory - CEF cannot initialize
-        return -1;
-    }
-    
-    const SString strMTADir = SharedUtil::PathJoin(strBaseDir, "MTA");
-    
-    SetDllDirectoryW(SharedUtil::FromUTF8(strMTADir));
+inline constexpr DWORD       CEF_PARENT_CHECK_INTERVAL       = 1000;
+inline constexpr const char* CEF_DLL_NAME                    = "libcef.dll";
+inline constexpr const char* CEF_MTA_SUBDIR                  = "MTA";
 
-    // Load libcef.dll from the DLL directory
-    assert(SUCCEEDED(__HrLoadAllImportsForDll("libcef.dll")));
+inline constexpr DWORD PARENT_CHECK_ERROR_NO_QUERY_FUNC    = 1;
+inline constexpr DWORD PARENT_CHECK_ERROR_QUERY_FAILED     = 2;
+inline constexpr DWORD PARENT_CHECK_ERROR_OPEN_FAILED      = 3;
 
-    // Load CEF
-    CefMainArgs        mainArgs(GetModuleHandle(NULL));
-    CefRefPtr<CCefApp> app{new CCefApp};
+using NtQueryInformationProcessFunc = NTSTATUS(NTAPI*)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG);
 
-    void* sandboxInfo = nullptr;
-#ifdef CEF_ENABLE_SANDBOX
-    CefScopedSandboxInfo scopedSandbox;
-    sandboxInfo = scopedSandbox.sandbox_info();
-#endif
+// Safe parent monitor thread shutdown
+std::atomic<bool> g_bShouldTerminateMonitor{false};
+std::atomic<HANDLE> g_hMonitorThread{nullptr};
 
-    const HANDLE parentCheckThread = CreateThread(nullptr, 0, CheckParentProcessAliveness, nullptr, 0, nullptr);
+namespace
+{
+    [[nodiscard]] auto GetNtQueryInformationProcess() noexcept -> NtQueryInformationProcessFunc
+    {
+        const auto ntdll = GetModuleHandleW(L"ntdll.dll");
+        if (!ntdll)
+            return nullptr;
+            
+        const auto procAddr = GetProcAddress(ntdll, "NtQueryInformationProcess");
+        if (!procAddr)
+            return nullptr;
+            
+        return reinterpret_cast<NtQueryInformationProcessFunc>(procAddr);
+    }
 
-    const int exitCode = CefExecuteProcess(mainArgs, app, sandboxInfo);
+    [[nodiscard]] auto GetParentProcessId(NtQueryInformationProcessFunc queryFunc) noexcept -> DWORD
+    {
+        PROCESS_BASIC_INFORMATION info{};
+        ULONG returnLength = 0;
+        
+        if (const auto status = queryFunc(GetCurrentProcess(), ProcessBasicInformation, &info, sizeof(info), &returnLength);
+            !NT_SUCCESS(status) || returnLength < sizeof(PROCESS_BASIC_INFORMATION))
+        {
+            return 0;
+        }
 
-    if (parentCheckThread != nullptr)
+        return static_cast<DWORD>(reinterpret_cast<ULONG_PTR>(info.Reserved3));
+    }
+
+    void MonitorParentProcess(HANDLE parentProcess) noexcept
     {
-        TerminateThread(parentCheckThread, 0);
-        CloseHandle(parentCheckThread);
+        while (!g_bShouldTerminateMonitor.load(std::memory_order_acquire))
+        {
+            const DWORD result = WaitForSingleObject(parentProcess, CEF_PARENT_CHECK_INTERVAL);
+            
+            if (result == WAIT_OBJECT_0)
+            {
+                DWORD exitCode = 0;
+                if (GetExitCodeProcess(parentProcess, &exitCode))
+                    ExitProcess(exitCode);
+                else
+                    ExitProcess(0);
+            }
+            else if (result == WAIT_FAILED)
+            {
+                // Wine/Proton compatibility: Exit thread instead of terminating process
+                // Wine's handle implementation dont support all wait operations reliably
+                break;
+            }
+        }
     }
+}            // namespace
 
-    return exitCode;
-}
+DWORD WINAPI CheckParentProcessAliveness(LPVOID) noexcept;
 
-static DWORD WINAPI CheckParentProcessAliveness(LPVOID)
+BOOL APIENTRY DllMain(HMODULE hModule, DWORD dwReason, [[maybe_unused]] LPVOID lpReserved)
 {
-    NTSTATUS(NTAPI * queryInformation)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG) = nullptr;
-
-    if (auto ntdll = GetModuleHandleW(L"ntdll.dll"); ntdll != nullptr)
+    if (dwReason == DLL_PROCESS_ATTACH)
     {
-        auto procAddr = GetProcAddress(ntdll, "NtQueryInformationProcess");
-        queryInformation = reinterpret_cast<decltype(queryInformation)>(reinterpret_cast<void*>(procAddr));
+        DisableThreadLibraryCalls(hModule);
+        g_bShouldTerminateMonitor.store(false, std::memory_order_relaxed);
+        g_hMonitorThread.store(nullptr, std::memory_order_relaxed);
     }
+    else if (dwReason == DLL_PROCESS_DETACH)
+    {
+        g_bShouldTerminateMonitor.store(true, std::memory_order_release);
+    }
+    
+    return TRUE;
+}
 
-    if (queryInformation == nullptr)
-        return 1;
+extern "C" [[nodiscard]] __declspec(dllexport) auto InitCEF() noexcept -> int
+{
+    const auto baseDir = SharedUtil::GetMTAProcessBaseDir();
+    if (baseDir.empty())
+        return CEF_INIT_ERROR_NO_BASE_DIR;
+    
+    const auto mtaDir = SharedUtil::PathJoin(baseDir, CEF_MTA_SUBDIR);
+    SetDllDirectoryW(SharedUtil::FromUTF8(mtaDir));
 
-    PROCESS_BASIC_INFORMATION info{};
+    if (FAILED(__HrLoadAllImportsForDll(CEF_DLL_NAME)))
+        return CEF_INIT_ERROR_DLL_LOAD_FAILED;
 
-    ULONG    returnLength = 0;
-    NTSTATUS status = queryInformation(GetCurrentProcess(), ProcessBasicInformation, &info, sizeof(info), &returnLength);
+    const CefMainArgs mainArgs(GetModuleHandleW(nullptr));
+    const CefRefPtr<CCefApp> app{new CCefApp};
 
-    if (!NT_SUCCESS(status) || returnLength < sizeof(PROCESS_BASIC_INFORMATION))
-        return 2;
+    void* sandboxInfo = nullptr;
+#ifdef CEF_ENABLE_SANDBOX
+    const CefScopedSandboxInfo scopedSandbox;
+    sandboxInfo = scopedSandbox.sandbox_info();
+#endif
 
-    const auto   parentProcessId = static_cast<DWORD>(reinterpret_cast<ULONG_PTR>(info.Reserved3));
-    const HANDLE parentProcess = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION, FALSE, parentProcessId);
+    const auto hThread = CreateThread(nullptr, 0, CheckParentProcessAliveness, nullptr, 0, nullptr);
+    if (hThread)
+        g_hMonitorThread.store(hThread, std::memory_order_release);
 
-    if (parentProcess == nullptr)
-    {
-        if (GetLastError() == ERROR_INVALID_PARAMETER)
-            ExitProcess(0);
+    return CefExecuteProcess(mainArgs, app, sandboxInfo);
+}
 
-        return 3;
-    }
+static auto WINAPI CheckParentProcessAliveness([[maybe_unused]] LPVOID) noexcept -> DWORD
+{
+    const auto queryFunc = GetNtQueryInformationProcess();
+    if (!queryFunc)
+        return PARENT_CHECK_ERROR_NO_QUERY_FUNC;
 
-    while (true)
-    {
-        DWORD exitCode{};
+    const auto parentProcessId = GetParentProcessId(queryFunc);
+    if (parentProcessId == 0)
+        return PARENT_CHECK_ERROR_QUERY_FAILED;
 
-        if (!GetExitCodeProcess(parentProcess, &exitCode) || exitCode != STILL_ACTIVE)
+    const auto parentProcess = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION, false, parentProcessId);
+    if (!parentProcess)
+    {
+        // Wine/Proton fallback: PROCESS_QUERY_LIMITED_INFORMATION may not be implemented
+        const auto parentProcessFallback = OpenProcess(SYNCHRONIZE, false, parentProcessId);
+        if (parentProcessFallback)
         {
-            CloseHandle(parentProcess);
-            ExitProcess(exitCode);
+            MonitorParentProcess(parentProcessFallback);
+            CloseHandle(parentProcessFallback);
+            return CEF_INIT_SUCCESS;
         }
-
-        Sleep(1000);
+        return PARENT_CHECK_ERROR_OPEN_FAILED;
     }
 
-    return 0;
+    MonitorParentProcess(parentProcess);
+    CloseHandle(parentProcess);
+    return CEF_INIT_SUCCESS;
 }
diff --git a/Client/cefweb/CWebCore.cpp b/Client/cefweb/CWebCore.cpp
@@ -66,16 +66,9 @@ bool CWebCore::Initialise(bool gpuEnabled)
     
     m_bGPUEnabled = gpuEnabled;
 
-    // Log current working directory at entry
-    std::array<wchar_t, MAX_PATH> cwdBefore{};
-    GetCurrentDirectoryW(static_cast<DWORD>(cwdBefore.size()), cwdBefore.data());
-    AddReportLog(8010, SString("CWebCore::Initialise - CWD at entry: %s", *SharedUtil::ToUTF8(cwdBefore.data())));
-
     // Get MTA base directory
     SString strBaseDir = SharedUtil::GetMTAProcessBaseDir();
     
-    AddReportLog(8011, SString("CWebCore::Initialise - GetMTAProcessBaseDir returned: '%s'", strBaseDir.c_str()));
-    
     if (strBaseDir.empty())
     {
         g_pCore->GetConsole()->Printf("CEF initialization skipped - Unable to determine MTA base directory");
@@ -99,17 +92,6 @@ bool CWebCore::Initialise(bool gpuEnabled)
     // Read GTA path from registry to pass to CEF subprocess
     int iRegistryResult = 0;
     const SString strGTAPath = GetCommonRegistryValue("", "GTA:SA Path", &iRegistryResult);
-    g_pCore->GetConsole()->Printf("DEBUG: Registry read result=%d, path='%s'", iRegistryResult, strGTAPath.c_str());
-    AddReportLog(8017, SString("DEBUG: Registry read result=%d, path='%s'", iRegistryResult, strGTAPath.c_str()));
-    
-    if (!strGTAPath.empty())
-    {
-        AddReportLog(8015, SString("Read GTA path from registry: %s", *strGTAPath));
-    }
-    else
-    {
-        AddReportLog(8016, "Failed to read GTA path from registry");
-    }
     
     // Check if process is running with elevated privileges
     // CEF subprocesses may have communication issues when running elevated
@@ -134,14 +116,9 @@ bool CWebCore::Initialise(bool gpuEnabled)
         AddReportLog(8021, "WARNING: Process is running with elevated privileges (Administrator)");
         AddReportLog(8022, "CEF browser features may not work correctly when running as Administrator");
         AddReportLog(8023, "Consider running MTA without Administrator privileges for full browser functionality");
-        g_pCore->GetConsole()->Printf("^3WARNING: Running as Administrator - browser features may be limited");
+        g_pCore->GetConsole()->Printf("WARNING: Running as Administrator - browser features may be limited");
     }
     
-    // Log current working directory before CEF initialization
-    std::array<wchar_t, MAX_PATH> cwdBeforeCef{};
-    GetCurrentDirectoryW(static_cast<DWORD>(cwdBeforeCef.size()), cwdBeforeCef.data());
-    AddReportLog(8012, SString("CWebCore::Initialise - CWD before CefInitialize: %s", *SharedUtil::ToUTF8(cwdBeforeCef.data())));
-    
     if (!FileExists(strLauncherPath))
     {
         g_pCore->GetConsole()->Printf("CEF initialization skipped - CEFLauncher not found: %s", *strLauncherPath);
@@ -164,11 +141,6 @@ bool CWebCore::Initialise(bool gpuEnabled)
         return false;
     }
 
-    // Proceed with CEF initialization
-    AddReportLog(8018, SString("Pre-CEF Init: Launcher path: %s", *strLauncherPath));
-    AddReportLog(8019, SString("Pre-CEF Init: Cache path: %s", *strCachePath));
-    AddReportLog(8020, SString("Pre-CEF Init: Locales path: %s", *strLocalesPath));
-    
     // Use std::filesystem for CWD management with RAII scope guard
     namespace fs = std::filesystem;
     std::error_code ec;
@@ -189,10 +161,6 @@ bool CWebCore::Initialise(bool gpuEnabled)
         ~CwdGuard() {
             std::error_code restoreEc;
             fs::current_path(savedPath, restoreEc);
-            if (!restoreEc)
-            {
-                AddReportLog(8027, SString("Restored original CWD: %s", savedPath.string().c_str()));
-            }
         }
     } cwdGuard(savedCwd);
     
@@ -205,7 +173,6 @@ bool CWebCore::Initialise(bool gpuEnabled)
         m_bInitialised = false;
         return false;
     }
-    AddReportLog(8026, SString("Temporarily changed CWD to MTA dir for CEF init: %s", *strMTADir));
     
     CefMainArgs        mainArgs;
     void*              sandboxInfo = nullptr;
@@ -249,18 +216,11 @@ bool CWebCore::Initialise(bool gpuEnabled)
     }
 
     // CWD will be restored by cwdGuard destructor when this function returns
-
-    // Log CWD after CEF initialization
-    std::array<wchar_t, MAX_PATH> cwdAfterCef{};
-    GetCurrentDirectoryW(static_cast<DWORD>(cwdAfterCef.size()), cwdAfterCef.data());
-    AddReportLog(8013, SString("CWebCore::Initialise - CWD after CefInitialize: %s", *SharedUtil::ToUTF8(cwdAfterCef.data())));
     
     if (m_bInitialised)
     {
         // Register custom scheme handler factory only if initialization succeeded
         CefRegisterSchemeHandlerFactory("http", "mta", app);
-        g_pCore->GetConsole()->Printf("CEF initialized successfully");
-        AddReportLog(8000, "CEF initialized successfully");
     }
     else
     {
