content/browser/site_instance_impl_unittest.cc

   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 "base/command_line.h"
   6 #include "base/compiler_specific.h"
   7 #include "base/memory/scoped_vector.h"
   8 #include "base/strings/string16.h"
   9 #include "content/browser/browser_thread_impl.h"
  10 #include "content/browser/browsing_instance.h"
  11 #include "content/browser/child_process_security_policy_impl.h"
  12 #include "content/browser/frame_host/navigation_entry_impl.h"
  13 #include "content/browser/renderer_host/render_process_host_impl.h"
  14 #include "content/browser/renderer_host/render_view_host_impl.h"
  15 #include "content/browser/site_instance_impl.h"
  16 #include "content/browser/web_contents/web_contents_impl.h"
  17 #include "content/browser/webui/web_ui_controller_factory_registry.h"
  18 #include "content/public/common/content_client.h"
  19 #include "content/public/common/content_constants.h"
  20 #include "content/public/common/content_switches.h"
  21 #include "content/public/common/url_constants.h"
  22 #include "content/public/common/url_utils.h"
  23 #include "content/public/test/mock_render_process_host.h"
  24 #include "content/public/test/test_browser_context.h"
  25 #include "content/public/test/test_browser_thread.h"
  26 #include "content/test/test_content_browser_client.h"
  27 #include "content/test/test_content_client.h"
  28 #include "content/test/test_render_view_host.h"
  29 #include "testing/gtest/include/gtest/gtest.h"
  30 #include "url/url_util.h"
  31
  32 namespace content {
  33 namespace {
  34
  35 const char kPrivilegedScheme[] = "privileged";
  36
  37 class SiteInstanceTestWebUIControllerFactory : public WebUIControllerFactory {
  38  public:
  39   WebUIController* CreateWebUIControllerForURL(WebUI* web_ui,
  40                                                const GURL& url) const override {
  41     return NULL;
  42   }
  43   WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
  44                              const GURL& url) const override {
  45     return WebUI::kNoWebUI;
  46   }
  47   bool UseWebUIForURL(BrowserContext* browser_context,
  48                       const GURL& url) const override {
  49     return HasWebUIScheme(url);
  50   }
  51   bool UseWebUIBindingsForURL(BrowserContext* browser_context,
  52                               const GURL& url) const override {
  53     return HasWebUIScheme(url);
  54   }
  55 };
  56
  57 class SiteInstanceTestBrowserClient : public TestContentBrowserClient {
  58  public:
  59   SiteInstanceTestBrowserClient()
  60       : privileged_process_id_(-1) {
  61     WebUIControllerFactory::RegisterFactory(&factory_);
  62   }
  63
  64   ~SiteInstanceTestBrowserClient() override {
  65     WebUIControllerFactory::UnregisterFactoryForTesting(&factory_);
  66   }
  67
  68   bool IsSuitableHost(RenderProcessHost* process_host,
  69                       const GURL& site_url) override {
  70     return (privileged_process_id_ == process_host->GetID()) ==
  71         site_url.SchemeIs(kPrivilegedScheme);
  72   }
  73
  74   void set_privileged_process_id(int process_id) {
  75     privileged_process_id_ = process_id;
  76   }
  77
  78  private:
  79   SiteInstanceTestWebUIControllerFactory factory_;
  80   int privileged_process_id_;
  81 };
  82
  83 class SiteInstanceTest : public testing::Test {
  84  public:
  85   SiteInstanceTest()
  86       : ui_thread_(BrowserThread::UI, &message_loop_),
  87         file_user_blocking_thread_(BrowserThread::FILE_USER_BLOCKING,
  88                                    &message_loop_),
  89         io_thread_(BrowserThread::IO, &message_loop_),
  90         old_browser_client_(NULL) {
  91   }
  92
  93   void SetUp() override {
  94     old_browser_client_ = SetBrowserClientForTesting(&browser_client_);
  95     url::AddStandardScheme(kPrivilegedScheme);
  96     url::AddStandardScheme(kChromeUIScheme);
  97
  98     SiteInstanceImpl::set_render_process_host_factory(&rph_factory_);
  99   }
 100
 101   void TearDown() override {
 102     // Ensure that no RenderProcessHosts are left over after the tests.
 103     EXPECT_TRUE(RenderProcessHost::AllHostsIterator().IsAtEnd());
 104
 105     SetBrowserClientForTesting(old_browser_client_);
 106     SiteInstanceImpl::set_render_process_host_factory(NULL);
 107
 108     // http://crbug.com/143565 found SiteInstanceTest leaking an
 109     // AppCacheDatabase. This happens because some part of the test indirectly
 110     // calls StoragePartitionImplMap::PostCreateInitialization(), which posts
 111     // a task to the IO thread to create the AppCacheDatabase. Since the
 112     // message loop is not running, the AppCacheDatabase ends up getting
 113     // created when DrainMessageLoops() gets called at the end of a test case.
 114     // Immediately after, the test case ends and the AppCacheDatabase gets
 115     // scheduled for deletion. Here, call DrainMessageLoops() again so the
 116     // AppCacheDatabase actually gets deleted.
 117     DrainMessageLoops();
 118   }
 119
 120   void set_privileged_process_id(int process_id) {
 121     browser_client_.set_privileged_process_id(process_id);
 122   }
 123
 124   void DrainMessageLoops() {
 125     // We don't just do this in TearDown() because we create TestBrowserContext
 126     // objects in each test, which will be destructed before
 127     // TearDown() is called.
 128     base::MessageLoop::current()->RunUntilIdle();
 129     message_loop_.RunUntilIdle();
 130   }
 131
 132  private:
 133   base::MessageLoopForUI message_loop_;
 134   TestBrowserThread ui_thread_;
 135   TestBrowserThread file_user_blocking_thread_;
 136   TestBrowserThread io_thread_;
 137
 138   SiteInstanceTestBrowserClient browser_client_;
 139   ContentBrowserClient* old_browser_client_;
 140   MockRenderProcessHostFactory rph_factory_;
 141 };
 142
 143 // Subclass of BrowsingInstance that updates a counter when deleted and
 144 // returns TestSiteInstances from GetSiteInstanceForURL.
 145 class TestBrowsingInstance : public BrowsingInstance {
 146  public:
 147   TestBrowsingInstance(BrowserContext* browser_context, int* delete_counter)
 148       : BrowsingInstance(browser_context),
 149         delete_counter_(delete_counter) {
 150   }
 151
 152   // Make a few methods public for tests.
 153   using BrowsingInstance::browser_context;
 154   using BrowsingInstance::HasSiteInstance;
 155   using BrowsingInstance::GetSiteInstanceForURL;
 156   using BrowsingInstance::RegisterSiteInstance;
 157   using BrowsingInstance::UnregisterSiteInstance;
 158
 159  private:
 160   ~TestBrowsingInstance() override { (*delete_counter_)++; }
 161
 162   int* delete_counter_;
 163 };
 164
 165 // Subclass of SiteInstanceImpl that updates a counter when deleted.
 166 class TestSiteInstance : public SiteInstanceImpl {
 167  public:
 168   static TestSiteInstance* CreateTestSiteInstance(
 169       BrowserContext* browser_context,
 170       int* site_delete_counter,
 171       int* browsing_delete_counter) {
 172     TestBrowsingInstance* browsing_instance =
 173         new TestBrowsingInstance(browser_context, browsing_delete_counter);
 174     return new TestSiteInstance(browsing_instance, site_delete_counter);
 175   }
 176
 177  private:
 178   TestSiteInstance(BrowsingInstance* browsing_instance, int* delete_counter)
 179     : SiteInstanceImpl(browsing_instance), delete_counter_(delete_counter) {}
 180   ~TestSiteInstance() override { (*delete_counter_)++; }
 181
 182   int* delete_counter_;
 183 };
 184
 185 }  // namespace
 186
 187 // Test to ensure no memory leaks for SiteInstance objects.
 188 TEST_F(SiteInstanceTest, SiteInstanceDestructor) {
 189   // The existence of this object will cause WebContentsImpl to create our
 190   // test one instead of the real one.
 191   RenderViewHostTestEnabler rvh_test_enabler;
 192   int site_delete_counter = 0;
 193   int browsing_delete_counter = 0;
 194   const GURL url("test:foo");
 195
 196   // Ensure that instances are deleted when their NavigationEntries are gone.
 197   TestSiteInstance* instance =
 198       TestSiteInstance::CreateTestSiteInstance(NULL, &site_delete_counter,
 199                                                &browsing_delete_counter);
 200   EXPECT_EQ(0, site_delete_counter);
 201
 202   NavigationEntryImpl* e1 = new NavigationEntryImpl(
 203       instance, 0, url, Referrer(), base::string16(), ui::PAGE_TRANSITION_LINK,
 204       false);
 205
 206   // Redundantly setting e1's SiteInstance shouldn't affect the ref count.
 207   e1->set_site_instance(instance);
 208   EXPECT_EQ(0, site_delete_counter);
 209
 210   // Add a second reference
 211   NavigationEntryImpl* e2 = new NavigationEntryImpl(
 212       instance, 0, url, Referrer(), base::string16(), ui::PAGE_TRANSITION_LINK,
 213       false);
 214
 215   // Now delete both entries and be sure the SiteInstance goes away.
 216   delete e1;
 217   EXPECT_EQ(0, site_delete_counter);
 218   EXPECT_EQ(0, browsing_delete_counter);
 219   delete e2;
 220   EXPECT_EQ(1, site_delete_counter);
 221   // instance is now deleted
 222   EXPECT_EQ(1, browsing_delete_counter);
 223   // browsing_instance is now deleted
 224
 225   // Ensure that instances are deleted when their RenderViewHosts are gone.
 226   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 227   instance =
 228       TestSiteInstance::CreateTestSiteInstance(browser_context.get(),
 229                                                &site_delete_counter,
 230                                                &browsing_delete_counter);
 231   {
 232     scoped_ptr<WebContentsImpl> web_contents(static_cast<WebContentsImpl*>(
 233         WebContents::Create(WebContents::CreateParams(
 234             browser_context.get(), instance))));
 235     EXPECT_EQ(1, site_delete_counter);
 236     EXPECT_EQ(1, browsing_delete_counter);
 237   }
 238
 239   // Make sure that we flush any messages related to the above WebContentsImpl
 240   // destruction.
 241   DrainMessageLoops();
 242
 243   EXPECT_EQ(2, site_delete_counter);
 244   EXPECT_EQ(2, browsing_delete_counter);
 245   // contents is now deleted, along with instance and browsing_instance
 246 }
 247
 248 // Test that NavigationEntries with SiteInstances can be cloned, but that their
 249 // SiteInstances can be changed afterwards.  Also tests that the ref counts are
 250 // updated properly after the change.
 251 TEST_F(SiteInstanceTest, CloneNavigationEntry) {
 252   int site_delete_counter1 = 0;
 253   int site_delete_counter2 = 0;
 254   int browsing_delete_counter = 0;
 255   const GURL url("test:foo");
 256
 257   SiteInstanceImpl* instance1 =
 258       TestSiteInstance::CreateTestSiteInstance(NULL, &site_delete_counter1,
 259                                                &browsing_delete_counter);
 260   SiteInstanceImpl* instance2 =
 261       TestSiteInstance::CreateTestSiteInstance(NULL, &site_delete_counter2,
 262                                                &browsing_delete_counter);
 263
 264   NavigationEntryImpl* e1 = new NavigationEntryImpl(
 265       instance1, 0, url, Referrer(), base::string16(), ui::PAGE_TRANSITION_LINK,
 266       false);
 267   // Clone the entry
 268   NavigationEntryImpl* e2 = new NavigationEntryImpl(*e1);
 269
 270   // Should be able to change the SiteInstance of the cloned entry.
 271   e2->set_site_instance(instance2);
 272
 273   // The first SiteInstance should go away after deleting e1, since e2 should
 274   // no longer be referencing it.
 275   delete e1;
 276   EXPECT_EQ(1, site_delete_counter1);
 277   EXPECT_EQ(0, site_delete_counter2);
 278
 279   // The second SiteInstance should go away after deleting e2.
 280   delete e2;
 281   EXPECT_EQ(1, site_delete_counter1);
 282   EXPECT_EQ(1, site_delete_counter2);
 283
 284   // Both BrowsingInstances are also now deleted
 285   EXPECT_EQ(2, browsing_delete_counter);
 286
 287   DrainMessageLoops();
 288 }
 289
 290 // Test to ensure GetProcess returns and creates processes correctly.
 291 TEST_F(SiteInstanceTest, GetProcess) {
 292   // Ensure that GetProcess returns a process.
 293   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 294   scoped_ptr<RenderProcessHost> host1;
 295   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 296       SiteInstance::Create(browser_context.get())));
 297   host1.reset(instance->GetProcess());
 298   EXPECT_TRUE(host1.get() != NULL);
 299
 300   // Ensure that GetProcess creates a new process.
 301   scoped_refptr<SiteInstanceImpl> instance2(static_cast<SiteInstanceImpl*>(
 302       SiteInstance::Create(browser_context.get())));
 303   scoped_ptr<RenderProcessHost> host2(instance2->GetProcess());
 304   EXPECT_TRUE(host2.get() != NULL);
 305   EXPECT_NE(host1.get(), host2.get());
 306
 307   DrainMessageLoops();
 308 }
 309
 310 // Test to ensure SetSite and site() work properly.
 311 TEST_F(SiteInstanceTest, SetSite) {
 312   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 313       SiteInstance::Create(NULL)));
 314   EXPECT_FALSE(instance->HasSite());
 315   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 316
 317   instance->SetSite(GURL("http://www.google.com/index.html"));
 318   EXPECT_EQ(GURL("http://google.com"), instance->GetSiteURL());
 319
 320   EXPECT_TRUE(instance->HasSite());
 321
 322   DrainMessageLoops();
 323 }
 324
 325 // Test to ensure GetSiteForURL properly returns sites for URLs.
 326 TEST_F(SiteInstanceTest, GetSiteForURL) {
 327   // Pages are irrelevant.
 328   GURL test_url = GURL("http://www.google.com/index.html");
 329   EXPECT_EQ(GURL("http://google.com"),
 330             SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 331
 332   // Ports are irrlevant.
 333   test_url = GURL("https://www.google.com:8080");
 334   EXPECT_EQ(GURL("https://google.com"),
 335             SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 336
 337   // Javascript URLs have no site.
 338   test_url = GURL("javascript:foo();");
 339   EXPECT_EQ(GURL(), SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 340
 341   test_url = GURL("http://foo/a.html");
 342   EXPECT_EQ(GURL("http://foo"), SiteInstanceImpl::GetSiteForURL(
 343       NULL, test_url));
 344
 345   test_url = GURL("file:///C:/Downloads/");
 346   EXPECT_EQ(GURL(), SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 347
 348   std::string guest_url(kGuestScheme);
 349   guest_url.append("://abc123");
 350   test_url = GURL(guest_url);
 351   EXPECT_EQ(test_url, SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 352
 353   // TODO(creis): Do we want to special case file URLs to ensure they have
 354   // either no site or a special "file://" site?  We currently return
 355   // "file://home/" as the site, which seems broken.
 356   // test_url = GURL("file://home/");
 357   // EXPECT_EQ(GURL(), SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 358
 359   DrainMessageLoops();
 360 }
 361
 362 // Test of distinguishing URLs from different sites.  Most of this logic is
 363 // tested in RegistryControlledDomainTest.  This test focuses on URLs with
 364 // different schemes or ports.
 365 TEST_F(SiteInstanceTest, IsSameWebSite) {
 366   GURL url_foo = GURL("http://foo/a.html");
 367   GURL url_foo2 = GURL("http://foo/b.html");
 368   GURL url_foo_https = GURL("https://foo/a.html");
 369   GURL url_foo_port = GURL("http://foo:8080/a.html");
 370   GURL url_javascript = GURL("javascript:alert(1);");
 371   GURL url_blank = GURL(url::kAboutBlankURL);
 372
 373   // Same scheme and port -> same site.
 374   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo, url_foo2));
 375
 376   // Different scheme -> different site.
 377   EXPECT_FALSE(SiteInstance::IsSameWebSite(NULL, url_foo, url_foo_https));
 378
 379   // Different port -> same site.
 380   // (Changes to document.domain make renderer ignore the port.)
 381   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo, url_foo_port));
 382
 383   // JavaScript links should be considered same site for anything.
 384   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_javascript, url_foo));
 385   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_javascript, url_foo_https));
 386   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_javascript, url_foo_port));
 387
 388   // Navigating to a blank page is considered the same site.
 389   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo, url_blank));
 390   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo_https, url_blank));
 391   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo_port, url_blank));
 392
 393   // Navigating from a blank site is not considered to be the same site.
 394   EXPECT_FALSE(SiteInstance::IsSameWebSite(NULL, url_blank, url_foo));
 395   EXPECT_FALSE(SiteInstance::IsSameWebSite(NULL, url_blank, url_foo_https));
 396   EXPECT_FALSE(SiteInstance::IsSameWebSite(NULL, url_blank, url_foo_port));
 397
 398   DrainMessageLoops();
 399 }
 400
 401 // Test to ensure that there is only one SiteInstance per site in a given
 402 // BrowsingInstance, when process-per-site is not in use.
 403 TEST_F(SiteInstanceTest, OneSiteInstancePerSite) {
 404   ASSERT_FALSE(base::CommandLine::ForCurrentProcess()->HasSwitch(
 405       switches::kProcessPerSite));
 406   int delete_counter = 0;
 407   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 408   TestBrowsingInstance* browsing_instance =
 409       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 410
 411   const GURL url_a1("http://www.google.com/1.html");
 412   scoped_refptr<SiteInstanceImpl> site_instance_a1(
 413       static_cast<SiteInstanceImpl*>(
 414           browsing_instance->GetSiteInstanceForURL(url_a1)));
 415   EXPECT_TRUE(site_instance_a1.get() != NULL);
 416
 417   // A separate site should create a separate SiteInstance.
 418   const GURL url_b1("http://www.yahoo.com/");
 419   scoped_refptr<SiteInstanceImpl> site_instance_b1(
 420       static_cast<SiteInstanceImpl*>(
 421           browsing_instance->GetSiteInstanceForURL(url_b1)));
 422   EXPECT_NE(site_instance_a1.get(), site_instance_b1.get());
 423   EXPECT_TRUE(site_instance_a1->IsRelatedSiteInstance(site_instance_b1.get()));
 424
 425   // Getting the new SiteInstance from the BrowsingInstance and from another
 426   // SiteInstance in the BrowsingInstance should give the same result.
 427   EXPECT_EQ(site_instance_b1.get(),
 428             site_instance_a1->GetRelatedSiteInstance(url_b1));
 429
 430   // A second visit to the original site should return the same SiteInstance.
 431   const GURL url_a2("http://www.google.com/2.html");
 432   EXPECT_EQ(site_instance_a1.get(),
 433             browsing_instance->GetSiteInstanceForURL(url_a2));
 434   EXPECT_EQ(site_instance_a1.get(),
 435             site_instance_a1->GetRelatedSiteInstance(url_a2));
 436
 437   // A visit to the original site in a new BrowsingInstance (same or different
 438   // browser context) should return a different SiteInstance.
 439   TestBrowsingInstance* browsing_instance2 =
 440       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 441   // Ensure the new SiteInstance is ref counted so that it gets deleted.
 442   scoped_refptr<SiteInstanceImpl> site_instance_a2_2(
 443       static_cast<SiteInstanceImpl*>(
 444           browsing_instance2->GetSiteInstanceForURL(url_a2)));
 445   EXPECT_NE(site_instance_a1.get(), site_instance_a2_2.get());
 446   EXPECT_FALSE(
 447       site_instance_a1->IsRelatedSiteInstance(site_instance_a2_2.get()));
 448
 449   // The two SiteInstances for http://google.com should not use the same process
 450   // if process-per-site is not enabled.
 451   scoped_ptr<RenderProcessHost> process_a1(site_instance_a1->GetProcess());
 452   scoped_ptr<RenderProcessHost> process_a2_2(site_instance_a2_2->GetProcess());
 453   EXPECT_NE(process_a1.get(), process_a2_2.get());
 454
 455   // Should be able to see that we do have SiteInstances.
 456   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 457       GURL("http://mail.google.com")));
 458   EXPECT_TRUE(browsing_instance2->HasSiteInstance(
 459       GURL("http://mail.google.com")));
 460   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 461       GURL("http://mail.yahoo.com")));
 462
 463   // Should be able to see that we don't have SiteInstances.
 464   EXPECT_FALSE(browsing_instance->HasSiteInstance(
 465       GURL("https://www.google.com")));
 466   EXPECT_FALSE(browsing_instance2->HasSiteInstance(
 467       GURL("http://www.yahoo.com")));
 468
 469   // browsing_instances will be deleted when their SiteInstances are deleted.
 470   // The processes will be unregistered when the RPH scoped_ptrs go away.
 471
 472   DrainMessageLoops();
 473 }
 474
 475 // Test to ensure that there is only one RenderProcessHost per site for an
 476 // entire BrowserContext, if process-per-site is in use.
 477 TEST_F(SiteInstanceTest, OneSiteInstancePerSiteInBrowserContext) {
 478   base::CommandLine::ForCurrentProcess()->AppendSwitch(
 479       switches::kProcessPerSite);
 480   int delete_counter = 0;
 481   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 482   TestBrowsingInstance* browsing_instance =
 483       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 484
 485   const GURL url_a1("http://www.google.com/1.html");
 486   scoped_refptr<SiteInstanceImpl> site_instance_a1(
 487       static_cast<SiteInstanceImpl*>(
 488           browsing_instance->GetSiteInstanceForURL(url_a1)));
 489   EXPECT_TRUE(site_instance_a1.get() != NULL);
 490   scoped_ptr<RenderProcessHost> process_a1(site_instance_a1->GetProcess());
 491
 492   // A separate site should create a separate SiteInstance.
 493   const GURL url_b1("http://www.yahoo.com/");
 494   scoped_refptr<SiteInstanceImpl> site_instance_b1(
 495       static_cast<SiteInstanceImpl*>(
 496           browsing_instance->GetSiteInstanceForURL(url_b1)));
 497   EXPECT_NE(site_instance_a1.get(), site_instance_b1.get());
 498   EXPECT_TRUE(site_instance_a1->IsRelatedSiteInstance(site_instance_b1.get()));
 499
 500   // Getting the new SiteInstance from the BrowsingInstance and from another
 501   // SiteInstance in the BrowsingInstance should give the same result.
 502   EXPECT_EQ(site_instance_b1.get(),
 503             site_instance_a1->GetRelatedSiteInstance(url_b1));
 504
 505   // A second visit to the original site should return the same SiteInstance.
 506   const GURL url_a2("http://www.google.com/2.html");
 507   EXPECT_EQ(site_instance_a1.get(),
 508             browsing_instance->GetSiteInstanceForURL(url_a2));
 509   EXPECT_EQ(site_instance_a1.get(),
 510             site_instance_a1->GetRelatedSiteInstance(url_a2));
 511
 512   // A visit to the original site in a new BrowsingInstance (same browser
 513   // context) should return a different SiteInstance with the same process.
 514   TestBrowsingInstance* browsing_instance2 =
 515       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 516   scoped_refptr<SiteInstanceImpl> site_instance_a1_2(
 517       static_cast<SiteInstanceImpl*>(
 518           browsing_instance2->GetSiteInstanceForURL(url_a1)));
 519   EXPECT_TRUE(site_instance_a1.get() != NULL);
 520   EXPECT_NE(site_instance_a1.get(), site_instance_a1_2.get());
 521   EXPECT_EQ(process_a1.get(), site_instance_a1_2->GetProcess());
 522
 523   // A visit to the original site in a new BrowsingInstance (different browser
 524   // context) should return a different SiteInstance with a different process.
 525   scoped_ptr<TestBrowserContext> browser_context2(new TestBrowserContext());
 526   TestBrowsingInstance* browsing_instance3 =
 527       new TestBrowsingInstance(browser_context2.get(), &delete_counter);
 528   scoped_refptr<SiteInstanceImpl> site_instance_a2_3(
 529       static_cast<SiteInstanceImpl*>(
 530           browsing_instance3->GetSiteInstanceForURL(url_a2)));
 531   EXPECT_TRUE(site_instance_a2_3.get() != NULL);
 532   scoped_ptr<RenderProcessHost> process_a2_3(site_instance_a2_3->GetProcess());
 533   EXPECT_NE(site_instance_a1.get(), site_instance_a2_3.get());
 534   EXPECT_NE(process_a1.get(), process_a2_3.get());
 535
 536   // Should be able to see that we do have SiteInstances.
 537   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 538       GURL("http://mail.google.com")));  // visited before
 539   EXPECT_TRUE(browsing_instance2->HasSiteInstance(
 540       GURL("http://mail.google.com")));  // visited before
 541   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 542       GURL("http://mail.yahoo.com")));  // visited before
 543
 544   // Should be able to see that we don't have SiteInstances.
 545   EXPECT_FALSE(browsing_instance2->HasSiteInstance(
 546       GURL("http://www.yahoo.com")));  // different BI, same browser context
 547   EXPECT_FALSE(browsing_instance->HasSiteInstance(
 548       GURL("https://www.google.com")));  // not visited before
 549   EXPECT_FALSE(browsing_instance3->HasSiteInstance(
 550       GURL("http://www.yahoo.com")));  // different BI, different context
 551
 552   // browsing_instances will be deleted when their SiteInstances are deleted.
 553   // The processes will be unregistered when the RPH scoped_ptrs go away.
 554
 555   DrainMessageLoops();
 556 }
 557
 558 static SiteInstanceImpl* CreateSiteInstance(BrowserContext* browser_context,
 559                                             const GURL& url) {
 560   return static_cast<SiteInstanceImpl*>(
 561       SiteInstance::CreateForURL(browser_context, url));
 562 }
 563
 564 // Test to ensure that pages that require certain privileges are grouped
 565 // in processes with similar pages.
 566 TEST_F(SiteInstanceTest, ProcessSharingByType) {
 567   // This test shouldn't run with --site-per-process or
 568   // --enable-strict-site-isolation modes, since they don't allow render
 569   // process reuse, which this test explicitly exercises.
 570   const base::CommandLine& command_line =
 571       *base::CommandLine::ForCurrentProcess();
 572   if (command_line.HasSwitch(switches::kSitePerProcess) ||
 573       command_line.HasSwitch(switches::kEnableStrictSiteIsolation))
 574     return;
 575
 576   // On Android by default the number of renderer hosts is unlimited and process
 577   // sharing doesn't happen. We set the override so that the test can run
 578   // everywhere.
 579   RenderProcessHost::SetMaxRendererProcessCount(kMaxRendererProcessCount);
 580
 581   ChildProcessSecurityPolicyImpl* policy =
 582       ChildProcessSecurityPolicyImpl::GetInstance();
 583
 584   // Make a bunch of mock renderers so that we hit the limit.
 585   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 586   ScopedVector<MockRenderProcessHost> hosts;
 587   for (size_t i = 0; i < kMaxRendererProcessCount; ++i)
 588     hosts.push_back(new MockRenderProcessHost(browser_context.get()));
 589
 590   // Create some extension instances and make sure they share a process.
 591   scoped_refptr<SiteInstanceImpl> extension1_instance(
 592       CreateSiteInstance(browser_context.get(),
 593           GURL(kPrivilegedScheme + std::string("://foo/bar"))));
 594   set_privileged_process_id(extension1_instance->GetProcess()->GetID());
 595
 596   scoped_refptr<SiteInstanceImpl> extension2_instance(
 597       CreateSiteInstance(browser_context.get(),
 598           GURL(kPrivilegedScheme + std::string("://baz/bar"))));
 599
 600   scoped_ptr<RenderProcessHost> extension_host(
 601       extension1_instance->GetProcess());
 602   EXPECT_EQ(extension1_instance->GetProcess(),
 603             extension2_instance->GetProcess());
 604
 605   // Create some WebUI instances and make sure they share a process.
 606   scoped_refptr<SiteInstanceImpl> webui1_instance(CreateSiteInstance(
 607       browser_context.get(), GURL(kChromeUIScheme + std::string("://newtab"))));
 608   policy->GrantWebUIBindings(webui1_instance->GetProcess()->GetID());
 609
 610   scoped_refptr<SiteInstanceImpl> webui2_instance(
 611       CreateSiteInstance(browser_context.get(),
 612                          GURL(kChromeUIScheme + std::string("://history"))));
 613
 614   scoped_ptr<RenderProcessHost> dom_host(webui1_instance->GetProcess());
 615   EXPECT_EQ(webui1_instance->GetProcess(), webui2_instance->GetProcess());
 616
 617   // Make sure none of differing privilege processes are mixed.
 618   EXPECT_NE(extension1_instance->GetProcess(), webui1_instance->GetProcess());
 619
 620   for (size_t i = 0; i < kMaxRendererProcessCount; ++i) {
 621     EXPECT_NE(extension1_instance->GetProcess(), hosts[i]);
 622     EXPECT_NE(webui1_instance->GetProcess(), hosts[i]);
 623   }
 624
 625   DrainMessageLoops();
 626
 627   // Disable the process limit override.
 628   RenderProcessHost::SetMaxRendererProcessCount(0u);
 629 }
 630
 631 // Test to ensure that HasWrongProcessForURL behaves properly for different
 632 // types of URLs.
 633 TEST_F(SiteInstanceTest, HasWrongProcessForURL) {
 634   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 635   scoped_ptr<RenderProcessHost> host;
 636   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 637       SiteInstance::Create(browser_context.get())));
 638
 639   EXPECT_FALSE(instance->HasSite());
 640   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 641
 642   instance->SetSite(GURL("http://evernote.com/"));
 643   EXPECT_TRUE(instance->HasSite());
 644
 645   // Check prior to "assigning" a process to the instance, which is expected
 646   // to return false due to not being attached to any process yet.
 647   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://google.com")));
 648
 649   // The call to GetProcess actually creates a new real process, which works
 650   // fine, but might be a cause for problems in different contexts.
 651   host.reset(instance->GetProcess());
 652   EXPECT_TRUE(host.get() != NULL);
 653   EXPECT_TRUE(instance->HasProcess());
 654
 655   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://evernote.com")));
 656   EXPECT_FALSE(instance->HasWrongProcessForURL(
 657       GURL("javascript:alert(document.location.href);")));
 658
 659   EXPECT_TRUE(instance->HasWrongProcessForURL(GURL("chrome://settings")));
 660
 661   // Test that WebUI SiteInstances reject normal web URLs.
 662   const GURL webui_url("chrome://settings");
 663   scoped_refptr<SiteInstanceImpl> webui_instance(static_cast<SiteInstanceImpl*>(
 664       SiteInstance::Create(browser_context.get())));
 665   webui_instance->SetSite(webui_url);
 666   scoped_ptr<RenderProcessHost> webui_host(webui_instance->GetProcess());
 667
 668   // Simulate granting WebUI bindings for the process.
 669   ChildProcessSecurityPolicyImpl::GetInstance()->GrantWebUIBindings(
 670       webui_host->GetID());
 671
 672   EXPECT_TRUE(webui_instance->HasProcess());
 673   EXPECT_FALSE(webui_instance->HasWrongProcessForURL(webui_url));
 674   EXPECT_TRUE(webui_instance->HasWrongProcessForURL(GURL("http://google.com")));
 675
 676   // WebUI uses process-per-site, so another instance will use the same process
 677   // even if we haven't called GetProcess yet.  Make sure HasWrongProcessForURL
 678   // doesn't crash (http://crbug.com/137070).
 679   scoped_refptr<SiteInstanceImpl> webui_instance2(
 680       static_cast<SiteInstanceImpl*>(
 681           SiteInstance::Create(browser_context.get())));
 682   webui_instance2->SetSite(webui_url);
 683   EXPECT_FALSE(webui_instance2->HasWrongProcessForURL(webui_url));
 684   EXPECT_TRUE(
 685       webui_instance2->HasWrongProcessForURL(GURL("http://google.com")));
 686
 687   DrainMessageLoops();
 688 }
 689
 690 // Test to ensure that HasWrongProcessForURL behaves properly even when
 691 // --site-per-process is used (http://crbug.com/160671).
 692 TEST_F(SiteInstanceTest, HasWrongProcessForURLInSitePerProcess) {
 693   base::CommandLine::ForCurrentProcess()->AppendSwitch(
 694       switches::kSitePerProcess);
 695
 696   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 697   scoped_ptr<RenderProcessHost> host;
 698   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 699       SiteInstance::Create(browser_context.get())));
 700
 701   instance->SetSite(GURL("http://evernote.com/"));
 702   EXPECT_TRUE(instance->HasSite());
 703
 704   // Check prior to "assigning" a process to the instance, which is expected
 705   // to return false due to not being attached to any process yet.
 706   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://google.com")));
 707
 708   // The call to GetProcess actually creates a new real process, which works
 709   // fine, but might be a cause for problems in different contexts.
 710   host.reset(instance->GetProcess());
 711   EXPECT_TRUE(host.get() != NULL);
 712   EXPECT_TRUE(instance->HasProcess());
 713
 714   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://evernote.com")));
 715   EXPECT_FALSE(instance->HasWrongProcessForURL(
 716       GURL("javascript:alert(document.location.href);")));
 717
 718   EXPECT_TRUE(instance->HasWrongProcessForURL(GURL("chrome://settings")));
 719
 720   DrainMessageLoops();
 721 }
 722
 723 // Test that we do not reuse a process in process-per-site mode if it has the
 724 // wrong bindings for its URL.  http://crbug.com/174059.
 725 TEST_F(SiteInstanceTest, ProcessPerSiteWithWrongBindings) {
 726   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 727   scoped_ptr<RenderProcessHost> host;
 728   scoped_ptr<RenderProcessHost> host2;
 729   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 730       SiteInstance::Create(browser_context.get())));
 731
 732   EXPECT_FALSE(instance->HasSite());
 733   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 734
 735   // Simulate navigating to a WebUI URL in a process that does not have WebUI
 736   // bindings.  This already requires bypassing security checks.
 737   const GURL webui_url("chrome://settings");
 738   instance->SetSite(webui_url);
 739   EXPECT_TRUE(instance->HasSite());
 740
 741   // The call to GetProcess actually creates a new real process.
 742   host.reset(instance->GetProcess());
 743   EXPECT_TRUE(host.get() != NULL);
 744   EXPECT_TRUE(instance->HasProcess());
 745
 746   // Without bindings, this should look like the wrong process.
 747   EXPECT_TRUE(instance->HasWrongProcessForURL(webui_url));
 748
 749   // WebUI uses process-per-site, so another instance would normally use the
 750   // same process.  Make sure it doesn't use the same process if the bindings
 751   // are missing.
 752   scoped_refptr<SiteInstanceImpl> instance2(
 753       static_cast<SiteInstanceImpl*>(
 754           SiteInstance::Create(browser_context.get())));
 755   instance2->SetSite(webui_url);
 756   host2.reset(instance2->GetProcess());
 757   EXPECT_TRUE(host2.get() != NULL);
 758   EXPECT_TRUE(instance2->HasProcess());
 759   EXPECT_NE(host.get(), host2.get());
 760
 761   DrainMessageLoops();
 762 }
 763
 764 // Test that we do not register processes with empty sites for process-per-site
 765 // mode.
 766 TEST_F(SiteInstanceTest, NoProcessPerSiteForEmptySite) {
 767   base::CommandLine::ForCurrentProcess()->AppendSwitch(
 768       switches::kProcessPerSite);
 769   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 770   scoped_ptr<RenderProcessHost> host;
 771   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 772       SiteInstance::Create(browser_context.get())));
 773
 774   instance->SetSite(GURL());
 775   EXPECT_TRUE(instance->HasSite());
 776   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 777   host.reset(instance->GetProcess());
 778
 779   EXPECT_FALSE(RenderProcessHostImpl::GetProcessHostForSite(
 780       browser_context.get(), GURL()));
 781
 782   DrainMessageLoops();
 783 }
 784
 785 }  // namespace content