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

chrome/browser/site_details.cc

+// Copyright 2013 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/site_details.h"
+
+#include "base/metrics/histogram.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
+
+using content::BrowserThread;
+using content::RenderProcessHost;
+using content::SiteInstance;
+using content::WebContents;
+
+SiteData::SiteData() {}
+
+SiteData::~SiteData() {}
+
+SiteDetails::SiteDetails() {}
+
+SiteDetails::~SiteDetails() {}
+
+void SiteDetails::CollectSiteInfo(WebContents* contents,
+                                  SiteData* site_data) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  content::BrowserContext* browser_context = contents->GetBrowserContext();
+
+  // 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) {
+    // Skip about:blank, since we won't usually give it its own process.
+    // Because about:blank has no host, its site URL will be blank.
+    if (iter->is_empty())
+      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 SiteDetails::UpdateHistograms(
+    const BrowserContextSiteDataMap& site_data_map,
+    int all_renderer_process_count,
+    int non_renderer_process_count) {
+  // Reports a set of site-based process metrics to UMA.
+  int process_limit = RenderProcessHost::GetMaxRendererProcessCount();
+
+  // 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 = site_data_map.begin();
+       i != site_data_map.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:
+  UMA_HISTOGRAM_COUNTS_100("SiteIsolation.CurrentRendererProcessCount",
+                           all_renderer_process_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:
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateAllSitesTotalProcessCountEstimate",
+      process_count_estimate + non_renderer_process_count);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateHttpsSitesTotalProcessCountEstimate",
+      process_count_https_estimate + non_renderer_process_count);
+}