blob: c5b8a6901bc6a785a5658643c2130fb71c5df387 [file] [log] [blame]
[email protected]b0b67cf2012-01-18 21:59:571// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
5#include "chrome/browser/memory_details.h"
initial.commit09911bf2008-07-26 23:55:296
[email protected]24d69692011-10-21 18:26:517#include "base/bind.h"
initial.commit09911bf2008-07-26 23:55:298#include "base/file_version_info.h"
[email protected]835d7c82010-10-14 04:38:389#include "base/metrics/histogram.h"
[email protected]76543b92009-08-31 17:27:4510#include "base/process_util.h"
[email protected]33b9df42010-07-29 06:46:3911#include "base/string_util.h"
[email protected]64048bd2010-03-08 23:28:5812#include "base/utf_string_conversions.h"
[email protected]8add5412011-10-01 21:02:1413#include "chrome/browser/extensions/extension_process_manager.h"
[email protected]79dc42cd2011-01-08 21:43:3514#include "chrome/browser/extensions/extension_service.h"
15#include "chrome/browser/profiles/profile.h"
[email protected]14afc012011-12-01 01:04:3916#include "chrome/common/chrome_view_type.h"
[email protected]fcf79352010-12-28 20:13:2017#include "chrome/common/extensions/extension.h"
[email protected]cd3d7892009-03-04 23:55:0618#include "chrome/common/url_constants.h"
[email protected]4967f792012-01-20 22:14:4019#include "content/public/browser/browser_child_process_host_iterator.h"
[email protected]c38831a12011-10-28 12:44:4920#include "content/public/browser/browser_thread.h"
[email protected]9c1662b2012-03-06 15:44:3321#include "content/public/browser/child_process_data.h"
[email protected]a53209b2012-01-20 16:48:1622#include "content/public/browser/navigation_controller.h"
[email protected]022af742011-12-28 18:37:2523#include "content/public/browser/navigation_entry.h"
[email protected]f3b1a082011-11-18 00:34:3024#include "content/public/browser/render_process_host.h"
[email protected]9c1662b2012-03-06 15:44:3325#include "content/public/browser/render_view_host.h"
[email protected]b0b67cf2012-01-18 21:59:5726#include "content/public/browser/render_view_host_delegate.h"
[email protected]83ff91c2012-01-05 20:54:1327#include "content/public/browser/web_contents.h"
[email protected]e091df82011-10-11 18:13:2128#include "content/public/common/bindings_policy.h"
[email protected]a54311142011-12-01 05:13:4129#include "content/public/common/process_type.h"
[email protected]ae5ca892009-07-30 18:00:4730#include "grit/chromium_strings.h"
[email protected]4f260d02010-12-23 18:35:4231#include "grit/generated_resources.h"
[email protected]c051a1b2011-01-21 23:30:1732#include "ui/base/l10n/l10n_util.h"
initial.commit09911bf2008-07-26 23:55:2933
[email protected]a423c9e2012-03-06 18:02:3134#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]c2c68b1f2012-02-25 00:29:1535#include "content/public/browser/zygote_host_linux.h"
[email protected]54fd1d32009-09-01 00:12:5836#endif
initial.commit09911bf2008-07-26 23:55:2937
[email protected]4967f792012-01-20 22:14:4038using content::BrowserChildProcessHostIterator;
[email protected]631bb742011-11-02 11:29:3939using content::BrowserThread;
[email protected]10f417c52011-12-28 21:04:2340using content::NavigationEntry;
[email protected]83ff91c2012-01-05 20:54:1341using content::WebContents;
[email protected]631bb742011-11-02 11:29:3942
[email protected]2c1978a2011-11-29 17:02:3943// static
44std::string ProcessMemoryInformation::GetRendererTypeNameInEnglish(
45 RendererProcessType type) {
46 switch (type) {
47 case RENDERER_NORMAL:
48 return "Tab";
49 case RENDERER_CHROME:
50 return "Tab (Chrome)";
51 case RENDERER_EXTENSION:
52 return "Extension";
53 case RENDERER_DEVTOOLS:
54 return "Devtools";
55 case RENDERER_INTERSTITIAL:
56 return "Interstitial";
57 case RENDERER_NOTIFICATION:
58 return "Notification";
59 case RENDERER_BACKGROUND_APP:
60 return "Background App";
61 case RENDERER_UNKNOWN:
62 default:
63 NOTREACHED() << "Unknown renderer process type!";
64 return "Unknown";
65 }
66}
67
68// static
69std::string ProcessMemoryInformation::GetFullTypeNameInEnglish(
[email protected]bd5d6cf2011-12-01 00:39:1270 content::ProcessType type,
[email protected]2c1978a2011-11-29 17:02:3971 RendererProcessType rtype) {
[email protected]bd5d6cf2011-12-01 00:39:1272 if (type == content::PROCESS_TYPE_RENDERER)
[email protected]2c1978a2011-11-29 17:02:3973 return GetRendererTypeNameInEnglish(rtype);
[email protected]a54311142011-12-01 05:13:4174 return content::GetProcessTypeNameInEnglish(type);
[email protected]2c1978a2011-11-29 17:02:3975}
76
[email protected]8e383412010-10-19 16:57:0377ProcessMemoryInformation::ProcessMemoryInformation()
78 : pid(0),
79 num_processes(0),
80 is_diagnostics(false),
[email protected]bd5d6cf2011-12-01 00:39:1281 type(content::PROCESS_TYPE_UNKNOWN),
[email protected]2c1978a2011-11-29 17:02:3982 renderer_type(RENDERER_UNKNOWN) {
[email protected]8e383412010-10-19 16:57:0383}
84
85ProcessMemoryInformation::~ProcessMemoryInformation() {}
86
[email protected]93aa89c72010-10-20 21:32:0487ProcessData::ProcessData() {}
88
89ProcessData::ProcessData(const ProcessData& rhs)
90 : name(rhs.name),
91 process_name(rhs.process_name),
92 processes(rhs.processes) {
93}
94
95ProcessData::~ProcessData() {}
96
97ProcessData& ProcessData::operator=(const ProcessData& rhs) {
98 name = rhs.name;
99 process_name = rhs.process_name;
100 processes = rhs.processes;
101 return *this;
102}
103
initial.commit09911bf2008-07-26 23:55:29104// About threading:
105//
106// This operation will hit no fewer than 3 threads.
107//
[email protected]a436d922009-02-13 23:16:42108// The ChildProcessInfo::Iterator can only be accessed from the IO thread.
initial.commit09911bf2008-07-26 23:55:29109//
110// The RenderProcessHostIterator can only be accessed from the UI thread.
111//
112// This operation can take 30-100ms to complete. We never want to have
113// one task run for that long on the UI or IO threads. So, we run the
114// expensive parts of this operation over on the file thread.
115//
initial.commit09911bf2008-07-26 23:55:29116void MemoryDetails::StartFetch() {
[email protected]9bb480ee2011-08-03 21:41:16117 // This might get called from the UI or FILE threads, but should not be
118 // getting called from the IO thread.
[email protected]f8b3ef82010-10-11 02:45:52119 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
initial.commit09911bf2008-07-26 23:55:29120
121 // In order to process this request, we need to use the plugin information.
122 // However, plugin process information is only available from the IO thread.
[email protected]f8b3ef82010-10-11 02:45:52123 BrowserThread::PostTask(
124 BrowserThread::IO, FROM_HERE,
[email protected]24d69692011-10-21 18:26:51125 base::Bind(&MemoryDetails::CollectChildInfoOnIOThread, this));
initial.commit09911bf2008-07-26 23:55:29126}
127
[email protected]8e383412010-10-19 16:57:03128MemoryDetails::~MemoryDetails() {}
129
[email protected]a27a9382009-02-11 23:55:10130void MemoryDetails::CollectChildInfoOnIOThread() {
[email protected]f8b3ef82010-10-11 02:45:52131 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
initial.commit09911bf2008-07-26 23:55:29132
[email protected]a27a9382009-02-11 23:55:10133 std::vector<ProcessMemoryInformation> child_info;
134
[email protected]a436d922009-02-13 23:16:42135 // Collect the list of child processes.
[email protected]4967f792012-01-20 22:14:40136 for (BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) {
[email protected]a27a9382009-02-11 23:55:10137 ProcessMemoryInformation info;
[email protected]4967f792012-01-20 22:14:40138 info.pid = base::GetProcId(iter.GetData().handle);
[email protected]a27a9382009-02-11 23:55:10139 if (!info.pid)
140 continue;
141
[email protected]4967f792012-01-20 22:14:40142 info.type = iter.GetData().type;
[email protected]2c1978a2011-11-29 17:02:39143 info.renderer_type = ProcessMemoryInformation::RENDERER_UNKNOWN;
[email protected]4967f792012-01-20 22:14:40144 info.titles.push_back(iter.GetData().name);
[email protected]a27a9382009-02-11 23:55:10145 child_info.push_back(info);
initial.commit09911bf2008-07-26 23:55:29146 }
147
148 // Now go do expensive memory lookups from the file thread.
[email protected]f8b3ef82010-10-11 02:45:52149 BrowserThread::PostTask(
150 BrowserThread::FILE, FROM_HERE,
[email protected]24d69692011-10-21 18:26:51151 base::Bind(&MemoryDetails::CollectProcessData, this, child_info));
initial.commit09911bf2008-07-26 23:55:29152}
153
[email protected]a27a9382009-02-11 23:55:10154void MemoryDetails::CollectChildInfoOnUIThread() {
[email protected]f8b3ef82010-10-11 02:45:52155 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
initial.commit09911bf2008-07-26 23:55:29156
[email protected]a423c9e2012-03-06 18:02:31157#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]c2c68b1f2012-02-25 00:29:15158 const pid_t zygote_pid = content::ZygoteHost::GetInstance()->GetPid();
[email protected]52356d22012-02-29 18:34:20159 const pid_t sandbox_helper_pid =
160 content::ZygoteHost::GetInstance()->GetSandboxHelperPid();
[email protected]54fd1d32009-09-01 00:12:58161#endif
162
163 ProcessData* const chrome_browser = ChromeBrowser();
[email protected]a27a9382009-02-11 23:55:10164 // Get more information about the process.
[email protected]54fd1d32009-09-01 00:12:58165 for (size_t index = 0; index < chrome_browser->processes.size();
initial.commit09911bf2008-07-26 23:55:29166 index++) {
[email protected]a27a9382009-02-11 23:55:10167 // Check if it's a renderer, if so get the list of page titles in it and
[email protected]fcf79352010-12-28 20:13:20168 // check if it's a diagnostics-related process. We skip about:memory pages.
169 // Iterate the RenderProcessHosts to find the tab contents.
[email protected]54fd1d32009-09-01 00:12:58170 ProcessMemoryInformation& process =
171 chrome_browser->processes[index];
172
[email protected]f3b1a082011-11-18 00:34:30173 for (content::RenderProcessHost::iterator renderer_iter(
174 content::RenderProcessHost::AllHostsIterator());
175 !renderer_iter.IsAtEnd(); renderer_iter.Advance()) {
176 content::RenderProcessHost* render_process_host =
177 renderer_iter.GetCurrentValue();
[email protected]fcf79352010-12-28 20:13:20178 DCHECK(render_process_host);
[email protected]8a34e6602010-10-02 17:29:43179 // Ignore processes that don't have a connection, such as crashed tabs.
[email protected]fcf79352010-12-28 20:13:20180 if (!render_process_host->HasConnection() ||
181 process.pid != base::GetProcId(render_process_host->GetHandle())) {
[email protected]a27a9382009-02-11 23:55:10182 continue;
[email protected]201b2732009-11-13 18:57:46183 }
[email protected]bd5d6cf2011-12-01 00:39:12184 process.type = content::PROCESS_TYPE_RENDERER;
[email protected]9b62ecf2011-07-27 20:23:08185 Profile* profile =
[email protected]f3b1a082011-11-18 00:34:30186 Profile::FromBrowserContext(
187 render_process_host->GetBrowserContext());
[email protected]79dc42cd2011-01-08 21:43:35188 ExtensionService* extension_service = profile->GetExtensionService();
[email protected]6f371442011-11-09 06:45:46189 extensions::ProcessMap* extension_process_map =
190 extension_service->process_map();
[email protected]79dc42cd2011-01-08 21:43:35191
[email protected]a27a9382009-02-11 23:55:10192 // The RenderProcessHost may host multiple TabContents. Any
193 // of them which contain diagnostics information make the whole
194 // process be considered a diagnostics process.
195 //
196 // NOTE: This is a bit dangerous. We know that for now, listeners
197 // are always RenderWidgetHosts. But in theory, they don't
198 // have to be.
[email protected]f3b1a082011-11-18 00:34:30199 content::RenderProcessHost::listeners_iterator iter(
[email protected]fcf79352010-12-28 20:13:20200 render_process_host->ListenersIterator());
[email protected]9de09f82009-08-17 20:13:53201 for (; !iter.IsAtEnd(); iter.Advance()) {
202 const RenderWidgetHost* widget =
[email protected]fd1ff072012-02-23 14:48:22203 RenderWidgetHost::FromIPCChannelListener(iter.GetCurrentValue());
[email protected]a27a9382009-02-11 23:55:10204 DCHECK(widget);
205 if (!widget || !widget->IsRenderView())
206 continue;
initial.commit09911bf2008-07-26 23:55:29207
[email protected]9c1662b2012-03-06 15:44:33208 const RenderViewHost* host =
209 RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
[email protected]9f76c1e2012-03-05 15:15:58210 content::RenderViewHostDelegate* host_delegate = host->GetDelegate();
[email protected]4e6ffde2011-03-11 00:59:27211 DCHECK(host_delegate);
[email protected]fcf79352010-12-28 20:13:20212 GURL url = host_delegate->GetURL();
[email protected]da4dfc42011-10-12 15:53:56213 content::ViewType type = host_delegate->GetRenderViewType();
[email protected]9f76c1e2012-03-05 15:15:58214 if (host->GetEnabledBindings() & content::BINDINGS_POLICY_WEB_UI) {
[email protected]fcf79352010-12-28 20:13:20215 // TODO(erikkay) the type for devtools doesn't actually appear to
216 // be set.
[email protected]da4dfc42011-10-12 15:53:56217 if (type == content::VIEW_TYPE_DEV_TOOLS_UI)
[email protected]2c1978a2011-11-29 17:02:39218 process.renderer_type = ProcessMemoryInformation::RENDERER_DEVTOOLS;
[email protected]fcf79352010-12-28 20:13:20219 else
[email protected]2c1978a2011-11-29 17:02:39220 process.renderer_type = ProcessMemoryInformation::RENDERER_CHROME;
[email protected]9f76c1e2012-03-05 15:15:58221 } else if (extension_process_map->Contains(
222 host->GetProcess()->GetID())) {
[email protected]6f371442011-11-09 06:45:46223 // For our purposes, don't count processes containing only hosted apps
224 // as extension processes. See also: crbug.com/102533.
225 std::set<std::string> extension_ids =
226 extension_process_map->GetExtensionsInProcess(
[email protected]9f76c1e2012-03-05 15:15:58227 host->GetProcess()->GetID());
[email protected]6f371442011-11-09 06:45:46228 for (std::set<std::string>::iterator iter = extension_ids.begin();
229 iter != extension_ids.end(); ++iter) {
230 const Extension* extension =
231 extension_service->GetExtensionById(*iter, false);
232 if (extension && !extension->is_hosted_app()) {
[email protected]2c1978a2011-11-29 17:02:39233 process.renderer_type =
234 ProcessMemoryInformation::RENDERER_EXTENSION;
[email protected]6f371442011-11-09 06:45:46235 break;
236 }
237 }
[email protected]fcf79352010-12-28 20:13:20238 }
[email protected]83ff91c2012-01-05 20:54:13239 WebContents* contents = host_delegate->GetAsWebContents();
[email protected]fcf79352010-12-28 20:13:20240 if (!contents) {
[email protected]9f76c1e2012-03-05 15:15:58241 if (extension_process_map->Contains(host->GetProcess()->GetID())) {
[email protected]79dc42cd2011-01-08 21:43:35242 const Extension* extension =
[email protected]615d88f2011-12-13 01:47:44243 extension_service->extensions()->GetByID(url.host());
[email protected]79dc42cd2011-01-08 21:43:35244 if (extension) {
245 string16 title = UTF8ToUTF16(extension->name());
246 process.titles.push_back(title);
247 }
[email protected]fcf79352010-12-28 20:13:20248 } else if (process.renderer_type ==
[email protected]2c1978a2011-11-29 17:02:39249 ProcessMemoryInformation::RENDERER_UNKNOWN) {
[email protected]fcf79352010-12-28 20:13:20250 process.titles.push_back(UTF8ToUTF16(url.spec()));
251 switch (type) {
[email protected]da4dfc42011-10-12 15:53:56252 case chrome::VIEW_TYPE_BACKGROUND_CONTENTS:
[email protected]fcf79352010-12-28 20:13:20253 process.renderer_type =
[email protected]2c1978a2011-11-29 17:02:39254 ProcessMemoryInformation::RENDERER_BACKGROUND_APP;
[email protected]fcf79352010-12-28 20:13:20255 break;
[email protected]da4dfc42011-10-12 15:53:56256 case content::VIEW_TYPE_INTERSTITIAL_PAGE:
[email protected]2c1978a2011-11-29 17:02:39257 process.renderer_type =
258 ProcessMemoryInformation::RENDERER_INTERSTITIAL;
[email protected]fcf79352010-12-28 20:13:20259 break;
[email protected]da4dfc42011-10-12 15:53:56260 case chrome::VIEW_TYPE_NOTIFICATION:
[email protected]2c1978a2011-11-29 17:02:39261 process.renderer_type =
262 ProcessMemoryInformation::RENDERER_NOTIFICATION;
[email protected]fcf79352010-12-28 20:13:20263 break;
264 default:
[email protected]2c1978a2011-11-29 17:02:39265 process.renderer_type =
266 ProcessMemoryInformation::RENDERER_UNKNOWN;
[email protected]fcf79352010-12-28 20:13:20267 break;
268 }
269 }
[email protected]a27a9382009-02-11 23:55:10270 continue;
[email protected]fcf79352010-12-28 20:13:20271 }
272
[email protected]83ff91c2012-01-05 20:54:13273 // Since We have a WebContents and and the renderer type hasn't been
[email protected]fcf79352010-12-28 20:13:20274 // set yet, it must be a normal tabbed renderer.
[email protected]2c1978a2011-11-29 17:02:39275 if (process.renderer_type == ProcessMemoryInformation::RENDERER_UNKNOWN)
276 process.renderer_type = ProcessMemoryInformation::RENDERER_NORMAL;
[email protected]fcf79352010-12-28 20:13:20277
[email protected]4f260d02010-12-23 18:35:42278 string16 title = contents->GetTitle();
[email protected]a27a9382009-02-11 23:55:10279 if (!title.length())
[email protected]4f260d02010-12-23 18:35:42280 title = l10n_util::GetStringUTF16(IDS_DEFAULT_TAB_TITLE);
[email protected]a27a9382009-02-11 23:55:10281 process.titles.push_back(title);
[email protected]cd3d7892009-03-04 23:55:06282
[email protected]ebe89e062009-08-13 23:16:54283 // We need to check the pending entry as well as the virtual_url to
[email protected]37ae3f22011-07-12 03:56:14284 // see if it's a chrome://memory URL (we don't want to count these in
285 // the total memory usage of the browser).
[email protected]cd3d7892009-03-04 23:55:06286 //
[email protected]37ae3f22011-07-12 03:56:14287 // When we reach here, chrome://memory will be the pending entry since
288 // we haven't responded with any data such that it would be committed.
289 // If you have another chrome://memory tab open (which would be
290 // committed), we don't want to count it either, so we also check the
291 // last committed entry.
[email protected]cd3d7892009-03-04 23:55:06292 //
293 // Either the pending or last committed entries can be NULL.
[email protected]10f417c52011-12-28 21:04:23294 const NavigationEntry* pending_entry =
[email protected]022af742011-12-28 18:37:25295 contents->GetController().GetPendingEntry();
[email protected]10f417c52011-12-28 21:04:23296 const NavigationEntry* last_committed_entry =
[email protected]f5fa20e2011-12-21 22:35:56297 contents->GetController().GetLastCommittedEntry();
[email protected]cd3d7892009-03-04 23:55:06298 if ((last_committed_entry &&
[email protected]36fc0392011-12-25 03:59:51299 LowerCaseEqualsASCII(last_committed_entry->GetVirtualURL().spec(),
[email protected]37ae3f22011-07-12 03:56:14300 chrome::kChromeUIMemoryURL)) ||
[email protected]cd3d7892009-03-04 23:55:06301 (pending_entry &&
[email protected]36fc0392011-12-25 03:59:51302 LowerCaseEqualsASCII(pending_entry->GetVirtualURL().spec(),
[email protected]37ae3f22011-07-12 03:56:14303 chrome::kChromeUIMemoryURL)))
[email protected]a27a9382009-02-11 23:55:10304 process.is_diagnostics = true;
initial.commit09911bf2008-07-26 23:55:29305 }
306 }
[email protected]54fd1d32009-09-01 00:12:58307
[email protected]a423c9e2012-03-06 18:02:31308#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]54fd1d32009-09-01 00:12:58309 if (process.pid == zygote_pid) {
[email protected]bd5d6cf2011-12-01 00:39:12310 process.type = content::PROCESS_TYPE_ZYGOTE;
[email protected]54fd1d32009-09-01 00:12:58311 } else if (process.pid == sandbox_helper_pid) {
[email protected]bd5d6cf2011-12-01 00:39:12312 process.type = content::PROCESS_TYPE_SANDBOX_HELPER;
[email protected]54fd1d32009-09-01 00:12:58313 }
314#endif
initial.commit09911bf2008-07-26 23:55:29315 }
316
[email protected]a27a9382009-02-11 23:55:10317 // Get rid of other Chrome processes that are from a different profile.
[email protected]54fd1d32009-09-01 00:12:58318 for (size_t index = 0; index < chrome_browser->processes.size();
[email protected]a27a9382009-02-11 23:55:10319 index++) {
[email protected]54fd1d32009-09-01 00:12:58320 if (chrome_browser->processes[index].type ==
[email protected]bd5d6cf2011-12-01 00:39:12321 content::PROCESS_TYPE_UNKNOWN) {
[email protected]54fd1d32009-09-01 00:12:58322 chrome_browser->processes.erase(
323 chrome_browser->processes.begin() + index);
[email protected]a436d922009-02-13 23:16:42324 index--;
[email protected]a27a9382009-02-11 23:55:10325 }
326 }
327
initial.commit09911bf2008-07-26 23:55:29328 UpdateHistograms();
329
330 OnDetailsAvailable();
331}
332
333void MemoryDetails::UpdateHistograms() {
334 // Reports a set of memory metrics to UMA.
[email protected]57c4b852009-08-17 21:59:29335 // Memory is measured in KB.
initial.commit09911bf2008-07-26 23:55:29336
[email protected]54fd1d32009-09-01 00:12:58337 const ProcessData& browser = *ChromeBrowser();
initial.commit09911bf2008-07-26 23:55:29338 size_t aggregate_memory = 0;
[email protected]fcf79352010-12-28 20:13:20339 int chrome_count = 0;
340 int extension_count = 0;
[email protected]a27a9382009-02-11 23:55:10341 int plugin_count = 0;
[email protected]eef348fb2011-08-01 21:11:08342 int pepper_plugin_count = 0;
[email protected]fcf79352010-12-28 20:13:20343 int renderer_count = 0;
344 int other_count = 0;
[email protected]a27a9382009-02-11 23:55:10345 int worker_count = 0;
initial.commit09911bf2008-07-26 23:55:29346 for (size_t index = 0; index < browser.processes.size(); index++) {
[email protected]921cd0cc2008-10-21 22:30:55347 int sample = static_cast<int>(browser.processes[index].working_set.priv);
348 aggregate_memory += sample;
[email protected]a27a9382009-02-11 23:55:10349 switch (browser.processes[index].type) {
[email protected]bd5d6cf2011-12-01 00:39:12350 case content::PROCESS_TYPE_BROWSER:
[email protected]f164cea2009-11-05 23:37:40351 UMA_HISTOGRAM_MEMORY_KB("Memory.Browser", sample);
352 break;
[email protected]bd5d6cf2011-12-01 00:39:12353 case content::PROCESS_TYPE_RENDERER: {
[email protected]2c1978a2011-11-29 17:02:39354 ProcessMemoryInformation::RendererProcessType renderer_type =
[email protected]fcf79352010-12-28 20:13:20355 browser.processes[index].renderer_type;
356 switch (renderer_type) {
[email protected]2c1978a2011-11-29 17:02:39357 case ProcessMemoryInformation::RENDERER_EXTENSION:
[email protected]fcf79352010-12-28 20:13:20358 UMA_HISTOGRAM_MEMORY_KB("Memory.Extension", sample);
359 extension_count++;
360 break;
[email protected]2c1978a2011-11-29 17:02:39361 case ProcessMemoryInformation::RENDERER_CHROME:
[email protected]fcf79352010-12-28 20:13:20362 UMA_HISTOGRAM_MEMORY_KB("Memory.Chrome", sample);
363 chrome_count++;
364 break;
[email protected]2c1978a2011-11-29 17:02:39365 case ProcessMemoryInformation::RENDERER_UNKNOWN:
[email protected]fcf79352010-12-28 20:13:20366 NOTREACHED() << "Unknown renderer process type.";
367 break;
[email protected]2c1978a2011-11-29 17:02:39368 case ProcessMemoryInformation::RENDERER_NORMAL:
[email protected]fcf79352010-12-28 20:13:20369 default:
370 // TODO(erikkay): Should we bother splitting out the other subtypes?
371 UMA_HISTOGRAM_MEMORY_KB("Memory.Renderer", sample);
372 renderer_count++;
373 break;
374 }
[email protected]f164cea2009-11-05 23:37:40375 break;
[email protected]fcf79352010-12-28 20:13:20376 }
[email protected]bd5d6cf2011-12-01 00:39:12377 case content::PROCESS_TYPE_PLUGIN:
[email protected]f164cea2009-11-05 23:37:40378 UMA_HISTOGRAM_MEMORY_KB("Memory.Plugin", sample);
379 plugin_count++;
380 break;
[email protected]bd5d6cf2011-12-01 00:39:12381 case content::PROCESS_TYPE_WORKER:
[email protected]f164cea2009-11-05 23:37:40382 UMA_HISTOGRAM_MEMORY_KB("Memory.Worker", sample);
383 worker_count++;
384 break;
[email protected]bd5d6cf2011-12-01 00:39:12385 case content::PROCESS_TYPE_UTILITY:
[email protected]f164cea2009-11-05 23:37:40386 UMA_HISTOGRAM_MEMORY_KB("Memory.Utility", sample);
[email protected]fcf79352010-12-28 20:13:20387 other_count++;
[email protected]f164cea2009-11-05 23:37:40388 break;
[email protected]bd5d6cf2011-12-01 00:39:12389 case content::PROCESS_TYPE_ZYGOTE:
[email protected]f164cea2009-11-05 23:37:40390 UMA_HISTOGRAM_MEMORY_KB("Memory.Zygote", sample);
[email protected]fcf79352010-12-28 20:13:20391 other_count++;
[email protected]f164cea2009-11-05 23:37:40392 break;
[email protected]bd5d6cf2011-12-01 00:39:12393 case content::PROCESS_TYPE_SANDBOX_HELPER:
[email protected]f164cea2009-11-05 23:37:40394 UMA_HISTOGRAM_MEMORY_KB("Memory.SandboxHelper", sample);
[email protected]fcf79352010-12-28 20:13:20395 other_count++;
[email protected]f164cea2009-11-05 23:37:40396 break;
[email protected]bd5d6cf2011-12-01 00:39:12397 case content::PROCESS_TYPE_NACL_LOADER:
[email protected]f164cea2009-11-05 23:37:40398 UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClient", sample);
[email protected]fcf79352010-12-28 20:13:20399 other_count++;
[email protected]f164cea2009-11-05 23:37:40400 break;
[email protected]bd5d6cf2011-12-01 00:39:12401 case content::PROCESS_TYPE_NACL_BROKER:
[email protected]aef8d5ae2010-03-17 22:40:52402 UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClientBroker", sample);
[email protected]fcf79352010-12-28 20:13:20403 other_count++;
[email protected]aef8d5ae2010-03-17 22:40:52404 break;
[email protected]bd5d6cf2011-12-01 00:39:12405 case content::PROCESS_TYPE_GPU:
[email protected]96fcbf2d2010-08-03 16:10:27406 UMA_HISTOGRAM_MEMORY_KB("Memory.Gpu", sample);
[email protected]fcf79352010-12-28 20:13:20407 other_count++;
[email protected]96fcbf2d2010-08-03 16:10:27408 break;
[email protected]bd5d6cf2011-12-01 00:39:12409 case content::PROCESS_TYPE_PPAPI_PLUGIN:
[email protected]eef348fb2011-08-01 21:11:08410 UMA_HISTOGRAM_MEMORY_KB("Memory.PepperPlugin", sample);
411 pepper_plugin_count++;
412 break;
[email protected]f164cea2009-11-05 23:37:40413 default:
414 NOTREACHED();
[email protected]eef348fb2011-08-01 21:11:08415 break;
initial.commit09911bf2008-07-26 23:55:29416 }
417 }
[email protected]57c4b852009-08-17 21:59:29418 UMA_HISTOGRAM_MEMORY_KB("Memory.BackingStore",
[email protected]0b07be452012-02-29 01:14:42419 RenderWidgetHost::BackingStoreMemorySize() / 1024);
[email protected]a27a9382009-02-11 23:55:10420
[email protected]553dba62009-02-24 19:08:23421 UMA_HISTOGRAM_COUNTS_100("Memory.ProcessCount",
initial.commit09911bf2008-07-26 23:55:29422 static_cast<int>(browser.processes.size()));
[email protected]fcf79352010-12-28 20:13:20423 UMA_HISTOGRAM_COUNTS_100("Memory.ChromeProcessCount", chrome_count);
424 UMA_HISTOGRAM_COUNTS_100("Memory.ExtensionProcessCount", extension_count);
425 UMA_HISTOGRAM_COUNTS_100("Memory.OtherProcessCount", other_count);
[email protected]553dba62009-02-24 19:08:23426 UMA_HISTOGRAM_COUNTS_100("Memory.PluginProcessCount", plugin_count);
[email protected]eef348fb2011-08-01 21:11:08427 UMA_HISTOGRAM_COUNTS_100("Memory.PepperPluginProcessCount",
428 pepper_plugin_count);
[email protected]fcf79352010-12-28 20:13:20429 UMA_HISTOGRAM_COUNTS_100("Memory.RendererProcessCount", renderer_count);
[email protected]553dba62009-02-24 19:08:23430 UMA_HISTOGRAM_COUNTS_100("Memory.WorkerProcessCount", worker_count);
[email protected]f164cea2009-11-05 23:37:40431 // TODO(viettrungluu): Do we want separate counts for the other
432 // (platform-specific) process types?
[email protected]921cd0cc2008-10-21 22:30:55433
434 int total_sample = static_cast<int>(aggregate_memory / 1000);
[email protected]553dba62009-02-24 19:08:23435 UMA_HISTOGRAM_MEMORY_MB("Memory.Total", total_sample);
initial.commit09911bf2008-07-26 23:55:29436}