style: unify code style, naming, and header ordering

Author: Bush2021

src/appid.cc

@@ -5,6 +5,7 @@
 #include <propkey.h>
 
 #include "detours.h"
+
 #include "utils.h"
 
 namespace {

src/chrome++.cc

@@ -16,7 +16,7 @@
 #include "utils.h"
 #include "version.h"
 
-typedef int (*Startup)();
+using Startup = int (*)();
 static bool should_run_exit_cmd = false;
 Startup ExeMain = nullptr;
 

src/green.cc

@@ -6,8 +6,9 @@
 #include <processthreadsapi.h>
 #include <shlwapi.h>
 
-#include "config.h"
 #include "detours.h"
+
+#include "config.h"
 #include "utils.h"
 
 namespace {

src/hijack.cc

@@ -96,35 +96,44 @@ void InstallDetours(PBYTE pTarget, PBYTE pDetour) {
   DetourTransactionCommit();
 }
 
-void LoadVersion(HINSTANCE hModule) {
-  PBYTE pImageBase = (PBYTE)hModule;
-  PIMAGE_DOS_HEADER pimDH = (PIMAGE_DOS_HEADER)pImageBase;
-  if (pimDH->e_magic == IMAGE_DOS_SIGNATURE) {
-    PIMAGE_NT_HEADERS pimNH = (PIMAGE_NT_HEADERS)(pImageBase + pimDH->e_lfanew);
-    if (pimNH->Signature == IMAGE_NT_SIGNATURE) {
-      PIMAGE_EXPORT_DIRECTORY pimExD =
-          (PIMAGE_EXPORT_DIRECTORY)(pImageBase +
-                                    pimNH->OptionalHeader
-                                        .DataDirectory
-                                            [IMAGE_DIRECTORY_ENTRY_EXPORT]
-                                        .VirtualAddress);
-      DWORD* pName = (DWORD*)(pImageBase + pimExD->AddressOfNames);
-      DWORD* pFunction = (DWORD*)(pImageBase + pimExD->AddressOfFunctions);
-      WORD* pNameOrdinals = (WORD*)(pImageBase + pimExD->AddressOfNameOrdinals);
+void LoadVersion(HINSTANCE module_handle) {
+  auto image_base = reinterpret_cast<PBYTE>(module_handle);
+  auto dos_header = reinterpret_cast<PIMAGE_DOS_HEADER>(image_base);
+  if (dos_header->e_magic == IMAGE_DOS_SIGNATURE) {
+    auto nt_headers =
+        reinterpret_cast<PIMAGE_NT_HEADERS>(image_base + dos_header->e_lfanew);
+    if (nt_headers->Signature == IMAGE_NT_SIGNATURE) {
+      auto export_directory = reinterpret_cast<PIMAGE_EXPORT_DIRECTORY>(
+          image_base +
+          nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]
+              .VirtualAddress);
+      auto name_table = reinterpret_cast<DWORD*>(
+          image_base + export_directory->AddressOfNames);
+      auto function_table = reinterpret_cast<DWORD*>(
+          image_base + export_directory->AddressOfFunctions);
+      auto ordinals_table = reinterpret_cast<WORD*>(
+          image_base + export_directory->AddressOfNameOrdinals);
 
-      wchar_t szSysDirectory[MAX_PATH + 1];
-      GetSystemDirectory(szSysDirectory, MAX_PATH);
+      wchar_t system_directory[MAX_PATH + 1];
+      GetSystemDirectory(system_directory, MAX_PATH);
 
-      wchar_t szDLLPath[MAX_PATH + 1];
-      lstrcpy(szDLLPath, szSysDirectory);
-      lstrcat(szDLLPath, TEXT("\\version.dll"));
+      wchar_t dll_path[MAX_PATH + 1];
+      lstrcpy(dll_path, system_directory);
+      lstrcat(dll_path, TEXT("\\version.dll"));
 
-      HINSTANCE module = LoadLibrary(szDLLPath);
-      for (size_t i = 0; i < pimExD->NumberOfNames; ++i) {
-        PBYTE Original =
-            (PBYTE)GetProcAddress(module, (char*)(pImageBase + pName[i]));
-        if (Original) {
-          InstallDetours(pImageBase + pFunction[pNameOrdinals[i]], Original);
+      HINSTANCE original_dll_handle = LoadLibrary(dll_path);
+      if (!original_dll_handle) {
+        return;
+      }
+
+      for (size_t i = 0; i < export_directory->NumberOfNames; ++i) {
+        auto function_name =
+            reinterpret_cast<char*>(image_base + name_table[i]);
+        auto original_function = reinterpret_cast<PBYTE>(
+            GetProcAddress(original_dll_handle, function_name));
+        if (original_function) {
+          InstallDetours(image_base + function_table[ordinals_table[i]],
+                         original_function);
         }
       }
     }

src/hotkey.cc

@@ -1,25 +1,26 @@
 #include "hotkey.h"
 
-#include <algorithm>
-#include <iterator>
-#include <string>
-#include <thread>
-#include <unordered_map>
-#include <vector>
-
 #include <windows.h>
 
 #include <audiopolicy.h>
 #include <endpointvolume.h>
 #include <mmdeviceapi.h>
 #include <tlhelp32.h>
 
+#include <algorithm>
+#include <iterator>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
 #include "config.h"
 #include "utils.h"
 
 namespace {
 
-typedef void (*HotkeyAction)();
+// typedef void (*HotkeyAction)();
+using HotkeyAction = void (*)();
 
 // Static variables for internal use
 bool is_hide = false;
@@ -62,16 +63,18 @@ UINT ParseHotkeys(const wchar_t* keys) {
       TCHAR wch = key[0];
       if (key.length() == 1)  // Parse single characters A-Z, 0-9, etc.
       {
-        if (isalnum(wch))
+        if (isalnum(wch)) {
           vk = toupper(wch);
-        else
+        } else {
           vk = LOWORD(VkKeyScan(wch));
+        }
       } else if (wch == 'F' || wch == 'f')  // Parse the F1-F24 function keys.
       {
         if (isdigit(key[1])) {
           int fx = _wtoi(&key[1]);
-          if (fx >= 1 && fx <= 24)
+          if (fx >= 1 && fx <= 24) {
             vk = VK_F1 + fx - 1;
+          }
         }
       }
     }
@@ -94,7 +97,7 @@ BOOL CALLBACK SearchChromeWindow(HWND hwnd, LPARAM lparam) {
       GetWindowThreadProcessId(hwnd, &pid);
       if (pid == GetCurrentProcessId()) {
         ShowWindow(hwnd, SW_HIDE);
-        hwnd_list.push_back(hwnd);
+        hwnd_list.emplace_back(hwnd);
       }
     }
   }
@@ -113,16 +116,17 @@ std::vector<DWORD> GetAppPids() {
   }
 
   HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-  if (snapshot == INVALID_HANDLE_VALUE)
+  if (snapshot == INVALID_HANDLE_VALUE) {
     return pids;
+  }
 
   PROCESSENTRY32W pe32;
   pe32.dwSize = sizeof(PROCESSENTRY32W);
 
   if (Process32FirstW(snapshot, &pe32)) {
     do {
       if (_wcsicmp(pe32.szExeFile, exe_name) == 0) {
-        pids.push_back(pe32.th32ProcessID);
+        pids.emplace_back(pe32.th32ProcessID);
       }
     } while (Process32NextW(snapshot, &pe32));
   }

src/iaccessible.cc

@@ -1,14 +1,14 @@
 #include "iaccessible.h"
 
+#include <windows.h>
+
 #include <functional>
 #include <memory>
 #include <string>
 #include <string_view>
 #include <thread>
 #include <vector>
 
-#include <windows.h>
-
 #include "config.h"
 #include "utils.h"
 

src/pakfile.cc

@@ -17,76 +17,78 @@ namespace {
 #pragma pack(push)
 #pragma pack(1)
 
-#define PACK4_FILE_VERSION (4)
-#define PACK5_FILE_VERSION (5)
+constexpr int kPack4FileVersion = 4;
+constexpr int kPack5FileVersion = 5;
 
-struct PAK4_HEADER {
+struct Pak4Header {
   uint32_t num_entries;
-  uint8_t encodeing;
+  uint8_t encoding;
 };
 
-struct PAK5_HEADER {
-  uint32_t encodeing;
+struct Pak5Header {
+  uint32_t encoding;
   uint16_t resource_count;
   uint16_t alias_count;
 };
 
-struct PAK_ENTRY {
+struct PakEntry {
   uint16_t resource_id;
   uint32_t file_offset;
 };
 
-struct PAK_ALIAS {
+struct PakAlias {
   uint16_t resource_id;
   uint16_t entry_index;
 };
 #pragma pack(pop)
 
 bool CheckHeader(uint8_t* buffer,
-                 PAK_ENTRY*& pak_entry,
-                 PAK_ENTRY*& end_entry) {
+                 PakEntry*& pak_entry,
+                 PakEntry*& end_entry) {
   uint32_t version = *(uint32_t*)buffer;
 
-  if (version != PACK4_FILE_VERSION && version != PACK5_FILE_VERSION)
+  if (version != kPack4FileVersion && version != kPack5FileVersion)
     return false;
 
-  if (version == PACK4_FILE_VERSION) {
-    PAK4_HEADER* pak_header = (PAK4_HEADER*)(buffer + sizeof(uint32_t));
-    if (pak_header->encodeing != 1)
+  if (version == kPack4FileVersion) {
+    Pak4Header* pak_header = (Pak4Header*)(buffer + sizeof(uint32_t));
+    if (pak_header->encoding != 1)
       return false;
 
-    pak_entry = (PAK_ENTRY*)(buffer + sizeof(uint32_t) + sizeof(PAK4_HEADER));
+    pak_entry = (PakEntry*)(buffer + sizeof(uint32_t) + sizeof(Pak4Header));
     end_entry = pak_entry + pak_header->num_entries;
   }
 
-  if (version == PACK5_FILE_VERSION) {
-    PAK5_HEADER* pak_header = (PAK5_HEADER*)(buffer + sizeof(uint32_t));
-    if (pak_header->encodeing != 1)
+  if (version == kPack5FileVersion) {
+    Pak5Header* pak_header = (Pak5Header*)(buffer + sizeof(uint32_t));
+    if (pak_header->encoding != 1)
       return false;
 
-    pak_entry = (PAK_ENTRY*)(buffer + sizeof(uint32_t) + sizeof(PAK5_HEADER));
+    pak_entry = (PakEntry*)(buffer + sizeof(uint32_t) + sizeof(Pak5Header));
     end_entry = pak_entry + pak_header->resource_count;
   }
 
   // In order to save the "next item" of the last item,
   // the id of this special item must be 0
-  if (!end_entry || end_entry->resource_id != 0)
+  if (!end_entry || end_entry->resource_id != 0) {
     return false;
+  }
 
   return true;
 }
 
 void PakFind(uint8_t* buffer,
              uint8_t* pos,
              std::function<void(uint8_t*, uint32_t)> f) {
-  PAK_ENTRY* pak_entry = nullptr;
-  PAK_ENTRY* end_entry = nullptr;
+  PakEntry* pak_entry = nullptr;
+  PakEntry* end_entry = nullptr;
 
-  if (!CheckHeader(buffer, pak_entry, end_entry))
+  if (!CheckHeader(buffer, pak_entry, end_entry)) {
     return;
+  }
 
   do {
-    PAK_ENTRY* next_entry = pak_entry + 1;
+    PakEntry* next_entry = pak_entry + 1;
     if (pos >= buffer + pak_entry->file_offset &&
         pos <= buffer + next_entry->file_offset) {
       f(buffer + pak_entry->file_offset,
@@ -101,14 +103,15 @@ void PakFind(uint8_t* buffer,
 
 void TraversalGZIPFile(uint8_t* buffer,
                        std::function<bool(uint8_t*, uint32_t, size_t&)>&& f) {
-  PAK_ENTRY* pak_entry = nullptr;
-  PAK_ENTRY* end_entry = nullptr;
+  PakEntry* pak_entry = nullptr;
+  PakEntry* end_entry = nullptr;
 
-  if (!CheckHeader(buffer, pak_entry, end_entry))
+  if (!CheckHeader(buffer, pak_entry, end_entry)) {
     return;
+  }
 
   do {
-    PAK_ENTRY* next_entry = pak_entry + 1;
+    PakEntry* next_entry = pak_entry + 1;
     size_t old_size = next_entry->file_offset - pak_entry->file_offset;
 
     if (old_size < 10 * 1024) {
@@ -126,8 +129,9 @@ void TraversalGZIPFile(uint8_t* buffer,
 
     uint32_t original_size = *(uint32_t*)(buffer + next_entry->file_offset - 4);
     uint8_t* unpack_buffer = (uint8_t*)malloc(original_size);
-    if (!unpack_buffer)
+    if (!unpack_buffer) {
       return;
+    }
 
     struct mini_gzip gz;
     mini_gz_start(&gz, buffer + pak_entry->file_offset, old_size);
@@ -165,8 +169,9 @@ void TraversalGZIPFile(uint8_t* buffer,
           // DebugLog(L"gzip compress error %d %d", compress_size, old_size);
         }
 
-        if (compress_buffer)
+        if (compress_buffer) {
           free(compress_buffer);
+        }
       }
     }
 

src/pakpatch.cc

@@ -2,7 +2,10 @@
 
 #include <windows.h>
 
+#include <string>
+
 #include "detours.h"
+
 #include "pakfile.h"
 #include "utils.h"
 #include "version.h"
@@ -63,7 +66,9 @@ HANDLE WINAPI MyMapViewOfFile(_In_ HANDLE hFileMappingObject,
                 R"(hidden="true")");
           }
 
-          const char prouct_title[] = R"({aboutBrowserVersion}</div><div class="secondary"><a target="_blank" href="https://github.com/Bush2021/chrome_plus">Chrome++</a> )" RELEASE_VER_STR R"( modified version</div>)";
+          const char prouct_title[] =
+              R"({aboutBrowserVersion}</div><div class="secondary"><a target="_blank" href="https://github.com/Bush2021/chrome_plus">Chrome++</a> )" RELEASE_VER_STR
+              R"( modified version</div>)";
           ReplaceStringInPlace(html, R"({aboutBrowserVersion}</div>)",
                                prouct_title);
 
@@ -135,7 +140,7 @@ HANDLE WINAPI MyCreateFile(_In_ LPCTSTR lpFileName,
                               lpSecurityAttributes, dwCreationDisposition,
                               dwFlagsAndAttributes, hTemplateFile);
 
-  if (isEndWith(lpFileName, L"resources.pak")) {
+  if (std::wstring(lpFileName).ends_with(L"resources.pak")) {
     resources_pak_file = file;
     resources_pak_size = GetFileSize(resources_pak_file, nullptr);