UMA stats to count RenderFrameProxyHosts

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_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 72 matching lines @@
 }  // namespace
 
 ScenarioBrowsingInstanceInfo::ScenarioBrowsingInstanceInfo() {}
 
 ScenarioBrowsingInstanceInfo::~ScenarioBrowsingInstanceInfo() {}
 
 BrowsingInstanceInfo::BrowsingInstanceInfo() {}
 
 BrowsingInstanceInfo::~BrowsingInstanceInfo() {}
 
-IsolationScenario::IsolationScenario() : policy(ISOLATE_ALL_SITES) {}
+IsolationScenario::IsolationScenario() {}
 
 IsolationScenario::~IsolationScenario() {}
 
-SiteData::SiteData() : out_of_process_frames(0) {
+SiteData::SiteData() {
   for (int i = 0; i <= ISOLATION_SCENARIO_LAST; i++)
     scenarios[i].policy = static_cast<IsolationScenarioType>(i);
 }
 
 SiteData::~SiteData() {}
 
 SiteDetails::SiteDetails() {}
 
 SiteDetails::~SiteDetails() {}
 
 void SiteDetails::CollectSiteInfo(WebContents* contents,
                                   SiteData* site_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserContext* context = contents->GetBrowserContext();
+
+  // The primary should be the same for the whole tab.
   SiteInstance* primary =
       DeterminePrimarySiteInstance(contents->GetSiteInstance(), site_data);
-  BrowserContext* context = primary->GetBrowserContext();
+  BrowsingInstanceInfo* browsing_instance =
+      &site_data->browsing_instances[primary];
+
+  for (RenderFrameHost* frame : contents->GetAllFrames()) {
+    // Ensure that we add the frame's SiteInstance to |site_instances|.
+    DCHECK(frame->GetSiteInstance()->IsRelatedSiteInstance(primary));
+    browsing_instance->site_instances.insert(frame->GetSiteInstance());
+    browsing_instance->proxy_count += frame->GetProxyCount();
+
+    if (frame->GetParent()) {
+      if (frame->GetSiteInstance() != frame->GetParent()->GetSiteInstance())
+        site_data->out_of_process_frames++;
+    }
+  }
 
   // Now keep track of how many sites we have in this BrowsingInstance (and
   // overall), including sites in iframes.
   for (IsolationScenario& scenario : site_data->scenarios) {
     std::map<RenderFrameHost*, GURL> frame_urls;
     for (RenderFrameHost* frame : contents->GetAllFrames()) {
       // Determine the site from the frame's origin, with a fallback to the
       // frame's URL.  In cases like <iframe sandbox>, we can wind up with an
       // http URL but a unique origin.  The origin of the resource will still
       // determine process placement.
@@ skipping 24 matching lines @@
       // We model process-per-site by only inserting those sites into the first
       // browsing instance in which they appear.
       if (scenario.all_sites.insert(site).second || !process_per_site)
         scenario.browsing_instances[primary->GetId()].sites.insert(site);
 
       // Record our result in |frame_urls| for use by children.
       frame_urls[frame] = site;
     }
   }
 
-  for (RenderFrameHost* frame : contents->GetAllFrames()) {
-    if (frame->GetParent()) {
-      if (frame->GetSiteInstance() != frame->GetParent()->GetSiteInstance())
-        site_data->out_of_process_frames++;
-    }
-    DeterminePrimarySiteInstance(frame->GetSiteInstance(), site_data);
-  }
 }
 
 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 and
   // the total number of out-of-process iframes.
   int num_sites[ISOLATION_SCENARIO_LAST + 1] = {};
   int num_isolated_site_instances[ISOLATION_SCENARIO_LAST + 1] = {};
   int num_browsing_instances = 0;
   int num_oopifs = 0;
+  int num_proxies = 0;
   for (auto& site_data_map_entry : site_data_map) {
     const SiteData& site_data = site_data_map_entry.second;
     for (const IsolationScenario& scenario : site_data.scenarios) {
       num_sites[scenario.policy] += scenario.all_sites.size();
       for (auto& entry : scenario.browsing_instances) {
         const ScenarioBrowsingInstanceInfo& scenario_browsing_instance_info =
             entry.second;
         num_isolated_site_instances[scenario.policy] +=
             scenario_browsing_instance_info.sites.size();
       }
     }
     for (const auto& entry : site_data.browsing_instances) {
       const BrowsingInstanceInfo& browsing_instance_info = entry.second;
       UMA_HISTOGRAM_COUNTS_100("SiteIsolation.SiteInstancesPerBrowsingInstance",
                                browsing_instance_info.site_instances.size());
+      UMA_HISTOGRAM_COUNTS_10000("SiteIsolation.ProxyCountPerBrowsingInstance",
+                                 browsing_instance_info.proxy_count);
+      num_proxies += browsing_instance_info.proxy_count;
     }
     num_browsing_instances += site_data.browsing_instances.size();
     num_oopifs += site_data.out_of_process_frames;
   }
 
   // Predict the number of processes needed when isolating all sites, when
   // isolating only HTTPS sites, and when isolating extensions.
   int process_count_lower_bound[ISOLATION_SCENARIO_LAST + 1];
   int process_count_upper_bound[ISOLATION_SCENARIO_LAST + 1];
   int process_count_estimate[ISOLATION_SCENARIO_LAST + 1];
   for (int policy = 0; policy <= ISOLATION_SCENARIO_LAST; policy++) {
     process_count_lower_bound[policy] = num_sites[policy];
     process_count_upper_bound[policy] = num_sites[policy] + process_limit - 1;
     process_count_estimate[policy] = std::min(
         num_isolated_site_instances[policy], process_count_upper_bound[policy]);
   }
 
   // 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_10000("SiteIsolation.ProxyCount", num_proxies);
   UMA_HISTOGRAM_COUNTS_100("SiteIsolation.OutOfProcessIframes", num_oopifs);
 
   // ISOLATE_NOTHING metrics.
   UMA_HISTOGRAM_COUNTS_100("SiteIsolation.IsolateNothingProcessCountNoLimit",
                            num_isolated_site_instances[ISOLATE_NOTHING]);
   UMA_HISTOGRAM_COUNTS_100("SiteIsolation.IsolateNothingProcessCountLowerBound",
                            process_count_lower_bound[ISOLATE_NOTHING]);
   UMA_HISTOGRAM_COUNTS_100("SiteIsolation.IsolateNothingProcessCountEstimate",
                            process_count_estimate[ISOLATE_NOTHING]);
   UMA_HISTOGRAM_COUNTS_100(
@@ skipping 31 matching lines @@
   UMA_HISTOGRAM_COUNTS_100(
       "SiteIsolation.IsolateExtensionsProcessCountLowerBound",
       process_count_lower_bound[ISOLATE_EXTENSIONS]);
   UMA_HISTOGRAM_COUNTS_100(
       "SiteIsolation.IsolateExtensionsProcessCountEstimate",
       process_count_estimate[ISOLATE_EXTENSIONS]);
   UMA_HISTOGRAM_COUNTS_100(
       "SiteIsolation.IsolateExtensionsTotalProcessCountEstimate",
       process_count_estimate[ISOLATE_EXTENSIONS] + non_renderer_process_count);
 }