Add UMA stats for predicted process counts with out-of-process iframes.

chrome/browser/memory_details.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/memory_details.h"
 
 #include "base/bind.h"
 #include "base/file_version_info.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
@@ skipping 232 matching lines @@
       for (; !iter.IsAtEnd(); iter.Advance()) {
         const RenderWidgetHost* widget = iter.GetCurrentValue();
         DCHECK(widget);
         if (!widget || !widget->IsRenderView())
           continue;
 
         RenderViewHost* host =
             RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
         WebContents* contents = WebContents::FromRenderViewHost(host);
         GURL url;
-        if (contents)
+        if (contents) {
           url = contents->GetURL();
+          SiteData* site_data =
+              &chrome_browser->site_data[contents->GetBrowserContext()];
+          SiteDetails::CollectSiteInfo(contents, site_data);
+        }
         extensions::ViewType type = extensions::GetViewType(contents);
         if (host->GetEnabledBindings() & content::BINDINGS_POLICY_WEB_UI) {
           process.renderer_type = ProcessMemoryInformation::RENDERER_CHROME;
         } else if (extension_process_map &&
             extension_process_map->Contains(host->GetProcess()->GetID())) {
           // For our purposes, don't count processes containing only hosted apps
           // as extension processes. See also: crbug.com/102533.
           std::set<std::string> extension_ids =
               extension_process_map->GetExtensionsInProcess(
                   host->GetProcess()->GetID());
@@ skipping 109 matching lines @@
   const ProcessData& browser = *ChromeBrowser();
   size_t aggregate_memory = 0;
   int chrome_count = 0;
   int extension_count = 0;
   int plugin_count = 0;
   int pepper_plugin_count = 0;
   int pepper_plugin_broker_count = 0;
   int renderer_count = 0;
   int other_count = 0;
   int worker_count = 0;
+  int process_limit = content::RenderProcessHost::GetMaxRendererProcessCount();
   for (size_t index = 0; index < browser.processes.size(); index++) {
     int sample = static_cast<int>(browser.processes[index].working_set.priv);
     aggregate_memory += sample;
     switch (browser.processes[index].process_type) {
       case content::PROCESS_TYPE_BROWSER:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Browser", sample);
         break;
       case content::PROCESS_TYPE_RENDERER: {
         ProcessMemoryInformation::RendererProcessType renderer_type =
             browser.processes[index].renderer_type;
@@ skipping 66 matching lines @@
   UMA_HISTOGRAM_MEMORY_KB("Memory.BackingStore",
                           RenderWidgetHost::BackingStoreMemorySize() / 1024);
 #if defined(OS_CHROMEOS)
   // Chrome OS exposes system-wide graphics driver memory which has historically
   // been a source of leak/bloat.
   base::SystemMemoryInfoKB meminfo;
   if (base::GetSystemMemoryInfo(&meminfo) && meminfo.gem_size != -1)
     UMA_HISTOGRAM_MEMORY_MB("Memory.Graphics", meminfo.gem_size / 1024 / 1024);
 #endif
 
+  UMA_HISTOGRAM_COUNTS_100("Memory.ProcessLimit", process_limit);
   UMA_HISTOGRAM_COUNTS_100("Memory.ProcessCount",
       static_cast<int>(browser.processes.size()));
   UMA_HISTOGRAM_COUNTS_100("Memory.ChromeProcessCount", chrome_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.ExtensionProcessCount", extension_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.OtherProcessCount", other_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.PluginProcessCount", plugin_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.PepperPluginProcessCount",
       pepper_plugin_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.PepperPluginBrokerProcessCount",
       pepper_plugin_broker_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.RendererProcessCount", renderer_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.WorkerProcessCount", worker_count);
   // TODO(viettrungluu): Do we want separate counts for the other
   // (platform-specific) process types?
 
   int total_sample = static_cast<int>(aggregate_memory / 1000);
   UMA_HISTOGRAM_MEMORY_MB("Memory.Total", total_sample);
+
+  // Predict the number of processes needed when isolating all sites and when
+  // isolating only HTTPS sites.
+  int all_renderer_count = renderer_count + chrome_count + extension_count;
+  int non_renderer_count = browser.processes.size() - all_renderer_count;
+  SiteDetails::UpdateHistograms(browser.site_data, all_renderer_count,
+                                non_renderer_count);
 }