// 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 GURL& site) {
  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;
}

content::SiteInstance* DeterminePrimarySiteInstance(
    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& 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.
  BrowsingInstanceInfo* browsing_instance =
      &site_data->browsing_instances[site_instance];
  browsing_instance->site_instances.insert(site_instance);

  return site_instance;
}

}  // namespace

ScenarioBrowsingInstanceInfo::ScenarioBrowsingInstanceInfo() {}

ScenarioBrowsingInstanceInfo::ScenarioBrowsingInstanceInfo(
    const ScenarioBrowsingInstanceInfo& other) = default;

ScenarioBrowsingInstanceInfo::~ScenarioBrowsingInstanceInfo() {}

BrowsingInstanceInfo::BrowsingInstanceInfo() {}

BrowsingInstanceInfo::BrowsingInstanceInfo(const BrowsingInstanceInfo& other) =
    default;

BrowsingInstanceInfo::~BrowsingInstanceInfo() {}

IsolationScenario::IsolationScenario() {}

IsolationScenario::IsolationScenario(const IsolationScenario& other) = default;

IsolationScenario::~IsolationScenario() {}

SiteData::SiteData() {
  for (int i = 0; i <= ISOLATION_SCENARIO_LAST; i++)
    scenarios[i].policy = static_cast<IsolationScenarioType>(i);
}

SiteData::SiteData(const SiteData& other) = default;

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);
  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.
      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.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;
    }
  }

}

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(
      "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]);
  UMA_HISTOGRAM_COUNTS_100(
      "SiteIsolation.IsolateExtensionsTotalProcessCountEstimate",
      process_count_estimate[ISOLATE_EXTENSIONS] + non_renderer_process_count);
}