【Chromium】Base库的最佳实践 - 进程和线程

void Process::Exited(int exit_code) const {
  base::debug::GlobalActivityTracker::RecordProcessExitIfEnabled(Pid(),
                                                                 exit_code);
}

bool Process::Terminate(int exit_code, bool wait) const {
  constexpr DWORD kWaitMs = 60 * 1000;
  
  DCHECK(IsValid());
  bool result = (::TerminateProcess(Handle(), exit_code) != FALSE);
  if (result) {
    if (wait && ::WaitForSingleObject(Handle(), kWaitMs) != WAIT_OBJECT_0)
      DPLOG(ERROR) << "Error waiting for process exit";
    Exited(exit_code);
  } else {
    if (GetLastError() != ERROR_ACCESS_DENIED)
      DPLOG(ERROR) << "Unable to terminate process";
    if (::WaitForSingleObject(Handle(), kWaitMs) == WAIT_OBJECT_0) {
      DWORD actual_exit;
      Exited(::GetExitCodeProcess(Handle(), &actual_exit) ? actual_exit
                                                          : exit_code);
      result = true;
    }
  }
  return result;
}

bool KillProcesses(const FilePath::StringType& executable_name,
                   int exit_code,
                   const ProcessFilter* filter) {
  bool result = true;
  NamedProcessIterator iter(executable_name, filter);
  while (const ProcessEntry* entry = iter.NextProcessEntry()) {
    Process process = Process::Open(entry->pid());
    if (!process.IsValid()) {
      result = false;
      continue;
    }
    result &= process.Terminate(exit_code, true);
  }
  return result;
}

