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_
|