Enable range-based for loops to loop over a WebContents' frame hosts.

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"
 #include "url/origin.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(BrowserContext* browser_context,
-                   const IsolationScenario* scenario,
+                   const IsolationScenario& scenario,
                    const GURL& site) {
-  switch (scenario->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;
 }
 
-// Walk the frame tree and 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.
-void CollectForScenario(std::map<RenderFrameHost*, GURL>* frame_urls,
-                        SiteInstance* primary,
-                        IsolationScenario* scenario,
-                        RenderFrameHost* frame) {
-  BrowserContext* context = primary->GetBrowserContext();
-
-  // 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.
-  url::Origin origin = frame->GetLastCommittedOrigin();
-  GURL site = SiteInstance::GetSiteForURL(
-      context, origin.unique() ? frame->GetLastCommittedURL()
-                               : GURL(origin.Serialize()));
-
-  bool should_isolate = ShouldIsolate(context, scenario, site);
-
-  // Treat a subframe as part of its parent site if neither needs isolation.
-  if (!should_isolate && frame->GetParent()) {
-    GURL parent_site = (*frame_urls)[frame->GetParent()];
-    if (!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 in a process-
-  // 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 |frame_urls| for use by children.
-  (*frame_urls)[frame] = site;
-}
-
 content::SiteInstance* DeterminePrimarySiteInstance(
     content::SiteInstance* instance,
     SiteData* site_data) {
   // Find the BrowsingInstance this WebContents belongs to by iterating over
   // the "primary" SiteInstances of each BrowsingInstance we've seen so far.
   for (auto& existing_site_instance : site_data->instances) {
     if (instance->IsRelatedSiteInstance(existing_site_instance.first)) {
       existing_site_instance.second.insert(instance);
       return existing_site_instance.first;
     }
   }
 
   // Add |instance| as the "primary" SiteInstance of a new BrowsingInstance.
   site_data->instances[instance].clear();
   site_data->instances[instance].insert(instance);
 
   return instance;
 }
 
-void CollectCurrentSnapshot(SiteData* site_data, RenderFrameHost* frame) {
-  if (frame->GetParent()) {
-    if (frame->GetSiteInstance() != frame->GetParent()->GetSiteInstance())
-      site_data->out_of_process_frames++;
-  }
-
-  DeterminePrimarySiteInstance(frame->GetSiteInstance(), site_data);
-}
-
 }  // namespace
 
 IsolationScenario::IsolationScenario() : policy(ISOLATE_ALL_SITES) {}
 
 IsolationScenario::~IsolationScenario() {}
 
 SiteData::SiteData() : out_of_process_frames(0) {
   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);
   SiteInstance* primary =
       DeterminePrimarySiteInstance(contents->GetSiteInstance(), site_data);
+  BrowserContext* context = primary->GetBrowserContext();
 
   // 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> memo;
-    contents->ForEachFrame(
-        base::Bind(&CollectForScenario, base::Unretained(&memo),
-                   base::Unretained(primary), base::Unretained(&scenario)));
+    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

[Lei Zhang, 2016/02/04 05:08:17]

formatting

[dcheng, 2016/02/04 05:59:58]

Done.

+      // determine
+      // process placement.
+      url::Origin origin = frame->GetLastCommittedOrigin();
+      GURL site = SiteInstance::GetSiteForURL(
+          context, origin.unique() ? frame->GetLastCommittedURL()
+                                   : GURL(origin.Serialize()));
+
+      bool should_isolate = ShouldIsolate(context, scenario, site);
+
+      // Treat a subframe as part of its parent site if neither needs isolation.
+      if (!should_isolate && frame->GetParent()) {
+        GURL parent_site = frame_urls[frame->GetParent()];
+        if (!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 in a process-
+      // 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 |frame_urls| for use by children.
+      frame_urls[frame] = site;
+    }
   }
 
-  contents->ForEachFrame(
-      base::Bind(&CollectCurrentSnapshot, base::Unretained(site_data)));
+  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
@@ skipping 82 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);
 }