bool Util::QtCreateProcess(const QString& program, const QString& arguments) {
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    ZeroMemory(&pi, sizeof(pi));

    // 将 QString 转换为 Windows 风格的命令行参数
    QString commandLine = program + " " + arguments;

    // 创建进程
    if (!::CreateProcess(NULL, (LPWSTR)commandLine.toStdWString().c_str(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
        return false;
    }
      
    // 关闭进程和主线程句柄
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
    return true;
}

inline constexpr const wchar_t* SLowIntegritySid = L"S-1-16-4096";
inline constexpr const wchar_t* SMediumIntegritySid = L"S-1-16-8192";
inline constexpr const wchar_t* SHighIntegritySid = L"S-1-16-12288";
inline constexpr const wchar_t* SSystemIntegritySid = L"S-1-16-16384";

operator HANDLE() {
   /* Get the current process' security token as a starting point, then modify
      a duplicate so that it runs with a fixed integrity level. */
   if (::OpenProcessToken(::GetCurrentProcess(), TOKEN_DUPLICATE | TOKEN_ADJUST_DEFAULT | TOKEN_QUERY | TOKEN_ASSIGN_PRIMARY, &m_curToken)) {
       if (::DuplicateTokenEx(m_curToken, 0, NULL, SecurityImpersonation, TokenPrimary, &m_dupToken)) {
           if (AdjustTokenIntegrityLevel(m_dupToken, m_lpSid)) {
               return m_dupToken;
           }
       }
   }
   return nullptr;
}

static BOOL AdjustTokenIntegrityLevel(HANDLE token, const wchar_t* sid) {
   /* Convert the string SID to a SID *, then adjust the token's
      privileges. */
   BOOL ret{};
   PSID psd{};
   if (::ConvertStringSidToSid(sid, &psd)) {
       TOKEN_MANDATORY_LABEL tml;

       ZeroMemory(&tml, sizeof(tml));
       tml.Label.Attributes = SE_GROUP_INTEGRITY;
       tml.Label.Sid = psd;

       ret = ::SetTokenInformation(token, TokenIntegrityLevel, &tml, sizeof(tml));
       if (!ret) {
           L_ERROR_NOCODE(L"SetTokenInformation return false, err:%d", ::GetLastError());
       }
       ::LocalFree(psd);
   }
   return ret;
}

CIntegrityLevelToken token(SMediumIntegritySid);
if (!::CreateProcessAsUser(token, NULL, (LPWSTR)commandLine.toStdWString().c_str(), NULL, NULL, FALSE, CREATE_PRESERVE_CODE_AUTHZ_LEVEL, NULL, NULL, &si, &pi)) {
    return false;
}

bool Util::CreateProcessAsUserWithExplore(const QString& program) {
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(STARTUPINFO);
    ZeroMemory(&pi, sizeof(pi));

    // 将 QString 转换为 Windows 风格的命令行参数
    QString commandLine = "explorer.exe " + program;

    if (!::CreateProcess(NULL, (LPWSTR)commandLine.toStdWString().c_str(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
        return false;
    }

    // 关闭进程和主线程句柄
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
    return true;
}

BASE_EXPORT bool GetAppOutput(const CommandLine& cl, std::string* output);

BASE_EXPORT bool GetAppOutputAndError(const CommandLine& cl, std::string* output);

BASE_EXPORT bool GetAppOutputWithExitCode(const CommandLine& cl, std::string* output, int* exit_code);

#include <string>
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/process/launch.h"

int main() {
  base::CommandLine cl(base::FilePath(FILE_PATH_LITERAL("myapp.exe")));
  cl.AppendArg("--arg1");
  cl.AppendArg("--arg2");

  std::string output;
  if (base::GetAppOutput(cl, &output)) {
    std::cout << "Command output:<< output<< std::endl;
  } else {
    std::cerr << "Failed to execute command."<< std::endl;
  }

  return 0;
}

#include "base/process/process_iterator.h"
#include<iostream>

class MyProcessFilter : public base::ProcessFilter {
 public:
  bool Includes(const base::ProcessEntry& entry) const override {
    // 这里可以添加自定义的筛选逻辑
    return true;  // 假设我们接受所有进程
  }
};

int main() {
  base::NamedProcessIterator it("chrome.exe", new MyProcessFilter());

  base::ProcessEntry entry;
  while (it.NextProcessEntry(&entry)) {
    std::cout << "Found process:<< entry.cmd_line().value()<< std::endl;
  }

  return 0;
}

base::string16 Util::GetProcessPathAndName(HANDLE process_handle) {
    wchar_t path_buffer[MAX_PATH] = { 0 };
    DWORD path_length = MAX_PATH;
    BOOL ret = QueryFullProcessImageName(process_handle, 0, path_buffer, &path_length);
    if (ret && path_length > 0 && path_length < MAX_PATH) {
        return base::string16(path_buffer, path_length);
    }
    else {
        return L"";
    }
}

base::FilePath Util::GetProcessPathByName(const std::wstring& process_name) {
    base::FilePath process_path;
    base::win::ScopedHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0));
    if (!snapshot.IsValid()) {
        return process_path;
    }

    PROCESSENTRY32 entry = {};
    entry.dwSize = sizeof(entry);
    if (!Process32First(snapshot.Get(), &entry)) {
        return process_path;
    }

    do {
        if (entry.szExeFile == process_name) {
            base::win::ScopedHandle process(OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, entry.th32ProcessID));
            if (process.IsValid()) {
                base::string16 path_wstring = GetProcessPathAndName(process.Get());
                if (!path_wstring.empty()) {
                    process_path = base::FilePath::FromUTF16Unsafe(path_wstring);
                    break;
                }
            }
        }
    } while (Process32Next(snapshot.Get(), &entry));

    return process_path;
}

#include "base/process/process_metrics.h"
#include<iostream>

int main() {
  // 获取当前进程的句柄
  base::ProcessHandle process_handle = base::GetCurrentProcessHandle();

  // 创建一个ProcessMetrics对象
  base::ProcessMetrics metrics(process_handle);

  // 获取CPU使用率
  double cpu_usage = metrics.GetPlatformIndependentCPUUsage();
  std::cout << "Current process CPU usage:<< cpu_usage<< "%"<< std::endl;

  // 获取内存使用情况
  size_t working_set_size = metrics.GetWorkingSetSize();
  std::cout << "Current process Working Set Size:<< working_set_size<< " bytes"<< std::endl;

  return 0;
}

enum class Thread_Type {
    TYPE_MAIN_UI,
    TYPE_FILE_IO,
    TYPE_BACKGROUND
};

// 普通任务丢到线程池，主线程任务丢到主线程创建的窗口循环去处理
// 异步任务接口
void PostTask(Thread_Type type, const base::Location& from_here, base::OnceClosure task);
void PostDelayedTask(Thread_Type type, const base::Location& from_here, base::OnceClosure task, base::TimeDelta delay);
bool PostTaskAndReply(Thread_Type type, const base::Location& from_here, base::OnceClosure task, base::OnceClosure reply);

// 传递参数的回复异步任务
template <template <typename> class CallbackType,
    typename TaskReturnType,
    typename ReplyArgType,
    typename = base::EnableIfIsBaseCallback<CallbackType>>
    bool PostTaskAndReplyWithResult(Thread_Type type, const base::Location& from_here,
        CallbackType<TaskReturnType()> task,
        CallbackType<void(ReplyArgType)> reply);

// 抛顺序执行任务
void PostSequnceTask(const base::Location& from_here, base::OnceClosure task);
void PostSequnceDelayedTask(const base::Location& from_here, base::OnceClosure task, base::TimeDelta delay);

// 单物理线程执行任务
void PostSingleThreadTask(const base::Location& from_here, base::OnceClosure task);
void PostSingleThreadDelayedTask(const base::Location& from_here, base::OnceClosure task, base::TimeDelta delay);

void ThreadPool::PostTask(Thread_Type type, const base::Location& from_here, base::OnceClosure task) {
    PostDelayedTask(type, from_here, std::move(task), base::TimeDelta());
}

void ThreadPool::PostDelayedTask(Thread_Type type, const base::Location& from_here, base::OnceClosure task, base::TimeDelta delay) {
    switch (type) {
    case Thread_Type::TYPE_MAIN_UI:
        PostDelayedUITask(from_here, std::move(WrapTask(type, from_here, std::move(task))), delay);
        break;
    case Thread_Type::TYPE_FILE_IO:
        m_spTaskRunnerFileIO->PostDelayedTask(from_here, std::move(WrapTask(type, from_here, std::move(task))), delay);
        break;
    case Thread_Type::TYPE_BACKGROUND:
        m_spTaskRunnerBackGround->PostDelayedTask(from_here, std::move(WrapTask(type, from_here, std::move(task))), delay);
        break;
    default:
        break;
    }
}

void ThreadPool::PostDelayedUITask(const base::Location& from_here, base::OnceClosure task, base::TimeDelta delay) {
    std::unique_ptr<base::PendingTask> newTask = std::make_unique<base::PendingTask>(from_here, std::move(task),
  base::TimeTicks::FromInternalValue(base::TimeTicks::Now().ToInternalValue() + delay.ToInternalValue()));
    m_upMessageUI->ScheduleDelayedWork(std::move(newTask));
}

base::win::MessageWindow m_hWindow;
m_hWindow.CreateNamed(base::BindRepeating(&MessageForUI::MessageCallback, base::Unretained(this)), std::wstring(L"WxDecryptMainWindow").c_str());

bool MessageForUI::MessageCallback(UINT message, WPARAM wparam, LPARAM lparam, LRESULT* result) {
    switch (message) {
    case kMsgHaveWork:
        HandleWorkMessage();
        break;
    case WM_TIMER:
        if (wparam == reinterpret_cast<UINT_PTR>(this))
            HandleTimerMessage();
        break;
    }
    return false;
}

using DelayedTaskQueue = std::priority_queue<base::PendingTask>;
bool PendingTask::operator<(const PendingTask& other) const {
  // Since the top of a priority queue is defined as the "greatest" element, we
  // need to invert the comparison here.  We want the smaller time to be at the
  // top of the heap.

  if (delayed_run_time < other.delayed_run_time)
    return false;

  if (delayed_run_time > other.delayed_run_time)
    return true;

  // If the times happen to match, then we use the sequence number to decide.
  // Compare the difference to support integer roll-over.
  return (sequence_num - other.sequence_num) > 0;
}

// 根据CPU核数来初始化线程池最大线程数，最大程度利用机器性能
const int num_cores = base::SysInfo::NumberOfProcessors();
base::ThreadPoolInstance::InitParams initParams(std::max(3, num_cores - 1));
m_spThreadPool = std::make_shared<base::internal::ThreadPoolImpl>("Thread Pool");
// 初始化线程池工作线程观察者，方便监控线程的回收和创建
m_spObserver = std::make_shared<ThreadPoolObserver>();
m_spThreadPool->Start(initParams, std::dynamic_pointer_cast<base::WorkerThreadObserver>(m_spObserver).get());

// 创建IO线程TaskRunner
base::TaskTraits traits{ base::TaskPriority::USER_VISIBLE };
m_spTaskRunnerFileIO = m_spThreadPool->CreateTaskRunner(traits);

// 创建后台线程TaskRunner
base::TaskTraits traitsEffort{ base::TaskPriority::BEST_EFFORT };
m_spTaskRunnerBackGround = m_spThreadPool->CreateTaskRunner(traitsEffort);

// 创建顺序任务Runner，这里抛出的任务会顺序执行，但是并不保证在同一线程
base::TaskTraits traitsUIThread{ base::TaskPriority::BEST_EFFORT };
m_spSeqTaskRunner = m_spThreadPool->CreateSequencedTaskRunner(traitsUIThread);

// 创建单线程任务Runner，这里是实际的物理线程
m_spSingleTaskRunner = m_spThreadPool->CreateSingleThreadTaskRunner(traitsUIThread, base::SingleThreadTaskRunnerThreadMode::DEDICATED);

// 主线程窗口循环初始化
m_upMessageUI = std::make_unique<MessageForUI>();

template <template <typename> class CallbackType,
    typename TaskReturnType,
    typename ReplyArgType,
    typename = base::EnableIfIsBaseCallback<CallbackType>>
    bool ThreadPool::PostTaskAndReplyWithResult(Thread_Type type, const base::Location& from_here,
        CallbackType<TaskReturnType()> task,
        CallbackType<void(ReplyArgType)> reply) {
    auto* result = new std::unique_ptr<TaskReturnType>();
    return PostTaskAndReply(type, from_here,
        base::BindOnce(&base::internal::ReturnAsParamAdapter<TaskReturnType>, std::move(task),
            result),
        base::BindOnce(&base::internal::ReplyAdapter<TaskReturnType, ReplyArgType>,
            std::move(reply), base::Owned(result)));
}

int readPool::AsyncTaskWithReturn() {
    return 1;
}

void ThreadPool::AsyncReplyWithParam(int i) {
    L_TRACE("i = [%d]", i);
}

Pool->PostTaskAndReplyWithResult(Thread_Type::TYPE_MAIN_UI, FROM_HERE,
  base::BindOnce(&WxThreadPool::AsyncTaskWithReturn, base::Unretained(Pool)),
  base::BindOnce(&WxThreadPool::AsyncReplyWithParam, base::Unretained(Pool)));

bool ThreadPool::PostTaskAndReplyOnMainUI(const base::Location& from_here, base::OnceClosure task, base::OnceClosure reply) {
    return PostTaskAndReply(Thread_Type::TYPE_BACKGROUND, from_here, std::move(task), base::BindOnce([](const base::Location& from_here, base::OnceClosure reply) {
        Pool->PostTask(Thread_Type::TYPE_MAIN_UI, from_here, std::move(reply));
        }, from_here, std::move(reply)));
}

PostDelayedUITask(from_here, std::move(task)), delay);

