Several Site Details / Memory metrics fixes

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"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #endif
 
+using content::BrowserContext;
 using content::BrowserThread;
+using content::RenderFrameHost;
 using content::RenderProcessHost;
 using content::SiteInstance;
 using content::WebContents;
 
 namespace {
 
-bool ShouldIsolate(content::BrowserContext* browser_context,
-                   IsolationScenarioType policy,
+bool ShouldIsolate(BrowserContext* browser_context,
+                   IsolationScenario* scenario,
                    const GURL& site) {
-  switch (policy) {
+  switch (scenario->policy) {
+    case ISOLATE_NOTHING:
+      return false;
     case ISOLATE_ALL_SITES:
       return true;
     case ISOLATE_HTTPS_SITES:
       // Note: For estimation purposes "isolate https sites" is really
       // implemented as "isolate non-http sites". This means that, for example,
       // the New Tab Page gets counted as two processes under this policy, and
       // extensions are isolated as well.
       return !site.SchemeIs(url::kHttpScheme);
     case ISOLATE_EXTENSIONS: {
 #if !defined(ENABLE_EXTENSIONS)
       return false;
 #else
       if (!site.SchemeIs(extensions::kExtensionScheme))
         return false;
       extensions::ExtensionRegistry* registry =
           extensions::ExtensionRegistry::Get(browser_context);
       const extensions::Extension* extension =
           registry->enabled_extensions().GetExtensionOrAppByURL(site);
       return extension && !extension->is_hosted_app();
 #endif
     }
   }
   NOTREACHED();
   return true;
 }
 
+void CollectForScenario(std::map<RenderFrameHost*, GURL>* memo,

[Charlie Reis, 2015/10/23 19:03:40]

nit: memo -> frame_urls?

We could add a comment above saying something like:
Update |scenario|'s data for the given frame.  Memoize each frame's computed URL
in |frame_urls| so it can be reused when visiting its children.

[ncarter (slow), 2015/10/29 19:55:06]

Done.

+                        SiteInstance* primary,
+                        IsolationScenario* scenario,
+                        RenderFrameHost* frame) {
+  BrowserContext* context = primary->GetBrowserContext();
+
+  GURL url = frame->GetLastCommittedURL();
+
+  // Treat about:blank url specially: use the URL on the SiteInstance if it is
+  // assigned. The rest of this computation must not depend on the
+  // SiteInstance's URL, since its value reflects the current process model, and
+  // this computation is simulating other process models.
+  if (url == GURL(url::kAboutBlankURL) &&
+      frame->GetSiteInstance()->GetSiteURL() != GURL()) {
+    url = frame->GetSiteInstance()->GetSiteURL();
+  }
+
+  GURL site = SiteInstance::GetSiteForURL(context, url);
+  bool should_isolate = ShouldIsolate(context, scenario, site);
+  if (frame->GetParent()) {

[Charlie Reis, 2015/10/23 19:03:40]

// Treat a subframe as part of its parent site if neither needs isolation.

[ncarter (slow), 2015/10/29 19:55:06]

Done.

+    GURL parent_site = (*memo)[frame->GetParent()];
+    if (!should_isolate && !ShouldIsolate(context, scenario, parent_site))
+      site = parent_site;
+  }
+
+  bool process_per_site =
+      site.is_valid() &&
+      RenderProcessHost::ShouldUseProcessPerSite(context, site);
+
+  // If we don't need a dedicated process, and aren't living it a process-

[Charlie Reis, 2015/10/23 19:03:40]

nit: s/it/in/

[ncarter (slow), 2015/10/29 19:55:06]

Done.

+  // per-site process, we are nothing special: collapse our URL to a dummy
+  // site.
+  if (!process_per_site && !should_isolate)
+    site = GURL("http://");
+
+  // We model process-per-site by only inserting those sites into the first
+  // browsing instance in which they appear.
+  if (scenario->sites.insert(site).second || !process_per_site)
+    scenario->browsing_instance_site_map[primary->GetId()].insert(site);
+
+  // Record our result in |memo| for use by children.
+  (*memo)[frame] = site;
+}
+
 }  // namespace
 
 IsolationScenario::IsolationScenario() : policy(ISOLATE_ALL_SITES) {}
 
 IsolationScenario::~IsolationScenario() {}
 
-void IsolationScenario::CollectSiteInfoForScenario(SiteInstance* primary,
-                                                   const GURL& site) {
-  const GURL& isolated =
-      ShouldIsolate(primary->GetBrowserContext(), policy, site)
-          ? site
-          : GURL("http://");
-  sites.insert(isolated);
-  browsing_instance_site_map[primary->GetId()].insert(isolated);
-}
-
 SiteData::SiteData() {
-  scenarios[ISOLATE_ALL_SITES].policy = ISOLATE_ALL_SITES;
-  scenarios[ISOLATE_HTTPS_SITES].policy = ISOLATE_HTTPS_SITES;
-  scenarios[ISOLATE_EXTENSIONS].policy = ISOLATE_EXTENSIONS;
+  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);
-  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 (SiteInstance* already_collected_instance : site_data->instances) {
     if (instance->IsRelatedSiteInstance(already_collected_instance)) {
       primary = already_collected_instance;
       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.
-  for (const GURL& site : contents->GetSitesInTab()) {
-    // Make sure we don't overcount process-per-site sites, like the NTP or
-    // extensions, by skipping over them if they're already logged for
-    // ISOLATE_ALL_SITES.
-    if (RenderProcessHost::ShouldUseProcessPerSite(browser_context, site) &&
-        site_data->scenarios[ISOLATE_ALL_SITES].sites.find(site) !=
-            site_data->scenarios[ISOLATE_ALL_SITES].sites.end()) {
-      continue;
-    }
-
-    for (IsolationScenario& scenario : site_data->scenarios) {
-      scenario.CollectSiteInfoForScenario(primary, site);
-    }
+  for (IsolationScenario& scenario : site_data->scenarios) {
+    std::map<RenderFrameHost*, GURL> memo;
+    contents->ForEachFrame(
+        base::Bind(&CollectForScenario, base::Unretained(&memo),
+                   base::Unretained(primary), base::Unretained(&scenario)));
   }
 }
 
 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();
 
@@ skipping 25 matching lines @@
     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);
+
+  // 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(
+      "SiteIsolation.IsolateNothingTotalProcessCountEstimate",
+      process_count_estimate[ISOLATE_NOTHING] + non_renderer_process_count);
+
+  // ISOLATE_ALL_SITES metrics.
   UMA_HISTOGRAM_COUNTS_100("SiteIsolation.IsolateAllSitesProcessCountNoLimit",
                            num_isolated_site_instances[ISOLATE_ALL_SITES]);
   UMA_HISTOGRAM_COUNTS_100(
       "SiteIsolation.IsolateAllSitesProcessCountLowerBound",
       process_count_lower_bound[ISOLATE_ALL_SITES]);
   UMA_HISTOGRAM_COUNTS_100("SiteIsolation.IsolateAllSitesProcessCountEstimate",
                            process_count_estimate[ISOLATE_ALL_SITES]);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateAllSitesTotalProcessCountEstimate",
+      process_count_estimate[ISOLATE_ALL_SITES] + non_renderer_process_count);
 
+  // ISOLATE_HTTPS_SITES metrics.
   UMA_HISTOGRAM_COUNTS_100("SiteIsolation.IsolateHttpsSitesProcessCountNoLimit",
                            num_isolated_site_instances[ISOLATE_HTTPS_SITES]);
   UMA_HISTOGRAM_COUNTS_100(
       "SiteIsolation.IsolateHttpsSitesProcessCountLowerBound",
       process_count_lower_bound[ISOLATE_HTTPS_SITES]);
   UMA_HISTOGRAM_COUNTS_100(
       "SiteIsolation.IsolateHttpsSitesProcessCountEstimate",
       process_count_estimate[ISOLATE_HTTPS_SITES]);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SiteIsolation.IsolateHttpsSitesTotalProcessCountEstimate",
+      process_count_estimate[ISOLATE_HTTPS_SITES] + non_renderer_process_count);
 
