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 21 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 #include "content/public/browser/zygote_host_linux.h"
 #endif
 
 using base::StringPrintf;
 using content::BrowserChildProcessHostIterator;
 using content::BrowserThread;
 using content::NavigationEntry;
+using content::RenderProcessHost;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
+using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 
 // static
 std::string ProcessMemoryInformation::GetRendererTypeNameInEnglish(
     RendererProcessType type) {
   switch (type) {
     case RENDERER_NORMAL:
       return "Tab";
     case RENDERER_CHROME:
@@ skipping 32 matching lines @@
       renderer_type(RENDERER_UNKNOWN) {
 }
 
 ProcessMemoryInformation::~ProcessMemoryInformation() {}
 
 bool ProcessMemoryInformation::operator<(
     const ProcessMemoryInformation& rhs) const {
   return working_set.priv < rhs.working_set.priv;
 }
 
+SiteData::SiteData() {}
+
+SiteData::~SiteData() {}
+
 ProcessData::ProcessData() {}
 
 ProcessData::ProcessData(const ProcessData& rhs)
     : name(rhs.name),
       process_name(rhs.process_name),
       processes(rhs.processes) {
 }
 
 ProcessData::~ProcessData() {}
 
@@ skipping 137 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();
+          CollectSiteInfo(contents);
+        }
         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 95 matching lines @@
       index--;
     }
   }
 
   if (user_metrics_mode_ == UPDATE_USER_METRICS)
     UpdateHistograms();
 
   OnDetailsAvailable();
 }
 
+void MemoryDetails::CollectSiteInfo(WebContents* contents) {
+  ProcessData* const chrome_browser = ChromeBrowser();
+
+  // Keep track of data for each BrowserContext separately, since tabs in
+  // different BrowserContexts can't share processes.
+  content::BrowserContext* browser_context = contents->GetBrowserContext();
+  SiteData* site_data = &chrome_browser->site_data[browser_context];
+
+  // Find the BrowsingInstance this WebContents belongs to by iterating over
+  // the "primary" SiteInstances of each BrowsingInstance we've seen so far.
+  SiteInstance* instance = contents->GetSiteInstance();
+  SiteInstance* primary = NULL;
+  for (size_t i = 0; i < site_data->instances.size(); ++i) {
+    if (instance->IsRelatedSiteInstance(site_data->instances[i])) {
+      primary = site_data->instances[i];
+      break;
+    }
+  }
+  if (!primary) {
+    // Remember this as the "primary" SiteInstance of a new BrowsingInstance.
+    primary = instance;
+    site_data->instances.push_back(instance);
+  }
+
+  // Now keep track of how many sites we have in this BrowsingInstance (and
+  // overall), including sites in iframes.
+  std::set<GURL> sites_in_tab = contents->GetSitesInTab();
+  for (std::set<GURL>::iterator iter = sites_in_tab.begin();
+       iter != sites_in_tab.end(); ++iter) {

[nasko, 2013/06/11 20:16:37]

nit: Shouldn't the increment part of the loop be on a new line? The same pattern
is in use below.

[Charlie Reis, 2013/06/11 21:36:39]

No, this looks like a common pattern.  You only need to do one
parameter-per-line for things like function declarations.  It's fine to combine
the test and iterate parts of a for loop on the same line if there's space.

+    // Skip about:blank, since we won't usually give it its own process.
+    if (iter->is_empty())

[nasko, 2013/06/11 20:16:37]

Is "about:blank" an actual empty GURL? I thought we always commit "about:blank"
and it is an explicit GURL.

[Charlie Reis, 2013/06/11 21:36:39]

It comes from GetSiteForURL, which has the comment "// URLs with no host should
have an empty site."  Granted, that does mean that this code will ignore any URL
without a host, but I'm not sure there are others that matter here.  I've
updated the comment.

+      continue;
+
+    // Make sure we don't overcount process-per-site sites, like the NTP.
+    if (RenderProcessHost::ShouldUseProcessPerSite(browser_context, *iter) &&
+        site_data->sites.find(*iter) != site_data->sites.end()) {
+      continue;
+    }
+
+    site_data->sites.insert(*iter);
+    site_data->instance_site_map[primary->GetId()].insert(*iter);
+
+    // Also keep track of how things would look if we only isolated HTTPS sites.
+    // In this model, all HTTP sites are grouped into one "http://" site.  HTTPS
+    // and other schemes (e.g., chrome:) are still isolated.
+    GURL https_site = iter->SchemeIs("http") ? GURL("http://") : *iter;
+    site_data->https_sites.insert(https_site);
+    site_data->instance_https_site_map[primary->GetId()].insert(https_site);
+  }
+}
+
 void MemoryDetails::UpdateHistograms() {
   // Reports a set of memory metrics to UMA.
   // Memory is measured in KB.
 
   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 = 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);
+
+  // Sum the number of sites and SiteInstances in each BrowserContext.
+  int num_sites = 0;
+  int num_https_sites = 0;
+  int num_browsing_instances = 0;
+  int num_isolated_site_instances = 0;
+  int num_isolated_https_site_instances = 0;
+  for (BrowserContextSiteDataMap::const_iterator i = browser.site_data.begin();
+       i != browser.site_data.end(); ++i) {
+    num_sites += i->second.sites.size();
+    num_https_sites += i->second.https_sites.size();
+    num_browsing_instances += i->second.instance_site_map.size();
+    for (BrowsingInstanceSiteMap::const_iterator iter =
+             i->second.instance_site_map.begin();
+         iter != i->second.instance_site_map.end(); ++iter) {
+      num_isolated_site_instances += iter->second.size();
+    }
+    for (BrowsingInstanceSiteMap::const_iterator iter =
+             i->second.instance_https_site_map.begin();
+         iter != i->second.instance_https_site_map.end(); ++iter) {
+      num_isolated_https_site_instances += iter->second.size();
+    }
+  }
+
+  // Predict the number of processes needed when isolating all sites and when
+  // isolating only HTTPS sites.
+  int process_count_lower_bound = num_sites;
+  int process_count_upper_bound = num_sites + process_limit - 1;
+  int process_count_estimate = std::min(
+      num_isolated_site_instances, process_count_upper_bound);
+
+  int process_count_https_lower_bound = num_https_sites;
+  int process_count_https_upper_bound = num_https_sites + process_limit - 1;
+  int process_count_https_estimate = std::min(
+      num_isolated_https_site_instances, process_count_https_upper_bound);
+
+  // Just renderer process count:
+  int all_renderer_count = renderer_count + chrome_count + extension_count;
+  UMA_HISTOGRAM_COUNTS_100("SiteIsolation.CurrentRendererProcessCount",
+                           all_renderer_count);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.BrowsingInstanceCount",
+      num_browsing_instances);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateAllSitesProcessCountNoLimit",
+      num_isolated_site_instances);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateAllSitesProcessCountLowerBound",
+      process_count_lower_bound);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateAllSitesProcessCountEstimate",
+      process_count_estimate);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateHttpsSitesProcessCountNoLimit",
+      num_isolated_https_site_instances);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateHttpsSitesProcessCountLowerBound",
+      process_count_https_lower_bound);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateHttpsSitesProcessCountEstimate",
+      process_count_https_estimate);
+
+  // Total process count:
+  int non_renderer_count = browser.processes.size() - all_renderer_count;
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateAllSitesTotalProcessCountEstimate",
+      process_count_estimate + non_renderer_count);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateHttpsSitesTotalProcessCountEstimate",
+      process_count_https_estimate + non_renderer_count);
 }