SiteDetailsBrowserTest: prepare to add proxy information

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 40 matching lines @@
           registry->enabled_extensions().GetExtensionOrAppByURL(site);
       return extension && !extension->is_hosted_app();
 #endif
     }
   }
   NOTREACHED();
   return true;
 }
 
 content::SiteInstance* DeterminePrimarySiteInstance(
-    content::SiteInstance* instance,
+    content::SiteInstance* site_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;
+  for (auto& entry : site_data->browsing_instances) {
+    BrowsingInstanceInfo* browsing_instance = &entry.second;
+    content::SiteInstance* primary_for_browsing_instance = entry.first;
+
+    if (site_instance->IsRelatedSiteInstance(primary_for_browsing_instance)) {
+      browsing_instance->site_instances.insert(site_instance);
+      return primary_for_browsing_instance;
     }
   }
 
   // Add |instance| as the "primary" SiteInstance of a new BrowsingInstance.
-  site_data->instances[instance].clear();
-  site_data->instances[instance].insert(instance);
+  BrowsingInstanceInfo* browsing_instance =
+      &site_data->browsing_instances[site_instance];
+  browsing_instance->site_instances.insert(site_instance);
 
-  return instance;
+  return site_instance;
 }
 
 }  // namespace
 
+ScenarioBrowsingInstanceInfo::ScenarioBrowsingInstanceInfo() {}
+
+ScenarioBrowsingInstanceInfo::~ScenarioBrowsingInstanceInfo() {}
+
+BrowsingInstanceInfo::BrowsingInstanceInfo() {}
+
+BrowsingInstanceInfo::~BrowsingInstanceInfo() {}
+
 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() {}
@@ skipping 37 matching lines @@
           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);
+      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;
-  for (BrowserContextSiteDataMap::const_iterator i = site_data_map.begin();
-       i != site_data_map.end(); ++i) {
-    for (const IsolationScenario& scenario : i->second.scenarios) {
-      num_sites[scenario.policy] += scenario.sites.size();
-      for (auto& browsing_instance : scenario.browsing_instance_site_map) {
+  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] +=
-            browsing_instance.second.size();
+            scenario_browsing_instance_info.sites.size();
       }
     }
-    num_browsing_instances += i->second.scenarios[ISOLATE_ALL_SITES]
-                                  .browsing_instance_site_map.size();
-    for (const auto& site_instance : i->second.instances) {
+    for (const auto& entry : site_data.browsing_instances) {
+      const BrowsingInstanceInfo& browsing_instance_info = entry.second;
       UMA_HISTOGRAM_COUNTS_100("SiteIsolation.SiteInstancesPerBrowsingInstance",
-                               site_instance.second.size());
+                               browsing_instance_info.site_instances.size());
     }
-    num_oopifs += i->second.out_of_process_frames;
+    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;
@@ skipping 51 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);
 }