+  // ISOLATE_EXTENSIONS metrics.
   UMA_HISTOGRAM_COUNTS_100("SiteIsolation.IsolateExtensionsProcessCountNoLimit",
                            num_isolated_site_instances[ISOLATE_EXTENSIONS]);
   UMA_HISTOGRAM_COUNTS_100(
       "SiteIsolation.IsolateExtensionsProcessCountLowerBound",
       process_count_lower_bound[ISOLATE_EXTENSIONS]);
   UMA_HISTOGRAM_COUNTS_100(
       "SiteIsolation.IsolateExtensionsProcessCountEstimate",
       process_count_estimate[ISOLATE_EXTENSIONS]);
-
-  // Total process count:
-  UMA_HISTOGRAM_COUNTS_100(
-      "SiteIsolation.IsolateAllSitesTotalProcessCountEstimate",
-      process_count_estimate[ISOLATE_ALL_SITES] + non_renderer_process_count);
-  UMA_HISTOGRAM_COUNTS_100(
-      "SiteIsolation.IsolateHttpsSitesTotalProcessCountEstimate",
-      process_count_estimate[ISOLATE_HTTPS_SITES] + non_renderer_process_count);
   UMA_HISTOGRAM_COUNTS_100(
       "SiteIsolation.IsolateExtensionsTotalProcessCountEstimate",
       process_count_estimate[ISOLATE_EXTENSIONS] + non_renderer_process_count);
 }