Remove base/process
Change-Id: I3fa5f6d059278cf8b0a17d475ac2e6ff881d09c0
Reviewed-on: https://gn-review.googlesource.com/1660
Reviewed-by: Brett Wilson <brettw@chromium.org>
Commit-Queue: Scott Graham <scottmg@chromium.org>
diff --git a/base/files/file.cc b/base/files/file.cc
index 8f779d5..8bc4fdb 100644
--- a/base/files/file.cc
+++ b/base/files/file.cc
@@ -4,7 +4,6 @@
#include "base/files/file.h"
#include "base/files/file_path.h"
-#include "base/timer/elapsed_timer.h"
#include "build_config.h"
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
diff --git a/base/files/file_util_win.cc b/base/files/file_util_win.cc
index 48190ad..545dbc0 100644
--- a/base/files/file_util_win.cc
+++ b/base/files/file_util_win.cc
@@ -23,7 +23,6 @@
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/macros.h"
-#include "base/process/process_handle.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
@@ -506,7 +505,7 @@
// the one exists, keep trying another path name until we reach some limit.
string16 new_dir_name;
new_dir_name.assign(prefix);
- new_dir_name.append(IntToString16(GetCurrentProcId()));
+ new_dir_name.append(IntToString16(::GetCurrentProcessId()));
new_dir_name.push_back('_');
new_dir_name.append(UTF8ToUTF16(GenerateGUID()));
diff --git a/base/process/internal_linux.cc b/base/process/internal_linux.cc
deleted file mode 100644
index 6c2cafa..0000000
--- a/base/process/internal_linux.cc
+++ /dev/null
@@ -1,220 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/internal_linux.h"
-
-#include <limits.h>
-#include <unistd.h>
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-#include "base/time/time.h"
-
-namespace base {
-namespace internal {
-
-const char kProcDir[] = "/proc";
-
-const char kStatFile[] = "stat";
-
-FilePath GetProcPidDir(pid_t pid) {
- return FilePath(kProcDir).Append(IntToString(pid));
-}
-
-pid_t ProcDirSlotToPid(const char* d_name) {
- int i;
- for (i = 0; i < NAME_MAX && d_name[i]; ++i) {
- if (!IsAsciiDigit(d_name[i])) {
- return 0;
- }
- }
- if (i == NAME_MAX)
- return 0;
-
- // Read the process's command line.
- pid_t pid;
- std::string pid_string(d_name);
- if (!StringToInt(pid_string, &pid)) {
- NOTREACHED();
- return 0;
- }
- return pid;
-}
-
-bool ReadProcFile(const FilePath& file, std::string* buffer) {
- buffer->clear();
- if (!ReadFileToString(file, buffer)) {
- DLOG(WARNING) << "Failed to read " << file.MaybeAsASCII();
- return false;
- }
- return !buffer->empty();
-}
-
-bool ReadProcStats(pid_t pid, std::string* buffer) {
- FilePath stat_file = internal::GetProcPidDir(pid).Append(kStatFile);
- return ReadProcFile(stat_file, buffer);
-}
-
-bool ParseProcStats(const std::string& stats_data,
- std::vector<std::string>* proc_stats) {
- // |stats_data| may be empty if the process disappeared somehow.
- // e.g. http://crbug.com/145811
- if (stats_data.empty())
- return false;
-
- // The stat file is formatted as:
- // pid (process name) data1 data2 .... dataN
- // Look for the closing paren by scanning backwards, to avoid being fooled by
- // processes with ')' in the name.
- size_t open_parens_idx = stats_data.find(" (");
- size_t close_parens_idx = stats_data.rfind(") ");
- if (open_parens_idx == std::string::npos ||
- close_parens_idx == std::string::npos ||
- open_parens_idx > close_parens_idx) {
- DLOG(WARNING) << "Failed to find matched parens in '" << stats_data << "'";
- NOTREACHED();
- return false;
- }
- open_parens_idx++;
-
- proc_stats->clear();
- // PID.
- proc_stats->push_back(stats_data.substr(0, open_parens_idx));
- // Process name without parentheses.
- proc_stats->push_back(stats_data.substr(
- open_parens_idx + 1, close_parens_idx - (open_parens_idx + 1)));
-
- // Split the rest.
- std::vector<std::string> other_stats =
- SplitString(stats_data.substr(close_parens_idx + 2), " ",
- base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
- for (size_t i = 0; i < other_stats.size(); ++i)
- proc_stats->push_back(other_stats[i]);
- return true;
-}
-
-typedef std::map<std::string, std::string> ProcStatMap;
-void ParseProcStat(const std::string& contents, ProcStatMap* output) {
- StringPairs key_value_pairs;
- SplitStringIntoKeyValuePairs(contents, ' ', '\n', &key_value_pairs);
- for (size_t i = 0; i < key_value_pairs.size(); ++i) {
- output->insert(key_value_pairs[i]);
- }
-}
-
-int64_t GetProcStatsFieldAsInt64(const std::vector<std::string>& proc_stats,
- ProcStatsFields field_num) {
- DCHECK_GE(field_num, VM_PPID);
- CHECK_LT(static_cast<size_t>(field_num), proc_stats.size());
-
- int64_t value;
- return StringToInt64(proc_stats[field_num], &value) ? value : 0;
-}
-
-size_t GetProcStatsFieldAsSizeT(const std::vector<std::string>& proc_stats,
- ProcStatsFields field_num) {
- DCHECK_GE(field_num, VM_PPID);
- CHECK_LT(static_cast<size_t>(field_num), proc_stats.size());
-
- size_t value;
- return StringToSizeT(proc_stats[field_num], &value) ? value : 0;
-}
-
-int64_t ReadStatFileAndGetFieldAsInt64(const FilePath& stat_file,
- ProcStatsFields field_num) {
- std::string stats_data;
- if (!ReadProcFile(stat_file, &stats_data))
- return 0;
- std::vector<std::string> proc_stats;
- if (!ParseProcStats(stats_data, &proc_stats))
- return 0;
- return GetProcStatsFieldAsInt64(proc_stats, field_num);
-}
-
-int64_t ReadProcStatsAndGetFieldAsInt64(pid_t pid, ProcStatsFields field_num) {
- FilePath stat_file = internal::GetProcPidDir(pid).Append(kStatFile);
- return ReadStatFileAndGetFieldAsInt64(stat_file, field_num);
-}
-
-int64_t ReadProcSelfStatsAndGetFieldAsInt64(ProcStatsFields field_num) {
- FilePath stat_file = FilePath(kProcDir).Append("self").Append(kStatFile);
- return ReadStatFileAndGetFieldAsInt64(stat_file, field_num);
-}
-
-size_t ReadProcStatsAndGetFieldAsSizeT(pid_t pid, ProcStatsFields field_num) {
- std::string stats_data;
- if (!ReadProcStats(pid, &stats_data))
- return 0;
- std::vector<std::string> proc_stats;
- if (!ParseProcStats(stats_data, &proc_stats))
- return 0;
- return GetProcStatsFieldAsSizeT(proc_stats, field_num);
-}
-
-Time GetBootTime() {
- FilePath path("/proc/stat");
- std::string contents;
- if (!ReadProcFile(path, &contents))
- return Time();
- ProcStatMap proc_stat;
- ParseProcStat(contents, &proc_stat);
- ProcStatMap::const_iterator btime_it = proc_stat.find("btime");
- if (btime_it == proc_stat.end())
- return Time();
- int btime;
- if (!StringToInt(btime_it->second, &btime))
- return Time();
- return Time::FromTimeT(btime);
-}
-
-TimeDelta GetUserCpuTimeSinceBoot() {
- FilePath path("/proc/stat");
- std::string contents;
- if (!ReadProcFile(path, &contents))
- return TimeDelta();
-
- ProcStatMap proc_stat;
- ParseProcStat(contents, &proc_stat);
- ProcStatMap::const_iterator cpu_it = proc_stat.find("cpu");
- if (cpu_it == proc_stat.end())
- return TimeDelta();
-
- std::vector<std::string> cpu = SplitString(
- cpu_it->second, kWhitespaceASCII, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
-
- if (cpu.size() < 2 || cpu[0] != "cpu")
- return TimeDelta();
-
- uint64_t user;
- uint64_t nice;
- if (!StringToUint64(cpu[0], &user) || !StringToUint64(cpu[1], &nice))
- return TimeDelta();
-
- return ClockTicksToTimeDelta(user + nice);
-}
-
-TimeDelta ClockTicksToTimeDelta(int clock_ticks) {
- // This queries the /proc-specific scaling factor which is
- // conceptually the system hertz. To dump this value on another
- // system, try
- // od -t dL /proc/self/auxv
- // and look for the number after 17 in the output; mine is
- // 0000040 17 100 3 134512692
- // which means the answer is 100.
- // It may be the case that this value is always 100.
- static const int kHertz = sysconf(_SC_CLK_TCK);
-
- return TimeDelta::FromMicroseconds(Time::kMicrosecondsPerSecond *
- clock_ticks / kHertz);
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/process/internal_linux.h b/base/process/internal_linux.h
deleted file mode 100644
index 56c08e6..0000000
--- a/base/process/internal_linux.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file contains internal routines that are called by other files in
-// base/process/.
-
-#ifndef BASE_PROCESS_INTERNAL_LINUX_H_
-#define BASE_PROCESS_INTERNAL_LINUX_H_
-
-#include <stddef.h>
-#include <stdint.h>
-#include <unistd.h>
-
-#include "base/files/file_path.h"
-
-namespace base {
-
-class Time;
-class TimeDelta;
-
-namespace internal {
-
-// "/proc"
-extern const char kProcDir[];
-
-// "stat"
-extern const char kStatFile[];
-
-// Returns a FilePath to "/proc/pid".
-base::FilePath GetProcPidDir(pid_t pid);
-
-// Take a /proc directory entry named |d_name|, and if it is the directory for
-// a process, convert it to a pid_t.
-// Returns 0 on failure.
-// e.g. /proc/self/ will return 0, whereas /proc/1234 will return 1234.
-pid_t ProcDirSlotToPid(const char* d_name);
-
-// Reads /proc/<pid>/stat into |buffer|. Returns true if the file can be read
-// and is non-empty.
-bool ReadProcStats(pid_t pid, std::string* buffer);
-
-// Takes |stats_data| and populates |proc_stats| with the values split by
-// spaces. Taking into account the 2nd field may, in itself, contain spaces.
-// Returns true if successful.
-bool ParseProcStats(const std::string& stats_data,
- std::vector<std::string>* proc_stats);
-
-// Fields from /proc/<pid>/stat, 0-based. See man 5 proc.
-// If the ordering ever changes, carefully review functions that use these
-// values.
-enum ProcStatsFields {
- VM_COMM = 1, // Filename of executable, without parentheses.
- VM_STATE = 2, // Letter indicating the state of the process.
- VM_PPID = 3, // PID of the parent.
- VM_PGRP = 4, // Process group id.
- VM_MINFLT = 9, // Minor page fault count excluding children.
- VM_MAJFLT = 11, // Major page fault count excluding children.
- VM_UTIME = 13, // Time scheduled in user mode in clock ticks.
- VM_STIME = 14, // Time scheduled in kernel mode in clock ticks.
- VM_NUMTHREADS = 19, // Number of threads.
- VM_STARTTIME = 21, // The time the process started in clock ticks.
- VM_VSIZE = 22, // Virtual memory size in bytes.
- VM_RSS = 23, // Resident Set Size in pages.
-};
-
-// Reads the |field_num|th field from |proc_stats|. Returns 0 on failure.
-// This version does not handle the first 3 values, since the first value is
-// simply |pid|, and the next two values are strings.
-int64_t GetProcStatsFieldAsInt64(const std::vector<std::string>& proc_stats,
- ProcStatsFields field_num);
-
-// Same as GetProcStatsFieldAsInt64(), but for size_t values.
-size_t GetProcStatsFieldAsSizeT(const std::vector<std::string>& proc_stats,
- ProcStatsFields field_num);
-
-// Convenience wrappers around GetProcStatsFieldAsInt64(), ParseProcStats() and
-// ReadProcStats(). See GetProcStatsFieldAsInt64() for details.
-int64_t ReadStatsFilendGetFieldAsInt64(const FilePath& stat_file,
- ProcStatsFields field_num);
-int64_t ReadProcStatsAndGetFieldAsInt64(pid_t pid, ProcStatsFields field_num);
-int64_t ReadProcSelfStatsAndGetFieldAsInt64(ProcStatsFields field_num);
-
-// Same as ReadProcStatsAndGetFieldAsInt64() but for size_t values.
-size_t ReadProcStatsAndGetFieldAsSizeT(pid_t pid, ProcStatsFields field_num);
-
-// Returns the time that the OS started. Clock ticks are relative to this.
-Time GetBootTime();
-
-// Returns the amount of time spent in user space since boot across all CPUs.
-TimeDelta GetUserCpuTimeSinceBoot();
-
-// Converts Linux clock ticks to a wall time delta.
-TimeDelta ClockTicksToTimeDelta(int clock_ticks);
-
-} // namespace internal
-} // namespace base
-
-#endif // BASE_PROCESS_INTERNAL_LINUX_H_
diff --git a/base/process/kill.cc b/base/process/kill.cc
deleted file mode 100644
index f73266d..0000000
--- a/base/process/kill.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/kill.h"
-
-#include "base/bind.h"
-#include "base/process/process_iterator.h"
-#include "base/time/time.h"
-
-namespace base {
-
-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());
- // Sometimes process open fails. This would cause a DCHECK in
- // process.Terminate(). Maybe the process has killed itself between the
- // time the process list was enumerated and the time we try to open the
- // process?
- if (!process.IsValid()) {
- result = false;
- continue;
- }
- result &= process.Terminate(exit_code, true);
- }
- return result;
-}
-
-} // namespace base
diff --git a/base/process/kill.h b/base/process/kill.h
deleted file mode 100644
index 89ab97b..0000000
--- a/base/process/kill.h
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file contains routines to kill processes and get the exit code and
-// termination status.
-
-#ifndef BASE_PROCESS_KILL_H_
-#define BASE_PROCESS_KILL_H_
-
-#include "base/files/file_path.h"
-#include "base/process/process.h"
-#include "base/process/process_handle.h"
-#include "base/time/time.h"
-#include "build_config.h"
-
-namespace base {
-
-class ProcessFilter;
-
-#if defined(OS_WIN)
-namespace win {
-
-// See definition in sandbox/win/src/sandbox_types.h
-const DWORD kSandboxFatalMemoryExceeded = 7012;
-
-// Exit codes with special meanings on Windows.
-const DWORD kNormalTerminationExitCode = 0;
-const DWORD kDebuggerInactiveExitCode = 0xC0000354;
-const DWORD kKeyboardInterruptExitCode = 0xC000013A;
-const DWORD kDebuggerTerminatedExitCode = 0x40010004;
-
-// This exit code is used by the Windows task manager when it kills a
-// process. It's value is obviously not that unique, and it's
-// surprising to me that the task manager uses this value, but it
-// seems to be common practice on Windows to test for it as an
-// indication that the task manager has killed something if the
-// process goes away.
-const DWORD kProcessKilledExitCode = 1;
-
-} // namespace win
-
-#endif // OS_WIN
-
-// Return status values from GetTerminationStatus. Don't use these as
-// exit code arguments to KillProcess*(), use platform/application
-// specific values instead.
-enum TerminationStatus {
- TERMINATION_STATUS_NORMAL_TERMINATION, // zero exit status
- TERMINATION_STATUS_ABNORMAL_TERMINATION, // non-zero exit status
- TERMINATION_STATUS_PROCESS_WAS_KILLED, // e.g. SIGKILL or task manager kill
- TERMINATION_STATUS_PROCESS_CRASHED, // e.g. Segmentation fault
- TERMINATION_STATUS_STILL_RUNNING, // child hasn't exited yet
- TERMINATION_STATUS_LAUNCH_FAILED, // child process never launched
- TERMINATION_STATUS_OOM, // Process died due to oom
- TERMINATION_STATUS_MAX_ENUM
-};
-
-// Attempts to kill all the processes on the current machine that were launched
-// from the given executable name, ending them with the given exit code. If
-// filter is non-null, then only processes selected by the filter are killed.
-// Returns true if all processes were able to be killed off, false if at least
-// one couldn't be killed.
-bool KillProcesses(const FilePath::StringType& executable_name,
- int exit_code,
- const ProcessFilter* filter);
-
-#if defined(OS_POSIX)
-// Attempts to kill the process group identified by |process_group_id|. Returns
-// true on success.
-bool KillProcessGroup(ProcessHandle process_group_id);
-#endif // defined(OS_POSIX)
-
-// Get the termination status of the process by interpreting the
-// circumstances of the child process' death. |exit_code| is set to
-// the status returned by waitpid() on POSIX, and from GetExitCodeProcess() on
-// Windows, and may not be null. Note that on Linux, this function
-// will only return a useful result the first time it is called after
-// the child exits (because it will reap the child and the information
-// will no longer be available).
-TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code);
-
-#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
-// Send a kill signal to the process and then wait for the process to exit
-// and get the termination status.
-//
-// This is used in situations where it is believed that the process is dead
-// or dying (because communication with the child process has been cut).
-// In order to avoid erroneously returning that the process is still running
-// because the kernel is still cleaning it up, this will wait for the process
-// to terminate. In order to avoid the risk of hanging while waiting for the
-// process to terminate, send a SIGKILL to the process before waiting for the
-// termination status.
-//
-// Note that it is not an option to call WaitForExitCode and then
-// GetTerminationStatus as the child will be reaped when WaitForExitCode
-// returns, and this information will be lost.
-//
-TerminationStatus GetKnownDeadTerminationStatus(ProcessHandle handle,
- int* exit_code);
-
-#if defined(OS_LINUX)
-// Spawns a thread to wait asynchronously for the child |process| to exit
-// and then reaps it.
-void EnsureProcessGetsReaped(Process process);
-#endif // defined(OS_LINUX)
-#endif // defined(OS_POSIX) && !defined(OS_FUCHSIA)
-
-// These are only sparingly used, and not needed on Fuchsia. They could be
-// implemented if necessary.
-#if !defined(OS_FUCHSIA)
-// Wait for all the processes based on the named executable to exit. If filter
-// is non-null, then only processes selected by the filter are waited on.
-// Returns after all processes have exited or wait_milliseconds have expired.
-// Returns true if all the processes exited, false otherwise.
-bool WaitForProcessesToExit(const FilePath::StringType& executable_name,
- base::TimeDelta wait,
- const ProcessFilter* filter);
-
-// Waits a certain amount of time (can be 0) for all the processes with a given
-// executable name to exit, then kills off any of them that are still around.
-// If filter is non-null, then only processes selected by the filter are waited
-// on. Killed processes are ended with the given exit code. Returns false if
-// any processes needed to be killed, true if they all exited cleanly within
-// the wait_milliseconds delay.
-bool CleanupProcesses(const FilePath::StringType& executable_name,
- base::TimeDelta wait,
- int exit_code,
- const ProcessFilter* filter);
-#endif // !defined(OS_FUCHSIA)
-
-} // namespace base
-
-#endif // BASE_PROCESS_KILL_H_
diff --git a/base/process/kill_posix.cc b/base/process/kill_posix.cc
deleted file mode 100644
index 0e4e84d..0000000
--- a/base/process/kill_posix.cc
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/kill.h"
-
-#include <errno.h>
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/process/process_iterator.h"
-#include "base/threading/platform_thread.h"
-#include "build_config.h"
-
-namespace base {
-
-namespace {
-
-TerminationStatus GetTerminationStatusImpl(ProcessHandle handle,
- bool can_block,
- int* exit_code) {
- DCHECK(exit_code);
-
- int status = 0;
- const pid_t result =
- HANDLE_EINTR(waitpid(handle, &status, can_block ? 0 : WNOHANG));
- if (result == -1) {
- DPLOG(ERROR) << "waitpid(" << handle << ")";
- *exit_code = 0;
- return TERMINATION_STATUS_NORMAL_TERMINATION;
- } else if (result == 0) {
- // the child hasn't exited yet.
- *exit_code = 0;
- return TERMINATION_STATUS_STILL_RUNNING;
- }
-
- *exit_code = status;
-
- if (WIFSIGNALED(status)) {
- switch (WTERMSIG(status)) {
- case SIGABRT:
- case SIGBUS:
- case SIGFPE:
- case SIGILL:
- case SIGSEGV:
- case SIGTRAP:
- case SIGSYS:
- return TERMINATION_STATUS_PROCESS_CRASHED;
- case SIGKILL:
- case SIGINT:
- case SIGTERM:
- return TERMINATION_STATUS_PROCESS_WAS_KILLED;
- default:
- break;
- }
- }
-
- if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
- return TERMINATION_STATUS_ABNORMAL_TERMINATION;
-
- return TERMINATION_STATUS_NORMAL_TERMINATION;
-}
-
-} // namespace
-
-#if !defined(OS_NACL_NONSFI)
-bool KillProcessGroup(ProcessHandle process_group_id) {
- bool result = kill(-1 * process_group_id, SIGKILL) == 0;
- if (!result)
- DPLOG(ERROR) << "Unable to terminate process group " << process_group_id;
- return result;
-}
-#endif // !defined(OS_NACL_NONSFI)
-
-TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) {
- return GetTerminationStatusImpl(handle, false /* can_block */, exit_code);
-}
-
-TerminationStatus GetKnownDeadTerminationStatus(ProcessHandle handle,
- int* exit_code) {
- bool result = kill(handle, SIGKILL) == 0;
-
- if (!result)
- DPLOG(ERROR) << "Unable to terminate process " << handle;
-
- return GetTerminationStatusImpl(handle, true /* can_block */, exit_code);
-}
-
-#if !defined(OS_NACL_NONSFI)
-bool WaitForProcessesToExit(const FilePath::StringType& executable_name,
- TimeDelta wait,
- const ProcessFilter* filter) {
- bool result = false;
-
- // TODO(port): This is inefficient, but works if there are multiple procs.
- // TODO(port): use waitpid to avoid leaving zombies around
-
- TimeTicks end_time = TimeTicks::Now() + wait;
- do {
- NamedProcessIterator iter(executable_name, filter);
- if (!iter.NextProcessEntry()) {
- result = true;
- break;
- }
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
- } while ((end_time - TimeTicks::Now()) > TimeDelta());
-
- return result;
-}
-
-bool CleanupProcesses(const FilePath::StringType& executable_name,
- TimeDelta wait,
- int exit_code,
- const ProcessFilter* filter) {
- bool exited_cleanly = WaitForProcessesToExit(executable_name, wait, filter);
- if (!exited_cleanly)
- KillProcesses(executable_name, exit_code, filter);
- return exited_cleanly;
-}
-
-#if !defined(OS_MACOSX)
-
-namespace {
-
-class BackgroundReaper : public PlatformThread::Delegate {
- public:
- BackgroundReaper(base::Process child_process, const TimeDelta& wait_time)
- : child_process_(std::move(child_process)), wait_time_(wait_time) {}
-
- void ThreadMain() override {
- if (!wait_time_.is_zero()) {
- child_process_.WaitForExitWithTimeout(wait_time_, nullptr);
- kill(child_process_.Handle(), SIGKILL);
- }
- child_process_.WaitForExit(nullptr);
- delete this;
- }
-
- private:
- Process child_process_;
- const TimeDelta wait_time_;
- DISALLOW_COPY_AND_ASSIGN(BackgroundReaper);
-};
-
-} // namespace
-
-void EnsureProcessTerminated(Process process) {
- DCHECK(!process.is_current());
-
- if (process.WaitForExitWithTimeout(TimeDelta(), nullptr))
- return;
-
- PlatformThread::CreateNonJoinable(
- 0, new BackgroundReaper(std::move(process), TimeDelta::FromSeconds(2)));
-}
-
-#if defined(OS_LINUX)
-void EnsureProcessGetsReaped(Process process) {
- DCHECK(!process.is_current());
-
- // If the child is already dead, then there's nothing to do.
- if (process.WaitForExitWithTimeout(TimeDelta(), nullptr))
- return;
-
- PlatformThread::CreateNonJoinable(
- 0, new BackgroundReaper(std::move(process), TimeDelta()));
-}
-#endif // defined(OS_LINUX)
-
-#endif // !defined(OS_MACOSX)
-#endif // !defined(OS_NACL_NONSFI)
-
-} // namespace base
diff --git a/base/process/kill_win.cc b/base/process/kill_win.cc
deleted file mode 100644
index f598c13..0000000
--- a/base/process/kill_win.cc
+++ /dev/null
@@ -1,114 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/kill.h"
-
-#include <algorithm>
-
-#include <io.h>
-#include <stdint.h>
-#include <windows.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/process/memory.h"
-#include "base/process/process_iterator.h"
-
-namespace base {
-
-TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) {
- DCHECK(exit_code);
-
- DWORD tmp_exit_code = 0;
-
- if (!::GetExitCodeProcess(handle, &tmp_exit_code)) {
- DPLOG(FATAL) << "GetExitCodeProcess() failed";
-
- // This really is a random number. We haven't received any
- // information about the exit code, presumably because this
- // process doesn't have permission to get the exit code, or
- // because of some other cause for GetExitCodeProcess to fail
- // (MSDN docs don't give the possible failure error codes for
- // this function, so it could be anything). But we don't want
- // to leave exit_code uninitialized, since that could cause
- // random interpretations of the exit code. So we assume it
- // terminated "normally" in this case.
- *exit_code = win::kNormalTerminationExitCode;
-
- // Assume the child has exited normally if we can't get the exit
- // code.
- return TERMINATION_STATUS_NORMAL_TERMINATION;
- }
- if (tmp_exit_code == STILL_ACTIVE) {
- DWORD wait_result = WaitForSingleObject(handle, 0);
- if (wait_result == WAIT_TIMEOUT) {
- *exit_code = wait_result;
- return TERMINATION_STATUS_STILL_RUNNING;
- }
-
- if (wait_result == WAIT_FAILED) {
- DPLOG(ERROR) << "WaitForSingleObject() failed";
- } else {
- DCHECK_EQ(WAIT_OBJECT_0, wait_result);
-
- // Strange, the process used 0x103 (STILL_ACTIVE) as exit code.
- NOTREACHED();
- }
-
- return TERMINATION_STATUS_ABNORMAL_TERMINATION;
- }
-
- *exit_code = tmp_exit_code;
-
- switch (tmp_exit_code) {
- case win::kNormalTerminationExitCode:
- return TERMINATION_STATUS_NORMAL_TERMINATION;
- case win::kDebuggerInactiveExitCode: // STATUS_DEBUGGER_INACTIVE.
- case win::kKeyboardInterruptExitCode: // Control-C/end session.
- case win::kDebuggerTerminatedExitCode: // Debugger terminated process.
- case win::kProcessKilledExitCode: // Task manager kill.
- return TERMINATION_STATUS_PROCESS_WAS_KILLED;
- case win::kSandboxFatalMemoryExceeded: // Terminated process due to
- // exceeding the sandbox job
- // object memory limits.
- case win::kOomExceptionCode: // Ran out of memory.
- return TERMINATION_STATUS_OOM;
- default:
- // All other exit codes indicate crashes.
- return TERMINATION_STATUS_PROCESS_CRASHED;
- }
-}
-
-bool WaitForProcessesToExit(const FilePath::StringType& executable_name,
- TimeDelta wait,
- const ProcessFilter* filter) {
- bool result = true;
- DWORD start_time = GetTickCount();
-
- NamedProcessIterator iter(executable_name, filter);
- for (const ProcessEntry* entry = iter.NextProcessEntry(); entry;
- entry = iter.NextProcessEntry()) {
- DWORD remaining_wait = static_cast<DWORD>(
- std::max(static_cast<int64_t>(0),
- wait.InMilliseconds() - (GetTickCount() - start_time)));
- HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, entry->th32ProcessID);
- DWORD wait_result = WaitForSingleObject(process, remaining_wait);
- CloseHandle(process);
- result &= (wait_result == WAIT_OBJECT_0);
- }
-
- return result;
-}
-
-bool CleanupProcesses(const FilePath::StringType& executable_name,
- TimeDelta wait,
- int exit_code,
- const ProcessFilter* filter) {
- if (WaitForProcessesToExit(executable_name, wait, filter))
- return true;
- KillProcesses(executable_name, exit_code, filter);
- return false;
-}
-
-} // namespace base
diff --git a/base/process/memory.cc b/base/process/memory.cc
deleted file mode 100644
index 2e87fea..0000000
--- a/base/process/memory.cc
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/memory.h"
-#include "base/logging.h"
-#include "build_config.h"
-
-namespace base {
-
-// Defined in memory_win.cc for Windows.
-#if !defined(OS_WIN)
-
-namespace {
-
-// Breakpad server classifies base::`anonymous namespace'::OnNoMemory as
-// out-of-memory crash.
-NOINLINE void OnNoMemory(size_t size) {
- LOG(FATAL) << "Out of memory. size=" << size;
-}
-
-} // namespace
-
-void TerminateBecauseOutOfMemory(size_t size) {
- OnNoMemory(size);
-}
-
-#endif
-
-// Defined in memory_mac.mm for Mac.
-#if !defined(OS_MACOSX)
-
-bool UncheckedCalloc(size_t num_items, size_t size, void** result) {
- const size_t alloc_size = num_items * size;
-
- // Overflow check
- if (size && ((alloc_size / size) != num_items)) {
- *result = nullptr;
- return false;
- }
-
- if (!UncheckedMalloc(alloc_size, result))
- return false;
-
- memset(*result, 0, alloc_size);
- return true;
-}
-
-#endif
-
-} // namespace base
diff --git a/base/process/memory.h b/base/process/memory.h
deleted file mode 100644
index bbcff68..0000000
--- a/base/process/memory.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_PROCESS_MEMORY_H_
-#define BASE_PROCESS_MEMORY_H_
-
-#include <stddef.h>
-
-#include "base/process/process_handle.h"
-#include "build_config.h"
-
-#ifdef PVALLOC_AVAILABLE
-// Build config explicitly tells us whether or not pvalloc is available.
-#elif defined(LIBC_GLIBC) && !defined(USE_TCMALLOC)
-#define PVALLOC_AVAILABLE 1
-#else
-#define PVALLOC_AVAILABLE 0
-#endif
-
-namespace base {
-
-// Enables 'terminate on heap corruption' flag. Helps protect against heap
-// overflow. Has no effect if the OS doesn't provide the necessary facility.
-void EnableTerminationOnHeapCorruption();
-
-// Turns on process termination if memory runs out.
-void EnableTerminationOnOutOfMemory();
-
-// Terminates process. Should be called only for out of memory errors.
-// Crash reporting classifies such crashes as OOM.
-void TerminateBecauseOutOfMemory(size_t size);
-
-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX)
-extern size_t g_oom_size;
-
-// The maximum allowed value for the OOM score.
-const int kMaxOomScore = 1000;
-
-// This adjusts /proc/<pid>/oom_score_adj so the Linux OOM killer will
-// prefer to kill certain process types over others. The range for the
-// adjustment is [-1000, 1000], with [0, 1000] being user accessible.
-// If the Linux system doesn't support the newer oom_score_adj range
-// of [0, 1000], then we revert to using the older oom_adj, and
-// translate the given value into [0, 15]. Some aliasing of values
-// may occur in that case, of course.
-bool AdjustOOMScore(ProcessId process, int score);
-#endif
-
-#if defined(OS_WIN)
-namespace win {
-
-// Custom Windows exception code chosen to indicate an out of memory error.
-// See https://msdn.microsoft.com/en-us/library/het71c37.aspx.
-// "To make sure that you do not define a code that conflicts with an existing
-// exception code" ... "The resulting error code should therefore have the
-// highest four bits set to hexadecimal E."
-// 0xe0000008 was chosen arbitrarily, as 0x00000008 is ERROR_NOT_ENOUGH_MEMORY.
-const DWORD kOomExceptionCode = 0xe0000008;
-
-} // namespace win
-#endif
-
-// Special allocator functions for callers that want to check for OOM.
-// These will not abort if the allocation fails even if
-// EnableTerminationOnOutOfMemory has been called.
-// This can be useful for huge and/or unpredictable size memory allocations.
-// Please only use this if you really handle the case when the allocation
-// fails. Doing otherwise would risk security.
-// These functions may still crash on OOM when running under memory tools,
-// specifically ASan and other sanitizers.
-// Return value tells whether the allocation succeeded. If it fails |result| is
-// set to NULL, otherwise it holds the memory address.
-WARN_UNUSED_RESULT bool UncheckedMalloc(size_t size, void** result);
-WARN_UNUSED_RESULT bool UncheckedCalloc(size_t num_items,
- size_t size,
- void** result);
-
-} // namespace base
-
-#endif // BASE_PROCESS_MEMORY_H_
diff --git a/base/process/memory_linux.cc b/base/process/memory_linux.cc
deleted file mode 100644
index 9c75b78..0000000
--- a/base/process/memory_linux.cc
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/memory.h"
-
-#include <stddef.h>
-
-#include <new>
-
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/process/internal_linux.h"
-#include "base/strings/string_number_conversions.h"
-#include "build_config.h"
-
-namespace base {
-
-size_t g_oom_size = 0U;
-
-namespace {
-
-void OnNoMemorySize(size_t size) {
- g_oom_size = size;
-
- if (size != 0)
- LOG(FATAL) << "Out of memory, size = " << size;
- LOG(FATAL) << "Out of memory.";
-}
-
-void OnNoMemory() {
- OnNoMemorySize(0);
-}
-
-} // namespace
-
-void EnableTerminationOnHeapCorruption() {
- // On Linux, there nothing to do AFAIK.
-}
-
-void EnableTerminationOnOutOfMemory() {
- // Set the new-out of memory handler.
- std::set_new_handler(&OnNoMemory);
- // If we're using glibc's allocator, the above functions will override
- // malloc and friends and make them die on out of memory.
-}
-
-// NOTE: This is not the only version of this function in the source:
-// the setuid sandbox (in process_util_linux.c, in the sandbox source)
-// also has its own C version.
-bool AdjustOOMScore(ProcessId process, int score) {
- if (score < 0 || score > kMaxOomScore)
- return false;
-
- FilePath oom_path(internal::GetProcPidDir(process));
-
- // Attempt to write the newer oom_score_adj file first.
- FilePath oom_file = oom_path.AppendASCII("oom_score_adj");
- if (PathExists(oom_file)) {
- std::string score_str = IntToString(score);
- int score_len = static_cast<int>(score_str.length());
- return (score_len == WriteFile(oom_file, score_str.c_str(), score_len));
- }
-
- // If the oom_score_adj file doesn't exist, then we write the old
- // style file and translate the oom_adj score to the range 0-15.
- oom_file = oom_path.AppendASCII("oom_adj");
- if (PathExists(oom_file)) {
- // Max score for the old oom_adj range. Used for conversion of new
- // values to old values.
- const int kMaxOldOomScore = 15;
-
- int converted_score = score * kMaxOldOomScore / kMaxOomScore;
- std::string score_str = IntToString(converted_score);
- int score_len = static_cast<int>(score_str.length());
- return (score_len == WriteFile(oom_file, score_str.c_str(), score_len));
- }
-
- return false;
-}
-
-bool UncheckedMalloc(size_t size, void** result) {
- *result = malloc(size);
- return *result != nullptr;
-}
-
-} // namespace base
diff --git a/base/process/memory_mac.mm b/base/process/memory_mac.mm
deleted file mode 100644
index 4fa31a1..0000000
--- a/base/process/memory_mac.mm
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/memory.h"
-
-#include "build_config.h"
-
-namespace base {
-
-namespace {
-void oom_killer_new() {
- TerminateBecauseOutOfMemory(0);
-}
-} // namespace
-
-void EnableTerminationOnHeapCorruption() {
-#if !ARCH_CPU_64_BITS
- DLOG(WARNING) << "EnableTerminationOnHeapCorruption only works on 64-bit";
-#endif
-}
-
-bool UncheckedMalloc(size_t size, void** result) {
- *result = malloc(size);
- return *result != nullptr;
-}
-
-bool UncheckedCalloc(size_t num_items, size_t size, void** result) {
- *result = calloc(num_items, size);
- return *result != nullptr;
-}
-
-void EnableTerminationOnOutOfMemory() {
- // Step 1: Enable OOM killer on C++ failures.
- std::set_new_handler(oom_killer_new);
-
- // Step 2: Enable OOM killer on all other malloc zones (or just "all" without
- // "other" if shim is disabled).
- allocator::InterceptAllocationsMac();
-}
-
-} // namespace base
diff --git a/base/process/memory_stubs.cc b/base/process/memory_stubs.cc
deleted file mode 100644
index df4657f..0000000
--- a/base/process/memory_stubs.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/memory.h"
-
-#include <stddef.h>
-#include <stdlib.h>
-
-namespace base {
-
-void EnableTerminationOnOutOfMemory() {}
-
-void EnableTerminationOnHeapCorruption() {}
-
-bool AdjustOOMScore(ProcessId process, int score) {
- return false;
-}
-
-void TerminateBecauseOutOfMemory(size_t size) {
- abort();
-}
-
-// UncheckedMalloc and Calloc exist so that platforms making use of
-// EnableTerminationOnOutOfMemory have a way to allocate memory without
-// crashing. This _stubs.cc file is for platforms that do not support
-// EnableTerminationOnOutOfMemory (note the empty implementation above). As
-// such, these two Unchecked.alloc functions need only trivially pass-through to
-// their respective stdlib function since those functions will return null on a
-// failure to allocate.
-
-bool UncheckedMalloc(size_t size, void** result) {
- *result = malloc(size);
- return *result != nullptr;
-}
-
-bool UncheckedCalloc(size_t num_items, size_t size, void** result) {
- *result = calloc(num_items, size);
- return *result != nullptr;
-}
-
-} // namespace base
diff --git a/base/process/memory_win.cc b/base/process/memory_win.cc
deleted file mode 100644
index 77a2398..0000000
--- a/base/process/memory_win.cc
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/memory.h"
-
-#include <windows.h> // Must be in front of other Windows header files.
-
-#include <new.h>
-#include <psapi.h>
-#include <stddef.h>
-
-#if defined(__clang__)
-// This global constructor is trivial and non-racy (per being const).
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wglobal-constructors"
-#endif
-
-// malloc_unchecked is required to implement UncheckedMalloc properly.
-// It's provided by allocator_shim_win.cc but since that's not always present,
-// we provide a default that falls back to regular malloc.
-typedef void* (*MallocFn)(size_t);
-extern "C" void* (*const malloc_unchecked)(size_t);
-extern "C" void* (*const malloc_default)(size_t) = &malloc;
-
-#if defined(__clang__)
-#pragma clang diagnostic pop // -Wglobal-constructors
-#endif
-
-#if defined(_M_IX86)
-#pragma comment(linker, "/alternatename:_malloc_unchecked=_malloc_default")
-#elif defined(_M_X64) || defined(_M_ARM)
-#pragma comment(linker, "/alternatename:malloc_unchecked=malloc_default")
-#else
-#error Unsupported platform
-#endif
-
-namespace base {
-
-namespace {
-
-#pragma warning(push)
-#pragma warning(disable : 4702) // Unreachable code after the _exit.
-
-NOINLINE int OnNoMemory(size_t size) {
- // Kill the process. This is important for security since most of code
- // does not check the result of memory allocation.
- // https://msdn.microsoft.com/en-us/library/het71c37.aspx
- // Pass the size of the failed request in an exception argument.
- ULONG_PTR exception_args[] = {size};
- ::RaiseException(win::kOomExceptionCode, EXCEPTION_NONCONTINUABLE,
- arraysize(exception_args), exception_args);
-
- // Safety check, make sure process exits here.
- _exit(win::kOomExceptionCode);
- return 0;
-}
-
-#pragma warning(pop)
-
-} // namespace
-
-void TerminateBecauseOutOfMemory(size_t size) {
- OnNoMemory(size);
-}
-
-void EnableTerminationOnHeapCorruption() {
- // Ignore the result code. Supported on XP SP3 and Vista.
- HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
-}
-
-void EnableTerminationOnOutOfMemory() {
- _set_new_handler(&OnNoMemory);
- _set_new_mode(1);
-}
-
-// Implemented using a weak symbol.
-bool UncheckedMalloc(size_t size, void** result) {
- *result = malloc_unchecked(size);
- return *result != NULL;
-}
-
-} // namespace base
diff --git a/base/process/process.h b/base/process/process.h
deleted file mode 100644
index 857bd6d..0000000
--- a/base/process/process.h
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_PROCESS_PROCESS_H_
-#define BASE_PROCESS_PROCESS_H_
-
-#include "base/macros.h"
-#include "base/process/process_handle.h"
-#include "base/time/time.h"
-#include "build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/scoped_handle.h"
-#endif
-
-namespace base {
-
-// Provides a move-only encapsulation of a process.
-//
-// This object is not tied to the lifetime of the underlying process: the
-// process may be killed and this object may still around, and it will still
-// claim to be valid. The actual behavior in that case is OS dependent like so:
-//
-// Windows: The underlying ProcessHandle will be valid after the process dies
-// and can be used to gather some information about that process, but most
-// methods will obviously fail.
-//
-// POSIX: The underlying ProcessHandle is not guaranteed to remain valid after
-// the process dies, and it may be reused by the system, which means that it may
-// end up pointing to the wrong process.
-class Process {
- public:
- // On Windows, this takes ownership of |handle|. On POSIX, this does not take
- // ownership of |handle|.
- explicit Process(ProcessHandle handle = kNullProcessHandle);
-
- Process(Process&& other);
-
- // The destructor does not terminate the process.
- ~Process();
-
- Process& operator=(Process&& other);
-
- // Returns an object for the current process.
- static Process Current();
-
- // Returns a Process for the given |pid|.
- static Process Open(ProcessId pid);
-
- // Returns a Process for the given |pid|. On Windows the handle is opened
- // with more access rights and must only be used by trusted code (can read the
- // address space and duplicate handles).
- static Process OpenWithExtraPrivileges(ProcessId pid);
-
-#if defined(OS_WIN)
- // Returns a Process for the given |pid|, using some |desired_access|.
- // See ::OpenProcess documentation for valid |desired_access|.
- static Process OpenWithAccess(ProcessId pid, DWORD desired_access);
-#endif
-
- // Terminates the current process immediately with |exit_code|.
- [[noreturn]] static void TerminateCurrentProcessImmediately(int exit_code);
-
- // Returns true if this objects represents a valid process.
- bool IsValid() const;
-
- // Returns a handle for this process. There is no guarantee about when that
- // handle becomes invalid because this object retains ownership.
- ProcessHandle Handle() const;
-
- // Returns a second object that represents this process.
- Process Duplicate() const;
-
- // Get the PID for this process.
- ProcessId Pid() const;
-
- // Returns true if this process is the current process.
- bool is_current() const;
-
- // Close the process handle. This will not terminate the process.
- void Close();
-
-// Returns true if this process is still running. This is only safe on Windows
-// (and maybe Fuchsia?), because the ProcessHandle will keep the zombie
-// process information available until itself has been released. But on Posix,
-// the OS may reuse the ProcessId.
-#if defined(OS_WIN)
- bool IsRunning() const {
- return !WaitForExitWithTimeout(base::TimeDelta(), nullptr);
- }
-#endif
-
- // Terminates the process with extreme prejudice. The given |exit_code| will
- // be the exit code of the process. If |wait| is true, this method will wait
- // for up to one minute for the process to actually terminate.
- // Returns true if the process terminates within the allowed time.
- // NOTE: On POSIX |exit_code| is ignored.
- bool Terminate(int exit_code, bool wait) const;
-
- // Waits for the process to exit. Returns true on success.
- // On POSIX, if the process has been signaled then |exit_code| is set to -1.
- // On Linux this must be a child process, however on Mac and Windows it can be
- // any process.
- // NOTE: |exit_code| is optional, nullptr can be passed if the exit code is
- // not required.
- bool WaitForExit(int* exit_code) const;
-
- // Same as WaitForExit() but only waits for up to |timeout|.
- // NOTE: |exit_code| is optional, nullptr can be passed if the exit code
- // is not required.
- bool WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) const;
-
- // Indicates that the process has exited with the specified |exit_code|.
- // This should be called if process exit is observed outside of this class.
- // (i.e. Not because Terminate or WaitForExit, above, was called.)
- // Note that nothing prevents this being called multiple times for a dead
- // process though that should be avoided.
- void Exited(int exit_code) const;
-
- // Returns an integer representing the priority of a process. The meaning
- // of this value is OS dependent.
- int GetPriority() const;
-
- private:
-#if defined(OS_WIN)
- win::ScopedHandle process_;
-#else
- ProcessHandle process_;
-#endif
-
-#if defined(OS_WIN)
- bool is_current_process_;
-#endif
-
- DISALLOW_COPY_AND_ASSIGN(Process);
-};
-
-} // namespace base
-
-#endif // BASE_PROCESS_PROCESS_H_
diff --git a/base/process/process_handle.cc b/base/process/process_handle.cc
deleted file mode 100644
index fde631e..0000000
--- a/base/process/process_handle.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <stdint.h>
-
-#include "base/logging.h"
-#include "base/process/process_handle.h"
-#include "build_config.h"
-
-namespace base {
-
-namespace {
-bool g_have_unique_id = false;
-uint32_t g_unique_id;
-
-// The process which set |g_unique_id|.
-ProcessId g_procid;
-
-// Mangle IDs so that they are not accidentally used as PIDs, e.g. as an
-// argument to kill or waitpid.
-uint32_t MangleProcessId(ProcessId process_id) {
- // Add a large power of 10 so that the pid is still the pid is still readable
- // inside the mangled id.
- return static_cast<uint32_t>(process_id) + 1000000000U;
-}
-
-} // namespace
-
-uint32_t GetUniqueIdForProcess() {
- if (!g_have_unique_id) {
- return MangleProcessId(GetCurrentProcId());
- }
-
- // Make sure we are the same process that set |g_procid|. This check may have
- // false negatives (if a process ID was reused) but should have no false
- // positives.
- DCHECK_EQ(GetCurrentProcId(), g_procid);
- return g_unique_id;
-}
-
-#if defined(OS_LINUX) || defined(OS_AIX)
-
-void InitUniqueIdForProcessInPidNamespace(ProcessId pid_outside_of_namespace) {
- g_unique_id = MangleProcessId(pid_outside_of_namespace);
- g_procid = GetCurrentProcId();
- g_have_unique_id = true;
-}
-
-#endif
-
-} // namespace base
diff --git a/base/process/process_handle.h b/base/process/process_handle.h
deleted file mode 100644
index 0ec6bf4..0000000
--- a/base/process/process_handle.h
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_PROCESS_PROCESS_HANDLE_H_
-#define BASE_PROCESS_PROCESS_HANDLE_H_
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include "base/files/file_path.h"
-#include "build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/windows_types.h"
-#endif
-
-namespace base {
-
-// ProcessHandle is a platform specific type which represents the underlying OS
-// handle to a process.
-// ProcessId is a number which identifies the process in the OS.
-#if defined(OS_WIN)
-typedef HANDLE ProcessHandle;
-typedef DWORD ProcessId;
-typedef HANDLE UserTokenHandle;
-const ProcessHandle kNullProcessHandle = NULL;
-const ProcessId kNullProcessId = 0;
-#elif defined(OS_POSIX)
-// On POSIX, our ProcessHandle will just be the PID.
-typedef pid_t ProcessHandle;
-typedef pid_t ProcessId;
-const ProcessHandle kNullProcessHandle = 0;
-const ProcessId kNullProcessId = 0;
-#endif // defined(OS_WIN)
-
-// To print ProcessIds portably use CrPRIdPid (based on PRIuS and friends from
-// C99 and format_macros.h) like this:
-// base::StringPrintf("PID is %" CrPRIdPid ".\n", pid);
-#if defined(OS_WIN)
-#define CrPRIdPid "ld"
-#else
-#define CrPRIdPid "d"
-#endif
-
-// Returns the id of the current process.
-// Note that on some platforms, this is not guaranteed to be unique across
-// processes (use GetUniqueIdForProcess if uniqueness is required).
-ProcessId GetCurrentProcId();
-
-// Returns a unique ID for the current process. The ID will be unique across all
-// currently running processes within the chrome session, but IDs of terminated
-// processes may be reused. This returns an opaque value that is different from
-// a process's PID.
-uint32_t GetUniqueIdForProcess();
-
-#if defined(OS_LINUX)
-// When a process is started in a different PID namespace from the browser
-// process, this function must be called with the process's PID in the browser's
-// PID namespace in order to initialize its unique ID. Not thread safe.
-// WARNING: To avoid inconsistent results from GetUniqueIdForProcess, this
-// should only be called very early after process startup - ideally as soon
-// after process creation as possible.
-void InitUniqueIdForProcessInPidNamespace(ProcessId pid_outside_of_namespace);
-#endif
-
-// Returns the ProcessHandle of the current process.
-ProcessHandle GetCurrentProcessHandle();
-
-// Returns the process ID for the specified process. This is functionally the
-// same as Windows' GetProcessId(), but works on versions of Windows before Win
-// XP SP1 as well.
-// DEPRECATED. New code should be using Process::Pid() instead.
-// Note that on some platforms, this is not guaranteed to be unique across
-// processes.
-ProcessId GetProcId(ProcessHandle process);
-
-#if !defined(OS_FUCHSIA)
-// Returns the ID for the parent of the given process. Not available on Fuchsia.
-// Returning a negative value indicates an error, such as if the |process| does
-// not exist. Returns 0 when |process| has no parent process.
-ProcessId GetParentProcessId(ProcessHandle process);
-#endif // !defined(OS_FUCHSIA)
-
-#if defined(OS_POSIX)
-// Returns the path to the executable of the given process.
-FilePath GetProcessExecutablePath(ProcessHandle process);
-#endif
-
-} // namespace base
-
-#endif // BASE_PROCESS_PROCESS_HANDLE_H_
diff --git a/base/process/process_handle_freebsd.cc b/base/process/process_handle_freebsd.cc
deleted file mode 100644
index bbbf660..0000000
--- a/base/process/process_handle_freebsd.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/macros.h"
-#include "base/process/process_handle.h"
-
-#include <limits.h>
-#include <stddef.h>
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#include <sys/user.h>
-#include <unistd.h>
-
-namespace base {
-
-ProcessId GetParentProcessId(ProcessHandle process) {
- struct kinfo_proc info;
- size_t length;
- int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, process};
-
- if (sysctl(mib, arraysize(mib), &info, &length, NULL, 0) < 0)
- return -1;
-
- return info.ki_ppid;
-}
-
-FilePath GetProcessExecutablePath(ProcessHandle process) {
- char pathname[PATH_MAX];
- size_t length;
- int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, process};
-
- length = sizeof(pathname);
-
- if (sysctl(mib, arraysize(mib), pathname, &length, NULL, 0) < 0 ||
- length == 0) {
- return FilePath();
- }
-
- return FilePath(std::string(pathname));
-}
-
-} // namespace base
diff --git a/base/process/process_handle_linux.cc b/base/process/process_handle_linux.cc
deleted file mode 100644
index 43e9ce2..0000000
--- a/base/process/process_handle_linux.cc
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_handle.h"
-
-#include "base/files/file_util.h"
-#include "base/process/internal_linux.h"
-
-namespace base {
-
-ProcessId GetParentProcessId(ProcessHandle process) {
- ProcessId pid =
- internal::ReadProcStatsAndGetFieldAsInt64(process, internal::VM_PPID);
- // TODO(zijiehe): Returns 0 if |process| does not have a parent process.
- if (pid)
- return pid;
- return -1;
-}
-
-FilePath GetProcessExecutablePath(ProcessHandle process) {
- FilePath stat_file = internal::GetProcPidDir(process).Append("exe");
- FilePath exe_name;
- if (!ReadSymbolicLink(stat_file, &exe_name)) {
- // No such process. Happens frequently in e.g. TerminateAllChromeProcesses
- return FilePath();
- }
- return exe_name;
-}
-
-} // namespace base
diff --git a/base/process/process_handle_mac.cc b/base/process/process_handle_mac.cc
deleted file mode 100644
index 6b62406..0000000
--- a/base/process/process_handle_mac.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_handle.h"
-
-#include <libproc.h>
-#include <stddef.h>
-#include <sys/sysctl.h>
-#include <sys/types.h>
-
-#include "base/logging.h"
-
-namespace base {
-
-ProcessId GetParentProcessId(ProcessHandle process) {
- struct kinfo_proc info;
- size_t length = sizeof(struct kinfo_proc);
- int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, process};
- if (sysctl(mib, 4, &info, &length, NULL, 0) < 0) {
- DPLOG(ERROR) << "sysctl";
- return -1;
- }
- if (length == 0)
- return -1;
- return info.kp_eproc.e_ppid;
-}
-
-FilePath GetProcessExecutablePath(ProcessHandle process) {
- char pathbuf[PROC_PIDPATHINFO_MAXSIZE];
- if (!proc_pidpath(process, pathbuf, sizeof(pathbuf)))
- return FilePath();
-
- return FilePath(pathbuf);
-}
-
-} // namespace base
diff --git a/base/process/process_handle_openbsd.cc b/base/process/process_handle_openbsd.cc
deleted file mode 100644
index 0e85770..0000000
--- a/base/process/process_handle_openbsd.cc
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/macros.h"
-#include "base/process/process_handle.h"
-
-#include <stddef.h>
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-namespace base {
-
-ProcessId GetParentProcessId(ProcessHandle process) {
- struct kinfo_proc info;
- size_t length;
- int mib[] = {
- CTL_KERN, KERN_PROC, KERN_PROC_PID, process, sizeof(struct kinfo_proc),
- 0};
-
- if (sysctl(mib, arraysize(mib), NULL, &length, NULL, 0) < 0)
- return -1;
-
- mib[5] = (length / sizeof(struct kinfo_proc));
-
- if (sysctl(mib, arraysize(mib), &info, &length, NULL, 0) < 0)
- return -1;
-
- return info.p_ppid;
-}
-
-FilePath GetProcessExecutablePath(ProcessHandle process) {
- struct kinfo_proc kp;
- size_t len;
- int mib[] = {
- CTL_KERN, KERN_PROC, KERN_PROC_PID, process, sizeof(struct kinfo_proc),
- 0};
-
- if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) == -1)
- return FilePath();
- mib[5] = (len / sizeof(struct kinfo_proc));
- if (sysctl(mib, arraysize(mib), &kp, &len, NULL, 0) < 0)
- return FilePath();
- if ((kp.p_flag & P_SYSTEM) != 0)
- return FilePath();
- if (strcmp(kp.p_comm, "chrome") == 0)
- return FilePath(kp.p_comm);
-
- return FilePath();
-}
-
-} // namespace base
diff --git a/base/process/process_handle_posix.cc b/base/process/process_handle_posix.cc
deleted file mode 100644
index 4e332df..0000000
--- a/base/process/process_handle_posix.cc
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_handle.h"
-
-#include <unistd.h>
-
-namespace base {
-
-ProcessId GetCurrentProcId() {
- return getpid();
-}
-
-ProcessHandle GetCurrentProcessHandle() {
- return GetCurrentProcId();
-}
-
-ProcessId GetProcId(ProcessHandle process) {
- return process;
-}
-
-} // namespace base
diff --git a/base/process/process_handle_win.cc b/base/process/process_handle_win.cc
deleted file mode 100644
index cf7ab2c..0000000
--- a/base/process/process_handle_win.cc
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_handle.h"
-
-#include <windows.h>
-
-#include <tlhelp32.h>
-
-#include "base/win/scoped_handle.h"
-#include "base/win/windows_version.h"
-
-namespace base {
-
-ProcessId GetCurrentProcId() {
- return ::GetCurrentProcessId();
-}
-
-ProcessHandle GetCurrentProcessHandle() {
- return ::GetCurrentProcess();
-}
-
-ProcessId GetProcId(ProcessHandle process) {
- // This returns 0 if we have insufficient rights to query the process handle.
- return GetProcessId(process);
-}
-
-ProcessId GetParentProcessId(ProcessHandle process) {
- ProcessId child_pid = GetProcId(process);
- PROCESSENTRY32 process_entry;
- process_entry.dwSize = sizeof(PROCESSENTRY32);
-
- win::ScopedHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0));
- if (snapshot.IsValid() && Process32First(snapshot.Get(), &process_entry)) {
- do {
- if (process_entry.th32ProcessID == child_pid)
- return process_entry.th32ParentProcessID;
- } while (Process32Next(snapshot.Get(), &process_entry));
- }
-
- // TODO(zijiehe): To match other platforms, -1 (UINT32_MAX) should be returned
- // if |child_id| cannot be found in the |snapshot|.
- return 0u;
-}
-
-} // namespace base
diff --git a/base/process/process_info.h b/base/process/process_info.h
deleted file mode 100644
index 291ad9d..0000000
--- a/base/process/process_info.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_PROCESS_PROCESS_INFO_H_
-#define BASE_PROCESS_PROCESS_INFO_H_
-
-#include "build_config.h"
-
-namespace base {
-
-class Time;
-
-// Vends information about the current process.
-class CurrentProcessInfo {
- public:
- // Returns the time at which the process was launched. May be empty if an
- // error occurred retrieving the information.
- static const Time CreationTime();
-};
-
-#if defined(OS_WIN)
-enum IntegrityLevel {
- INTEGRITY_UNKNOWN,
- LOW_INTEGRITY,
- MEDIUM_INTEGRITY,
- HIGH_INTEGRITY,
-};
-
-// Returns the integrity level of the process. Returns INTEGRITY_UNKNOWN in the
-// case of an underlying system failure.
-IntegrityLevel GetCurrentProcessIntegrityLevel();
-
-// Determines whether the current process is elevated.
-bool IsCurrentProcessElevated();
-
-#endif // defined(OS_WIN)
-
-} // namespace base
-
-#endif // BASE_PROCESS_PROCESS_INFO_H_
diff --git a/base/process/process_info_linux.cc b/base/process/process_info_linux.cc
deleted file mode 100644
index 2f22748..0000000
--- a/base/process/process_info_linux.cc
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_info.h"
-
-#include <stdint.h>
-
-#include "base/logging.h"
-#include "base/process/internal_linux.h"
-#include "base/process/process_handle.h"
-#include "base/time/time.h"
-
-namespace base {
-
-// static
-const Time CurrentProcessInfo::CreationTime() {
- int64_t start_ticks =
- internal::ReadProcSelfStatsAndGetFieldAsInt64(internal::VM_STARTTIME);
- if (!start_ticks)
- return Time();
- TimeDelta start_offset = internal::ClockTicksToTimeDelta(start_ticks);
- Time boot_time = internal::GetBootTime();
- if (boot_time.is_null())
- return Time();
- return Time(boot_time + start_offset);
-}
-
-} // namespace base
diff --git a/base/process/process_info_mac.cc b/base/process/process_info_mac.cc
deleted file mode 100644
index 3083e53..0000000
--- a/base/process/process_info_mac.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_info.h"
-
-#include <stddef.h>
-#include <sys/sysctl.h>
-#include <sys/time.h>
-#include <unistd.h>
-
-#include <memory>
-
-#include "base/macros.h"
-#include "base/memory/free_deleter.h"
-#include "base/time/time.h"
-
-namespace base {
-
-// static
-const Time CurrentProcessInfo::CreationTime() {
- int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()};
- size_t len = 0;
- if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) < 0)
- return Time();
-
- std::unique_ptr<struct kinfo_proc, base::FreeDeleter> proc(
- static_cast<struct kinfo_proc*>(malloc(len)));
- if (sysctl(mib, arraysize(mib), proc.get(), &len, NULL, 0) < 0)
- return Time();
- return Time::FromTimeVal(proc->kp_proc.p_un.__p_starttime);
-}
-
-} // namespace base
diff --git a/base/process/process_info_win.cc b/base/process/process_info_win.cc
deleted file mode 100644
index 23e93e3..0000000
--- a/base/process/process_info_win.cc
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_info.h"
-
-#include <windows.h>
-#include <memory>
-
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/time/time.h"
-#include "base/win/scoped_handle.h"
-
-namespace base {
-
-namespace {
-
-HANDLE GetCurrentProcessToken() {
- HANDLE process_token;
- OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &process_token);
- DCHECK(process_token != NULL && process_token != INVALID_HANDLE_VALUE);
- return process_token;
-}
-
-} // namespace
-
-// static
-const Time CurrentProcessInfo::CreationTime() {
- FILETIME creation_time = {};
- FILETIME ignore1 = {};
- FILETIME ignore2 = {};
- FILETIME ignore3 = {};
- if (!::GetProcessTimes(::GetCurrentProcess(), &creation_time, &ignore1,
- &ignore2, &ignore3)) {
- return Time();
- }
- return Time::FromFileTime(creation_time);
-}
-
-IntegrityLevel GetCurrentProcessIntegrityLevel() {
- HANDLE process_token(GetCurrentProcessToken());
-
- DWORD token_info_length = 0;
- if (::GetTokenInformation(process_token, TokenIntegrityLevel, nullptr, 0,
- &token_info_length) ||
- ::GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
- return INTEGRITY_UNKNOWN;
- }
-
- auto token_label_bytes = std::make_unique<char[]>(token_info_length);
- TOKEN_MANDATORY_LABEL* token_label =
- reinterpret_cast<TOKEN_MANDATORY_LABEL*>(token_label_bytes.get());
- if (!::GetTokenInformation(process_token, TokenIntegrityLevel, token_label,
- token_info_length, &token_info_length)) {
- return INTEGRITY_UNKNOWN;
- }
-
- DWORD integrity_level = *::GetSidSubAuthority(
- token_label->Label.Sid,
- static_cast<DWORD>(*::GetSidSubAuthorityCount(token_label->Label.Sid) -
- 1));
-
- if (integrity_level < SECURITY_MANDATORY_MEDIUM_RID)
- return LOW_INTEGRITY;
-
- if (integrity_level >= SECURITY_MANDATORY_MEDIUM_RID &&
- integrity_level < SECURITY_MANDATORY_HIGH_RID) {
- return MEDIUM_INTEGRITY;
- }
-
- if (integrity_level >= SECURITY_MANDATORY_HIGH_RID)
- return HIGH_INTEGRITY;
-
- NOTREACHED();
- return INTEGRITY_UNKNOWN;
-}
-
-bool IsCurrentProcessElevated() {
- HANDLE process_token(GetCurrentProcessToken());
-
- // Unlike TOKEN_ELEVATION_TYPE which returns TokenElevationTypeDefault when
- // UAC is turned off, TOKEN_ELEVATION returns whether the process is elevated.
- DWORD size;
- TOKEN_ELEVATION elevation;
- if (!GetTokenInformation(process_token, TokenElevation, &elevation,
- sizeof(elevation), &size)) {
- PLOG(ERROR) << "GetTokenInformation() failed";
- return false;
- }
- return !!elevation.TokenIsElevated;
-}
-
-} // namespace base
diff --git a/base/process/process_iterator.cc b/base/process/process_iterator.cc
deleted file mode 100644
index e56b349..0000000
--- a/base/process/process_iterator.cc
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_iterator.h"
-#include "build_config.h"
-
-namespace base {
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-ProcessEntry::ProcessEntry() : pid_(0), ppid_(0), gid_(0) {}
-ProcessEntry::ProcessEntry(const ProcessEntry& other) = default;
-ProcessEntry::~ProcessEntry() = default;
-#endif
-
-const ProcessEntry* ProcessIterator::NextProcessEntry() {
- bool result = false;
- do {
- result = CheckForNextProcess();
- } while (result && !IncludeEntry());
- if (result)
- return &entry_;
- return nullptr;
-}
-
-ProcessIterator::ProcessEntries ProcessIterator::Snapshot() {
- ProcessEntries found;
- while (const ProcessEntry* process_entry = NextProcessEntry()) {
- found.push_back(*process_entry);
- }
- return found;
-}
-
-bool ProcessIterator::IncludeEntry() {
- return !filter_ || filter_->Includes(entry_);
-}
-
-NamedProcessIterator::NamedProcessIterator(
- const FilePath::StringType& executable_name,
- const ProcessFilter* filter)
- : ProcessIterator(filter), executable_name_(executable_name) {}
-
-NamedProcessIterator::~NamedProcessIterator() = default;
-
-int GetProcessCount(const FilePath::StringType& executable_name,
- const ProcessFilter* filter) {
- int count = 0;
- NamedProcessIterator iter(executable_name, filter);
- while (iter.NextProcessEntry())
- ++count;
- return count;
-}
-
-} // namespace base
diff --git a/base/process/process_iterator.h b/base/process/process_iterator.h
deleted file mode 100644
index b0d96e4..0000000
--- a/base/process/process_iterator.h
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file contains methods to iterate over processes on the system.
-
-#ifndef BASE_PROCESS_PROCESS_ITERATOR_H_
-#define BASE_PROCESS_PROCESS_ITERATOR_H_
-
-#include <stddef.h>
-
-#include <list>
-#include <string>
-#include <vector>
-
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/process/process.h"
-#include "build_config.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-
-#include <tlhelp32.h>
-#elif defined(OS_MACOSX) || defined(OS_OPENBSD)
-#include <sys/sysctl.h>
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <dirent.h>
-#endif
-
-namespace base {
-
-#if defined(OS_WIN)
-struct ProcessEntry : public PROCESSENTRY32 {
- ProcessId pid() const { return th32ProcessID; }
- ProcessId parent_pid() const { return th32ParentProcessID; }
- const wchar_t* exe_file() const { return szExeFile; }
-};
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-struct ProcessEntry {
- ProcessEntry();
- ProcessEntry(const ProcessEntry& other);
- ~ProcessEntry();
-
- ProcessId pid() const { return pid_; }
- ProcessId parent_pid() const { return ppid_; }
- ProcessId gid() const { return gid_; }
- const char* exe_file() const { return exe_file_.c_str(); }
- const std::vector<std::string>& cmd_line_args() const {
- return cmd_line_args_;
- }
-
- ProcessId pid_;
- ProcessId ppid_;
- ProcessId gid_;
- std::string exe_file_;
- std::vector<std::string> cmd_line_args_;
-};
-#endif // defined(OS_WIN)
-
-// Used to filter processes by process ID.
-class ProcessFilter {
- public:
- // Returns true to indicate set-inclusion and false otherwise. This method
- // should not have side-effects and should be idempotent.
- virtual bool Includes(const ProcessEntry& entry) const = 0;
-
- protected:
- virtual ~ProcessFilter() = default;
-};
-
-// This class provides a way to iterate through a list of processes on the
-// current machine with a specified filter.
-// To use, create an instance and then call NextProcessEntry() until it returns
-// false.
-class ProcessIterator {
- public:
- typedef std::list<ProcessEntry> ProcessEntries;
-
- explicit ProcessIterator(const ProcessFilter* filter);
- virtual ~ProcessIterator();
-
- // If there's another process that matches the given executable name,
- // returns a const pointer to the corresponding PROCESSENTRY32.
- // If there are no more matching processes, returns NULL.
- // The returned pointer will remain valid until NextProcessEntry()
- // is called again or this NamedProcessIterator goes out of scope.
- const ProcessEntry* NextProcessEntry();
-
- // Takes a snapshot of all the ProcessEntry found.
- ProcessEntries Snapshot();
-
- protected:
- virtual bool IncludeEntry();
- const ProcessEntry& entry() { return entry_; }
-
- private:
- // Determines whether there's another process (regardless of executable)
- // left in the list of all processes. Returns true and sets entry_ to
- // that process's info if there is one, false otherwise.
- bool CheckForNextProcess();
-
- // Initializes a PROCESSENTRY32 data structure so that it's ready for
- // use with Process32First/Process32Next.
- void InitProcessEntry(ProcessEntry* entry);
-
-#if defined(OS_WIN)
- HANDLE snapshot_;
- bool started_iteration_;
-#elif defined(OS_MACOSX) || defined(OS_BSD)
- std::vector<kinfo_proc> kinfo_procs_;
- size_t index_of_kinfo_proc_;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- DIR* procfs_dir_;
-#endif
- ProcessEntry entry_;
- const ProcessFilter* filter_;
-
- DISALLOW_COPY_AND_ASSIGN(ProcessIterator);
-};
-
-// This class provides a way to iterate through the list of processes
-// on the current machine that were started from the given executable
-// name. To use, create an instance and then call NextProcessEntry()
-// until it returns false.
-class NamedProcessIterator : public ProcessIterator {
- public:
- NamedProcessIterator(const FilePath::StringType& executable_name,
- const ProcessFilter* filter);
- ~NamedProcessIterator() override;
-
- protected:
- bool IncludeEntry() override;
-
- private:
- FilePath::StringType executable_name_;
-
- DISALLOW_COPY_AND_ASSIGN(NamedProcessIterator);
-};
-
-// Returns the number of processes on the machine that are running from the
-// given executable name. If filter is non-null, then only processes selected
-// by the filter will be counted.
-int GetProcessCount(const FilePath::StringType& executable_name,
- const ProcessFilter* filter);
-
-} // namespace base
-
-#endif // BASE_PROCESS_PROCESS_ITERATOR_H_
diff --git a/base/process/process_iterator_freebsd.cc b/base/process/process_iterator_freebsd.cc
deleted file mode 100644
index a69b2f0..0000000
--- a/base/process/process_iterator_freebsd.cc
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_iterator.h"
-
-#include <errno.h>
-#include <stddef.h>
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-
-ProcessIterator::ProcessIterator(const ProcessFilter* filter)
- : index_of_kinfo_proc_(), filter_(filter) {
- int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid()};
-
- bool done = false;
- int try_num = 1;
- const int max_tries = 10;
-
- do {
- size_t len = 0;
- if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) < 0) {
- LOG(ERROR) << "failed to get the size needed for the process list";
- kinfo_procs_.resize(0);
- done = true;
- } else {
- size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
- // Leave some spare room for process table growth (more could show up
- // between when we check and now)
- num_of_kinfo_proc += 16;
- kinfo_procs_.resize(num_of_kinfo_proc);
- len = num_of_kinfo_proc * sizeof(struct kinfo_proc);
- if (sysctl(mib, arraysize(mib), &kinfo_procs_[0], &len, NULL, 0) < 0) {
- // If we get a mem error, it just means we need a bigger buffer, so
- // loop around again. Anything else is a real error and give up.
- if (errno != ENOMEM) {
- LOG(ERROR) << "failed to get the process list";
- kinfo_procs_.resize(0);
- done = true;
- }
- } else {
- // Got the list, just make sure we're sized exactly right
- size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
- kinfo_procs_.resize(num_of_kinfo_proc);
- done = true;
- }
- }
- } while (!done && (try_num++ < max_tries));
-
- if (!done) {
- LOG(ERROR) << "failed to collect the process list in a few tries";
- kinfo_procs_.resize(0);
- }
-}
-
-ProcessIterator::~ProcessIterator() {}
-
-bool ProcessIterator::CheckForNextProcess() {
- std::string data;
-
- for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
- size_t length;
- struct kinfo_proc kinfo = kinfo_procs_[index_of_kinfo_proc_];
- int mib[] = {CTL_KERN, KERN_PROC_ARGS, kinfo.ki_pid};
-
- if ((kinfo.ki_pid > 0) && (kinfo.ki_stat == SZOMB))
- continue;
-
- length = 0;
- if (sysctl(mib, arraysize(mib), NULL, &length, NULL, 0) < 0) {
- LOG(ERROR) << "failed to figure out the buffer size for a command line";
- continue;
- }
-
- data.resize(length);
-
- if (sysctl(mib, arraysize(mib), &data[0], &length, NULL, 0) < 0) {
- LOG(ERROR) << "failed to fetch a commandline";
- continue;
- }
-
- std::string delimiters;
- delimiters.push_back('\0');
- entry_.cmd_line_args_ =
- SplitString(data, delimiters, KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
-
- size_t exec_name_end = data.find('\0');
- if (exec_name_end == std::string::npos) {
- LOG(ERROR) << "command line data didn't match expected format";
- continue;
- }
-
- entry_.pid_ = kinfo.ki_pid;
- entry_.ppid_ = kinfo.ki_ppid;
- entry_.gid_ = kinfo.ki_pgid;
-
- size_t last_slash = data.rfind('/', exec_name_end);
- if (last_slash == std::string::npos) {
- entry_.exe_file_.assign(data, 0, exec_name_end);
- } else {
- entry_.exe_file_.assign(data, last_slash + 1,
- exec_name_end - last_slash - 1);
- }
-
- // Start w/ the next entry next time through
- ++index_of_kinfo_proc_;
-
- return true;
- }
- return false;
-}
-
-bool NamedProcessIterator::IncludeEntry() {
- if (executable_name_ != entry().exe_file())
- return false;
-
- return ProcessIterator::IncludeEntry();
-}
-
-} // namespace base
diff --git a/base/process/process_iterator_linux.cc b/base/process/process_iterator_linux.cc
deleted file mode 100644
index 9894052..0000000
--- a/base/process/process_iterator_linux.cc
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_iterator.h"
-
-#include <stddef.h>
-
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/process/internal_linux.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-
-namespace {
-
-// Reads the |field_num|th field from |proc_stats|.
-// Returns an empty string on failure.
-// This version only handles VM_COMM and VM_STATE, which are the only fields
-// that are strings.
-std::string GetProcStatsFieldAsString(
- const std::vector<std::string>& proc_stats,
- internal::ProcStatsFields field_num) {
- if (field_num < internal::VM_COMM || field_num > internal::VM_STATE) {
- NOTREACHED();
- return std::string();
- }
-
- if (proc_stats.size() > static_cast<size_t>(field_num))
- return proc_stats[field_num];
-
- NOTREACHED();
- return nullptr;
-}
-
-// Reads /proc/<pid>/cmdline and populates |proc_cmd_line_args| with the command
-// line arguments. Returns true if successful.
-// Note: /proc/<pid>/cmdline contains command line arguments separated by single
-// null characters. We tokenize it into a vector of strings using '\0' as a
-// delimiter.
-bool GetProcCmdline(pid_t pid, std::vector<std::string>* proc_cmd_line_args) {
- FilePath cmd_line_file = internal::GetProcPidDir(pid).Append("cmdline");
- std::string cmd_line;
- if (!ReadFileToString(cmd_line_file, &cmd_line))
- return false;
- std::string delimiters;
- delimiters.push_back('\0');
- *proc_cmd_line_args =
- SplitString(cmd_line, delimiters, KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
- return true;
-}
-
-} // namespace
-
-ProcessIterator::ProcessIterator(const ProcessFilter* filter)
- : filter_(filter) {
- procfs_dir_ = opendir(internal::kProcDir);
- if (!procfs_dir_) {
- // On Android, SELinux may prevent reading /proc. See
- // https://crbug.com/581517 for details.
- PLOG(ERROR) << "opendir " << internal::kProcDir;
- }
-}
-
-ProcessIterator::~ProcessIterator() {
- if (procfs_dir_) {
- closedir(procfs_dir_);
- procfs_dir_ = nullptr;
- }
-}
-
-bool ProcessIterator::CheckForNextProcess() {
- // TODO(port): skip processes owned by different UID
-
- if (!procfs_dir_) {
- DLOG(ERROR) << "Skipping CheckForNextProcess(), no procfs_dir_";
- return false;
- }
-
- pid_t pid = kNullProcessId;
- std::vector<std::string> cmd_line_args;
- std::string stats_data;
- std::vector<std::string> proc_stats;
-
- // Arbitrarily guess that there will never be more than 200 non-process
- // files in /proc. Hardy has 53 and Lucid has 61.
- int skipped = 0;
- const int kSkipLimit = 200;
- while (skipped < kSkipLimit) {
- dirent* slot = readdir(procfs_dir_);
- // all done looking through /proc?
- if (!slot)
- return false;
-
- // If not a process, keep looking for one.
- pid = internal::ProcDirSlotToPid(slot->d_name);
- if (!pid) {
- skipped++;
- continue;
- }
-
- if (!GetProcCmdline(pid, &cmd_line_args))
- continue;
-
- if (!internal::ReadProcStats(pid, &stats_data))
- continue;
- if (!internal::ParseProcStats(stats_data, &proc_stats))
- continue;
-
- std::string runstate =
- GetProcStatsFieldAsString(proc_stats, internal::VM_STATE);
- if (runstate.size() != 1) {
- NOTREACHED();
- continue;
- }
-
- // Is the process in 'Zombie' state, i.e. dead but waiting to be reaped?
- // Allowed values: D R S T Z
- if (runstate[0] != 'Z')
- break;
-
- // Nope, it's a zombie; somebody isn't cleaning up after their children.
- // (e.g. WaitForProcessesToExit doesn't clean up after dead children yet.)
- // There could be a lot of zombies, can't really decrement i here.
- }
- if (skipped >= kSkipLimit) {
- NOTREACHED();
- return false;
- }
-
- entry_.pid_ = pid;
- entry_.ppid_ = GetProcStatsFieldAsInt64(proc_stats, internal::VM_PPID);
- entry_.gid_ = GetProcStatsFieldAsInt64(proc_stats, internal::VM_PGRP);
- entry_.cmd_line_args_.assign(cmd_line_args.begin(), cmd_line_args.end());
- entry_.exe_file_ = GetProcessExecutablePath(pid).BaseName().value();
- return true;
-}
-
-bool NamedProcessIterator::IncludeEntry() {
- if (executable_name_ != entry().exe_file())
- return false;
- return ProcessIterator::IncludeEntry();
-}
-
-} // namespace base
diff --git a/base/process/process_iterator_mac.cc b/base/process/process_iterator_mac.cc
deleted file mode 100644
index 10d712b..0000000
--- a/base/process/process_iterator_mac.cc
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_iterator.h"
-
-#include <errno.h>
-#include <stddef.h>
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-
-ProcessIterator::ProcessIterator(const ProcessFilter* filter)
- : index_of_kinfo_proc_(0), filter_(filter) {
- // Get a snapshot of all of my processes (yes, as we loop it can go stale, but
- // but trying to find where we were in a constantly changing list is basically
- // impossible.
-
- int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_UID, static_cast<int>(geteuid())};
-
- // Since more processes could start between when we get the size and when
- // we get the list, we do a loop to keep trying until we get it.
- bool done = false;
- int try_num = 1;
- const int max_tries = 10;
- do {
- // Get the size of the buffer
- size_t len = 0;
- if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) < 0) {
- DLOG(ERROR) << "failed to get the size needed for the process list";
- kinfo_procs_.resize(0);
- done = true;
- } else {
- size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
- // Leave some spare room for process table growth (more could show up
- // between when we check and now)
- num_of_kinfo_proc += 16;
- kinfo_procs_.resize(num_of_kinfo_proc);
- len = num_of_kinfo_proc * sizeof(struct kinfo_proc);
- // Load the list of processes
- if (sysctl(mib, arraysize(mib), &kinfo_procs_[0], &len, NULL, 0) < 0) {
- // If we get a mem error, it just means we need a bigger buffer, so
- // loop around again. Anything else is a real error and give up.
- if (errno != ENOMEM) {
- DLOG(ERROR) << "failed to get the process list";
- kinfo_procs_.resize(0);
- done = true;
- }
- } else {
- // Got the list, just make sure we're sized exactly right
- kinfo_procs_.resize(len / sizeof(struct kinfo_proc));
- done = true;
- }
- }
- } while (!done && (try_num++ < max_tries));
-
- if (!done) {
- DLOG(ERROR) << "failed to collect the process list in a few tries";
- kinfo_procs_.resize(0);
- }
-}
-
-ProcessIterator::~ProcessIterator() {}
-
-bool ProcessIterator::CheckForNextProcess() {
- std::string data;
- for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
- kinfo_proc& kinfo = kinfo_procs_[index_of_kinfo_proc_];
-
- // Skip processes just awaiting collection
- if ((kinfo.kp_proc.p_pid > 0) && (kinfo.kp_proc.p_stat == SZOMB))
- continue;
-
- int mib[] = {CTL_KERN, KERN_PROCARGS, kinfo.kp_proc.p_pid};
-
- // Find out what size buffer we need.
- size_t data_len = 0;
- if (sysctl(mib, arraysize(mib), NULL, &data_len, NULL, 0) < 0) {
- continue;
- }
-
- data.resize(data_len);
- if (sysctl(mib, arraysize(mib), &data[0], &data_len, NULL, 0) < 0) {
- continue;
- }
-
- // |data| contains all the command line parameters of the process, separated
- // by blocks of one or more null characters. We tokenize |data| into a
- // vector of strings using '\0' as a delimiter and populate
- // |entry_.cmd_line_args_|.
- std::string delimiters;
- delimiters.push_back('\0');
- entry_.cmd_line_args_ =
- SplitString(data, delimiters, KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
-
- // |data| starts with the full executable path followed by a null character.
- // We search for the first instance of '\0' and extract everything before it
- // to populate |entry_.exe_file_|.
- size_t exec_name_end = data.find('\0');
- if (exec_name_end == std::string::npos) {
- DLOG(ERROR) << "command line data didn't match expected format";
- continue;
- }
-
- entry_.pid_ = kinfo.kp_proc.p_pid;
- entry_.ppid_ = kinfo.kp_eproc.e_ppid;
- entry_.gid_ = kinfo.kp_eproc.e_pgid;
- size_t last_slash = data.rfind('/', exec_name_end);
- if (last_slash == std::string::npos)
- entry_.exe_file_.assign(data, 0, exec_name_end);
- else
- entry_.exe_file_.assign(data, last_slash + 1,
- exec_name_end - last_slash - 1);
- // Start w/ the next entry next time through
- ++index_of_kinfo_proc_;
- // Done
- return true;
- }
- return false;
-}
-
-bool NamedProcessIterator::IncludeEntry() {
- return (executable_name_ == entry().exe_file() &&
- ProcessIterator::IncludeEntry());
-}
-
-} // namespace base
diff --git a/base/process/process_iterator_openbsd.cc b/base/process/process_iterator_openbsd.cc
deleted file mode 100644
index 4362c9a..0000000
--- a/base/process/process_iterator_openbsd.cc
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_iterator.h"
-
-#include <errno.h>
-#include <stddef.h>
-#include <sys/sysctl.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-
-ProcessIterator::ProcessIterator(const ProcessFilter* filter)
- : index_of_kinfo_proc_(), filter_(filter) {
- int mib[] = {
- CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid(), sizeof(struct kinfo_proc),
- 0};
-
- bool done = false;
- int try_num = 1;
- const int max_tries = 10;
-
- do {
- size_t len = 0;
- if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) < 0) {
- DLOG(ERROR) << "failed to get the size needed for the process list";
- kinfo_procs_.resize(0);
- done = true;
- } else {
- size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
- // Leave some spare room for process table growth (more could show up
- // between when we check and now)
- num_of_kinfo_proc += 16;
- kinfo_procs_.resize(num_of_kinfo_proc);
- len = num_of_kinfo_proc * sizeof(struct kinfo_proc);
- if (sysctl(mib, arraysize(mib), &kinfo_procs_[0], &len, NULL, 0) < 0) {
- // If we get a mem error, it just means we need a bigger buffer, so
- // loop around again. Anything else is a real error and give up.
- if (errno != ENOMEM) {
- DLOG(ERROR) << "failed to get the process list";
- kinfo_procs_.resize(0);
- done = true;
- }
- } else {
- // Got the list, just make sure we're sized exactly right
- size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
- kinfo_procs_.resize(num_of_kinfo_proc);
- done = true;
- }
- }
- } while (!done && (try_num++ < max_tries));
-
- if (!done) {
- DLOG(ERROR) << "failed to collect the process list in a few tries";
- kinfo_procs_.resize(0);
- }
-}
-
-ProcessIterator::~ProcessIterator() {}
-
-bool ProcessIterator::CheckForNextProcess() {
- std::string data;
- for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
- kinfo_proc& kinfo = kinfo_procs_[index_of_kinfo_proc_];
-
- // Skip processes just awaiting collection
- if ((kinfo.p_pid > 0) && (kinfo.p_stat == SZOMB))
- continue;
-
- int mib[] = {CTL_KERN, KERN_PROC_ARGS, kinfo.p_pid};
-
- // Find out what size buffer we need.
- size_t data_len = 0;
- if (sysctl(mib, arraysize(mib), NULL, &data_len, NULL, 0) < 0) {
- continue;
- }
-
- data.resize(data_len);
- if (sysctl(mib, arraysize(mib), &data[0], &data_len, NULL, 0) < 0) {
- continue;
- }
-
- // |data| contains all the command line parameters of the process, separated
- // by blocks of one or more null characters. We tokenize |data| into a
- // vector of strings using '\0' as a delimiter and populate
- // |entry_.cmd_line_args_|.
- std::string delimiters;
- delimiters.push_back('\0');
- entry_.cmd_line_args_ =
- SplitString(data, delimiters, KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
-
- // |data| starts with the full executable path followed by a null character.
- // We search for the first instance of '\0' and extract everything before it
- // to populate |entry_.exe_file_|.
- size_t exec_name_end = data.find('\0');
- if (exec_name_end == std::string::npos) {
- DLOG(ERROR) << "command line data didn't match expected format";
- continue;
- }
-
- entry_.pid_ = kinfo.p_pid;
- entry_.ppid_ = kinfo.p_ppid;
- entry_.gid_ = kinfo.p__pgid;
- size_t last_slash = data.rfind('/', exec_name_end);
- if (last_slash == std::string::npos)
- entry_.exe_file_.assign(data, 0, exec_name_end);
- else
- entry_.exe_file_.assign(data, last_slash + 1,
- exec_name_end - last_slash - 1);
- // Start w/ the next entry next time through
- ++index_of_kinfo_proc_;
- // Done
- return true;
- }
- return false;
-}
-
-bool NamedProcessIterator::IncludeEntry() {
- return (executable_name_ == entry().exe_file() &&
- ProcessIterator::IncludeEntry());
-}
-
-} // namespace base
diff --git a/base/process/process_iterator_win.cc b/base/process/process_iterator_win.cc
deleted file mode 100644
index e1bf808..0000000
--- a/base/process/process_iterator_win.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process_iterator.h"
-
-namespace base {
-
-ProcessIterator::ProcessIterator(const ProcessFilter* filter)
- : started_iteration_(false), filter_(filter) {
- snapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-}
-
-ProcessIterator::~ProcessIterator() {
- CloseHandle(snapshot_);
-}
-
-bool ProcessIterator::CheckForNextProcess() {
- InitProcessEntry(&entry_);
-
- if (!started_iteration_) {
- started_iteration_ = true;
- return !!Process32First(snapshot_, &entry_);
- }
-
- return !!Process32Next(snapshot_, &entry_);
-}
-
-void ProcessIterator::InitProcessEntry(ProcessEntry* entry) {
- memset(entry, 0, sizeof(*entry));
- entry->dwSize = sizeof(*entry);
-}
-
-bool NamedProcessIterator::IncludeEntry() {
- // Case insensitive.
- return _wcsicmp(executable_name_.c_str(), entry().exe_file()) == 0 &&
- ProcessIterator::IncludeEntry();
-}
-
-} // namespace base
diff --git a/base/process/process_posix.cc b/base/process/process_posix.cc
deleted file mode 100644
index 5c9ce05..0000000
--- a/base/process/process_posix.cc
+++ /dev/null
@@ -1,338 +0,0 @@
-// Copyright 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process.h"
-
-#include <errno.h>
-#include <signal.h>
-#include <stdint.h>
-#include <sys/resource.h>
-#include <sys/wait.h>
-
-#include "base/files/scoped_file.h"
-#include "base/logging.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/process/kill.h"
-#include "build_config.h"
-
-#if defined(OS_MACOSX)
-#include <sys/event.h>
-#endif
-
-namespace {
-
-#if !defined(OS_NACL_NONSFI)
-
-bool WaitpidWithTimeout(base::ProcessHandle handle,
- int* status,
- base::TimeDelta wait) {
- // This POSIX version of this function only guarantees that we wait no less
- // than |wait| for the process to exit. The child process may
- // exit sometime before the timeout has ended but we may still block for up
- // to 256 milliseconds after the fact.
- //
- // waitpid() has no direct support on POSIX for specifying a timeout, you can
- // either ask it to block indefinitely or return immediately (WNOHANG).
- // When a child process terminates a SIGCHLD signal is sent to the parent.
- // Catching this signal would involve installing a signal handler which may
- // affect other parts of the application and would be difficult to debug.
- //
- // Our strategy is to call waitpid() once up front to check if the process
- // has already exited, otherwise to loop for |wait|, sleeping for
- // at most 256 milliseconds each time using usleep() and then calling
- // waitpid(). The amount of time we sleep starts out at 1 milliseconds, and
- // we double it every 4 sleep cycles.
- //
- // usleep() is speced to exit if a signal is received for which a handler
- // has been installed. This means that when a SIGCHLD is sent, it will exit
- // depending on behavior external to this function.
- //
- // This function is used primarily for unit tests, if we want to use it in
- // the application itself it would probably be best to examine other routes.
-
- if (wait == base::TimeDelta::Max()) {
- return HANDLE_EINTR(waitpid(handle, status, 0)) > 0;
- }
-
- pid_t ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
- static const int64_t kMaxSleepInMicroseconds = 1 << 18; // ~256 milliseconds.
- int64_t max_sleep_time_usecs = 1 << 10; // ~1 milliseconds.
- int64_t double_sleep_time = 0;
-
- // If the process hasn't exited yet, then sleep and try again.
- base::TimeTicks wakeup_time = base::TimeTicks::Now() + wait;
- while (ret_pid == 0) {
- base::TimeTicks now = base::TimeTicks::Now();
- if (now > wakeup_time)
- break;
- // Guaranteed to be non-negative!
- int64_t sleep_time_usecs = (wakeup_time - now).InMicroseconds();
- // Sleep for a bit while we wait for the process to finish.
- if (sleep_time_usecs > max_sleep_time_usecs)
- sleep_time_usecs = max_sleep_time_usecs;
-
- // usleep() will return 0 and set errno to EINTR on receipt of a signal
- // such as SIGCHLD.
- usleep(sleep_time_usecs);
- ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
-
- if ((max_sleep_time_usecs < kMaxSleepInMicroseconds) &&
- (double_sleep_time++ % 4 == 0)) {
- max_sleep_time_usecs *= 2;
- }
- }
-
- return ret_pid > 0;
-}
-
-#if defined(OS_MACOSX)
-// Using kqueue on Mac so that we can wait on non-child processes.
-// We can't use kqueues on child processes because we need to reap
-// our own children using wait.
-bool WaitForSingleNonChildProcess(base::ProcessHandle handle,
- base::TimeDelta wait) {
- DCHECK_GT(handle, 0);
-
- base::ScopedFD kq(kqueue());
- if (!kq.is_valid()) {
- DPLOG(ERROR) << "kqueue";
- return false;
- }
-
- struct kevent change = {0};
- EV_SET(&change, handle, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
- int result = HANDLE_EINTR(kevent(kq.get(), &change, 1, NULL, 0, NULL));
- if (result == -1) {
- if (errno == ESRCH) {
- // If the process wasn't found, it must be dead.
- return true;
- }
-
- DPLOG(ERROR) << "kevent (setup " << handle << ")";
- return false;
- }
-
- // Keep track of the elapsed time to be able to restart kevent if it's
- // interrupted.
- bool wait_forever = (wait == base::TimeDelta::Max());
- base::TimeDelta remaining_delta;
- base::TimeTicks deadline;
- if (!wait_forever) {
- remaining_delta = wait;
- deadline = base::TimeTicks::Now() + remaining_delta;
- }
-
- result = -1;
- struct kevent event = {0};
-
- do {
- struct timespec remaining_timespec;
- struct timespec* remaining_timespec_ptr;
- if (wait_forever) {
- remaining_timespec_ptr = NULL;
- } else {
- remaining_timespec = remaining_delta.ToTimeSpec();
- remaining_timespec_ptr = &remaining_timespec;
- }
-
- result = kevent(kq.get(), NULL, 0, &event, 1, remaining_timespec_ptr);
-
- if (result == -1 && errno == EINTR) {
- if (!wait_forever) {
- remaining_delta = deadline - base::TimeTicks::Now();
- }
- result = 0;
- } else {
- break;
- }
- } while (wait_forever || remaining_delta > base::TimeDelta());
-
- if (result < 0) {
- DPLOG(ERROR) << "kevent (wait " << handle << ")";
- return false;
- } else if (result > 1) {
- DLOG(ERROR) << "kevent (wait " << handle << "): unexpected result "
- << result;
- return false;
- } else if (result == 0) {
- // Timed out.
- return false;
- }
-
- DCHECK_EQ(result, 1);
-
- if (event.filter != EVFILT_PROC || (event.fflags & NOTE_EXIT) == 0 ||
- event.ident != static_cast<uintptr_t>(handle)) {
- DLOG(ERROR) << "kevent (wait " << handle
- << "): unexpected event: filter=" << event.filter
- << ", fflags=" << event.fflags << ", ident=" << event.ident;
- return false;
- }
-
- return true;
-}
-#endif // OS_MACOSX
-
-bool WaitForExitWithTimeoutImpl(base::ProcessHandle handle,
- int* exit_code,
- base::TimeDelta timeout) {
- const base::ProcessHandle our_pid = base::GetCurrentProcessHandle();
- if (handle == our_pid) {
- // We won't be able to wait for ourselves to exit.
- return false;
- }
-
- const base::ProcessHandle parent_pid = base::GetParentProcessId(handle);
- const bool exited = (parent_pid < 0);
-
- if (!exited && parent_pid != our_pid) {
-#if defined(OS_MACOSX)
- // On Mac we can wait on non child processes.
- return WaitForSingleNonChildProcess(handle, timeout);
-#else
- // Currently on Linux we can't handle non child processes.
- NOTIMPLEMENTED();
-#endif // OS_MACOSX
- }
-
- int status;
- if (!WaitpidWithTimeout(handle, &status, timeout)) {
- // If multiple threads wait on the same |handle| then one wait will succeed
- // and the other will fail with errno set to ECHILD.
- return exited || (errno == ECHILD);
- }
- if (WIFSIGNALED(status)) {
- if (exit_code)
- *exit_code = -1;
- return true;
- }
- if (WIFEXITED(status)) {
- if (exit_code)
- *exit_code = WEXITSTATUS(status);
- return true;
- }
- return exited;
-}
-#endif // !defined(OS_NACL_NONSFI)
-
-} // namespace
-
-namespace base {
-
-Process::Process(ProcessHandle handle) : process_(handle) {}
-
-Process::~Process() = default;
-
-Process::Process(Process&& other) : process_(other.process_) {
- other.Close();
-}
-
-Process& Process::operator=(Process&& other) {
- process_ = other.process_;
- other.Close();
- return *this;
-}
-
-// static
-Process Process::Current() {
- return Process(GetCurrentProcessHandle());
-}
-
-// static
-Process Process::Open(ProcessId pid) {
- if (pid == GetCurrentProcId())
- return Current();
-
- // On POSIX process handles are the same as PIDs.
- return Process(pid);
-}
-
-// static
-Process Process::OpenWithExtraPrivileges(ProcessId pid) {
- // On POSIX there are no privileges to set.
- return Open(pid);
-}
-
-// static
-void Process::TerminateCurrentProcessImmediately(int exit_code) {
- _exit(exit_code);
-}
-
-bool Process::IsValid() const {
- return process_ != kNullProcessHandle;
-}
-
-ProcessHandle Process::Handle() const {
- return process_;
-}
-
-Process Process::Duplicate() const {
- if (is_current())
- return Current();
-
- return Process(process_);
-}
-
-ProcessId Process::Pid() const {
- DCHECK(IsValid());
- return GetProcId(process_);
-}
-
-bool Process::is_current() const {
- return process_ == GetCurrentProcessHandle();
-}
-
-void Process::Close() {
- process_ = kNullProcessHandle;
- // if the process wasn't terminated (so we waited) or the state
- // wasn't already collected w/ a wait from process_utils, we're gonna
- // end up w/ a zombie when it does finally exit.
-}
-
-#if !defined(OS_NACL_NONSFI)
-bool Process::Terminate(int exit_code, bool wait) const {
- // exit_code isn't supportable.
- DCHECK(IsValid());
- CHECK_GT(process_, 0);
-
- bool did_terminate = kill(process_, SIGTERM) == 0;
-
- if (wait && did_terminate) {
- if (WaitForExitWithTimeout(TimeDelta::FromSeconds(60), nullptr))
- return true;
- did_terminate = kill(process_, SIGKILL) == 0;
- if (did_terminate)
- return WaitForExit(nullptr);
- }
-
- if (!did_terminate)
- DPLOG(ERROR) << "Unable to terminate process " << process_;
-
- return did_terminate;
-}
-#endif // !defined(OS_NACL_NONSFI)
-
-bool Process::WaitForExit(int* exit_code) const {
- return WaitForExitWithTimeout(TimeDelta::Max(), exit_code);
-}
-
-bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) const {
- int local_exit_code;
- bool exited = WaitForExitWithTimeoutImpl(Handle(), &local_exit_code, timeout);
- if (exited) {
- Exited(local_exit_code);
- if (exit_code)
- *exit_code = local_exit_code;
- }
- return exited;
-}
-
-void Process::Exited(int exit_code) const {}
-
-int Process::GetPriority() const {
- DCHECK(IsValid());
- return getpriority(PRIO_PROCESS, process_);
-}
-
-} // namespace base
diff --git a/base/process/process_win.cc b/base/process/process_win.cc
deleted file mode 100644
index ce2b394..0000000
--- a/base/process/process_win.cc
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process.h"
-
-#include "base/logging.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/process/kill.h"
-
-#include <windows.h>
-
-namespace {
-
-DWORD kBasicProcessAccess =
- PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION | SYNCHRONIZE;
-
-} // namespace
-
-namespace base {
-
-Process::Process(ProcessHandle handle)
- : process_(handle), is_current_process_(false) {
- CHECK_NE(handle, ::GetCurrentProcess());
-}
-
-Process::Process(Process&& other)
- : process_(other.process_.Take()),
- is_current_process_(other.is_current_process_) {
- other.Close();
-}
-
-Process::~Process() {}
-
-Process& Process::operator=(Process&& other) {
- DCHECK_NE(this, &other);
- process_.Set(other.process_.Take());
- is_current_process_ = other.is_current_process_;
- other.Close();
- return *this;
-}
-
-// static
-Process Process::Current() {
- Process process;
- process.is_current_process_ = true;
- return process;
-}
-
-// static
-Process Process::Open(ProcessId pid) {
- return Process(::OpenProcess(kBasicProcessAccess, FALSE, pid));
-}
-
-// static
-Process Process::OpenWithExtraPrivileges(ProcessId pid) {
- DWORD access = kBasicProcessAccess | PROCESS_DUP_HANDLE | PROCESS_VM_READ;
- return Process(::OpenProcess(access, FALSE, pid));
-}
-
-// static
-Process Process::OpenWithAccess(ProcessId pid, DWORD desired_access) {
- return Process(::OpenProcess(desired_access, FALSE, pid));
-}
-
-// static
-void Process::TerminateCurrentProcessImmediately(int exit_code) {
- ::TerminateProcess(GetCurrentProcess(), exit_code);
- // There is some ambiguity over whether the call above can return. Rather than
- // hitting confusing crashes later on we should crash right here.
- IMMEDIATE_CRASH();
-}
-
-bool Process::IsValid() const {
- return process_.IsValid() || is_current();
-}
-
-ProcessHandle Process::Handle() const {
- return is_current_process_ ? GetCurrentProcess() : process_.Get();
-}
-
-Process Process::Duplicate() const {
- if (is_current())
- return Current();
-
- ProcessHandle out_handle;
- if (!IsValid() ||
- !::DuplicateHandle(GetCurrentProcess(), Handle(), GetCurrentProcess(),
- &out_handle, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
- return Process();
- }
- return Process(out_handle);
-}
-
-ProcessId Process::Pid() const {
- DCHECK(IsValid());
- return GetProcId(Handle());
-}
-
-bool Process::is_current() const {
- return is_current_process_;
-}
-
-void Process::Close() {
- is_current_process_ = false;
- if (!process_.IsValid())
- return;
-
- process_.Close();
-}
-
-bool Process::Terminate(int exit_code, bool wait) const {
- constexpr DWORD kWaitMs = 60 * 1000;
-
- // exit_code cannot be implemented.
- DCHECK(IsValid());
- bool result = (::TerminateProcess(Handle(), exit_code) != FALSE);
- if (result) {
- // The process may not end immediately due to pending I/O
- if (wait && ::WaitForSingleObject(Handle(), kWaitMs) != WAIT_OBJECT_0)
- DPLOG(ERROR) << "Error waiting for process exit";
- Exited(exit_code);
- } else {
- // The process can't be terminated, perhaps because it has already
- // exited or is in the process of exiting. A non-zero timeout is necessary
- // here for the same reasons as above.
- 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 Process::WaitForExit(int* exit_code) const {
- return WaitForExitWithTimeout(TimeDelta::FromMilliseconds(INFINITE),
- exit_code);
-}
-
-bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) const {
- // Limit timeout to INFINITE.
- DWORD timeout_ms = saturated_cast<DWORD>(timeout.InMilliseconds());
- if (::WaitForSingleObject(Handle(), timeout_ms) != WAIT_OBJECT_0)
- return false;
-
- DWORD temp_code; // Don't clobber out-parameters in case of failure.
- if (!::GetExitCodeProcess(Handle(), &temp_code))
- return false;
-
- if (exit_code)
- *exit_code = temp_code;
-
- Exited(temp_code);
- return true;
-}
-
-void Process::Exited(int exit_code) const {}
-
-int Process::GetPriority() const {
- DCHECK(IsValid());
- return ::GetPriorityClass(Handle());
-}
-
-} // namespace base
diff --git a/build/gen.py b/build/gen.py
index ffd2bbe..ff6084e 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -244,10 +244,6 @@
'base/md5.cc',
'base/memory/ref_counted.cc',
'base/memory/weak_ptr.cc',
- 'base/process/kill.cc',
- 'base/process/memory.cc',
- 'base/process/process_handle.cc',
- 'base/process/process_iterator.cc',
'base/sha1.cc',
'base/strings/string_number_conversions.cc',
'base/strings/string_piece.cc',
@@ -471,9 +467,6 @@
'base/files/file_util_posix.cc',
'base/posix/file_descriptor_shuffle.cc',
'base/posix/safe_strerror.cc',
- 'base/process/kill_posix.cc',
- 'base/process/process_handle_posix.cc',
- 'base/process/process_posix.cc',
'base/strings/string16.cc',
'base/synchronization/condition_variable_posix.cc',
'base/synchronization/lock_impl_posix.cc',
@@ -483,11 +476,6 @@
if is_linux:
static_libraries['base']['sources'].extend([
- 'base/process/internal_linux.cc',
- 'base/process/memory_linux.cc',
- 'base/process/process_handle_linux.cc',
- 'base/process/process_info_linux.cc',
- 'base/process/process_iterator_linux.cc',
'base/strings/sys_string_conversions_posix.cc',
'base/synchronization/waitable_event_posix.cc',
'base/time/time_exploded_posix.cc',
@@ -512,9 +500,6 @@
'base/mac/mach_logging.cc',
'base/mac/scoped_mach_port.cc',
'base/mac/scoped_nsautorelease_pool.mm',
- 'base/process/process_handle_mac.cc',
- 'base/process/process_info_mac.cc',
- 'base/process/process_iterator_mac.cc',
'base/strings/sys_string_conversions_mac.mm',
'base/synchronization/waitable_event_mac.cc',
'base/time/time_exploded_posix.cc',
@@ -534,12 +519,6 @@
'base/files/file_enumerator_win.cc',
'base/files/file_util_win.cc',
'base/files/file_win.cc',
- 'base/process/kill_win.cc',
- 'base/process/memory_win.cc',
- 'base/process/process_handle_win.cc',
- 'base/process/process_info_win.cc',
- 'base/process/process_iterator_win.cc',
- 'base/process/process_win.cc',
'base/strings/sys_string_conversions_win.cc',
'base/synchronization/condition_variable_win.cc',
'base/synchronization/lock_impl_win.cc',
diff --git a/tools/gn/exec_process.cc b/tools/gn/exec_process.cc
index 6afc8a1..662fd68 100644
--- a/tools/gn/exec_process.cc
+++ b/tools/gn/exec_process.cc
@@ -11,8 +11,6 @@
#include "base/command_line.h"
#include "base/files/file_util.h"
#include "base/logging.h"
-#include "base/process/kill.h"
-#include "base/process/process.h"
#include "build_config.h"
#if defined(OS_WIN)
@@ -23,6 +21,7 @@
#else
#include <errno.h>
#include <fcntl.h>
+#include <sys/wait.h>
#include <unistd.h>
#include "base/posix/eintr_wrapper.h"
@@ -37,6 +36,15 @@
std::string* std_out,
std::string* std_err,
int* exit_code) {
+ return ExecProcess(cmdline.GetCommandLineString(), startup_dir, std_out,
+ std_err, exit_code);
+}
+
+bool ExecProcess(const base::string16& cmdline_str,
+ const base::FilePath& startup_dir,
+ std::string* std_out,
+ std::string* std_err,
+ int* exit_code) {
SECURITY_ATTRIBUTES sa_attr;
// Set the bInheritHandle flag so pipe handles are inherited.
sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
@@ -65,16 +73,14 @@
// Ensure the read handle to the pipe for STDOUT/STDERR is not inherited.
if (!SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)) {
- NOTREACHED() << "Failed to disabled pipe inheritance";
+ NOTREACHED() << "Failed to disable pipe inheritance";
return false;
}
if (!SetHandleInformation(err_read, HANDLE_FLAG_INHERIT, 0)) {
- NOTREACHED() << "Failed to disabled pipe inheritance";
+ NOTREACHED() << "Failed to disable pipe inheritance";
return false;
}
- base::FilePath::StringType cmdline_str(cmdline.GetCommandLineString());
-
STARTUPINFO start_info = {};
start_info.cb = sizeof(STARTUPINFO);
@@ -86,9 +92,11 @@
start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
start_info.dwFlags |= STARTF_USESTDHANDLES;
+ base::string16 cmdline_writable = cmdline_str;
+
// Create the child process.
PROCESS_INFORMATION temp_process_info = {};
- if (!CreateProcess(nullptr, &cmdline_str[0], nullptr, nullptr,
+ if (!CreateProcess(nullptr, &cmdline_writable[0], nullptr, nullptr,
TRUE, // Handles are inherited.
NORMAL_PRIORITY_CLASS, nullptr,
startup_dir.value().c_str(), &start_info,
@@ -97,8 +105,8 @@
}
base::win::ScopedProcessInformation proc_info(temp_process_info);
- // Close our writing end of pipes now. Otherwise later read would not be able
- // to detect end of child's output.
+ // Close our writing end of pipes now. Otherwise later read would not be
+ // able to detect end of child's output.
scoped_out_write.Close();
scoped_err_write.Close();
@@ -143,6 +151,24 @@
return true;
}
+bool WaitForExit(int pid, int *exit_code) {
+ int status;
+ if (waitpid(pid, &status, 0) < 0) {
+ PLOG(ERROR) << "waitpid";
+ return false;
+ }
+
+ if (WIFEXITED(status)) {
+ *exit_code = WEXITSTATUS(status);
+ return true;
+ } else if (WIFSIGNALED(status)) {
+ if (WTERMSIG(status) == SIGINT || WTERMSIG(status) == SIGTERM
+ || WTERMSIG(status) == SIGHUP)
+ return false;
+ }
+ return false;
+}
+
bool ExecProcess(const base::CommandLine& cmdline,
const base::FilePath& startup_dir,
std::string* std_out,
@@ -243,8 +269,7 @@
err_open = ReadFromPipe(err_read.get(), std_err);
}
- base::Process process(pid);
- return process.WaitForExit(exit_code);
+ return WaitForExit(pid, exit_code);
}
}
diff --git a/tools/gn/exec_process.h b/tools/gn/exec_process.h
index 43c2a1d..f361ba8 100644
--- a/tools/gn/exec_process.h
+++ b/tools/gn/exec_process.h
@@ -7,6 +7,9 @@
#include <string>
+#include "base/strings/string16.h"
+#include "build_config.h"
+
namespace base {
class CommandLine;
class FilePath;
@@ -20,6 +23,14 @@
std::string* std_err,
int* exit_code);
+#if defined(OS_WIN)
+bool ExecProcess(const base::string16& cmdline_str,
+ const base::FilePath& startup_dir,
+ std::string* std_out,
+ std::string* std_err,
+ int* exit_code);
+#endif // OS_WIN
+
} // namespace internal
#endif // TOOLS_GN_EXEC_PROCESS_H_
diff --git a/tools/gn/ninja_build_writer.cc b/tools/gn/ninja_build_writer.cc
index 7953939..f1933f6 100644
--- a/tools/gn/ninja_build_writer.cc
+++ b/tools/gn/ninja_build_writer.cc
@@ -13,7 +13,6 @@
#include "base/command_line.h"
#include "base/files/file_util.h"
-#include "base/process/process_handle.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "build_config.h"
diff --git a/tools/gn/setup.cc b/tools/gn/setup.cc
index 726b037..0b27244 100644
--- a/tools/gn/setup.cc
+++ b/tools/gn/setup.cc
@@ -16,7 +16,6 @@
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/memory/ref_counted.h"
-#include "base/process/kill.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/sys_string_conversions.h"
@@ -24,6 +23,7 @@
#include "build_config.h"
#include "tools/gn/command_format.h"
#include "tools/gn/commands.h"
+#include "tools/gn/exec_process.h"
#include "tools/gn/filesystem_utils.h"
#include "tools/gn/input_file.h"
#include "tools/gn/parse_tree.h"
@@ -190,83 +190,6 @@
#if defined(OS_WIN)
-bool GetAppOutput(const base::StringPiece16& cl, std::string* output) {
- HANDLE out_read = nullptr;
- HANDLE out_write = nullptr;
-
- SECURITY_ATTRIBUTES sa_attr;
- // Set the bInheritHandle flag so pipe handles are inherited.
- sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
- sa_attr.bInheritHandle = TRUE;
- sa_attr.lpSecurityDescriptor = nullptr;
-
- // Create the pipe for the child process's STDOUT.
- if (!CreatePipe(&out_read, &out_write, &sa_attr, 0)) {
- NOTREACHED() << "Failed to create pipe";
- return false;
- }
-
- // Ensure we don't leak the handles.
- base::win::ScopedHandle scoped_out_read(out_read);
- base::win::ScopedHandle scoped_out_write(out_write);
-
- // Ensure the read handles to the pipes are not inherited.
- if (!SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)) {
- NOTREACHED() << "Failed to disabled pipe inheritance";
- return false;
- }
-
- base::FilePath::StringType writable_command_line_string;
- writable_command_line_string.assign(cl.data(), cl.size());
-
- STARTUPINFO start_info = {};
-
- start_info.cb = sizeof(STARTUPINFO);
- start_info.hStdOutput = out_write;
- // Keep the normal stdin/stderr.
- start_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
- start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
- start_info.dwFlags |= STARTF_USESTDHANDLES;
-
- // Create the child process.
- PROCESS_INFORMATION temp_process_info = {};
- if (!CreateProcess(nullptr, &writable_command_line_string[0], nullptr,
- nullptr,
- TRUE, // Handles are inherited.
- 0, nullptr, nullptr, &start_info, &temp_process_info)) {
- NOTREACHED() << "Failed to start process";
- return false;
- }
-
- base::win::ScopedProcessInformation proc_info(temp_process_info);
-
- // Close our writing end of pipe now. Otherwise later read would not be able
- // to detect end of child's output.
- scoped_out_write.Close();
-
- // Read output from the child process's pipe for STDOUT
- const int kBufferSize = 1024;
- char buffer[kBufferSize];
-
- for (;;) {
- DWORD bytes_read = 0;
- BOOL success =
- ::ReadFile(out_read, buffer, kBufferSize, &bytes_read, nullptr);
- if (!success || bytes_read == 0)
- break;
- output->append(buffer, bytes_read);
- }
-
- // Let's wait for the process to finish.
- WaitForSingleObject(proc_info.process_handle(), INFINITE);
-
- int exit_code;
- base::TerminationStatus status =
- base::GetTerminationStatus(proc_info.process_handle(), &exit_code);
- return status != base::TERMINATION_STATUS_PROCESS_CRASHED &&
- status != base::TERMINATION_STATUS_ABNORMAL_TERMINATION;
-}
-
// Given the path to a batch file that runs Python, extracts the name of the
// executable actually implementing Python. Generally people write a batch file
// to put something named "python" on the path, which then just redirects to
@@ -283,7 +206,12 @@
command.append(L"\" -c \"import sys; print sys.executable\"\"");
std::string python_path;
- if (GetAppOutput(command, &python_path)) {
+ std::string std_err;
+ int exit_code;
+ base::FilePath cwd;
+ GetCurrentDirectory(&cwd);
+ if (internal::ExecProcess(command, cwd, &python_path, &std_err, &exit_code) &&
+ exit_code == 0 && std_err.empty()) {
base::TrimWhitespaceASCII(python_path, base::TRIM_ALL, &python_path);
// Python uses the system multibyte code page for sys.executable.
