blob: 2e7e852426630b3a638c45adb5f08a74df3211a6 (
plain)
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
|
// Copyright (c) 2006-2008 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 CHROME_BROWSER_MEMORY_DETAILS_H_
#define CHROME_BROWSER_MEMORY_DETAILS_H_
#include <vector>
#include "base/process_util.h"
#include "base/ref_counted.h"
#include "chrome/common/child_process_info.h"
class MessageLoop;
// We collect data about each browser process. A browser may
// have multiple processes (of course!). Even IE has multiple
// processes these days.
struct ProcessMemoryInformation {
ProcessMemoryInformation()
: pid(0),
num_processes(0),
is_diagnostics(false),
type(ChildProcessInfo::UNKNOWN_PROCESS) {
}
// The process id.
int pid;
// The working set information.
base::WorkingSetKBytes working_set;
// The committed bytes.
base::CommittedKBytes committed;
// The process version
std::wstring version;
// The process product name.
std::wstring product_name;
// The number of processes which this memory represents.
int num_processes;
// A process is a diagnostics process if it is rendering
// about:xxx information.
bool is_diagnostics;
// If this is a child process of Chrome, what type (i.e. plugin) it is.
ChildProcessInfo::ProcessType type;
// A collection of titles used, i.e. for a tab it'll show all the page titles.
std::vector<std::wstring> titles;
};
typedef std::vector<ProcessMemoryInformation> ProcessMemoryInformationList;
// Browser Process Information.
struct ProcessData {
std::wstring name;
std::wstring 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() : MemoryDetails(true) {
// StartFetch(); // Starts fetching details.
// }
//
// // Your class stuff here
//
// virtual void OnDetailsAvailable() {
// // do work with memory info here
// }
// }
class MemoryDetails : public base::RefCountedThreadSafe<MemoryDetails> {
public:
// Constructor.
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_; }
// 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() {}
private:
// Collect child process information on the IO thread. This is needed because
// information about some child process types (i.e. plugins) can only be taken
// on that thread. The data will be used by about:memory. When finished,
// invokes back to the file thread to run the rest of the about:memory
// functionality.
void CollectChildInfoOnIOThread();
// 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 file thread.
// The parameter holds information about processes from the IO thread.
void CollectProcessData(std::vector<ProcessMemoryInformation>);
// Collect child process information on the UI thread. Information about
// renderer processes is only available there.
void CollectChildInfoOnUIThread();
// Each time we take a memory sample, we do a little work to update
// the global histograms for tracking memory usage.
void UpdateHistograms();
// Returns a pointer to the ProcessData structure for Chrome.
ProcessData* ChromeBrowser();
std::vector<ProcessData> process_data_;
MessageLoop* ui_loop_;
DISALLOW_EVIL_CONSTRUCTORS(MemoryDetails);
};
#endif // CHROME_BROWSER_MEMORY_DETAILS_H_
|
