1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/site_instance_impl.h"
6
7#include "base/command_line.h"
8#include "content/browser/browsing_instance.h"
9#include "content/browser/child_process_security_policy_impl.h"
10#include "content/browser/frame_host/debug_urls.h"
11#include "content/browser/renderer_host/render_process_host_impl.h"
12#include "content/browser/storage_partition_impl.h"
13#include "content/public/browser/content_browser_client.h"
14#include "content/public/browser/render_process_host_factory.h"
15#include "content/public/browser/web_ui_controller_factory.h"
16#include "content/public/common/content_switches.h"
17#include "content/public/common/url_constants.h"
18#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
19
20namespace content {
21
22const RenderProcessHostFactory*
23    SiteInstanceImpl::g_render_process_host_factory_ = NULL;
24int32 SiteInstanceImpl::next_site_instance_id_ = 1;
25
26SiteInstanceImpl::SiteInstanceImpl(BrowsingInstance* browsing_instance)
27    : id_(next_site_instance_id_++),
28      active_view_count_(0),
29      browsing_instance_(browsing_instance),
30      process_(NULL),
31      has_site_(false) {
32  DCHECK(browsing_instance);
33}
34
35SiteInstanceImpl::~SiteInstanceImpl() {
36  GetContentClient()->browser()->SiteInstanceDeleting(this);
37
38  if (process_)
39    process_->RemoveObserver(this);
40
41  // Now that no one is referencing us, we can safely remove ourselves from
42  // the BrowsingInstance.  Any future visits to a page from this site
43  // (within the same BrowsingInstance) can safely create a new SiteInstance.
44  if (has_site_)
45    browsing_instance_->UnregisterSiteInstance(
46        static_cast<SiteInstance*>(this));
47}
48
49int32 SiteInstanceImpl::GetId() {
50  return id_;
51}
52
53bool SiteInstanceImpl::HasProcess() const {
54  if (process_ != NULL)
55    return true;
56
57  // If we would use process-per-site for this site, also check if there is an
58  // existing process that we would use if GetProcess() were called.
59  BrowserContext* browser_context =
60      browsing_instance_->browser_context();
61  if (has_site_ &&
62      RenderProcessHost::ShouldUseProcessPerSite(browser_context, site_) &&
63      RenderProcessHostImpl::GetProcessHostForSite(browser_context, site_)) {
64    return true;
65  }
66
67  return false;
68}
69
70RenderProcessHost* SiteInstanceImpl::GetProcess() {
71  // TODO(erikkay) It would be nice to ensure that the renderer type had been
72  // properly set before we get here.  The default tab creation case winds up
73  // with no site set at this point, so it will default to TYPE_NORMAL.  This
74  // may not be correct, so we'll wind up potentially creating a process that
75  // we then throw away, or worse sharing a process with the wrong process type.
76  // See crbug.com/43448.
77
78  // Create a new process if ours went away or was reused.
79  if (!process_) {
80    BrowserContext* browser_context = browsing_instance_->browser_context();
81
82    // If we should use process-per-site mode (either in general or for the
83    // given site), then look for an existing RenderProcessHost for the site.
84    bool use_process_per_site = has_site_ &&
85        RenderProcessHost::ShouldUseProcessPerSite(browser_context, site_);
86    if (use_process_per_site) {
87      process_ = RenderProcessHostImpl::GetProcessHostForSite(browser_context,
88                                                              site_);
89    }
90
91    // If not (or if none found), see if we should reuse an existing process.
92    if (!process_ && RenderProcessHostImpl::ShouldTryToUseExistingProcessHost(
93            browser_context, site_)) {
94      process_ = RenderProcessHostImpl::GetExistingProcessHost(browser_context,
95                                                               site_);
96    }
97
98    // Otherwise (or if that fails), create a new one.
99    if (!process_) {
100      if (g_render_process_host_factory_) {
101        process_ = g_render_process_host_factory_->CreateRenderProcessHost(
102            browser_context, this);
103      } else {
104        StoragePartitionImpl* partition =
105            static_cast<StoragePartitionImpl*>(
106                BrowserContext::GetStoragePartition(browser_context, this));
107        process_ = new RenderProcessHostImpl(browser_context,
108                                             partition,
109                                             site_.SchemeIs(kGuestScheme));
110      }
111    }
112    CHECK(process_);
113    process_->AddObserver(this);
114
115    // If we are using process-per-site, we need to register this process
116    // for the current site so that we can find it again.  (If no site is set
117    // at this time, we will register it in SetSite().)
118    if (use_process_per_site) {
119      RenderProcessHostImpl::RegisterProcessHostForSite(browser_context,
120                                                        process_, site_);
121    }
122
123    TRACE_EVENT2("navigation", "SiteInstanceImpl::GetProcess",
124                 "site id", id_, "process id", process_->GetID());
125    GetContentClient()->browser()->SiteInstanceGotProcess(this);
126
127    if (has_site_)
128      LockToOrigin();
129  }
130  DCHECK(process_);
131
132  return process_;
133}
134
135void SiteInstanceImpl::SetSite(const GURL& url) {
136  TRACE_EVENT2("navigation", "SiteInstanceImpl::SetSite",
137               "site id", id_, "url", url.possibly_invalid_spec());
138  // A SiteInstance's site should not change.
139  // TODO(creis): When following links or script navigations, we can currently
140  // render pages from other sites in this SiteInstance.  This will eventually
141  // be fixed, but until then, we should still not set the site of a
142  // SiteInstance more than once.
143  DCHECK(!has_site_);
144
145  // Remember that this SiteInstance has been used to load a URL, even if the
146  // URL is invalid.
147  has_site_ = true;
148  BrowserContext* browser_context = browsing_instance_->browser_context();
149  site_ = GetSiteForURL(browser_context, url);
150
151  // Now that we have a site, register it with the BrowsingInstance.  This
152  // ensures that we won't create another SiteInstance for this site within
153  // the same BrowsingInstance, because all same-site pages within a
154  // BrowsingInstance can script each other.
155  browsing_instance_->RegisterSiteInstance(this);
156
157  if (process_) {
158    LockToOrigin();
159
160    // Ensure the process is registered for this site if necessary.
161    if (RenderProcessHost::ShouldUseProcessPerSite(browser_context, site_)) {
162      RenderProcessHostImpl::RegisterProcessHostForSite(
163          browser_context, process_, site_);
164    }
165  }
166}
167
168const GURL& SiteInstanceImpl::GetSiteURL() const {
169  return site_;
170}
171
172bool SiteInstanceImpl::HasSite() const {
173  return has_site_;
174}
175
176bool SiteInstanceImpl::HasRelatedSiteInstance(const GURL& url) {
177  return browsing_instance_->HasSiteInstance(url);
178}
179
180SiteInstance* SiteInstanceImpl::GetRelatedSiteInstance(const GURL& url) {
181  return browsing_instance_->GetSiteInstanceForURL(url);
182}
183
184bool SiteInstanceImpl::IsRelatedSiteInstance(const SiteInstance* instance) {
185  return browsing_instance_.get() == static_cast<const SiteInstanceImpl*>(
186                                         instance)->browsing_instance_.get();
187}
188
189size_t SiteInstanceImpl::GetRelatedActiveContentsCount() {
190  return browsing_instance_->active_contents_count();
191}
192
193bool SiteInstanceImpl::HasWrongProcessForURL(const GURL& url) {
194  // Having no process isn't a problem, since we'll assign it correctly.
195  // Note that HasProcess() may return true if process_ is null, in
196  // process-per-site cases where there's an existing process available.
197  // We want to use such a process in the IsSuitableHost check, so we
198  // may end up assigning process_ in the GetProcess() call below.
199  if (!HasProcess())
200    return false;
201
202  // If the URL to navigate to can be associated with any site instance,
203  // we want to keep it in the same process.
204  if (IsRendererDebugURL(url))
205    return false;
206
207  // If the site URL is an extension (e.g., for hosted apps or WebUI) but the
208  // process is not (or vice versa), make sure we notice and fix it.
209  GURL site_url = GetSiteForURL(browsing_instance_->browser_context(), url);
210  return !RenderProcessHostImpl::IsSuitableHost(
211      GetProcess(), browsing_instance_->browser_context(), site_url);
212}
213
214void SiteInstanceImpl::IncrementRelatedActiveContentsCount() {
215  browsing_instance_->increment_active_contents_count();
216}
217
218void SiteInstanceImpl::DecrementRelatedActiveContentsCount() {
219  browsing_instance_->decrement_active_contents_count();
220}
221
222void SiteInstanceImpl::set_render_process_host_factory(
223    const RenderProcessHostFactory* rph_factory) {
224  g_render_process_host_factory_ = rph_factory;
225}
226
227BrowserContext* SiteInstanceImpl::GetBrowserContext() const {
228  return browsing_instance_->browser_context();
229}
230
231/*static*/
232SiteInstance* SiteInstance::Create(BrowserContext* browser_context) {
233  return new SiteInstanceImpl(new BrowsingInstance(browser_context));
234}
235
236/*static*/
237SiteInstance* SiteInstance::CreateForURL(BrowserContext* browser_context,
238                                         const GURL& url) {
239  // This BrowsingInstance may be deleted if it returns an existing
240  // SiteInstance.
241  scoped_refptr<BrowsingInstance> instance(
242      new BrowsingInstance(browser_context));
243  return instance->GetSiteInstanceForURL(url);
244}
245
246/*static*/
247bool SiteInstance::IsSameWebSite(BrowserContext* browser_context,
248                                 const GURL& real_src_url,
249                                 const GURL& real_dest_url) {
250  GURL src_url = SiteInstanceImpl::GetEffectiveURL(browser_context,
251                                                   real_src_url);
252  GURL dest_url = SiteInstanceImpl::GetEffectiveURL(browser_context,
253                                                    real_dest_url);
254
255  // We infer web site boundaries based on the registered domain name of the
256  // top-level page and the scheme.  We do not pay attention to the port if
257  // one is present, because pages served from different ports can still
258  // access each other if they change their document.domain variable.
259
260  // Some special URLs will match the site instance of any other URL. This is
261  // done before checking both of them for validity, since we want these URLs
262  // to have the same site instance as even an invalid one.
263  if (IsRendererDebugURL(src_url) || IsRendererDebugURL(dest_url))
264    return true;
265
266  // If either URL is invalid, they aren't part of the same site.
267  if (!src_url.is_valid() || !dest_url.is_valid())
268    return false;
269
270  // If the destination url is just a blank page, we treat them as part of the
271  // same site.
272  GURL blank_page(url::kAboutBlankURL);
273  if (dest_url == blank_page)
274    return true;
275
276  // If the schemes differ, they aren't part of the same site.
277  if (src_url.scheme() != dest_url.scheme())
278    return false;
279
280  return net::registry_controlled_domains::SameDomainOrHost(
281      src_url,
282      dest_url,
283      net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
284}
285
286/*static*/
287GURL SiteInstance::GetSiteForURL(BrowserContext* browser_context,
288                                 const GURL& real_url) {
289  // TODO(fsamuel, creis): For some reason appID is not recognized as a host.
290  if (real_url.SchemeIs(kGuestScheme))
291    return real_url;
292
293  GURL url = SiteInstanceImpl::GetEffectiveURL(browser_context, real_url);
294
295  // URLs with no host should have an empty site.
296  GURL site;
297
298  // TODO(creis): For many protocols, we should just treat the scheme as the
299  // site, since there is no host.  e.g., file:, about:, chrome:
300
301  // If the url has a host, then determine the site.
302  if (url.has_host()) {
303    // Only keep the scheme and registered domain as given by GetOrigin.  This
304    // may also include a port, which we need to drop.
305    site = url.GetOrigin();
306
307    // Remove port, if any.
308    if (site.has_port()) {
309      GURL::Replacements rep;
310      rep.ClearPort();
311      site = site.ReplaceComponents(rep);
312    }
313
314    // If this URL has a registered domain, we only want to remember that part.
315    std::string domain =
316        net::registry_controlled_domains::GetDomainAndRegistry(
317            url,
318            net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
319    if (!domain.empty()) {
320      GURL::Replacements rep;
321      rep.SetHostStr(domain);
322      site = site.ReplaceComponents(rep);
323    }
324  }
325  return site;
326}
327
328/*static*/
329GURL SiteInstanceImpl::GetEffectiveURL(BrowserContext* browser_context,
330                                       const GURL& url) {
331  return GetContentClient()->browser()->
332      GetEffectiveURL(browser_context, url);
333}
334
335void SiteInstanceImpl::RenderProcessHostDestroyed(RenderProcessHost* host) {
336  DCHECK_EQ(process_, host);
337  process_->RemoveObserver(this);
338  process_ = NULL;
339}
340
341void SiteInstanceImpl::LockToOrigin() {
342  // We currently only restrict this process to a particular site if the
343  // --enable-strict-site-isolation or --site-per-process flags are present.
344  const base::CommandLine& command_line =
345      *base::CommandLine::ForCurrentProcess();
346  if (command_line.HasSwitch(switches::kEnableStrictSiteIsolation) ||
347      command_line.HasSwitch(switches::kSitePerProcess)) {
348    ChildProcessSecurityPolicyImpl* policy =
349        ChildProcessSecurityPolicyImpl::GetInstance();
350    policy->LockToOrigin(process_->GetID(), site_);
351  }
352}
353
354}  // namespace content
355