src/chrome/browser/memory_details.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/memory_details.h"
   6
   7 #include "base/bind.h"
   8 #include "base/file_version_info.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "chrome/browser/extensions/extension_process_manager.h"
  14 #include "chrome/browser/extensions/extension_service.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/common/extensions/extension.h"
  17 #include "chrome/common/url_constants.h"
  18 #include "components/nacl/common/nacl_process_type.h"
  19 #include "content/public/browser/browser_child_process_host_iterator.h"
  20 #include "content/public/browser/browser_thread.h"
  21 #include "content/public/browser/child_process_data.h"
  22 #include "content/public/browser/navigation_controller.h"
  23 #include "content/public/browser/navigation_entry.h"
  24 #include "content/public/browser/render_process_host.h"
  25 #include "content/public/browser/render_view_host.h"
  26 #include "content/public/browser/render_widget_host_iterator.h"
  27 #include "content/public/browser/web_contents.h"
  28 #include "content/public/common/bindings_policy.h"
  29 #include "extensions/browser/view_type_utils.h"
  30 #include "grit/chromium_strings.h"
  31 #include "grit/generated_resources.h"
  32 #include "ui/base/l10n/l10n_util.h"
  33
  34 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
  35 #include "content/public/browser/zygote_host_linux.h"
  36 #endif
  37
  38 using base::StringPrintf;
  39 using content::BrowserChildProcessHostIterator;
  40 using content::BrowserThread;
  41 using content::NavigationEntry;
  42 using content::RenderViewHost;
  43 using content::RenderWidgetHost;
  44 using content::WebContents;
  45 using extensions::Extension;
  46
  47 // static
  48 std::string ProcessMemoryInformation::GetRendererTypeNameInEnglish(
  49     RendererProcessType type) {
  50   switch (type) {
  51     case RENDERER_NORMAL:
  52       return "Tab";
  53     case RENDERER_CHROME:
  54       return "Tab (Chrome)";
  55     case RENDERER_EXTENSION:
  56       return "Extension";
  57     case RENDERER_DEVTOOLS:
  58       return "Devtools";
  59     case RENDERER_INTERSTITIAL:
  60       return "Interstitial";
  61     case RENDERER_NOTIFICATION:
  62       return "Notification";
  63     case RENDERER_BACKGROUND_APP:
  64       return "Background App";
  65     case RENDERER_UNKNOWN:
  66     default:
  67       NOTREACHED() << "Unknown renderer process type!";
  68       return "Unknown";
  69   }
  70 }
  71
  72 // static
  73 std::string ProcessMemoryInformation::GetFullTypeNameInEnglish(
  74     int process_type,
  75     RendererProcessType rtype) {
  76   if (process_type == content::PROCESS_TYPE_RENDERER)
  77     return GetRendererTypeNameInEnglish(rtype);
  78   return content::GetProcessTypeNameInEnglish(process_type);
  79 }
  80
  81 ProcessMemoryInformation::ProcessMemoryInformation()
  82     : pid(0),
  83       num_processes(0),
  84       is_diagnostics(false),
  85       process_type(content::PROCESS_TYPE_UNKNOWN),
  86       renderer_type(RENDERER_UNKNOWN) {
  87 }
  88
  89 ProcessMemoryInformation::~ProcessMemoryInformation() {}
  90
  91 bool ProcessMemoryInformation::operator<(
  92     const ProcessMemoryInformation& rhs) const {
  93   return working_set.priv < rhs.working_set.priv;
  94 }
  95
  96 ProcessData::ProcessData() {}
  97
  98 ProcessData::ProcessData(const ProcessData& rhs)
  99     : name(rhs.name),
 100       process_name(rhs.process_name),
 101       processes(rhs.processes) {
 102 }
 103
 104 ProcessData::~ProcessData() {}
 105
 106 ProcessData& ProcessData::operator=(const ProcessData& rhs) {
 107   name = rhs.name;
 108   process_name = rhs.process_name;
 109   processes = rhs.processes;
 110   return *this;
 111 }
 112
 113 // About threading:
 114 //
 115 // This operation will hit no fewer than 3 threads.
 116 //
 117 // The BrowserChildProcessHostIterator can only be accessed from the IO thread.
 118 //
 119 // The RenderProcessHostIterator can only be accessed from the UI thread.
 120 //
 121 // This operation can take 30-100ms to complete.  We never want to have
 122 // one task run for that long on the UI or IO threads.  So, we run the
 123 // expensive parts of this operation over on the file thread.
 124 //
 125 void MemoryDetails::StartFetch(UserMetricsMode user_metrics_mode) {
 126   // This might get called from the UI or FILE threads, but should not be
 127   // getting called from the IO thread.
 128   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
 129   user_metrics_mode_ = user_metrics_mode;
 130
 131   // In order to process this request, we need to use the plugin information.
 132   // However, plugin process information is only available from the IO thread.
 133   BrowserThread::PostTask(
 134       BrowserThread::IO, FROM_HERE,
 135       base::Bind(&MemoryDetails::CollectChildInfoOnIOThread, this));
 136 }
 137
 138 MemoryDetails::~MemoryDetails() {}
 139
 140 std::string MemoryDetails::ToLogString() {
 141   std::string log;
 142   log.reserve(4096);
 143   ProcessMemoryInformationList processes = ChromeBrowser()->processes;
 144   // Sort by memory consumption, low to high.
 145   std::sort(processes.begin(), processes.end());
 146   // Print from high to low.
 147   for (ProcessMemoryInformationList::reverse_iterator iter1 =
 148           processes.rbegin();
 149        iter1 != processes.rend();
 150        ++iter1) {
 151     log += ProcessMemoryInformation::GetFullTypeNameInEnglish(
 152             iter1->process_type, iter1->renderer_type);
 153     if (!iter1->titles.empty()) {
 154       log += " [";
 155       for (std::vector<string16>::const_iterator iter2 =
 156                iter1->titles.begin();
 157            iter2 != iter1->titles.end(); ++iter2) {
 158         if (iter2 != iter1->titles.begin())
 159           log += "|";
 160         log += UTF16ToUTF8(*iter2);
 161       }
 162       log += "]";
 163     }
 164     log += StringPrintf(" %d MB private, %d MB shared",
 165                         static_cast<int>(iter1->working_set.priv) / 1024,
 166                         static_cast<int>(iter1->working_set.shared) / 1024);
 167 #if defined(OS_CHROMEOS)
 168     log += StringPrintf(", %d MB swapped",
 169                         static_cast<int>(iter1->working_set.swapped) / 1024);
 170 #endif
 171     log += "\n";
 172   }
 173   return log;
 174 }
 175
 176 void MemoryDetails::CollectChildInfoOnIOThread() {
 177   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 178
 179   std::vector<ProcessMemoryInformation> child_info;
 180
 181   // Collect the list of child processes. A 0 |handle| means that
 182   // the process is being launched, so we skip it.
 183   for (BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) {
 184     ProcessMemoryInformation info;
 185     if (!iter.GetData().handle)
 186       continue;
 187     info.pid = base::GetProcId(iter.GetData().handle);
 188     if (!info.pid)
 189       continue;
 190
 191     info.process_type = iter.GetData().process_type;
 192     info.renderer_type = ProcessMemoryInformation::RENDERER_UNKNOWN;
 193     info.titles.push_back(iter.GetData().name);
 194     child_info.push_back(info);
 195   }
 196
 197   // Now go do expensive memory lookups from the file thread.
 198   BrowserThread::PostTask(
 199       BrowserThread::FILE, FROM_HERE,
 200       base::Bind(&MemoryDetails::CollectProcessData, this, child_info));
 201 }
 202
 203 void MemoryDetails::CollectChildInfoOnUIThread() {
 204   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 205
 206 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 207   const pid_t zygote_pid = content::ZygoteHost::GetInstance()->GetPid();
 208   const pid_t sandbox_helper_pid =
 209       content::ZygoteHost::GetInstance()->GetSandboxHelperPid();
 210 #endif
 211
 212   ProcessData* const chrome_browser = ChromeBrowser();
 213   // Get more information about the process.
 214   for (size_t index = 0; index < chrome_browser->processes.size();
 215       index++) {
 216     // Check if it's a renderer, if so get the list of page titles in it and
 217     // check if it's a diagnostics-related process.  We skip about:memory pages.
 218     // Iterate the RenderProcessHosts to find the tab contents.
 219     ProcessMemoryInformation& process =
 220         chrome_browser->processes[index];
 221
 222     scoped_ptr<content::RenderWidgetHostIterator> widgets(
 223         RenderWidgetHost::GetRenderWidgetHosts());
 224     while (content::RenderWidgetHost* widget = widgets->GetNextHost()) {
 225       content::RenderProcessHost* render_process_host =
 226           widget->GetProcess();
 227       DCHECK(render_process_host);
 228       // Ignore processes that don't have a connection, such as crashed tabs.
 229       if (!render_process_host->HasConnection() ||
 230           process.pid != base::GetProcId(render_process_host->GetHandle())) {
 231         continue;
 232       }
 233       process.process_type = content::PROCESS_TYPE_RENDERER;
 234       Profile* profile =
 235           Profile::FromBrowserContext(
 236               render_process_host->GetBrowserContext());
 237       ExtensionService* extension_service = profile->GetExtensionService();
 238       extensions::ProcessMap* extension_process_map = NULL;
 239       // No extensions on Android. So extension_service can be NULL.
 240       if (extension_service)
 241           extension_process_map = extension_service->process_map();
 242
 243       // The RenderProcessHost may host multiple WebContentses.  Any
 244       // of them which contain diagnostics information make the whole
 245       // process be considered a diagnostics process.
 246       if (!widget->IsRenderView())
 247         continue;
 248
 249       RenderViewHost* host = RenderViewHost::From(widget);
 250       WebContents* contents = WebContents::FromRenderViewHost(host);
 251       GURL url;
 252       if (contents) {
 253         url = contents->GetURL();
 254         SiteData* site_data =
 255             &chrome_browser->site_data[contents->GetBrowserContext()];
 256         SiteDetails::CollectSiteInfo(contents, site_data);
 257       }
 258       extensions::ViewType type = extensions::GetViewType(contents);
 259       if (host->GetEnabledBindings() & content::BINDINGS_POLICY_WEB_UI) {
 260         process.renderer_type = ProcessMemoryInformation::RENDERER_CHROME;
 261       } else if (extension_process_map &&
 262                  extension_process_map->Contains(host->GetProcess()->GetID())) {
 263         // For our purposes, don't count processes containing only hosted apps
 264         // as extension processes. See also: crbug.com/102533.
 265         std::set<std::string> extension_ids =
 266             extension_process_map->GetExtensionsInProcess(
 267             host->GetProcess()->GetID());
 268         for (std::set<std::string>::iterator iter = extension_ids.begin();
 269              iter != extension_ids.end(); ++iter) {
 270           const Extension* extension =
 271               extension_service->GetExtensionById(*iter, false);
 272           if (extension && !extension->is_hosted_app()) {
 273             process.renderer_type =
 274                 ProcessMemoryInformation::RENDERER_EXTENSION;
 275             break;
 276           }
 277         }
 278       }
 279       if (extension_process_map &&
 280           extension_process_map->Contains(host->GetProcess()->GetID())) {
 281         const Extension* extension =
 282             extension_service->extensions()->GetByID(url.host());
 283         if (extension) {
 284           string16 title = UTF8ToUTF16(extension->name());
 285           process.titles.push_back(title);
 286           process.renderer_type =
 287               ProcessMemoryInformation::RENDERER_EXTENSION;
 288           continue;
 289         }
 290       }
 291
 292       if (!contents) {
 293         process.renderer_type =
 294             ProcessMemoryInformation::RENDERER_INTERSTITIAL;
 295         continue;
 296       }
 297
 298       if (type == extensions::VIEW_TYPE_BACKGROUND_CONTENTS) {
 299         process.titles.push_back(UTF8ToUTF16(url.spec()));
 300         process.renderer_type =
 301             ProcessMemoryInformation::RENDERER_BACKGROUND_APP;
 302         continue;
 303       }
 304
 305       if (type == extensions::VIEW_TYPE_NOTIFICATION) {
 306         process.titles.push_back(UTF8ToUTF16(url.spec()));
 307         process.renderer_type =
 308             ProcessMemoryInformation::RENDERER_NOTIFICATION;
 309         continue;
 310       }
 311
 312       // Since we have a WebContents and and the renderer type hasn't been
 313       // set yet, it must be a normal tabbed renderer.
 314       if (process.renderer_type == ProcessMemoryInformation::RENDERER_UNKNOWN)
 315         process.renderer_type = ProcessMemoryInformation::RENDERER_NORMAL;
 316
 317       string16 title = contents->GetTitle();
 318       if (!title.length())
 319         title = l10n_util::GetStringUTF16(IDS_DEFAULT_TAB_TITLE);
 320       process.titles.push_back(title);
 321
 322       // We need to check the pending entry as well as the virtual_url to
 323       // see if it's a chrome://memory URL (we don't want to count these in
 324       // the total memory usage of the browser).
 325       //
 326       // When we reach here, chrome://memory will be the pending entry since
 327       // we haven't responded with any data such that it would be committed.
 328       // If you have another chrome://memory tab open (which would be
 329       // committed), we don't want to count it either, so we also check the
 330       // last committed entry.
 331       //
 332       // Either the pending or last committed entries can be NULL.
 333       const NavigationEntry* pending_entry =
 334           contents->GetController().GetPendingEntry();
 335       const NavigationEntry* last_committed_entry =
 336           contents->GetController().GetLastCommittedEntry();
 337       if ((last_committed_entry &&
 338            LowerCaseEqualsASCII(last_committed_entry->GetVirtualURL().spec(),
 339                                 chrome::kChromeUIMemoryURL)) ||
 340           (pending_entry &&
 341            LowerCaseEqualsASCII(pending_entry->GetVirtualURL().spec(),
 342                                 chrome::kChromeUIMemoryURL))) {
 343         process.is_diagnostics = true;
 344       }
 345     }
 346
 347 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 348     if (process.pid == zygote_pid) {
 349       process.process_type = content::PROCESS_TYPE_ZYGOTE;
 350     } else if (process.pid == sandbox_helper_pid) {
 351       process.process_type = content::PROCESS_TYPE_SANDBOX_HELPER;
 352     }
 353 #endif
 354   }
 355
 356   // Get rid of other Chrome processes that are from a different profile.
 357   for (size_t index = 0; index < chrome_browser->processes.size();
 358       index++) {
 359     if (chrome_browser->processes[index].process_type ==
 360         content::PROCESS_TYPE_UNKNOWN) {
 361       chrome_browser->processes.erase(
 362           chrome_browser->processes.begin() + index);
 363       index--;
 364     }
 365   }
 366
 367   if (user_metrics_mode_ == UPDATE_USER_METRICS)
 368     UpdateHistograms();
 369
 370   OnDetailsAvailable();
 371 }
 372
 373 void MemoryDetails::UpdateHistograms() {
 374   // Reports a set of memory metrics to UMA.
 375   // Memory is measured in KB.
 376
 377   const ProcessData& browser = *ChromeBrowser();
 378   size_t aggregate_memory = 0;
 379   int chrome_count = 0;
 380   int extension_count = 0;
 381   int plugin_count = 0;
 382   int pepper_plugin_count = 0;
 383   int pepper_plugin_broker_count = 0;
 384   int renderer_count = 0;
 385   int other_count = 0;
 386   int worker_count = 0;
 387   int process_limit = content::RenderProcessHost::GetMaxRendererProcessCount();
 388   for (size_t index = 0; index < browser.processes.size(); index++) {
 389     int sample = static_cast<int>(browser.processes[index].working_set.priv);
 390     aggregate_memory += sample;
 391     switch (browser.processes[index].process_type) {
 392       case content::PROCESS_TYPE_BROWSER:
 393         UMA_HISTOGRAM_MEMORY_KB("Memory.Browser", sample);
 394         continue;
 395       case content::PROCESS_TYPE_RENDERER: {
 396         ProcessMemoryInformation::RendererProcessType renderer_type =
 397             browser.processes[index].renderer_type;
 398         switch (renderer_type) {
 399           case ProcessMemoryInformation::RENDERER_EXTENSION:
 400             UMA_HISTOGRAM_MEMORY_KB("Memory.Extension", sample);
 401             extension_count++;
 402             continue;
 403           case ProcessMemoryInformation::RENDERER_CHROME:
 404             UMA_HISTOGRAM_MEMORY_KB("Memory.Chrome", sample);
 405             chrome_count++;
 406             continue;
 407           case ProcessMemoryInformation::RENDERER_UNKNOWN:
 408             NOTREACHED() << "Unknown renderer process type.";
 409             continue;
 410           case ProcessMemoryInformation::RENDERER_NORMAL:
 411           default:
 412             // TODO(erikkay): Should we bother splitting out the other subtypes?
 413             UMA_HISTOGRAM_MEMORY_KB("Memory.Renderer", sample);
 414             renderer_count++;
 415             continue;
 416         }
 417       }
 418       case content::PROCESS_TYPE_PLUGIN:
 419         UMA_HISTOGRAM_MEMORY_KB("Memory.Plugin", sample);
 420         plugin_count++;
 421         continue;
 422       case content::PROCESS_TYPE_WORKER:
 423         UMA_HISTOGRAM_MEMORY_KB("Memory.Worker", sample);
 424         worker_count++;
 425         continue;
 426       case content::PROCESS_TYPE_UTILITY:
 427         UMA_HISTOGRAM_MEMORY_KB("Memory.Utility", sample);
 428         other_count++;
 429         continue;
 430       case content::PROCESS_TYPE_ZYGOTE:
 431         UMA_HISTOGRAM_MEMORY_KB("Memory.Zygote", sample);
 432         other_count++;
 433         continue;
 434       case content::PROCESS_TYPE_SANDBOX_HELPER:
 435         UMA_HISTOGRAM_MEMORY_KB("Memory.SandboxHelper", sample);
 436         other_count++;
 437         continue;
 438       case content::PROCESS_TYPE_GPU:
 439         UMA_HISTOGRAM_MEMORY_KB("Memory.Gpu", sample);
 440         other_count++;
 441         continue;
 442       case content::PROCESS_TYPE_PPAPI_PLUGIN:
 443         UMA_HISTOGRAM_MEMORY_KB("Memory.PepperPlugin", sample);
 444         pepper_plugin_count++;
 445         continue;
 446       case content::PROCESS_TYPE_PPAPI_BROKER:
 447         UMA_HISTOGRAM_MEMORY_KB("Memory.PepperPluginBroker", sample);
 448         pepper_plugin_broker_count++;
 449         continue;
 450       case PROCESS_TYPE_NACL_LOADER:
 451         UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClient", sample);
 452         other_count++;
 453         continue;
 454       case PROCESS_TYPE_NACL_BROKER:
 455         UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClientBroker", sample);
 456         other_count++;
 457         continue;
 458       default:
 459         NOTREACHED();
 460         continue;
 461     }
 462   }
 463   UMA_HISTOGRAM_MEMORY_KB("Memory.BackingStore",
 464                           RenderWidgetHost::BackingStoreMemorySize() / 1024);
 465 #if defined(OS_CHROMEOS)
 466   // Chrome OS exposes system-wide graphics driver memory which has historically
 467   // been a source of leak/bloat.
 468   base::SystemMemoryInfoKB meminfo;
 469   if (base::GetSystemMemoryInfo(&meminfo) && meminfo.gem_size != -1)
 470     UMA_HISTOGRAM_MEMORY_MB("Memory.Graphics", meminfo.gem_size / 1024 / 1024);
 471 #endif
 472
 473   UMA_HISTOGRAM_COUNTS_100("Memory.ProcessLimit", process_limit);
 474   UMA_HISTOGRAM_COUNTS_100("Memory.ProcessCount",
 475       static_cast<int>(browser.processes.size()));
 476   UMA_HISTOGRAM_COUNTS_100("Memory.ChromeProcessCount", chrome_count);
 477   UMA_HISTOGRAM_COUNTS_100("Memory.ExtensionProcessCount", extension_count);
 478   UMA_HISTOGRAM_COUNTS_100("Memory.OtherProcessCount", other_count);
 479   UMA_HISTOGRAM_COUNTS_100("Memory.PluginProcessCount", plugin_count);
 480   UMA_HISTOGRAM_COUNTS_100("Memory.PepperPluginProcessCount",
 481       pepper_plugin_count);
 482   UMA_HISTOGRAM_COUNTS_100("Memory.PepperPluginBrokerProcessCount",
 483       pepper_plugin_broker_count);
 484   UMA_HISTOGRAM_COUNTS_100("Memory.RendererProcessCount", renderer_count);
 485   UMA_HISTOGRAM_COUNTS_100("Memory.WorkerProcessCount", worker_count);
 486   // TODO(viettrungluu): Do we want separate counts for the other
 487   // (platform-specific) process types?
 488
 489   int total_sample = static_cast<int>(aggregate_memory / 1000);
 490   UMA_HISTOGRAM_MEMORY_MB("Memory.Total", total_sample);
 491
 492 #if defined(OS_CHROMEOS)
 493   UpdateSwapHistograms();
 494 #endif
 495
 496 }
 497
 498 #if defined(OS_CHROMEOS)
 499 void MemoryDetails::UpdateSwapHistograms() {
 500   UMA_HISTOGRAM_BOOLEAN("Memory.Swap.HaveSwapped", swap_info_.num_writes > 0);
 501   if (swap_info_.num_writes == 0)
 502     return;
 503
 504   // Only record swap info when any swaps have happened, to give us more
 505   // detail in the histograms.
 506   const ProcessData& browser = *ChromeBrowser();
 507   size_t aggregate_memory = 0;
 508   for (size_t index = 0; index < browser.processes.size(); index++) {
 509     int sample = static_cast<int>(browser.processes[index].working_set.swapped);
 510     aggregate_memory += sample;
 511     switch (browser.processes[index].process_type) {
 512       case content::PROCESS_TYPE_BROWSER:
 513         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.Browser", sample);
 514         continue;
 515       case content::PROCESS_TYPE_RENDERER: {
 516         ProcessMemoryInformation::RendererProcessType renderer_type =
 517             browser.processes[index].renderer_type;
 518         switch (renderer_type) {
 519           case ProcessMemoryInformation::RENDERER_EXTENSION:
 520             UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.Extension", sample);
 521             continue;
 522           case ProcessMemoryInformation::RENDERER_CHROME:
 523             UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.Chrome", sample);
 524             continue;
 525           case ProcessMemoryInformation::RENDERER_UNKNOWN:
 526             NOTREACHED() << "Unknown renderer process type.";
 527             continue;
 528           case ProcessMemoryInformation::RENDERER_NORMAL:
 529           default:
 530             UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.Renderer", sample);
 531             continue;
 532         }
 533       }
 534       case content::PROCESS_TYPE_PLUGIN:
 535         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.Plugin", sample);
 536         continue;
 537       case content::PROCESS_TYPE_WORKER:
 538         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.Worker", sample);
 539         continue;
 540       case content::PROCESS_TYPE_UTILITY:
 541         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.Utility", sample);
 542         continue;
 543       case content::PROCESS_TYPE_ZYGOTE:
 544         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.Zygote", sample);
 545         continue;
 546       case content::PROCESS_TYPE_SANDBOX_HELPER:
 547         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.SandboxHelper", sample);
 548         continue;
 549       case content::PROCESS_TYPE_GPU:
 550         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.Gpu", sample);
 551         continue;
 552       case content::PROCESS_TYPE_PPAPI_PLUGIN:
 553         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.PepperPlugin", sample);
 554         continue;
 555       case content::PROCESS_TYPE_PPAPI_BROKER:
 556         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.PepperPluginBroker", sample);
 557         continue;
 558       case PROCESS_TYPE_NACL_LOADER:
 559         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.NativeClient", sample);
 560         continue;
 561       case PROCESS_TYPE_NACL_BROKER:
 562         UMA_HISTOGRAM_MEMORY_KB("Memory.Swap.NativeClientBroker", sample);
 563         continue;
 564       default:
 565         NOTREACHED();
 566         continue;
 567     }
 568   }
 569
 570   int total_sample = static_cast<int>(aggregate_memory / 1000);
 571   UMA_HISTOGRAM_MEMORY_MB("Memory.Swap.Total", total_sample);
 572
 573   UMA_HISTOGRAM_CUSTOM_COUNTS("Memory.Swap.CompressedDataSize",
 574                               swap_info_.compr_data_size / (1024 * 1024),
 575                               1, 4096, 50);
 576   UMA_HISTOGRAM_CUSTOM_COUNTS("Memory.Swap.OriginalDataSize",
 577                               swap_info_.orig_data_size / (1024 * 1024),
 578                               1, 4096, 50);
 579   UMA_HISTOGRAM_CUSTOM_COUNTS("Memory.Swap.MemUsedTotal",
 580                               swap_info_.mem_used_total / (1024 * 1024),
 581                               1, 4096, 50);
 582   UMA_HISTOGRAM_CUSTOM_COUNTS("Memory.Swap.NumReads",
 583                               swap_info_.num_reads,
 584                               1, 100000000, 100);
 585   UMA_HISTOGRAM_CUSTOM_COUNTS("Memory.Swap.NumWrites",
 586                               swap_info_.num_writes,
 587                               1, 100000000, 100);
 588
 589   if (swap_info_.orig_data_size > 0 && swap_info_.compr_data_size > 0) {
 590     UMA_HISTOGRAM_CUSTOM_COUNTS(
 591         "Memory.Swap.CompressionRatio",
 592         swap_info_.orig_data_size / swap_info_.compr_data_size,
 593         1, 20, 20);
 594   }
 595 }
 596
 597 #endif