chrome/browser/site_details.cc

   1 // Copyright 2013 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/site_details.h"
   6
   7 #include "base/metrics/histogram.h"
   8 #include "content/public/browser/browser_thread.h"
   9 #include "content/public/browser/render_process_host.h"
  10
  11 using content::BrowserThread;
  12 using content::RenderProcessHost;
  13 using content::SiteInstance;
  14 using content::WebContents;
  15
  16 SiteData::SiteData() {}
  17
  18 SiteData::~SiteData() {}
  19
  20 SiteDetails::SiteDetails() {}
  21
  22 SiteDetails::~SiteDetails() {}
  23
  24 void SiteDetails::CollectSiteInfo(WebContents* contents,
  25                                   SiteData* site_data) {
  26   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  27   content::BrowserContext* browser_context = contents->GetBrowserContext();
  28
  29   // Find the BrowsingInstance this WebContents belongs to by iterating over
  30   // the "primary" SiteInstances of each BrowsingInstance we've seen so far.
  31   SiteInstance* instance = contents->GetSiteInstance();
  32   SiteInstance* primary = NULL;
  33   for (size_t i = 0; i < site_data->instances.size(); ++i) {
  34     if (instance->IsRelatedSiteInstance(site_data->instances[i])) {
  35       primary = site_data->instances[i];
  36       break;
  37     }
  38   }
  39   if (!primary) {
  40     // Remember this as the "primary" SiteInstance of a new BrowsingInstance.
  41     primary = instance;
  42     site_data->instances.push_back(instance);
  43   }
  44
  45   // Now keep track of how many sites we have in this BrowsingInstance (and
  46   // overall), including sites in iframes.
  47   std::set<GURL> sites_in_tab = contents->GetSitesInTab();
  48   for (std::set<GURL>::iterator iter = sites_in_tab.begin();
  49        iter != sites_in_tab.end(); ++iter) {
  50     // Skip about:blank, since we won't usually give it its own process.
  51     // Because about:blank has no host, its site URL will be blank.
  52     if (iter->is_empty())
  53       continue;
  54
  55     // Make sure we don't overcount process-per-site sites, like the NTP.
  56     if (RenderProcessHost::ShouldUseProcessPerSite(browser_context, *iter) &&
  57         site_data->sites.find(*iter) != site_data->sites.end()) {
  58       continue;
  59     }
  60
  61     site_data->sites.insert(*iter);
  62     site_data->instance_site_map[primary->GetId()].insert(*iter);
  63
  64     // Also keep track of how things would look if we only isolated HTTPS sites.
  65     // In this model, all HTTP sites are grouped into one "http://" site.  HTTPS
  66     // and other schemes (e.g., chrome:) are still isolated.
  67     GURL https_site = iter->SchemeIs("http") ? GURL("http://") : *iter;
  68     site_data->https_sites.insert(https_site);
  69     site_data->instance_https_site_map[primary->GetId()].insert(https_site);
  70   }
  71 }
  72
  73 void SiteDetails::UpdateHistograms(
  74     const BrowserContextSiteDataMap& site_data_map,
  75     int all_renderer_process_count,
  76     int non_renderer_process_count) {
  77   // Reports a set of site-based process metrics to UMA.
  78   int process_limit = RenderProcessHost::GetMaxRendererProcessCount();
  79
  80   // Sum the number of sites and SiteInstances in each BrowserContext.
  81   int num_sites = 0;
  82   int num_https_sites = 0;
  83   int num_browsing_instances = 0;
  84   int num_isolated_site_instances = 0;
  85   int num_isolated_https_site_instances = 0;
  86   for (BrowserContextSiteDataMap::const_iterator i = site_data_map.begin();
  87        i != site_data_map.end(); ++i) {
  88     num_sites += i->second.sites.size();
  89     num_https_sites += i->second.https_sites.size();
  90     num_browsing_instances += i->second.instance_site_map.size();
  91     for (BrowsingInstanceSiteMap::const_iterator iter =
  92              i->second.instance_site_map.begin();
  93          iter != i->second.instance_site_map.end(); ++iter) {
  94       num_isolated_site_instances += iter->second.size();
  95     }
  96     for (BrowsingInstanceSiteMap::const_iterator iter =
  97              i->second.instance_https_site_map.begin();
  98          iter != i->second.instance_https_site_map.end(); ++iter) {
  99       num_isolated_https_site_instances += iter->second.size();
 100     }
 101   }
 102
 103   // Predict the number of processes needed when isolating all sites and when
 104   // isolating only HTTPS sites.
 105   int process_count_lower_bound = num_sites;
 106   int process_count_upper_bound = num_sites + process_limit - 1;
 107   int process_count_estimate = std::min(
 108       num_isolated_site_instances, process_count_upper_bound);
 109
 110   int process_count_https_lower_bound = num_https_sites;
 111   int process_count_https_upper_bound = num_https_sites + process_limit - 1;
 112   int process_count_https_estimate = std::min(
 113       num_isolated_https_site_instances, process_count_https_upper_bound);
 114
 115   // Just renderer process count:
 116   UMA_HISTOGRAM_COUNTS_100("SiteIsolation.CurrentRendererProcessCount",
 117                            all_renderer_process_count);
 118   UMA_HISTOGRAM_COUNTS_100(
 119       "SiteIsolation.BrowsingInstanceCount",
 120       num_browsing_instances);
 121   UMA_HISTOGRAM_COUNTS_100(
 122       "SiteIsolation.IsolateAllSitesProcessCountNoLimit",
 123       num_isolated_site_instances);
 124   UMA_HISTOGRAM_COUNTS_100(
 125       "SiteIsolation.IsolateAllSitesProcessCountLowerBound",
 126       process_count_lower_bound);
 127   UMA_HISTOGRAM_COUNTS_100(
 128       "SiteIsolation.IsolateAllSitesProcessCountEstimate",
 129       process_count_estimate);
 130   UMA_HISTOGRAM_COUNTS_100(
 131       "SiteIsolation.IsolateHttpsSitesProcessCountNoLimit",
 132       num_isolated_https_site_instances);
 133   UMA_HISTOGRAM_COUNTS_100(
 134       "SiteIsolation.IsolateHttpsSitesProcessCountLowerBound",
 135       process_count_https_lower_bound);
 136   UMA_HISTOGRAM_COUNTS_100(
 137       "SiteIsolation.IsolateHttpsSitesProcessCountEstimate",
 138       process_count_https_estimate);
 139
 140   // Total process count:
 141   UMA_HISTOGRAM_COUNTS_100(
 142       "SiteIsolation.IsolateAllSitesTotalProcessCountEstimate",
 143       process_count_estimate + non_renderer_process_count);
 144   UMA_HISTOGRAM_COUNTS_100(
 145       "SiteIsolation.IsolateHttpsSitesTotalProcessCountEstimate",
 146       process_count_https_estimate + non_renderer_process_count);
 147 }