Run ./utils/clang-format.ps1

Author: qaisjp

Client/ceflauncher_DLL/CCefApp.h

@@ -41,7 +41,8 @@ class CCefApp : public CefApp, public CefRenderProcessHandler
             if (!node)
                 return;
 
-            if (node->GetType() == CefDOMNode::Type::DOM_NODE_TYPE_ELEMENT && node->GetFormControlElementType() != CefDOMNode::FormControlType::DOM_FORM_CONTROL_TYPE_UNSUPPORTED)
+            if (node->GetType() == CefDOMNode::Type::DOM_NODE_TYPE_ELEMENT &&
+                node->GetFormControlElementType() != CefDOMNode::FormControlType::DOM_FORM_CONTROL_TYPE_UNSUPPORTED)
             {
                 auto message = CefProcessMessage::Create("InputFocus");
                 message->GetArgumentList()->SetBool(0, true);

Client/ceflauncher_DLL/CCefAppAuth.h

@@ -29,15 +29,15 @@ namespace CefAppAuth
             return false;
 
         auto& authCode = AuthCodeStorage();
-        
+
         // Block messages until initialized (prevents race condition)
         if (authCode.empty()) [[unlikely]]
             return false;
-        
+
         CefRefPtr<CefListValue> args = message->GetArgumentList();
-        const auto size = args->GetSize();
+        const auto              size = args->GetSize();
         args->SetSize(size + 1);
         args->SetString(size, authCode.c_str());
         return true;
     }
-}
+}            // namespace CefAppAuth

Client/ceflauncher_DLL/Main.cpp

@@ -30,27 +30,27 @@
 #include <SharedUtil.h>
 
 #ifdef CEF_ENABLE_SANDBOX
-#include <cef3/cef/include/cef_sandbox_win.h>
-#pragma comment(lib, "cef_sandbox.lib")
+    #include <cef3/cef/include/cef_sandbox_win.h>
+    #pragma comment(lib, "cef_sandbox.lib")
 #endif
 
 // 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;
+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;
 
-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";
+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";
 
-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;
+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;
 
 using NtQueryInformationProcessFunc = NTSTATUS(NTAPI*)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG);
 
 // Safe parent monitor thread shutdown
-std::atomic<bool> g_bShouldTerminateMonitor{false};
+std::atomic<bool>   g_bShouldTerminateMonitor{false};
 std::atomic<HANDLE> g_hMonitorThread{nullptr};
 
 namespace
@@ -60,19 +60,19 @@ namespace
         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);
     }
 
     [[nodiscard]] auto GetParentProcessId(NtQueryInformationProcessFunc queryFunc) noexcept -> DWORD
     {
         PROCESS_BASIC_INFORMATION info{};
-        ULONG returnLength = 0;
-        
+        ULONG                     returnLength = 0;
+
         if (const auto status = queryFunc(GetCurrentProcess(), ProcessBasicInformation, &info, sizeof(info), &returnLength);
             !NT_SUCCESS(status) || returnLength < sizeof(PROCESS_BASIC_INFORMATION))
         {
@@ -87,7 +87,7 @@ namespace
         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;
@@ -120,7 +120,7 @@ BOOL APIENTRY DllMain(HMODULE hModule, DWORD dwReason, [[maybe_unused]] LPVOID l
     {
         g_bShouldTerminateMonitor.store(true, std::memory_order_release);
     }
-    
+
     return TRUE;
 }
 
@@ -130,30 +130,28 @@ extern "C" [[nodiscard]] __declspec(dllexport) auto InitCEF() noexcept -> int
     const std::wstring_view cmdLine{GetCommandLineW()};
     if (const auto pos = cmdLine.find(L"--kgfiv8n="); pos != std::wstring_view::npos)
     {
-        const auto valueStart = pos + 11;  // Skip "--kgfiv8n="
+        const auto valueStart = pos + 11;            // Skip "--kgfiv8n="
         const auto valueEnd = cmdLine.find_first_of(L" \t\"", valueStart);
-        const auto authCodeW = cmdLine.substr(valueStart, 
-            valueEnd == std::wstring_view::npos ? 30 : std::min<size_t>(30, valueEnd - valueStart));
-        
+        const auto authCodeW = cmdLine.substr(valueStart, valueEnd == std::wstring_view::npos ? 30 : std::min<size_t>(30, valueEnd - valueStart));
+
         std::string authCode;
         authCode.reserve(30);
-        std::transform(authCodeW.begin(), authCodeW.end(), std::back_inserter(authCode),
-            [](const wchar_t wc) { return static_cast<char>(wc); });
-        
+        std::transform(authCodeW.begin(), authCodeW.end(), std::back_inserter(authCode), [](const wchar_t wc) { return static_cast<char>(wc); });
+
         CefAppAuth::AuthCodeStorage() = std::move(authCode);
     }
 
     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));
 
     if (FAILED(__HrLoadAllImportsForDll(CEF_DLL_NAME)))
         return CEF_INIT_ERROR_DLL_LOAD_FAILED;
 
