1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// Copyright (c) 2009 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 "chrome/test/chrome_process_util.h"
#include <vector>
#include <set>
#include "base/process_util.h"
#include "base/time.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/result_codes.h"
using base::Time;
using base::TimeDelta;
void TerminateAllChromeProcesses(base::ProcessId browser_pid) {
// Total time the function will wait for chrome processes
// to terminate after it told them to do so.
const TimeDelta kExitTimeout = TimeDelta::FromSeconds(30);
ChromeProcessList process_pids(GetRunningChromeProcesses(browser_pid));
std::vector<base::ProcessHandle> handles;
{
ChromeProcessList::const_iterator it;
for (it = process_pids.begin(); it != process_pids.end(); ++it) {
base::ProcessHandle handle;
// Ignore processes for which we can't open the handle. We don't guarantee
// that all processes will terminate, only try to do so.
if (base::OpenPrivilegedProcessHandle(*it, &handle))
handles.push_back(handle);
}
}
std::vector<base::ProcessHandle>::const_iterator it;
for (it = handles.begin(); it != handles.end(); ++it)
base::KillProcess(*it, ResultCodes::TASKMAN_KILL, false);
const Time start = Time::Now();
for (it = handles.begin();
it != handles.end() && Time::Now() - start < kExitTimeout;
++it) {
int64 wait_time_ms = (Time::Now() - start).InMilliseconds();
base::WaitForSingleProcess(*it, wait_time_ms);
}
for (it = handles.begin(); it != handles.end(); ++it)
base::CloseProcessHandle(*it);
}
class ChildProcessFilter : public base::ProcessFilter {
public:
explicit ChildProcessFilter(base::ProcessId parent_pid)
: parent_pids_(&parent_pid, (&parent_pid) + 1) {}
explicit ChildProcessFilter(std::vector<base::ProcessId> parent_pids)
: parent_pids_(parent_pids.begin(), parent_pids.end()) {}
virtual bool Includes(base::ProcessId pid, base::ProcessId parent_pid) const {
return parent_pids_.find(parent_pid) != parent_pids_.end();
}
private:
const std::set<base::ProcessId> parent_pids_;
DISALLOW_COPY_AND_ASSIGN(ChildProcessFilter);
};
ChromeProcessList GetRunningChromeProcesses(base::ProcessId browser_pid) {
ChromeProcessList result;
if (browser_pid == static_cast<base::ProcessId>(-1))
return result;
ChildProcessFilter filter(browser_pid);
base::NamedProcessIterator it(chrome::kBrowserProcessExecutableName, &filter);
const ProcessEntry* process_entry;
while ((process_entry = it.NextProcessEntry())) {
#if defined(OS_WIN)
result.push_back(process_entry->th32ProcessID);
#elif defined(OS_POSIX)
result.push_back(process_entry->pid);
#endif
}
#if defined(OS_LINUX)
// On Linux we might be running with a zygote process for the renderers.
// Because of that we sweep the list of processes again and pick those which
// are children of one of the processes that we've already seen.
{
ChildProcessFilter filter(result);
base::NamedProcessIterator it(chrome::kBrowserProcessExecutableName,
&filter);
while ((process_entry = it.NextProcessEntry()))
result.push_back(process_entry->pid);
}
#endif // defined(OS_LINUX)
#if defined(OS_LINUX) || defined(OS_MACOSX)
// On Mac OS X we run the subprocesses with a different bundle, and
// on Linux via /proc/self/exe, so they end up with a different
// name. We must collect them in a second pass.
{
ChildProcessFilter filter(browser_pid);
base::NamedProcessIterator it(chrome::kHelperProcessExecutableName,
&filter);
while ((process_entry = it.NextProcessEntry()))
result.push_back(process_entry->pid);
}
#endif // defined(OS_MACOSX)
result.push_back(browser_pid);
return result;
}
#if !defined(OS_MACOSX)
size_t ChromeTestProcessMetrics::GetPagefileUsage() {
return process_metrics_->GetPagefileUsage();
}
size_t ChromeTestProcessMetrics::GetWorkingSetSize() {
return process_metrics_->GetWorkingSetSize();
}
#endif // !defined(OS_MACOSX)
|