// 调整为

PostDelayedUITask(from_here, std::move(WrapTask(type, from_here, std::move(task))), delay);

base::OnceClosure WxThreadPool::WrapTask(Thread_Type type, const base::Location& from_here, base::OnceClosure task) {
    return base::BindOnce([](Thread_Type from_type, const base::Location& from_here, base::OnceClosure fromtask) {
        base::Time start_time = base::Time::Now();
        std::move(fromtask).Run();
        base::Time end_time = base::Time::Now();
        base::TimeDelta time_difference = end_time - start_time;
        double microseconds_difference = time_difference.InMicrosecondsF();
        L_TRACE("[%s]task location [%s] run cost [%.3f]ms", Util::TaskTypeToString(from_type).c_str(), from_here.ToString().c_str(), microseconds_difference / 1000);
        }, type, from_here, std::move(task));
}

#define PRINT_DEBUG_INFO() \
  do { \
    base::debug::StackTrace stack_trace; \
    L_TRACE("stack_trace [%s]", stack_trace.ToString().c_str()); \
    base::debug::TaskTrace task_trace; \
    L_TRACE("task trace [%s]", task_trace.ToString().c_str()); \
  } while (0)

void TaskCenter::SomeTask() {
    // 输出堆栈信息
    PRINT_DEBUG_INFO();
}

