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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/memory_details.h"
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "base/functional/bind.h"
#include "base/process/process_iterator.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/scoped_blocking_call.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/grit/branded_strings.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/common/process_type.h"
#include "ui/base/l10n/l10n_util.h"
using base::ProcessEntry;
using base::ProcessId;
namespace {
// A helper for |CollectProcessData()| to include the chrome sandboxed
// processes in android which are not running as a child of the browser
// process.
void AddNonChildChromeProcesses(
std::vector<ProcessMemoryInformation>* processes) {
base::ProcessIterator process_iter(NULL);
while (const ProcessEntry* process_entry = process_iter.NextProcessEntry()) {
const std::vector<std::string>& cmd_args = process_entry->cmd_line_args();
if (cmd_args.empty() ||
cmd_args[0].find(chrome::kHelperProcessExecutableName) ==
std::string::npos) {
continue;
}
ProcessMemoryInformation info;
info.pid = process_entry->pid();
processes->push_back(info);
}
}
// For each of the pids, collect memory information about that process
// and append a record to |out|.
void GetProcessDataMemoryInformation(
const std::set<ProcessId>& pids, ProcessData* out) {
for (std::set<ProcessId>::const_iterator i = pids.begin(); i != pids.end();
++i) {
ProcessMemoryInformation pmi;
pmi.pid = *i;
pmi.num_processes = 1;
base::ProcessId current_pid = base::GetCurrentProcId();
if (pmi.pid == current_pid)
pmi.process_type = content::PROCESS_TYPE_BROWSER;
else
pmi.process_type = content::PROCESS_TYPE_UNKNOWN;
std::unique_ptr<base::ProcessMetrics> metrics(
base::ProcessMetrics::CreateProcessMetrics(*i));
// TODO(ssid): Reading "/proc/fd" only works for current process. For child
// processes, the values need to be computed by the process itself.
if (pmi.pid == current_pid) {
pmi.num_open_fds = metrics->GetOpenFdCount();
pmi.open_fds_soft_limit = metrics->GetOpenFdSoftLimit();
}
out->processes.push_back(pmi);
}
}
// Find all children of the given process.
void GetAllChildren(const std::vector<ProcessEntry>& processes,
const std::set<ProcessId>& roots,
std::set<ProcessId>* out) {
*out = roots;
std::set<ProcessId> wavefront;
for (std::set<ProcessId>::const_iterator i = roots.begin(); i != roots.end();
++i) {
wavefront.insert(*i);
}
while (wavefront.size()) {
std::set<ProcessId> next_wavefront;
for (std::vector<ProcessEntry>::const_iterator i = processes.begin();
i != processes.end(); ++i) {
if (wavefront.count(i->parent_pid())) {
out->insert(i->pid());
next_wavefront.insert(i->pid());
}
}
wavefront.clear();
wavefront.swap(next_wavefront);
}
}
} // namespace
MemoryDetails::MemoryDetails() = default;
ProcessData* MemoryDetails::ChromeBrowser() {
return &process_data_[0];
}
void MemoryDetails::CollectProcessData(
const std::vector<ProcessMemoryInformation>& chrome_processes) {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::WILL_BLOCK);
std::vector<ProcessMemoryInformation> all_processes(chrome_processes);
AddNonChildChromeProcesses(&all_processes);
std::vector<ProcessEntry> processes;
base::ProcessIterator process_iter(NULL);
while (const ProcessEntry* process_entry = process_iter.NextProcessEntry()) {
processes.push_back(*process_entry);
}
std::set<ProcessId> roots;
roots.insert(base::GetCurrentProcId());
for (std::vector<ProcessMemoryInformation>::const_iterator
i = all_processes.begin(); i != all_processes.end(); ++i) {
roots.insert(i->pid);
}
std::set<ProcessId> current_browser_processes;
GetAllChildren(processes, roots, ¤t_browser_processes);
ProcessData current_browser;
GetProcessDataMemoryInformation(current_browser_processes, ¤t_browser);
current_browser.name = l10n_util::GetStringUTF16(IDS_PRODUCT_NAME);
current_browser.process_name =
base::ASCIIToUTF16(chrome::kBrowserProcessExecutableName);
process_data_.push_back(current_browser);
// Finally return to the browser thread.
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&MemoryDetails::CollectChildInfoOnUIThread, this));
}
|
