Merge branch 'master' into fix/skip_av_wine

Author: Xenius97

.git-blame-ignore-revs

@@ -247,3 +247,9 @@ b42518e64803762d27fe6277b36044d1a71fc2c4
 # Date:   Mon Jun 12 19:01:59 2023 +0300
 #
 # Apply win-apply-clang-format.bat
+
+466c162fbd1af45b290849cc0771fab66f55ba34
+# Author: Dutchman101 <mcak105@outlook.com>
+# Date:   Wed April 9 19:01:39 2025 +0300
+#
+# Eliminate the use of http:// across whole project

Client/cefweb/CAjaxResourceHandler.cpp

@@ -13,7 +13,7 @@
 #include "CAjaxResourceHandler.h"
 #undef min
 
-CAjaxResourceHandler::CAjaxResourceHandler(std::vector<SString>& vecGet, std::vector<SString>& vecPost, const CefString& strMime)
+CAjaxResourceHandler::CAjaxResourceHandler(std::vector<std::string> vecGet, std::vector<std::string> vecPost, const CefString& strMime)
     : m_vecGetData(std::move(vecGet)), m_vecPostData(std::move(vecPost)), m_strMime(strMime)
 {
 }
@@ -27,13 +27,13 @@ CAjaxResourceHandler::~CAjaxResourceHandler()
     m_callback = nullptr;
 }
 