PostTask(**，&TaskCenter::SomeTask, ***);

class MySingleton {
 public:
  // 获取单例对象的引用
  static MySingleton& GetInstance() {
    return base::Singleton<MySingleton>::get();
  }

  // 示例方法
  void DoSomething() {
    std::cout << "Doing something..."<< std::endl;
  }

 private:
  // 私有构造函数，防止外部构造
  MySingleton() {}

  // 禁止拷贝和赋值
  MySingleton(const MySingleton&) = delete;
  MySingleton& operator=(const MySingleton&) = delete;

  // 单例的析构函数
  friend struct base::DefaultSingletonTraits<MySingleton>;
  ~MySingleton() {}
};

int main() {
  MySingleton& singleton = MySingleton::GetInstance();
  singleton.DoSomething();
  return 0;
}

#include "base/bind.h"
#include "base/callback.h"
#include "base/run_loop.h"
#include<iostream>

class MyClass {
 public:
  void MyMethod(const std::string& message) {
    std::cout<< message<< std::endl;
  }
};

void MyFunction(const std::string& message) {
  std::cout<< message<< std::endl;
}

int main() {
  MyClass my_class;
  std::string message = "Hello, World!";

  // 使用Unretained
  base::OnceClosure unretained_callback = base::BindOnce(&MyClass::MyMethod, base::Unretained(&my_class), message);

  // 使用RetainedRef
  base::OnceClosure retained_ref_callback = base::BindOnce(&MyClass::MyMethod, base::RetainedRef(&my_class), message);

  // 使用Owned（需要手动管理对象的生命周期）
  std::unique_ptr<MyClass> my_class_owned(new MyClass());
  base::OnceClosure owned_callback = base::BindOnce(&MyClass::MyMethod, base::Owned(my_class_owned.get()), message);

  // 使用Passed
  base::OnceClosure passed_callback = base::BindOnce(&MyFunction, base::Passed(std::make_unique<std::string>(message)));

  // 执行回调
  base::RunLoop run_loop;
  run_loop.RunUntilIdle();

  return 0;
}