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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// 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.
#ifndef CHROME_BROWSER_MEMORY_DETAILS_H_
#define CHROME_BROWSER_MEMORY_DETAILS_H_
#include <map>
#include <string>
#include <vector>
#include "base/memory/ref_counted.h"
#include "base/process/process_handle.h"
#include "base/process/process_metrics.h"
#include "build/build_config.h"
#include "content/public/common/process_type.h"
namespace memory_instrumentation {
class GlobalMemoryDump;
} // namespace memory_instrumentation
// We collect data about each browser process. A browser may
// have multiple processes (of course!). Even IE has multiple
// processes these days.
struct ProcessMemoryInformation {
// NOTE: Do not remove or reorder the elements in this enum, and only add new
// items at the end. We depend on these specific values in a histogram.
enum RendererProcessType {
RENDERER_UNKNOWN = 0,
RENDERER_NORMAL,
RENDERER_CHROME, // WebUI (chrome:// URL)
RENDERER_EXTENSION, // chrome-extension://
RENDERER_DEVTOOLS, // Web inspector
RENDERER_INTERSTITIAL, // malware/phishing interstitial
RENDERER_BACKGROUND_APP // hosted app background page
};
static std::string GetRendererTypeNameInEnglish(RendererProcessType type);
static std::string GetFullTypeNameInEnglish(
int process_type,
RendererProcessType rtype);
ProcessMemoryInformation();
ProcessMemoryInformation(const ProcessMemoryInformation& other);
~ProcessMemoryInformation();
// Default ordering is by private memory consumption.
bool operator<(const ProcessMemoryInformation& rhs) const;
// The process id.
base::ProcessId pid;
// The process version
std::u16string version;
// The process product name.
std::u16string product_name;
// The number of processes which this memory represents.
int num_processes;
// If this is a child process of Chrome, what type (i.e. plugin) it is.
int process_type;
// Number of open file descriptors in this process.
int num_open_fds;
// Maximum number of file descriptors that can be opened in this process.
int open_fds_soft_limit;
// If this is a renderer process, what type it is.
RendererProcessType renderer_type;
// A collection of titles used, i.e. for a tab it'll show all the page titles.
std::vector<std::u16string> titles;
// Consistent memory metric for all platforms.
size_t private_memory_footprint_kb;
};
typedef std::vector<ProcessMemoryInformation> ProcessMemoryInformationList;
// Browser Process Information.
struct ProcessData {
ProcessData();
ProcessData(const ProcessData& rhs);
~ProcessData();
ProcessData& operator=(const ProcessData& rhs);
std::u16string name;
std::u16string process_name;
ProcessMemoryInformationList processes;
};
// MemoryDetails fetches memory details about current running browsers.
// Because this data can only be fetched asynchronously, callers use
// this class via a callback.
//
// Example usage:
//
// class MyMemoryDetailConsumer : public MemoryDetails {
//
// MyMemoryDetailConsumer() {
// // Anything but |StartFetch()|.
// }
//
// // (Or just call |StartFetch()| explicitly if there's nothing else to
// // do.)
// void StartDoingStuff() {
// StartFetch(); // Starts fetching details.
// // Etc.
// }
//
// // Your other class stuff here
//
// virtual void OnDetailsAvailable() {
// // do work with memory info here
// }
// }
class MemoryDetails : public base::RefCountedThreadSafe<MemoryDetails> {
public:
// Constructor.
MemoryDetails();
MemoryDetails(const MemoryDetails&) = delete;
MemoryDetails& operator=(const MemoryDetails&) = delete;
// Initiate updating the current memory details. These are fetched
// asynchronously because data must be collected from multiple threads.
// OnDetailsAvailable will be called when this process is complete.
void StartFetch();
virtual void OnDetailsAvailable() = 0;
// Returns a string summarizing memory usage of the Chrome browser process
// and all sub-processes, suitable for logging. Tab title may contain PII,
// set |include_tab_title| to false to exclude tab titles when there are
// privacy concerns.
std::string ToLogString(bool include_tab_title);
protected:
friend class base::RefCountedThreadSafe<MemoryDetails>;
virtual ~MemoryDetails();
// Access to the process detail information. This data is only available
// after OnDetailsAvailable() has been called.
const std::vector<ProcessData>& processes() { return process_data_; }
// Returns a pointer to the ProcessData structure for Chrome.
ProcessData* ChromeBrowser();
#if BUILDFLAG(IS_CHROMEOS)
const base::SwapInfo& swap_info() const { return swap_info_; }
#endif
private:
// Collect current process information from the OS and store it
// for processing. If data has already been collected, clears old
// data and re-collects the data.
// Note - this function enumerates memory details from many processes
// and is fairly expensive to run, hence it's run on the blocking pool.
// The parameter holds information about processes from the IO thread.
void CollectProcessData(
const std::vector<ProcessMemoryInformation>& child_info);
// Collect child process information on the UI thread. Information about
// renderer processes is only available there.
void CollectChildInfoOnUIThread();
void DidReceiveMemoryDump(
bool success,
std::unique_ptr<memory_instrumentation::GlobalMemoryDump> dump);
std::vector<ProcessData> process_data_;
#if BUILDFLAG(IS_CHROMEOS)
base::SwapInfo swap_info_;
#endif
};
#endif // CHROME_BROWSER_MEMORY_DETAILS_H_
|