-void CAjaxResourceHandler::SetResponse(const SString& data)
+void CAjaxResourceHandler::SetResponse(std::string data)
 {
     // Prevent response corruption: ignore subsequent calls after data is set
     if (m_bHasData) [[unlikely]]
         return;
 
-    m_strResponse = data;
+    m_strResponse = std::move(data);
     m_bHasData = true;
 
     if (!m_callback)
@@ -72,12 +72,17 @@ void CAjaxResourceHandler::GetResponseHeaders(CefRefPtr<CefResponse> response, i
 
 bool CAjaxResourceHandler::ProcessRequest([[maybe_unused]] CefRefPtr<CefRequest> request, CefRefPtr<CefCallback> callback)
 {
-    // Don't call Continue() here - let ReadResponse handle async flow
-    // Calling Continue() immediately would use the callback before data is ready
+    if (!callback)
+        return false;
+
+    // Store callback so SetResponse can resume once data is ready
+    m_callback = callback;
+
+    // Do not call Continue() yet; SetResponse triggers it after data is prepared
     return true;
 }
 
-bool CAjaxResourceHandler::ReadResponse(void* data_out, int bytes_to_read, int& bytes_read, CefRefPtr<CefCallback> callback)
+bool CAjaxResourceHandler::ReadResponse(void* data_out, int bytes_to_read, int& bytes_read, [[maybe_unused]] CefRefPtr<CefCallback> callback)
 {
     // Validate input parameters first
     if (!data_out || bytes_to_read <= 0) [[unlikely]]
@@ -86,13 +91,10 @@ bool CAjaxResourceHandler::ReadResponse(void* data_out, int bytes_to_read, int&
         return false;
     }
 
-    // If we have no data yet, wait
+    // If we have no data yet, wait until SetResponse provides it
     if (!m_bHasData)
     {
         bytes_read = 0;
-        // Store callback only if we don't already have one (prevent overwrite/leak)
-        if (callback && !m_callback)
-            m_callback = callback;
         return true;
     }
 

Client/cefweb/CAjaxResourceHandler.h

@@ -13,18 +13,19 @@
 #include <core/CAjaxResourceHandlerInterface.h>
 #include <cef3/cef/include/cef_resource_handler.h>
 #include <SString.h>
+#include <string>
 
 class CWebView;
 
 class CAjaxResourceHandler : public CefResourceHandler, public CAjaxResourceHandlerInterface
 {
 public:
-    CAjaxResourceHandler(std::vector<SString>& vecGet, std::vector<SString>& vecPost, const CefString& mimeType);
+    CAjaxResourceHandler(std::vector<std::string> vecGet, std::vector<std::string> vecPost, const CefString& mimeType);
     ~CAjaxResourceHandler();
 
-    std::vector<SString>& GetGetData() override { return m_vecGetData; }
-    std::vector<SString>& GetPostData() override { return m_vecPostData; }
-    void SetResponse(const SString& data) override;
+    std::vector<std::string>& GetGetData() override { return m_vecGetData; }
+    std::vector<std::string>& GetPostData() override { return m_vecPostData; }
+    void SetResponse(std::string data) override;
 
     // CefResourceHandler
     virtual void Cancel() override;
@@ -37,10 +38,10 @@ class CAjaxResourceHandler : public CefResourceHandler, public CAjaxResourceHand
 
 private:
     CefRefPtr<CefCallback> m_callback;
-    std::vector<SString>   m_vecGetData;
-    std::vector<SString>   m_vecPostData;
-    SString                m_strResponse;
-    CefString              m_strMime;
-    bool                   m_bHasData = false;
-    size_t                 m_DataOffset = 0;
+    std::vector<std::string> m_vecGetData;
+    std::vector<std::string> m_vecPostData;
+    std::string              m_strResponse;
+    CefString                m_strMime;
+    bool                     m_bHasData = false;
+    size_t                   m_DataOffset = 0;
 };

Client/cefweb/CWebApp.cpp

@@ -16,9 +16,17 @@
 #include <cef3/cef/include/cef_stream.h>
 #include <cef3/cef/include/wrapper/cef_stream_resource_handler.h>
 #include "CAjaxResourceHandler.h"
+#include <cstdlib>
 
 namespace
 {
+    // Helper to detect Wine/Proton environment
+    bool IsRunningOnWine()
+    {
+        HMODULE hNtdll = GetModuleHandle("ntdll.dll");
+        return hNtdll && GetProcAddress(hNtdll, "wine_get_version");
+    }
+
     // Centralises command-line switch setup so both pre-launch callbacks stay in sync
     void ConfigureCommandLineSwitches(const CefRefPtr<CefCommandLine>& commandLine, const CefString& processType)
     {
@@ -30,7 +38,16 @@ namespace
             return;
 
         // Always provide base installation paths so loader-proxy can validate subprocess origin
-        const SString gtaPath = GetCommonRegistryValue("", "GTA:SA Path");
+        SString gtaPath = GetCommonRegistryValue("", "GTA:SA Path");
+        if (gtaPath.empty())
+        {
+            // Fallback for Wine/compatibility layer: check environment variable
+            if (const char* envGtaPath = std::getenv("MTA_GTA_PATH"))
+            {
+                gtaPath = envGtaPath;
+            }
+        }
+
         if (!gtaPath.empty())
         {
             commandLine->AppendSwitchWithValue("mta-gta-path", gtaPath);
@@ -70,6 +87,21 @@ namespace
             }
         }
 
+        // Wine/Proton compatibility: Allow GPU unless explicitly disabled or forced software
+        if (IsRunningOnWine())
+        {
+            if (std::getenv("MTA_FORCE_SOFTWARE_RENDERING"))
+            {
+                disableGpu = true;
+            }
+            else
+            {
+                // In Wine, we generally want to try GPU (DXVK handles it well)
+                // But disable-gpu-compositing is already set above which is key
+                // If user hasn't explicitly disabled GPU in cvars, let it run
+            }
+        }
+
         if (disableGpu)
             commandLine->AppendSwitch("disable-gpu");
     }
@@ -96,19 +128,6 @@ void CWebApp::OnBeforeChildProcessLaunch(CefRefPtr<CefCommandLine> command_line)
     if (!command_line)
         return;
 
-    // Add GTA path and MTA base path switches before g_pCore check
-    // This callback runs in both browser process and subprocess
-    // In subprocess, g_pCore is NULL, so switches must be added before that check
-    // Read GTA path from registry
-    int iResult = 0;
-    const SString strGTAPath = GetCommonRegistryValue("", "GTA:SA Path", &iResult);
-    if (!strGTAPath.empty())
-    {
-        // Pass GTA directory path to CEFLauncher subprocess via command-line switch
-        // CEF's AppendSwitchWithValue handles quoting automatically
-        command_line->AppendSwitchWithValue("mta-gta-path", strGTAPath);
-        // AddReportLog only available in browser process where g_pCore exists
-    }
     const CefString processType = command_line->GetSwitchValue("type");
     ConfigureCommandLineSwitches(command_line, processType);
 }
@@ -191,8 +210,8 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
 
             if (pWebView->HasAjaxHandler(resourcePath))
             {
-                std::vector<SString> vecGet;
-                std::vector<SString> vecPost;
+                std::vector<std::string> vecGet;
+                std::vector<std::string> vecPost;
 
                 if (urlParts.query.str)
                 {
@@ -201,6 +220,10 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
                     vecTmp.reserve(8);  // Reserve space for common query parameter count
                     strGet.Split("&", vecTmp);
 
+                    const size_t paramCount = vecTmp.size();
+                    if (paramCount > 0)
+                        vecGet.reserve(vecGet.size() + paramCount * 2);
+
                     SString key;
                     SString value;
                     for (auto&& param : vecTmp)
@@ -239,6 +262,10 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
                         vecTmp.reserve(8);
                         postParam.Split("&", vecTmp);
 
+                        const size_t postParamCount = vecTmp.size();
+                        if (postParamCount > 0)
+                            vecPost.reserve(vecPost.size() + postParamCount * 2);
+
                         for (auto&& param : vecTmp)
                         {
                             param.Split("=", &key, &value);
@@ -248,7 +275,7 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
                     }
                 }
 
-                CefRefPtr<CAjaxResourceHandler> handler(new CAjaxResourceHandler(vecGet, vecPost, mimeType));
+                CefRefPtr<CAjaxResourceHandler> handler(new CAjaxResourceHandler(std::move(vecGet), std::move(vecPost), mimeType));
                 pWebView->HandleAjaxRequest(resourcePath, handler.get());
                 return handler;
             }

Client/cefweb/CWebCore.cpp

@@ -19,6 +19,8 @@
 #include "CWebApp.h"
 #include <algorithm>
 #include <ranges>
+#include <filesystem>
+#include <cstdlib>
 
 // #define CEF_ENABLE_SANDBOX
 #ifdef CEF_ENABLE_SANDBOX
@@ -87,7 +89,27 @@ bool CWebCore::Initialise(bool gpuEnabled)
 
     // Set DLL directory for CEFLauncher subprocess to locate required libraries
     SString strCEFDir = PathJoin(strMTADir, "CEF");
+#ifdef _WIN32
     SetDllDirectoryW(FromUTF8(strCEFDir));
+#else
+    // On Wine/Proton: Use environment variable for library search
+    const char* existingPath = std::getenv("LD_LIBRARY_PATH");
+    SString newPath = strCEFDir;
+    if (existingPath) {
+        newPath = SString("%s:%s", strCEFDir.c_str(), existingPath);
+    }
+    // Note: setenv is not available in MSVC, but _putenv is. 
+    // However, since we are compiling for Windows (running on Wine), we use Windows APIs.
+    // Wine maps Windows environment variables.
+    // But LD_LIBRARY_PATH is a Linux variable.
+    // If we are in Wine, we might want to set PATH instead or as well.
+    // SetDllDirectoryW handles the Windows loader.
+    
+    // Log for debugging
+    if (std::getenv("WINE") || std::getenv("WINEPREFIX")) {
+        g_pCore->GetConsole()->Printf("DEBUG: CEF library path set via SetDllDirectoryW: %s", strCEFDir.c_str());
+    }
+#endif
 
     // Read GTA path from registry to pass to CEF subprocess
     int iRegistryResult = 0;
@@ -96,6 +118,13 @@ bool CWebCore::Initialise(bool gpuEnabled)
     // Check if process is running with elevated privileges
     // CEF subprocesses may have communication issues when running elevated
     const bool bIsElevated = []() -> bool {
+        // Check for Wine environment
+        if (std::getenv("WINE") || std::getenv("WINEPREFIX")) {
+            // In Wine, privilege escalation works differently
+            // Assume not elevated for browser feature purposes
+            return false;
+        }
+
         HANDLE hToken = nullptr;
         if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
             return false;
@@ -111,14 +140,28 @@ bool CWebCore::Initialise(bool gpuEnabled)
         return elevation.TokenIsElevated != 0;
     }();
 
-    if (bIsElevated)
+    if (bIsElevated && !std::getenv("WINE"))
     {
         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("WARNING: Running as Administrator - browser features may be limited");
     }
 
+    // Verify CEFLauncher can run in current environment
+    auto CanExecuteCEFLauncher = []() -> bool {
+        #ifdef _WIN32
+            // On Windows, we know it works
+            if (!std::getenv("WINE") && !std::getenv("WINEPREFIX") && !std::getenv("PROTON_VERSION"))
+                return true;
+        #endif
+        
+        // Check if Wine can execute the launcher
+        // This is a basic check - if we are in Wine, we assume it works unless proven otherwise
+        // But we can log if we are in a mixed environment
+        return true;
+    };
+
     if (!FileExists(strLauncherPath))
     {
         g_pCore->GetConsole()->Printf("CEF initialization skipped - CEFLauncher not found: %s", *strLauncherPath);
@@ -127,6 +170,13 @@ bool CWebCore::Initialise(bool gpuEnabled)
         return false;
     }
 
+    if (!CanExecuteCEFLauncher()) {
+        g_pCore->GetConsole()->Printf("CEF initialization skipped - Wine/Proton not available");
+        AddReportLog(8026, "CEF initialization skipped - Wine/Proton not available or misconfigured");
+        m_bInitialised = false;
+        return false;
+    }
+
     // Ensure cache directory can be created
     const SString strCachePath = PathJoin(strMTADir, "CEF", "cache");
     MakeSureDirExists(strCachePath);

Client/cefweb/CWebView.cpp

@@ -308,6 +308,10 @@ void CWebView::UpdateTexture()
             // Unlock surface
             pSurface->UnlockRect();
         }
+        else
+        {
+            OutputDebugLine("[CWebView] UpdateTexture: LockRect failed");
+        }
     }
 
     m_RenderData.cefThreadState = ECefThreadState::Running;