-    const CefMainArgs mainArgs(GetModuleHandleW(nullptr));
+    const CefMainArgs        mainArgs(GetModuleHandleW(nullptr));
     const CefRefPtr<CCefApp> app{new CCefApp};
 
     void* sandboxInfo = nullptr;

Client/cefweb/CAjaxResourceHandler.cpp

@@ -66,13 +66,13 @@ void CAjaxResourceHandler::GetResponseHeaders(CefRefPtr<CefResponse> response, i
     constexpr int HTTP_OK = 200;
     response->SetStatus(HTTP_OK);
     response->SetStatusText("OK");
-    
+
     // Use default MIME type if none provided
     if (!m_strMime.empty())
         response->SetMimeType(m_strMime);
     else
         response->SetMimeType("application/octet-stream");
-    
+
     response_length = -1;
 }
 
@@ -116,10 +116,10 @@ bool CAjaxResourceHandler::ReadResponse(void* data_out, int bytes_to_read, int&
     const auto copyBytes = std::min(static_cast<size_t>(bytes_to_read), remainingBytes);
 
     memcpy(data_out, m_strResponse.c_str() + m_DataOffset, copyBytes);
-    
+
     // copyBytes is bounded by bytes_to_read (an int), so cast is always safe
     bytes_read = static_cast<int>(copyBytes);
-    
+
     m_DataOffset += copyBytes;
 
     return true;

Client/cefweb/CAjaxResourceHandler.h

@@ -25,7 +25,7 @@ class CAjaxResourceHandler : public CefResourceHandler, public CAjaxResourceHand
 
     std::vector<std::string>& GetGetData() override { return m_vecGetData; }
     std::vector<std::string>& GetPostData() override { return m_vecPostData; }
-    void SetResponse(std::string data) override;
+    void                      SetResponse(std::string data) override;
 
     // CefResourceHandler
     virtual void Cancel() override;
@@ -37,7 +37,7 @@ class CAjaxResourceHandler : public CefResourceHandler, public CAjaxResourceHand
     DISALLOW_COPY_AND_ASSIGN(CAjaxResourceHandler);
 
 private:
-    CefRefPtr<CefCallback> m_callback;
+    CefRefPtr<CefCallback>   m_callback;
     std::vector<std::string> m_vecGetData;
     std::vector<std::string> m_vecPostData;
     std::string              m_strResponse;

Client/cefweb/CWebApp.cpp

@@ -110,10 +110,7 @@ namespace
 
 [[nodiscard]] CefRefPtr<CefResourceHandler> CWebApp::HandleError(const SString& strError, unsigned int uiError)
 {
-    auto stream = CefStreamReader::CreateForData(
-        (void*)strError.c_str(), 
-        strError.length()
-    );
+    auto stream = CefStreamReader::CreateForData((void*)strError.c_str(), strError.length());
     if (!stream)
         return nullptr;
     return CefRefPtr<CefResourceHandler>(new CefStreamResourceHandler(uiError, strError, "text/plain", CefResponse::HeaderMap(), stream));
@@ -131,7 +128,7 @@ void CWebApp::OnBeforeChildProcessLaunch(CefRefPtr<CefCommandLine> command_line)
 
     const CefString processType = command_line->GetSwitchValue("type");
     ConfigureCommandLineSwitches(command_line, processType);
-    
+
     // Attach IPC validation code for render processes
     // This runs in browser process context where g_pCore and webCore are valid
     // The auth code is generated in CWebCore constructor and passed to subprocesses
@@ -186,7 +183,7 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
         path = path.substr(1);            // Remove slash at the front
         if (const auto slashPos = path.find('/'); slashPos == std::string::npos)
         {
-            static constexpr auto ERROR_404 = "404 - Not found";
+            static constexpr auto         ERROR_404 = "404 - Not found";
             static constexpr unsigned int CODE_404 = 404;
             return HandleError(ERROR_404, CODE_404);
         }
@@ -197,7 +194,7 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
 
             if (resourcePath.empty())
             {
-                static constexpr auto ERROR_404 = "404 - Not found";
+                static constexpr auto         ERROR_404 = "404 - Not found";
                 static constexpr unsigned int CODE_404 = 404;
                 return HandleError(ERROR_404, CODE_404);
             }
@@ -223,7 +220,7 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
                 {
                     const SString        strGet = UTF16ToMbUTF8(urlParts.query.str);
                     std::vector<SString> vecTmp;
-                    vecTmp.reserve(8);  // Reserve space for common query parameter count
+                    vecTmp.reserve(8);            // Reserve space for common query parameter count
                     strGet.Split("&", vecTmp);
 
                     const size_t paramCount = vecTmp.size();
@@ -251,7 +248,7 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
                     {
                         // Limit to 5MiB and allow byte data only
                         constexpr size_t MAX_POST_SIZE = 5 * 1024 * 1024;
-                        size_t bytesCount = post->GetBytesCount();
+                        size_t           bytesCount = post->GetBytesCount();
                         if (bytesCount > MAX_POST_SIZE || post->GetType() != CefPostDataElement::Type::PDE_TYPE_BYTES)
                             continue;
 
@@ -294,7 +291,7 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
                 // Calculate absolute path
                 if (!pWebView->GetFullPathFromLocal(path))
                 {
-                    static constexpr auto ERROR_404 = "404 - Not found";
+                    static constexpr auto         ERROR_404 = "404 - Not found";
                     static constexpr unsigned int CODE_404 = 404;
                     return HandleError(ERROR_404, CODE_404);
                 }
@@ -303,7 +300,7 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
                 CBuffer fileData;
                 if (!pWebView->VerifyFile(path, fileData))
                 {
-                    static constexpr auto ERROR_403 = "403 - Access Denied";
+                    static constexpr auto         ERROR_403 = "403 - Access Denied";
                     static constexpr unsigned int CODE_403 = 403;
                     return HandleError(ERROR_403, CODE_403);
                 }
@@ -315,17 +312,14 @@ CefRefPtr<CefResourceHandler> CWebApp::Create(CefRefPtr<CefBrowser> browser, Cef
                     fileData = CBuffer(emptyStr, std::size(emptyStr));
                 }
 
-                auto stream = CefStreamReader::CreateForData(
-                    fileData.GetData(),
-                    fileData.GetSize()
-                );
+                auto stream = CefStreamReader::CreateForData(fileData.GetData(), fileData.GetSize());
                 if (!stream)
                 {
-                    static constexpr auto ERROR_404 = "404 - Not found";
+                    static constexpr auto         ERROR_404 = "404 - Not found";
                     static constexpr unsigned int CODE_404 = 404;
                     return HandleError(ERROR_404, CODE_404);
                 }
-                    
+
                 return CefRefPtr<CefResourceHandler>(new CefStreamResourceHandler(mimeType, stream));
             }
         }

Client/cefweb/CWebAppAuth.h

@@ -52,18 +52,18 @@ namespace WebAppAuth
 
     // Auth code configuration
     inline constexpr std::size_t AUTH_CODE_LENGTH = 30;
-    inline constexpr char AUTH_CODE_MIN_CHAR = 'A';
-    inline constexpr char AUTH_CODE_MAX_CHAR = 'Z';
+    inline constexpr char        AUTH_CODE_MIN_CHAR = 'A';
+    inline constexpr char        AUTH_CODE_MAX_CHAR = 'Z';
 
     // Generates random 30-character auth code (A-Z)
     [[nodiscard]] inline std::string GenerateAuthCode()
     {
         std::array<char, AUTH_CODE_LENGTH> buffer{};
-        
+
         // Use mt19937 with time-based seed (fast, cryptographic strength not needed for DoS prevention)
-        static std::mt19937 rng(static_cast<unsigned int>(std::chrono::high_resolution_clock::now().time_since_epoch().count()));
+        static std::mt19937                rng(static_cast<unsigned int>(std::chrono::high_resolution_clock::now().time_since_epoch().count()));
         std::uniform_int_distribution<int> dist(0, AUTH_CODE_MAX_CHAR - AUTH_CODE_MIN_CHAR);
-        
+
         for (auto& ch : buffer)
             ch = static_cast<char>(AUTH_CODE_MIN_CHAR + dist(rng));
 
@@ -77,7 +77,7 @@ namespace WebAppAuth
             return;
 
         const std::lock_guard<std::mutex> lock{GetSharedAuthMutex()};
-        
+
         // Always use webCore->m_AuthCode (already populated in CWebCore constructor)
         // No need for fallback - webCore is guaranteed to exist before this is called
         if (!::g_pCore || !IsReadablePointer(::g_pCore, sizeof(void*))) [[unlikely]]
@@ -93,4 +93,4 @@ namespace WebAppAuth
 
         commandLine->AppendSwitchWithValue("kgfiv8n", webCore->m_AuthCode);
     }
-}
+}            // namespace WebAppAuth