[email protected] | 144a810 | 2012-01-14 01:05:31 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
license.bot | bf09a50 | 2008-08-24 00:55:55 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 4 | |
[email protected] | b658359 | 2012-01-25 19:52:33 | [diff] [blame] | 5 | #include "content/browser/site_instance_impl.h" |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 6 | |
avi | cb129c0 | 2017-05-03 06:49:29 | [diff] [blame^] | 7 | #include "base/memory/ptr_util.h" |
[email protected] | 3936521 | 2011-02-24 01:01:00 | [diff] [blame] | 8 | #include "content/browser/browsing_instance.h" |
[email protected] | b953542 | 2012-02-09 01:47:59 | [diff] [blame] | 9 | #include "content/browser/child_process_security_policy_impl.h" |
[email protected] | c02f1ba | 2014-02-03 06:53:53 | [diff] [blame] | 10 | #include "content/browser/frame_host/debug_urls.h" |
nick | 9f34e289 | 2016-01-12 21:01:07 | [diff] [blame] | 11 | #include "content/browser/frame_host/frame_tree_node.h" |
[email protected] | f3b1a08 | 2011-11-18 00:34:30 | [diff] [blame] | 12 | #include "content/browser/renderer_host/render_process_host_impl.h" |
[email protected] | 4c3a2358 | 2012-08-18 08:54:34 | [diff] [blame] | 13 | #include "content/browser/storage_partition_impl.h" |
nick | d30fd96 | 2015-07-27 21:51:08 | [diff] [blame] | 14 | #include "content/common/site_isolation_policy.h" |
[email protected] | 87f3c08 | 2011-10-19 18:07:44 | [diff] [blame] | 15 | #include "content/public/browser/content_browser_client.h" |
[email protected] | f3b1a08 | 2011-11-18 00:34:30 | [diff] [blame] | 16 | #include "content/public/browser/render_process_host_factory.h" |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 17 | #include "content/public/browser/web_ui_controller_factory.h" |
[email protected] | a1d2916 | 2011-10-14 17:14:03 | [diff] [blame] | 18 | #include "content/public/common/url_constants.h" |
[email protected] | be28b5f4 | 2012-07-20 11:31:25 | [diff] [blame] | 19 | #include "net/base/registry_controlled_domains/registry_controlled_domain.h" |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 20 | |
[email protected] | 4648832 | 2012-10-30 03:22:20 | [diff] [blame] | 21 | namespace content { |
[email protected] | b658359 | 2012-01-25 19:52:33 | [diff] [blame] | 22 | |
[email protected] | 3059caa | 2013-06-06 03:48:41 | [diff] [blame] | 23 | const RenderProcessHostFactory* |
| 24 | SiteInstanceImpl::g_render_process_host_factory_ = NULL; |
avi | b734894 | 2015-12-25 20:57:10 | [diff] [blame] | 25 | int32_t SiteInstanceImpl::next_site_instance_id_ = 1; |
[email protected] | 992db4c | 2011-05-12 15:37:15 | [diff] [blame] | 26 | |
[email protected] | b658359 | 2012-01-25 19:52:33 | [diff] [blame] | 27 | SiteInstanceImpl::SiteInstanceImpl(BrowsingInstance* browsing_instance) |
[email protected] | 992db4c | 2011-05-12 15:37:15 | [diff] [blame] | 28 | : id_(next_site_instance_id_++), |
creis | cce56cd | 2014-09-29 22:45:22 | [diff] [blame] | 29 | active_frame_count_(0), |
[email protected] | 992db4c | 2011-05-12 15:37:15 | [diff] [blame] | 30 | browsing_instance_(browsing_instance), |
nick | d5bbd0b | 2016-03-31 19:52:44 | [diff] [blame] | 31 | process_(nullptr), |
| 32 | has_site_(false), |
| 33 | is_default_subframe_site_instance_(false) { |
[email protected] | 4566f13 | 2009-03-12 01:55:13 | [diff] [blame] | 34 | DCHECK(browsing_instance); |
[email protected] | 4566f13 | 2009-03-12 01:55:13 | [diff] [blame] | 35 | } |
| 36 | |
[email protected] | b658359 | 2012-01-25 19:52:33 | [diff] [blame] | 37 | SiteInstanceImpl::~SiteInstanceImpl() { |
[email protected] | 4648832 | 2012-10-30 03:22:20 | [diff] [blame] | 38 | GetContentClient()->browser()->SiteInstanceDeleting(this); |
[email protected] | 056ad2a | 2011-07-12 02:13:55 | [diff] [blame] | 39 | |
[email protected] | 40bfaf3 | 2013-11-19 01:35:43 | [diff] [blame] | 40 | if (process_) |
| 41 | process_->RemoveObserver(this); |
| 42 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 43 | // Now that no one is referencing us, we can safely remove ourselves from |
| 44 | // the BrowsingInstance. Any future visits to a page from this site |
| 45 | // (within the same BrowsingInstance) can safely create a new SiteInstance. |
| 46 | if (has_site_) |
dcheng | bccd6b8 | 2016-03-30 16:24:19 | [diff] [blame] | 47 | browsing_instance_->UnregisterSiteInstance(this); |
| 48 | } |
| 49 | |
| 50 | scoped_refptr<SiteInstanceImpl> SiteInstanceImpl::Create( |
| 51 | BrowserContext* browser_context) { |
| 52 | return make_scoped_refptr( |
| 53 | new SiteInstanceImpl(new BrowsingInstance(browser_context))); |
| 54 | } |
| 55 | |
| 56 | scoped_refptr<SiteInstanceImpl> SiteInstanceImpl::CreateForURL( |
| 57 | BrowserContext* browser_context, |
| 58 | const GURL& url) { |
| 59 | // This will create a new SiteInstance and BrowsingInstance. |
| 60 | scoped_refptr<BrowsingInstance> instance( |
| 61 | new BrowsingInstance(browser_context)); |
| 62 | return instance->GetSiteInstanceForURL(url); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 63 | } |
| 64 | |
avi | b734894 | 2015-12-25 20:57:10 | [diff] [blame] | 65 | int32_t SiteInstanceImpl::GetId() { |
[email protected] | b658359 | 2012-01-25 19:52:33 | [diff] [blame] | 66 | return id_; |
| 67 | } |
| 68 | |
| 69 | bool SiteInstanceImpl::HasProcess() const { |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 70 | if (process_ != NULL) |
| 71 | return true; |
| 72 | |
| 73 | // If we would use process-per-site for this site, also check if there is an |
| 74 | // existing process that we would use if GetProcess() were called. |
[email protected] | 4648832 | 2012-10-30 03:22:20 | [diff] [blame] | 75 | BrowserContext* browser_context = |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 76 | browsing_instance_->browser_context(); |
| 77 | if (has_site_ && |
[email protected] | 1ae93fb1 | 2013-06-14 03:38:56 | [diff] [blame] | 78 | RenderProcessHost::ShouldUseProcessPerSite(browser_context, site_) && |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 79 | RenderProcessHostImpl::GetProcessHostForSite(browser_context, site_)) { |
| 80 | return true; |
| 81 | } |
| 82 | |
| 83 | return false; |
[email protected] | 5ab79b0 | 2010-04-26 16:47:11 | [diff] [blame] | 84 | } |
| 85 | |
avi | 6d686db | 2017-01-06 02:28:57 | [diff] [blame] | 86 | namespace { |
| 87 | |
| 88 | const void* const kDefaultSubframeProcessHostHolderKey = |
| 89 | &kDefaultSubframeProcessHostHolderKey; |
| 90 | |
| 91 | class DefaultSubframeProcessHostHolder : public base::SupportsUserData::Data, |
| 92 | public RenderProcessHostObserver { |
| 93 | public: |
| 94 | explicit DefaultSubframeProcessHostHolder(BrowserContext* browser_context) |
| 95 | : browser_context_(browser_context) {} |
| 96 | ~DefaultSubframeProcessHostHolder() override {} |
| 97 | |
| 98 | // Gets the correct render process to use for this SiteInstance. |
| 99 | RenderProcessHost* GetProcessHost(SiteInstance* site_instance, |
| 100 | bool is_for_guests_only) { |
| 101 | StoragePartition* default_partition = |
| 102 | BrowserContext::GetDefaultStoragePartition(browser_context_); |
| 103 | StoragePartition* partition = |
| 104 | BrowserContext::GetStoragePartition(browser_context_, site_instance); |
| 105 | |
| 106 | // Is this the default storage partition? If it isn't, then just give it its |
| 107 | // own non-shared process. |
| 108 | if (partition != default_partition || is_for_guests_only) { |
| 109 | RenderProcessHostImpl* host = new RenderProcessHostImpl( |
| 110 | browser_context_, static_cast<StoragePartitionImpl*>(partition), |
| 111 | is_for_guests_only); |
| 112 | host->SetIsNeverSuitableForReuse(); |
| 113 | return host; |
| 114 | } |
| 115 | |
| 116 | if (host_) { |
| 117 | // If we already have a shared host for the default storage partition, use |
| 118 | // it. |
| 119 | return host_; |
| 120 | } |
| 121 | |
| 122 | host_ = new RenderProcessHostImpl( |
| 123 | browser_context_, static_cast<StoragePartitionImpl*>(partition), |
| 124 | false /* for guests only */); |
| 125 | host_->SetIsNeverSuitableForReuse(); |
| 126 | host_->AddObserver(this); |
| 127 | |
| 128 | return host_; |
| 129 | } |
| 130 | |
| 131 | void RenderProcessHostDestroyed(RenderProcessHost* host) override { |
| 132 | DCHECK_EQ(host_, host); |
| 133 | host_->RemoveObserver(this); |
| 134 | host_ = nullptr; |
| 135 | } |
| 136 | |
| 137 | private: |
| 138 | BrowserContext* browser_context_; |
| 139 | |
| 140 | // The default subframe render process used for the default storage partition |
| 141 | // of this BrowserContext. |
| 142 | RenderProcessHostImpl* host_ = nullptr; |
| 143 | }; |
| 144 | |
| 145 | } // namespace |
| 146 | |
| 147 | RenderProcessHost* SiteInstanceImpl::GetDefaultSubframeProcessHost( |
| 148 | BrowserContext* browser_context, |
| 149 | bool is_for_guests_only) { |
| 150 | DefaultSubframeProcessHostHolder* holder = |
| 151 | static_cast<DefaultSubframeProcessHostHolder*>( |
| 152 | browser_context->GetUserData(&kDefaultSubframeProcessHostHolderKey)); |
| 153 | if (!holder) { |
| 154 | holder = new DefaultSubframeProcessHostHolder(browser_context); |
avi | cb129c0 | 2017-05-03 06:49:29 | [diff] [blame^] | 155 | browser_context->SetUserData(kDefaultSubframeProcessHostHolderKey, |
| 156 | base::WrapUnique(holder)); |
avi | 6d686db | 2017-01-06 02:28:57 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | return holder->GetProcessHost(this, is_for_guests_only); |
| 160 | } |
| 161 | |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 162 | RenderProcessHost* SiteInstanceImpl::GetProcess() { |
[email protected] | 08c8ec7e | 2010-07-11 17:14:48 | [diff] [blame] | 163 | // TODO(erikkay) It would be nice to ensure that the renderer type had been |
| 164 | // properly set before we get here. The default tab creation case winds up |
| 165 | // with no site set at this point, so it will default to TYPE_NORMAL. This |
| 166 | // may not be correct, so we'll wind up potentially creating a process that |
| 167 | // we then throw away, or worse sharing a process with the wrong process type. |
| 168 | // See crbug.com/43448. |
| 169 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 170 | // Create a new process if ours went away or was reused. |
[email protected] | 4566f13 | 2009-03-12 01:55:13 | [diff] [blame] | 171 | if (!process_) { |
[email protected] | 4c3a2358 | 2012-08-18 08:54:34 | [diff] [blame] | 172 | BrowserContext* browser_context = browsing_instance_->browser_context(); |
avi | 6d686db | 2017-01-06 02:28:57 | [diff] [blame] | 173 | bool is_for_guests_only = site_.SchemeIs(kGuestScheme); |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 174 | |
| 175 | // If we should use process-per-site mode (either in general or for the |
| 176 | // given site), then look for an existing RenderProcessHost for the site. |
| 177 | bool use_process_per_site = has_site_ && |
[email protected] | 1ae93fb1 | 2013-06-14 03:38:56 | [diff] [blame] | 178 | RenderProcessHost::ShouldUseProcessPerSite(browser_context, site_); |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 179 | if (use_process_per_site) { |
| 180 | process_ = RenderProcessHostImpl::GetProcessHostForSite(browser_context, |
| 181 | site_); |
| 182 | } |
| 183 | |
avi | 6d686db | 2017-01-06 02:28:57 | [diff] [blame] | 184 | if (!process_ && IsDefaultSubframeSiteInstance() && |
| 185 | SiteIsolationPolicy::IsTopDocumentIsolationEnabled()) { |
| 186 | process_ = |
| 187 | GetDefaultSubframeProcessHost(browser_context, is_for_guests_only); |
| 188 | } |
| 189 | |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 190 | // If not (or if none found), see if we should reuse an existing process. |
| 191 | if (!process_ && RenderProcessHostImpl::ShouldTryToUseExistingProcessHost( |
| 192 | browser_context, site_)) { |
| 193 | process_ = RenderProcessHostImpl::GetExistingProcessHost(browser_context, |
| 194 | site_); |
| 195 | } |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 196 | |
| 197 | // Otherwise (or if that fails), create a new one. |
[email protected] | 4566f13 | 2009-03-12 01:55:13 | [diff] [blame] | 198 | if (!process_) { |
[email protected] | 3059caa | 2013-06-06 03:48:41 | [diff] [blame] | 199 | if (g_render_process_host_factory_) { |
| 200 | process_ = g_render_process_host_factory_->CreateRenderProcessHost( |
[email protected] | f681b07 | 2013-06-06 21:53:12 | [diff] [blame] | 201 | browser_context, this); |
[email protected] | a6df511 | 2009-01-21 23:50:15 | [diff] [blame] | 202 | } else { |
[email protected] | 4c3a2358 | 2012-08-18 08:54:34 | [diff] [blame] | 203 | StoragePartitionImpl* partition = |
| 204 | static_cast<StoragePartitionImpl*>( |
| 205 | BrowserContext::GetStoragePartition(browser_context, this)); |
avi | 6d686db | 2017-01-06 02:28:57 | [diff] [blame] | 206 | process_ = new RenderProcessHostImpl(browser_context, partition, |
| 207 | is_for_guests_only); |
[email protected] | a6df511 | 2009-01-21 23:50:15 | [diff] [blame] | 208 | } |
| 209 | } |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 210 | CHECK(process_); |
[email protected] | 40bfaf3 | 2013-11-19 01:35:43 | [diff] [blame] | 211 | process_->AddObserver(this); |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 212 | |
| 213 | // If we are using process-per-site, we need to register this process |
| 214 | // for the current site so that we can find it again. (If no site is set |
| 215 | // at this time, we will register it in SetSite().) |
| 216 | if (use_process_per_site) { |
| 217 | RenderProcessHostImpl::RegisterProcessHostForSite(browser_context, |
| 218 | process_, site_); |
| 219 | } |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 220 | |
nasko | b8744d2 | 2014-08-28 17:07:43 | [diff] [blame] | 221 | TRACE_EVENT2("navigation", "SiteInstanceImpl::GetProcess", |
| 222 | "site id", id_, "process id", process_->GetID()); |
[email protected] | 4648832 | 2012-10-30 03:22:20 | [diff] [blame] | 223 | GetContentClient()->browser()->SiteInstanceGotProcess(this); |
[email protected] | 6f37144 | 2011-11-09 06:45:46 | [diff] [blame] | 224 | |
[email protected] | 313b80bd | 2011-11-23 03:49:10 | [diff] [blame] | 225 | if (has_site_) |
| 226 | LockToOrigin(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 227 | } |
[email protected] | 4566f13 | 2009-03-12 01:55:13 | [diff] [blame] | 228 | DCHECK(process_); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 229 | |
[email protected] | 4566f13 | 2009-03-12 01:55:13 | [diff] [blame] | 230 | return process_; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 231 | } |
| 232 | |
[email protected] | b658359 | 2012-01-25 19:52:33 | [diff] [blame] | 233 | void SiteInstanceImpl::SetSite(const GURL& url) { |
nasko | b8744d2 | 2014-08-28 17:07:43 | [diff] [blame] | 234 | TRACE_EVENT2("navigation", "SiteInstanceImpl::SetSite", |
| 235 | "site id", id_, "url", url.possibly_invalid_spec()); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 236 | // A SiteInstance's site should not change. |
| 237 | // TODO(creis): When following links or script navigations, we can currently |
| 238 | // render pages from other sites in this SiteInstance. This will eventually |
| 239 | // be fixed, but until then, we should still not set the site of a |
| 240 | // SiteInstance more than once. |
| 241 | DCHECK(!has_site_); |
| 242 | |
| 243 | // Remember that this SiteInstance has been used to load a URL, even if the |
| 244 | // URL is invalid. |
| 245 | has_site_ = true; |
[email protected] | 4c3a2358 | 2012-08-18 08:54:34 | [diff] [blame] | 246 | BrowserContext* browser_context = browsing_instance_->browser_context(); |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 247 | site_ = GetSiteForURL(browser_context, url); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 248 | |
| 249 | // Now that we have a site, register it with the BrowsingInstance. This |
| 250 | // ensures that we won't create another SiteInstance for this site within |
| 251 | // the same BrowsingInstance, because all same-site pages within a |
| 252 | // BrowsingInstance can script each other. |
| 253 | browsing_instance_->RegisterSiteInstance(this); |
[email protected] | 313b80bd | 2011-11-23 03:49:10 | [diff] [blame] | 254 | |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 255 | if (process_) { |
[email protected] | 313b80bd | 2011-11-23 03:49:10 | [diff] [blame] | 256 | LockToOrigin(); |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 257 | |
| 258 | // Ensure the process is registered for this site if necessary. |
[email protected] | 1ae93fb1 | 2013-06-14 03:38:56 | [diff] [blame] | 259 | if (RenderProcessHost::ShouldUseProcessPerSite(browser_context, site_)) { |
[email protected] | 41fb79a5 | 2012-06-29 16:34:33 | [diff] [blame] | 260 | RenderProcessHostImpl::RegisterProcessHostForSite( |
| 261 | browser_context, process_, site_); |
| 262 | } |
| 263 | } |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 264 | } |
| 265 | |
[email protected] | 77ab1731 | 2012-09-28 15:34:59 | [diff] [blame] | 266 | const GURL& SiteInstanceImpl::GetSiteURL() const { |
[email protected] | b658359 | 2012-01-25 19:52:33 | [diff] [blame] | 267 | return site_; |
| 268 | } |
| 269 | |
| 270 | bool SiteInstanceImpl::HasSite() const { |
| 271 | return has_site_; |
| 272 | } |
| 273 | |
| 274 | bool SiteInstanceImpl::HasRelatedSiteInstance(const GURL& url) { |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 275 | return browsing_instance_->HasSiteInstance(url); |
| 276 | } |
| 277 | |
dcheng | bccd6b8 | 2016-03-30 16:24:19 | [diff] [blame] | 278 | scoped_refptr<SiteInstance> SiteInstanceImpl::GetRelatedSiteInstance( |
| 279 | const GURL& url) { |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 280 | return browsing_instance_->GetSiteInstanceForURL(url); |
| 281 | } |
| 282 | |
[email protected] | 14392a5 | 2012-05-02 20:28:44 | [diff] [blame] | 283 | bool SiteInstanceImpl::IsRelatedSiteInstance(const SiteInstance* instance) { |
[email protected] | fc72bb1 | 2013-06-02 21:13:46 | [diff] [blame] | 284 | return browsing_instance_.get() == static_cast<const SiteInstanceImpl*>( |
| 285 | instance)->browsing_instance_.get(); |
[email protected] | 14392a5 | 2012-05-02 20:28:44 | [diff] [blame] | 286 | } |
| 287 | |
[email protected] | d5072a8 | 2014-05-15 05:50:18 | [diff] [blame] | 288 | size_t SiteInstanceImpl::GetRelatedActiveContentsCount() { |
| 289 | return browsing_instance_->active_contents_count(); |
| 290 | } |
| 291 | |
[email protected] | f88628d0 | 2012-11-11 17:58:59 | [diff] [blame] | 292 | bool SiteInstanceImpl::HasWrongProcessForURL(const GURL& url) { |
[email protected] | d292d8a | 2011-05-25 03:47:11 | [diff] [blame] | 293 | // Having no process isn't a problem, since we'll assign it correctly. |
[email protected] | f88628d0 | 2012-11-11 17:58:59 | [diff] [blame] | 294 | // Note that HasProcess() may return true if process_ is null, in |
| 295 | // process-per-site cases where there's an existing process available. |
| 296 | // We want to use such a process in the IsSuitableHost check, so we |
| 297 | // may end up assigning process_ in the GetProcess() call below. |
| 298 | if (!HasProcess()) |
[email protected] | d292d8a | 2011-05-25 03:47:11 | [diff] [blame] | 299 | return false; |
| 300 | |
[email protected] | 144a810 | 2012-01-14 01:05:31 | [diff] [blame] | 301 | // If the URL to navigate to can be associated with any site instance, |
| 302 | // we want to keep it in the same process. |
[email protected] | c02f1ba | 2014-02-03 06:53:53 | [diff] [blame] | 303 | if (IsRendererDebugURL(url)) |
[email protected] | 144a810 | 2012-01-14 01:05:31 | [diff] [blame] | 304 | return false; |
| 305 | |
[email protected] | 88aae97 | 2011-12-16 01:14:18 | [diff] [blame] | 306 | // If the site URL is an extension (e.g., for hosted apps or WebUI) but the |
[email protected] | d292d8a | 2011-05-25 03:47:11 | [diff] [blame] | 307 | // process is not (or vice versa), make sure we notice and fix it. |
[email protected] | 2a5221b | 2011-09-27 23:07:31 | [diff] [blame] | 308 | GURL site_url = GetSiteForURL(browsing_instance_->browser_context(), url); |
[email protected] | 88aae97 | 2011-12-16 01:14:18 | [diff] [blame] | 309 | return !RenderProcessHostImpl::IsSuitableHost( |
[email protected] | f88628d0 | 2012-11-11 17:58:59 | [diff] [blame] | 310 | GetProcess(), browsing_instance_->browser_context(), site_url); |
[email protected] | d292d8a | 2011-05-25 03:47:11 | [diff] [blame] | 311 | } |
| 312 | |
nick | d5bbd0b | 2016-03-31 19:52:44 | [diff] [blame] | 313 | scoped_refptr<SiteInstanceImpl> |
| 314 | SiteInstanceImpl::GetDefaultSubframeSiteInstance() { |
| 315 | return browsing_instance_->GetDefaultSubframeSiteInstance(); |
| 316 | } |
| 317 | |
nick | d30fd96 | 2015-07-27 21:51:08 | [diff] [blame] | 318 | bool SiteInstanceImpl::RequiresDedicatedProcess() { |
| 319 | if (!has_site_) |
| 320 | return false; |
nick | d5bbd0b | 2016-03-31 19:52:44 | [diff] [blame] | 321 | |
| 322 | return DoesSiteRequireDedicatedProcess(GetBrowserContext(), site_); |
nick | d30fd96 | 2015-07-27 21:51:08 | [diff] [blame] | 323 | } |
| 324 | |
avi | 85cacb7 | 2016-10-26 22:39:33 | [diff] [blame] | 325 | bool SiteInstanceImpl::IsDefaultSubframeSiteInstance() const { |
| 326 | return is_default_subframe_site_instance_; |
| 327 | } |
| 328 | |
nick | 9f34e289 | 2016-01-12 21:01:07 | [diff] [blame] | 329 | void SiteInstanceImpl::IncrementActiveFrameCount() { |
| 330 | active_frame_count_++; |
| 331 | } |
| 332 | |
| 333 | void SiteInstanceImpl::DecrementActiveFrameCount() { |
ericwilligers | 254597b | 2016-10-17 10:32:31 | [diff] [blame] | 334 | if (--active_frame_count_ == 0) { |
| 335 | for (auto& observer : observers_) |
| 336 | observer.ActiveFrameCountIsZero(this); |
| 337 | } |
nick | 9f34e289 | 2016-01-12 21:01:07 | [diff] [blame] | 338 | } |
| 339 | |
[email protected] | d5072a8 | 2014-05-15 05:50:18 | [diff] [blame] | 340 | void SiteInstanceImpl::IncrementRelatedActiveContentsCount() { |
| 341 | browsing_instance_->increment_active_contents_count(); |
| 342 | } |
| 343 | |
| 344 | void SiteInstanceImpl::DecrementRelatedActiveContentsCount() { |
| 345 | browsing_instance_->decrement_active_contents_count(); |
| 346 | } |
| 347 | |
nick | 9f34e289 | 2016-01-12 21:01:07 | [diff] [blame] | 348 | void SiteInstanceImpl::AddObserver(Observer* observer) { |
| 349 | observers_.AddObserver(observer); |
| 350 | } |
| 351 | |
| 352 | void SiteInstanceImpl::RemoveObserver(Observer* observer) { |
| 353 | observers_.RemoveObserver(observer); |
| 354 | } |
| 355 | |
[email protected] | 3059caa | 2013-06-06 03:48:41 | [diff] [blame] | 356 | void SiteInstanceImpl::set_render_process_host_factory( |
| 357 | const RenderProcessHostFactory* rph_factory) { |
| 358 | g_render_process_host_factory_ = rph_factory; |
| 359 | } |
| 360 | |
[email protected] | 4c3a2358 | 2012-08-18 08:54:34 | [diff] [blame] | 361 | BrowserContext* SiteInstanceImpl::GetBrowserContext() const { |
[email protected] | 72daaa9 | 2012-01-18 13:39:02 | [diff] [blame] | 362 | return browsing_instance_->browser_context(); |
| 363 | } |
| 364 | |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 365 | // static |
dcheng | bccd6b8 | 2016-03-30 16:24:19 | [diff] [blame] | 366 | scoped_refptr<SiteInstance> SiteInstance::Create( |
| 367 | BrowserContext* browser_context) { |
| 368 | return SiteInstanceImpl::Create(browser_context); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 369 | } |
| 370 | |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 371 | // static |
dcheng | bccd6b8 | 2016-03-30 16:24:19 | [diff] [blame] | 372 | scoped_refptr<SiteInstance> SiteInstance::CreateForURL( |
| 373 | BrowserContext* browser_context, |
| 374 | const GURL& url) { |
| 375 | return SiteInstanceImpl::CreateForURL(browser_context, url); |
[email protected] | d8a9662 | 2009-05-07 19:21:16 | [diff] [blame] | 376 | } |
| 377 | |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 378 | // static |
[email protected] | 399583b | 2012-12-11 09:33:42 | [diff] [blame] | 379 | bool SiteInstance::IsSameWebSite(BrowserContext* browser_context, |
[email protected] | 855d7d57 | 2014-08-02 11:18:17 | [diff] [blame] | 380 | const GURL& real_src_url, |
| 381 | const GURL& real_dest_url) { |
| 382 | GURL src_url = SiteInstanceImpl::GetEffectiveURL(browser_context, |
| 383 | real_src_url); |
| 384 | GURL dest_url = SiteInstanceImpl::GetEffectiveURL(browser_context, |
| 385 | real_dest_url); |
[email protected] | 399583b | 2012-12-11 09:33:42 | [diff] [blame] | 386 | |
| 387 | // We infer web site boundaries based on the registered domain name of the |
| 388 | // top-level page and the scheme. We do not pay attention to the port if |
| 389 | // one is present, because pages served from different ports can still |
| 390 | // access each other if they change their document.domain variable. |
| 391 | |
| 392 | // Some special URLs will match the site instance of any other URL. This is |
| 393 | // done before checking both of them for validity, since we want these URLs |
| 394 | // to have the same site instance as even an invalid one. |
[email protected] | 855d7d57 | 2014-08-02 11:18:17 | [diff] [blame] | 395 | if (IsRendererDebugURL(src_url) || IsRendererDebugURL(dest_url)) |
[email protected] | 399583b | 2012-12-11 09:33:42 | [diff] [blame] | 396 | return true; |
| 397 | |
| 398 | // If either URL is invalid, they aren't part of the same site. |
[email protected] | 855d7d57 | 2014-08-02 11:18:17 | [diff] [blame] | 399 | if (!src_url.is_valid() || !dest_url.is_valid()) |
[email protected] | 399583b | 2012-12-11 09:33:42 | [diff] [blame] | 400 | return false; |
| 401 | |
[email protected] | 855d7d57 | 2014-08-02 11:18:17 | [diff] [blame] | 402 | // If the destination url is just a blank page, we treat them as part of the |
| 403 | // same site. |
| 404 | GURL blank_page(url::kAboutBlankURL); |
| 405 | if (dest_url == blank_page) |
| 406 | return true; |
| 407 | |
[email protected] | 399583b | 2012-12-11 09:33:42 | [diff] [blame] | 408 | // If the schemes differ, they aren't part of the same site. |
[email protected] | 855d7d57 | 2014-08-02 11:18:17 | [diff] [blame] | 409 | if (src_url.scheme() != dest_url.scheme()) |
[email protected] | 399583b | 2012-12-11 09:33:42 | [diff] [blame] | 410 | return false; |
| 411 | |
[email protected] | ed32c21 | 2013-05-14 20:49:29 | [diff] [blame] | 412 | return net::registry_controlled_domains::SameDomainOrHost( |
[email protected] | 855d7d57 | 2014-08-02 11:18:17 | [diff] [blame] | 413 | src_url, |
| 414 | dest_url, |
[email protected] | aabe179 | 2014-01-30 21:37:46 | [diff] [blame] | 415 | net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES); |
[email protected] | 399583b | 2012-12-11 09:33:42 | [diff] [blame] | 416 | } |
| 417 | |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 418 | // static |
[email protected] | 399583b | 2012-12-11 09:33:42 | [diff] [blame] | 419 | GURL SiteInstance::GetSiteForURL(BrowserContext* browser_context, |
| 420 | const GURL& real_url) { |
[email protected] | 25a9e8e53 | 2012-06-22 06:16:28 | [diff] [blame] | 421 | // TODO(fsamuel, creis): For some reason appID is not recognized as a host. |
[email protected] | 6eb1a11e | 2013-10-09 00:54:37 | [diff] [blame] | 422 | if (real_url.SchemeIs(kGuestScheme)) |
[email protected] | 25a9e8e53 | 2012-06-22 06:16:28 | [diff] [blame] | 423 | return real_url; |
| 424 | |
[email protected] | b658359 | 2012-01-25 19:52:33 | [diff] [blame] | 425 | GURL url = SiteInstanceImpl::GetEffectiveURL(browser_context, real_url); |
nick | 1dd4792 | 2016-04-29 16:44:48 | [diff] [blame] | 426 | url::Origin origin(url); |
[email protected] | 3a8eecb | 2010-04-22 23:56:30 | [diff] [blame] | 427 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 428 | // If the url has a host, then determine the site. |
nick | 1dd4792 | 2016-04-29 16:44:48 | [diff] [blame] | 429 | if (!origin.host().empty()) { |
| 430 | // Only keep the scheme and registered domain of |origin|. |
| 431 | std::string domain = net::registry_controlled_domains::GetDomainAndRegistry( |
| 432 | origin.host(), |
| 433 | net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES); |
| 434 | std::string site = origin.scheme(); |
| 435 | site += url::kStandardSchemeSeparator; |
| 436 | site += domain.empty() ? origin.host() : domain; |
| 437 | return GURL(site); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 438 | } |
creis | f60c2cd | 2014-12-18 00:41:02 | [diff] [blame] | 439 | |
| 440 | // If there is no host but there is a scheme, return the scheme. |
| 441 | // This is useful for cases like file URLs. |
| 442 | if (url.has_scheme()) |
| 443 | return GURL(url.scheme() + ":"); |
| 444 | |
| 445 | // Otherwise the URL should be invalid; return an empty site. |
| 446 | DCHECK(!url.is_valid()); |
| 447 | return GURL(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 448 | } |
| 449 | |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 450 | // static |
[email protected] | 4c3a2358 | 2012-08-18 08:54:34 | [diff] [blame] | 451 | GURL SiteInstanceImpl::GetEffectiveURL(BrowserContext* browser_context, |
| 452 | const GURL& url) { |
[email protected] | 4648832 | 2012-10-30 03:22:20 | [diff] [blame] | 453 | return GetContentClient()->browser()-> |
[email protected] | 3d7474ff | 2011-07-27 17:47:37 | [diff] [blame] | 454 | GetEffectiveURL(browser_context, url); |
[email protected] | 3a8eecb | 2010-04-22 23:56:30 | [diff] [blame] | 455 | } |
| 456 | |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 457 | // static |
| 458 | bool SiteInstanceImpl::DoesSiteRequireDedicatedProcess( |
| 459 | BrowserContext* browser_context, |
nick | db193a1 | 2016-09-09 23:09:23 | [diff] [blame] | 460 | const GURL& url) { |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 461 | // If --site-per-process is enabled, site isolation is enabled everywhere. |
| 462 | if (SiteIsolationPolicy::UseDedicatedProcessesForAllSites()) |
| 463 | return true; |
| 464 | |
nick | db193a1 | 2016-09-09 23:09:23 | [diff] [blame] | 465 | // Let the content embedder enable site isolation for specific URLs. Use the |
| 466 | // canonical site url for this check, so that schemes with nested origins |
| 467 | // (blob and filesystem) work properly. |
| 468 | GURL site_url = GetSiteForURL(browser_context, url); |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 469 | if (GetContentClient()->IsSupplementarySiteIsolationModeEnabled() && |
| 470 | GetContentClient()->browser()->DoesSiteRequireDedicatedProcess( |
nick | db193a1 | 2016-09-09 23:09:23 | [diff] [blame] | 471 | browser_context, site_url)) { |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 472 | return true; |
| 473 | } |
| 474 | |
| 475 | return false; |
| 476 | } |
| 477 | |
[email protected] | 40bfaf3 | 2013-11-19 01:35:43 | [diff] [blame] | 478 | void SiteInstanceImpl::RenderProcessHostDestroyed(RenderProcessHost* host) { |
| 479 | DCHECK_EQ(process_, host); |
| 480 | process_->RemoveObserver(this); |
nick | d5bbd0b | 2016-03-31 19:52:44 | [diff] [blame] | 481 | process_ = nullptr; |
[email protected] | 4566f13 | 2009-03-12 01:55:13 | [diff] [blame] | 482 | } |
[email protected] | 313b80bd | 2011-11-23 03:49:10 | [diff] [blame] | 483 | |
nick | 9f34e289 | 2016-01-12 21:01:07 | [diff] [blame] | 484 | void SiteInstanceImpl::RenderProcessWillExit(RenderProcessHost* host) { |
| 485 | // TODO(nick): http://crbug.com/575400 - RenderProcessWillExit might not serve |
| 486 | // any purpose here. |
ericwilligers | 254597b | 2016-10-17 10:32:31 | [diff] [blame] | 487 | for (auto& observer : observers_) |
| 488 | observer.RenderProcessGone(this); |
nick | 9f34e289 | 2016-01-12 21:01:07 | [diff] [blame] | 489 | } |
| 490 | |
| 491 | void SiteInstanceImpl::RenderProcessExited(RenderProcessHost* host, |
| 492 | base::TerminationStatus status, |
| 493 | int exit_code) { |
ericwilligers | 254597b | 2016-10-17 10:32:31 | [diff] [blame] | 494 | for (auto& observer : observers_) |
| 495 | observer.RenderProcessGone(this); |
nick | 9f34e289 | 2016-01-12 21:01:07 | [diff] [blame] | 496 | } |
| 497 | |
[email protected] | b658359 | 2012-01-25 19:52:33 | [diff] [blame] | 498 | void SiteInstanceImpl::LockToOrigin() { |
nick | d30fd96 | 2015-07-27 21:51:08 | [diff] [blame] | 499 | // TODO(nick): When all sites are isolated, this operation provides strong |
| 500 | // protection. If only some sites are isolated, we need additional logic to |
| 501 | // prevent the non-isolated sites from requesting resources for isolated |
| 502 | // sites. https://crbug.com/509125 |
nick | cc0d914 | 2015-10-14 16:27:10 | [diff] [blame] | 503 | if (RequiresDedicatedProcess()) { |
lazyboy | f5283a4 | 2015-06-24 21:53:35 | [diff] [blame] | 504 | // Guest processes cannot be locked to its site because guests always have |
| 505 | // a fixed SiteInstance. The site of GURLs a guest loads doesn't match that |
| 506 | // SiteInstance. So we skip locking the guest process to the site. |
| 507 | // TODO(ncarter): Remove this exclusion once we can make origin lock per |
| 508 | // RenderFrame routing id. |
| 509 | if (site_.SchemeIs(content::kGuestScheme)) |
| 510 | return; |
| 511 | |
lfg | 24d08379 | 2015-07-17 20:45:35 | [diff] [blame] | 512 | // TODO(creis, nick) https://crbug.com/510588 Chrome UI pages use the same |
| 513 | // site (chrome://chrome), so they can't be locked because the site being |
| 514 | // loaded doesn't match the SiteInstance. |
| 515 | if (site_.SchemeIs(content::kChromeUIScheme)) |
| 516 | return; |
| 517 | |
creis | e5d6d173 | 2015-08-25 19:47:06 | [diff] [blame] | 518 | // TODO(creis, nick): Until we can handle sites with effective URLs at the |
| 519 | // call sites of ChildProcessSecurityPolicy::CanAccessDataForOrigin, we |
| 520 | // must give the embedder a chance to exempt some sites to avoid process |
| 521 | // kills. |
nick | 7d0984c | 2015-08-29 00:13:46 | [diff] [blame] | 522 | if (!GetContentClient()->browser()->ShouldLockToOrigin( |
| 523 | browsing_instance_->browser_context(), site_)) |
creis | e5d6d173 | 2015-08-25 19:47:06 | [diff] [blame] | 524 | return; |
| 525 | |
[email protected] | b953542 | 2012-02-09 01:47:59 | [diff] [blame] | 526 | ChildProcessSecurityPolicyImpl* policy = |
| 527 | ChildProcessSecurityPolicyImpl::GetInstance(); |
[email protected] | 313b80bd | 2011-11-23 03:49:10 | [diff] [blame] | 528 | policy->LockToOrigin(process_->GetID(), site_); |
| 529 | } |
| 530 | } |
[email protected] | 4648832 | 2012-10-30 03:22:20 | [diff] [blame] | 531 | |
| 532 | } // namespace content |