@@ -427,13 +431,16 @@ bool CWebView::SetAudioVolume(float fVolume)
         "tags = document.getElementsByTagName('video'); for (var i = 0; i<tags.length; ++i) { mta_adjustAudioVol(tags[i], %f); }",
         fVolume, fVolume);
 
+    // Note: GetFrameNames is deprecated, but no modern alternative exists for audio volume control
+    // This is a legacy thing that works with CEF3
     std::vector<CefString> frameNames;
     m_pWebView->GetFrameNames(frameNames);
 
     for (auto& name : frameNames)
     {
         auto frame = m_pWebView->GetFrameByName(name);
-        frame->ExecuteJavaScript(strJSCode, "", 0);
+        if (frame)
+            frame->ExecuteJavaScript(strJSCode, "", 0);
     }
     m_fVolume = fVolume;
     return true;
@@ -762,6 +769,7 @@ void CWebView::OnPaint(CefRefPtr<CefBrowser> browser, CefRenderHandler::PaintEle
 ////////////////////////////////////////////////////////////////////
 void CWebView::OnLoadStart(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, TransitionType transitionType)
 {
+    // Note: TransitionType parameter is deprecated in CEF3 but still required by virtual interface override
     SString strURL = UTF16ToMbUTF8(frame->GetURL());
     if (strURL == "blank")
         return;
@@ -1074,6 +1082,7 @@ bool CWebView::OnTooltip(CefRefPtr<CefBrowser> browser, CefString& title)
 ////////////////////////////////////////////////////////////////////
 bool CWebView::OnConsoleMessage(CefRefPtr<CefBrowser> browser, cef_log_severity_t level, const CefString& message, const CefString& source, int line)
 {
+    // Note: cef_log_severity_t parameter is deprecated in CEF3 but required for virtual override
     // Redirect console message to debug window (if development mode is enabled)
     if (g_pCore->GetWebCore()->IsTestModeEnabled())
     {

Client/cefweb/CWebView.h

@@ -109,17 +109,17 @@ class CWebView : public CWebViewInterface,
     bool CanGoForward();
     bool GoBack();
     bool GoForward();
-    void Refresh(bool ignoreCache);
+    void Refresh(bool bIgnoreCache);
 
     // CefClient methods
-    virtual CefRefPtr<CefRenderHandler>      GetRenderHandler() override { return this; };
-    virtual CefRefPtr<CefLoadHandler>        GetLoadHandler() override { return this; };
-    virtual CefRefPtr<CefRequestHandler>     GetRequestHandler() override { return this; };
-    virtual CefRefPtr<CefLifeSpanHandler>    GetLifeSpanHandler() override { return this; };
-    virtual CefRefPtr<CefJSDialogHandler>    GetJSDialogHandler() override { return this; };
-    virtual CefRefPtr<CefDialogHandler>      GetDialogHandler() override { return this; };
-    virtual CefRefPtr<CefDisplayHandler>     GetDisplayHandler() override { return this; };
-    virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() override { return this; };
+    virtual CefRefPtr<CefRenderHandler>      GetRenderHandler() override { return this; }
+    virtual CefRefPtr<CefLoadHandler>        GetLoadHandler() override { return this; }
+    virtual CefRefPtr<CefRequestHandler>     GetRequestHandler() override { return this; }
+    virtual CefRefPtr<CefLifeSpanHandler>    GetLifeSpanHandler() override { return this; }
+    virtual CefRefPtr<CefJSDialogHandler>    GetJSDialogHandler() override { return this; }
+    virtual CefRefPtr<CefDialogHandler>      GetDialogHandler() override { return this; }
+    virtual CefRefPtr<CefDisplayHandler>     GetDisplayHandler() override { return this; }
+    virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() override { return this; }
     virtual bool                             OnProcessMessageReceived(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefProcessId source_process,
                                                                       CefRefPtr<CefProcessMessage> message) override;