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   virtual WebUIController* CreateWebUIControllerForURL(
  40       WebUI* web_ui, const GURL& url) const OVERRIDE {
  41     return NULL;
  42   }
  43   virtual WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
  44       const GURL& url) const OVERRIDE {
  45     return WebUI::kNoWebUI;
  46   }
  47   virtual bool UseWebUIForURL(BrowserContext* browser_context,
  48                               const GURL& url) const OVERRIDE {
  49     return HasWebUIScheme(url);
  50   }
  51   virtual 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   virtual ~SiteInstanceTestBrowserClient() {
  65     WebUIControllerFactory::UnregisterFactoryForTesting(&factory_);
  66   }
  67
  68   virtual 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   virtual void SetUp() {
  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   virtual void TearDown() {
 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   virtual ~TestBrowsingInstance() {
 161     (*delete_counter_)++;
 162   }
 163
 164   int* delete_counter_;
 165 };
 166
 167 // Subclass of SiteInstanceImpl that updates a counter when deleted.
 168 class TestSiteInstance : public SiteInstanceImpl {
 169  public:
 170   static TestSiteInstance* CreateTestSiteInstance(
 171       BrowserContext* browser_context,
 172       int* site_delete_counter,
 173       int* browsing_delete_counter) {
 174     TestBrowsingInstance* browsing_instance =
 175         new TestBrowsingInstance(browser_context, browsing_delete_counter);
 176     return new TestSiteInstance(browsing_instance, site_delete_counter);
 177   }
 178
 179  private:
 180   TestSiteInstance(BrowsingInstance* browsing_instance, int* delete_counter)
 181     : SiteInstanceImpl(browsing_instance), delete_counter_(delete_counter) {}
 182   virtual ~TestSiteInstance() {
 183     (*delete_counter_)++;
 184   }
 185
 186   int* delete_counter_;
 187 };
 188
 189 }  // namespace
 190
 191 // Test to ensure no memory leaks for SiteInstance objects.
 192 TEST_F(SiteInstanceTest, SiteInstanceDestructor) {
 193   // The existence of this object will cause WebContentsImpl to create our
 194   // test one instead of the real one.
 195   RenderViewHostTestEnabler rvh_test_enabler;
 196   int site_delete_counter = 0;
 197   int browsing_delete_counter = 0;
 198   const GURL url("test:foo");
 199
 200   // Ensure that instances are deleted when their NavigationEntries are gone.
 201   TestSiteInstance* instance =
 202       TestSiteInstance::CreateTestSiteInstance(NULL, &site_delete_counter,
 203                                                &browsing_delete_counter);
 204   EXPECT_EQ(0, site_delete_counter);
 205
 206   NavigationEntryImpl* e1 = new NavigationEntryImpl(
 207       instance, 0, url, Referrer(), base::string16(), PAGE_TRANSITION_LINK,
 208       false);
 209
 210   // Redundantly setting e1's SiteInstance shouldn't affect the ref count.
 211   e1->set_site_instance(instance);
 212   EXPECT_EQ(0, site_delete_counter);
 213
 214   // Add a second reference
 215   NavigationEntryImpl* e2 = new NavigationEntryImpl(
 216       instance, 0, url, Referrer(), base::string16(), PAGE_TRANSITION_LINK,
 217       false);
 218
 219   // Now delete both entries and be sure the SiteInstance goes away.
 220   delete e1;
 221   EXPECT_EQ(0, site_delete_counter);
 222   EXPECT_EQ(0, browsing_delete_counter);
 223   delete e2;
 224   EXPECT_EQ(1, site_delete_counter);
 225   // instance is now deleted
 226   EXPECT_EQ(1, browsing_delete_counter);
 227   // browsing_instance is now deleted
 228
 229   // Ensure that instances are deleted when their RenderViewHosts are gone.
 230   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 231   instance =
 232       TestSiteInstance::CreateTestSiteInstance(browser_context.get(),
 233                                                &site_delete_counter,
 234                                                &browsing_delete_counter);
 235   {
 236     scoped_ptr<WebContentsImpl> web_contents(static_cast<WebContentsImpl*>(
 237         WebContents::Create(WebContents::CreateParams(
 238             browser_context.get(), instance))));
 239     EXPECT_EQ(1, site_delete_counter);
 240     EXPECT_EQ(1, browsing_delete_counter);
 241   }
 242
 243   // Make sure that we flush any messages related to the above WebContentsImpl
 244   // destruction.
 245   DrainMessageLoops();
 246
 247   EXPECT_EQ(2, site_delete_counter);
 248   EXPECT_EQ(2, browsing_delete_counter);
 249   // contents is now deleted, along with instance and browsing_instance
 250 }
 251
 252 // Test that NavigationEntries with SiteInstances can be cloned, but that their
 253 // SiteInstances can be changed afterwards.  Also tests that the ref counts are
 254 // updated properly after the change.
 255 TEST_F(SiteInstanceTest, CloneNavigationEntry) {
 256   int site_delete_counter1 = 0;
 257   int site_delete_counter2 = 0;
 258   int browsing_delete_counter = 0;
 259   const GURL url("test:foo");
 260
 261   SiteInstanceImpl* instance1 =
 262       TestSiteInstance::CreateTestSiteInstance(NULL, &site_delete_counter1,
 263                                                &browsing_delete_counter);
 264   SiteInstanceImpl* instance2 =
 265       TestSiteInstance::CreateTestSiteInstance(NULL, &site_delete_counter2,
 266                                                &browsing_delete_counter);
 267
 268   NavigationEntryImpl* e1 = new NavigationEntryImpl(
 269       instance1, 0, url, Referrer(), base::string16(), PAGE_TRANSITION_LINK,
 270       false);
 271   // Clone the entry
 272   NavigationEntryImpl* e2 = new NavigationEntryImpl(*e1);
 273
 274   // Should be able to change the SiteInstance of the cloned entry.
 275   e2->set_site_instance(instance2);
 276
 277   // The first SiteInstance should go away after deleting e1, since e2 should
 278   // no longer be referencing it.
 279   delete e1;
 280   EXPECT_EQ(1, site_delete_counter1);
 281   EXPECT_EQ(0, site_delete_counter2);
 282
 283   // The second SiteInstance should go away after deleting e2.
 284   delete e2;
 285   EXPECT_EQ(1, site_delete_counter1);
 286   EXPECT_EQ(1, site_delete_counter2);
 287
 288   // Both BrowsingInstances are also now deleted
 289   EXPECT_EQ(2, browsing_delete_counter);
 290
 291   DrainMessageLoops();
 292 }
 293
 294 // Test to ensure GetProcess returns and creates processes correctly.
 295 TEST_F(SiteInstanceTest, GetProcess) {
 296   // Ensure that GetProcess returns a process.
 297   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 298   scoped_ptr<RenderProcessHost> host1;
 299   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 300       SiteInstance::Create(browser_context.get())));
 301   host1.reset(instance->GetProcess());
 302   EXPECT_TRUE(host1.get() != NULL);
 303
 304   // Ensure that GetProcess creates a new process.
 305   scoped_refptr<SiteInstanceImpl> instance2(static_cast<SiteInstanceImpl*>(
 306       SiteInstance::Create(browser_context.get())));
 307   scoped_ptr<RenderProcessHost> host2(instance2->GetProcess());
 308   EXPECT_TRUE(host2.get() != NULL);
 309   EXPECT_NE(host1.get(), host2.get());
 310
 311   DrainMessageLoops();
 312 }
 313
 314 // Test to ensure SetSite and site() work properly.
 315 TEST_F(SiteInstanceTest, SetSite) {
 316   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 317       SiteInstance::Create(NULL)));
 318   EXPECT_FALSE(instance->HasSite());
 319   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 320
 321   instance->SetSite(GURL("http://www.google.com/index.html"));
 322   EXPECT_EQ(GURL("http://google.com"), instance->GetSiteURL());
 323
 324   EXPECT_TRUE(instance->HasSite());
 325
 326   DrainMessageLoops();
 327 }
 328
 329 // Test to ensure GetSiteForURL properly returns sites for URLs.
 330 TEST_F(SiteInstanceTest, GetSiteForURL) {
 331   // Pages are irrelevant.
 332   GURL test_url = GURL("http://www.google.com/index.html");
 333   EXPECT_EQ(GURL("http://google.com"),
 334             SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 335
 336   // Ports are irrlevant.
 337   test_url = GURL("https://www.google.com:8080");
 338   EXPECT_EQ(GURL("https://google.com"),
 339             SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 340
 341   // Javascript URLs have no site.
 342   test_url = GURL("javascript:foo();");
 343   EXPECT_EQ(GURL(), SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 344
 345   test_url = GURL("http://foo/a.html");
 346   EXPECT_EQ(GURL("http://foo"), SiteInstanceImpl::GetSiteForURL(
 347       NULL, test_url));
 348
 349   test_url = GURL("file:///C:/Downloads/");
 350   EXPECT_EQ(GURL(), SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 351
 352   std::string guest_url(kGuestScheme);
 353   guest_url.append("://abc123");
 354   test_url = GURL(guest_url);
 355   EXPECT_EQ(test_url, SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 356
 357   // TODO(creis): Do we want to special case file URLs to ensure they have
 358   // either no site or a special "file://" site?  We currently return
 359   // "file://home/" as the site, which seems broken.
 360   // test_url = GURL("file://home/");
 361   // EXPECT_EQ(GURL(), SiteInstanceImpl::GetSiteForURL(NULL, test_url));
 362
 363   DrainMessageLoops();
 364 }
 365
 366 // Test of distinguishing URLs from different sites.  Most of this logic is
 367 // tested in RegistryControlledDomainTest.  This test focuses on URLs with
 368 // different schemes or ports.
 369 TEST_F(SiteInstanceTest, IsSameWebSite) {
 370   GURL url_foo = GURL("http://foo/a.html");
 371   GURL url_foo2 = GURL("http://foo/b.html");
 372   GURL url_foo_https = GURL("https://foo/a.html");
 373   GURL url_foo_port = GURL("http://foo:8080/a.html");
 374   GURL url_javascript = GURL("javascript:alert(1);");
 375
 376   // Same scheme and port -> same site.
 377   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo, url_foo2));
 378
 379   // Different scheme -> different site.
 380   EXPECT_FALSE(SiteInstance::IsSameWebSite(NULL, url_foo, url_foo_https));
 381
 382   // Different port -> same site.
 383   // (Changes to document.domain make renderer ignore the port.)
 384   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo, url_foo_port));
 385
 386   // JavaScript links should be considered same site for anything.
 387   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_javascript, url_foo));
 388   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_javascript, url_foo_https));
 389   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_javascript, url_foo_port));
 390
 391   DrainMessageLoops();
 392 }
 393
 394 // Test to ensure that there is only one SiteInstance per site in a given
 395 // BrowsingInstance, when process-per-site is not in use.
 396 TEST_F(SiteInstanceTest, OneSiteInstancePerSite) {
 397   ASSERT_FALSE(CommandLine::ForCurrentProcess()->HasSwitch(
 398       switches::kProcessPerSite));
 399   int delete_counter = 0;
 400   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 401   TestBrowsingInstance* browsing_instance =
 402       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 403
 404   const GURL url_a1("http://www.google.com/1.html");
 405   scoped_refptr<SiteInstanceImpl> site_instance_a1(
 406       static_cast<SiteInstanceImpl*>(
 407           browsing_instance->GetSiteInstanceForURL(url_a1)));
 408   EXPECT_TRUE(site_instance_a1.get() != NULL);
 409
 410   // A separate site should create a separate SiteInstance.
 411   const GURL url_b1("http://www.yahoo.com/");
 412   scoped_refptr<SiteInstanceImpl> site_instance_b1(
 413       static_cast<SiteInstanceImpl*>(
 414           browsing_instance->GetSiteInstanceForURL(url_b1)));
 415   EXPECT_NE(site_instance_a1.get(), site_instance_b1.get());
 416   EXPECT_TRUE(site_instance_a1->IsRelatedSiteInstance(site_instance_b1.get()));
 417
 418   // Getting the new SiteInstance from the BrowsingInstance and from another
 419   // SiteInstance in the BrowsingInstance should give the same result.
 420   EXPECT_EQ(site_instance_b1.get(),
 421             site_instance_a1->GetRelatedSiteInstance(url_b1));
 422
 423   // A second visit to the original site should return the same SiteInstance.
 424   const GURL url_a2("http://www.google.com/2.html");
 425   EXPECT_EQ(site_instance_a1.get(),
 426             browsing_instance->GetSiteInstanceForURL(url_a2));
 427   EXPECT_EQ(site_instance_a1.get(),
 428             site_instance_a1->GetRelatedSiteInstance(url_a2));
 429
 430   // A visit to the original site in a new BrowsingInstance (same or different
 431   // browser context) should return a different SiteInstance.
 432   TestBrowsingInstance* browsing_instance2 =
 433       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 434   // Ensure the new SiteInstance is ref counted so that it gets deleted.
 435   scoped_refptr<SiteInstanceImpl> site_instance_a2_2(
 436       static_cast<SiteInstanceImpl*>(
 437           browsing_instance2->GetSiteInstanceForURL(url_a2)));
 438   EXPECT_NE(site_instance_a1.get(), site_instance_a2_2.get());
 439   EXPECT_FALSE(
 440       site_instance_a1->IsRelatedSiteInstance(site_instance_a2_2.get()));
 441
 442   // The two SiteInstances for http://google.com should not use the same process
 443   // if process-per-site is not enabled.
 444   scoped_ptr<RenderProcessHost> process_a1(site_instance_a1->GetProcess());
 445   scoped_ptr<RenderProcessHost> process_a2_2(site_instance_a2_2->GetProcess());
 446   EXPECT_NE(process_a1.get(), process_a2_2.get());
 447
 448   // Should be able to see that we do have SiteInstances.
 449   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 450       GURL("http://mail.google.com")));
 451   EXPECT_TRUE(browsing_instance2->HasSiteInstance(
 452       GURL("http://mail.google.com")));
 453   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 454       GURL("http://mail.yahoo.com")));
 455
 456   // Should be able to see that we don't have SiteInstances.
 457   EXPECT_FALSE(browsing_instance->HasSiteInstance(
 458       GURL("https://www.google.com")));
 459   EXPECT_FALSE(browsing_instance2->HasSiteInstance(
 460       GURL("http://www.yahoo.com")));
 461
 462   // browsing_instances will be deleted when their SiteInstances are deleted.
 463   // The processes will be unregistered when the RPH scoped_ptrs go away.
 464
 465   DrainMessageLoops();
 466 }
 467
 468 // Test to ensure that there is only one RenderProcessHost per site for an
 469 // entire BrowserContext, if process-per-site is in use.
 470 TEST_F(SiteInstanceTest, OneSiteInstancePerSiteInBrowserContext) {
 471   CommandLine::ForCurrentProcess()->AppendSwitch(
 472       switches::kProcessPerSite);
 473   int delete_counter = 0;
 474   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 475   TestBrowsingInstance* browsing_instance =
 476       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 477
 478   const GURL url_a1("http://www.google.com/1.html");
 479   scoped_refptr<SiteInstanceImpl> site_instance_a1(
 480       static_cast<SiteInstanceImpl*>(
 481           browsing_instance->GetSiteInstanceForURL(url_a1)));
 482   EXPECT_TRUE(site_instance_a1.get() != NULL);
 483   scoped_ptr<RenderProcessHost> process_a1(site_instance_a1->GetProcess());
 484
 485   // A separate site should create a separate SiteInstance.
 486   const GURL url_b1("http://www.yahoo.com/");
 487   scoped_refptr<SiteInstanceImpl> site_instance_b1(
 488       static_cast<SiteInstanceImpl*>(
 489           browsing_instance->GetSiteInstanceForURL(url_b1)));
 490   EXPECT_NE(site_instance_a1.get(), site_instance_b1.get());
 491   EXPECT_TRUE(site_instance_a1->IsRelatedSiteInstance(site_instance_b1.get()));
 492
 493   // Getting the new SiteInstance from the BrowsingInstance and from another
 494   // SiteInstance in the BrowsingInstance should give the same result.
 495   EXPECT_EQ(site_instance_b1.get(),
 496             site_instance_a1->GetRelatedSiteInstance(url_b1));
 497
 498   // A second visit to the original site should return the same SiteInstance.
 499   const GURL url_a2("http://www.google.com/2.html");
 500   EXPECT_EQ(site_instance_a1.get(),
 501             browsing_instance->GetSiteInstanceForURL(url_a2));
 502   EXPECT_EQ(site_instance_a1.get(),
 503             site_instance_a1->GetRelatedSiteInstance(url_a2));
 504
 505   // A visit to the original site in a new BrowsingInstance (same browser
 506   // context) should return a different SiteInstance with the same process.
 507   TestBrowsingInstance* browsing_instance2 =
 508       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 509   scoped_refptr<SiteInstanceImpl> site_instance_a1_2(
 510       static_cast<SiteInstanceImpl*>(
 511           browsing_instance2->GetSiteInstanceForURL(url_a1)));
 512   EXPECT_TRUE(site_instance_a1.get() != NULL);
 513   EXPECT_NE(site_instance_a1.get(), site_instance_a1_2.get());
 514   EXPECT_EQ(process_a1.get(), site_instance_a1_2->GetProcess());
 515
 516   // A visit to the original site in a new BrowsingInstance (different browser
 517   // context) should return a different SiteInstance with a different process.
 518   scoped_ptr<TestBrowserContext> browser_context2(new TestBrowserContext());
 519   TestBrowsingInstance* browsing_instance3 =
 520       new TestBrowsingInstance(browser_context2.get(), &delete_counter);
 521   scoped_refptr<SiteInstanceImpl> site_instance_a2_3(
 522       static_cast<SiteInstanceImpl*>(
 523           browsing_instance3->GetSiteInstanceForURL(url_a2)));
 524   EXPECT_TRUE(site_instance_a2_3.get() != NULL);
 525   scoped_ptr<RenderProcessHost> process_a2_3(site_instance_a2_3->GetProcess());
 526   EXPECT_NE(site_instance_a1.get(), site_instance_a2_3.get());
 527   EXPECT_NE(process_a1.get(), process_a2_3.get());
 528
 529   // Should be able to see that we do have SiteInstances.
 530   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 531       GURL("http://mail.google.com")));  // visited before
 532   EXPECT_TRUE(browsing_instance2->HasSiteInstance(
 533       GURL("http://mail.google.com")));  // visited before
 534   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 535       GURL("http://mail.yahoo.com")));  // visited before
 536
 537   // Should be able to see that we don't have SiteInstances.
 538   EXPECT_FALSE(browsing_instance2->HasSiteInstance(
 539       GURL("http://www.yahoo.com")));  // different BI, same browser context
 540   EXPECT_FALSE(browsing_instance->HasSiteInstance(
 541       GURL("https://www.google.com")));  // not visited before
 542   EXPECT_FALSE(browsing_instance3->HasSiteInstance(
 543       GURL("http://www.yahoo.com")));  // different BI, different context
 544
 545   // browsing_instances will be deleted when their SiteInstances are deleted.
 546   // The processes will be unregistered when the RPH scoped_ptrs go away.
 547
 548   DrainMessageLoops();
 549 }
 550
 551 static SiteInstanceImpl* CreateSiteInstance(BrowserContext* browser_context,
 552                                             const GURL& url) {
 553   return static_cast<SiteInstanceImpl*>(
 554       SiteInstance::CreateForURL(browser_context, url));
 555 }
 556
 557 // Test to ensure that pages that require certain privileges are grouped
 558 // in processes with similar pages.
 559 TEST_F(SiteInstanceTest, ProcessSharingByType) {
 560   // This test shouldn't run with --site-per-process mode, since it doesn't
 561   // allow render process reuse, which this test explicitly exercises.
 562   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess))
 563     return;
 564
 565   ChildProcessSecurityPolicyImpl* policy =
 566       ChildProcessSecurityPolicyImpl::GetInstance();
 567
 568   // Make a bunch of mock renderers so that we hit the limit.
 569   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 570   ScopedVector<MockRenderProcessHost> hosts;
 571   for (size_t i = 0; i < kMaxRendererProcessCount; ++i)
 572     hosts.push_back(new MockRenderProcessHost(browser_context.get()));
 573
 574   // Create some extension instances and make sure they share a process.
 575   scoped_refptr<SiteInstanceImpl> extension1_instance(
 576       CreateSiteInstance(browser_context.get(),
 577           GURL(kPrivilegedScheme + std::string("://foo/bar"))));
 578   set_privileged_process_id(extension1_instance->GetProcess()->GetID());
 579
 580   scoped_refptr<SiteInstanceImpl> extension2_instance(
 581       CreateSiteInstance(browser_context.get(),
 582           GURL(kPrivilegedScheme + std::string("://baz/bar"))));
 583
 584   scoped_ptr<RenderProcessHost> extension_host(
 585       extension1_instance->GetProcess());
 586   EXPECT_EQ(extension1_instance->GetProcess(),
 587             extension2_instance->GetProcess());
 588
 589   // Create some WebUI instances and make sure they share a process.
 590   scoped_refptr<SiteInstanceImpl> webui1_instance(CreateSiteInstance(
 591       browser_context.get(), GURL(kChromeUIScheme + std::string("://newtab"))));
 592   policy->GrantWebUIBindings(webui1_instance->GetProcess()->GetID());
 593
 594   scoped_refptr<SiteInstanceImpl> webui2_instance(
 595       CreateSiteInstance(browser_context.get(),
 596                          GURL(kChromeUIScheme + std::string("://history"))));
 597
 598   scoped_ptr<RenderProcessHost> dom_host(webui1_instance->GetProcess());
 599   EXPECT_EQ(webui1_instance->GetProcess(), webui2_instance->GetProcess());
 600
 601   // Make sure none of differing privilege processes are mixed.
 602   EXPECT_NE(extension1_instance->GetProcess(), webui1_instance->GetProcess());
 603
 604   for (size_t i = 0; i < kMaxRendererProcessCount; ++i) {
 605     EXPECT_NE(extension1_instance->GetProcess(), hosts[i]);
 606     EXPECT_NE(webui1_instance->GetProcess(), hosts[i]);
 607   }
 608
 609   DrainMessageLoops();
 610 }
 611
 612 // Test to ensure that HasWrongProcessForURL behaves properly for different
 613 // types of URLs.
 614 TEST_F(SiteInstanceTest, HasWrongProcessForURL) {
 615   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 616   scoped_ptr<RenderProcessHost> host;
 617   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 618       SiteInstance::Create(browser_context.get())));
 619
 620   EXPECT_FALSE(instance->HasSite());
 621   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 622
 623   instance->SetSite(GURL("http://evernote.com/"));
 624   EXPECT_TRUE(instance->HasSite());
 625
 626   // Check prior to "assigning" a process to the instance, which is expected
 627   // to return false due to not being attached to any process yet.
 628   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://google.com")));
 629
 630   // The call to GetProcess actually creates a new real process, which works
 631   // fine, but might be a cause for problems in different contexts.
 632   host.reset(instance->GetProcess());
 633   EXPECT_TRUE(host.get() != NULL);
 634   EXPECT_TRUE(instance->HasProcess());
 635
 636   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://evernote.com")));
 637   EXPECT_FALSE(instance->HasWrongProcessForURL(
 638       GURL("javascript:alert(document.location.href);")));
 639
 640   EXPECT_TRUE(instance->HasWrongProcessForURL(GURL("chrome://settings")));
 641
 642   // Test that WebUI SiteInstances reject normal web URLs.
 643   const GURL webui_url("chrome://settings");
 644   scoped_refptr<SiteInstanceImpl> webui_instance(static_cast<SiteInstanceImpl*>(
 645       SiteInstance::Create(browser_context.get())));
 646   webui_instance->SetSite(webui_url);
 647   scoped_ptr<RenderProcessHost> webui_host(webui_instance->GetProcess());
 648
 649   // Simulate granting WebUI bindings for the process.
 650   ChildProcessSecurityPolicyImpl::GetInstance()->GrantWebUIBindings(
 651       webui_host->GetID());
 652
 653   EXPECT_TRUE(webui_instance->HasProcess());
 654   EXPECT_FALSE(webui_instance->HasWrongProcessForURL(webui_url));
 655   EXPECT_TRUE(webui_instance->HasWrongProcessForURL(GURL("http://google.com")));
 656
 657   // WebUI uses process-per-site, so another instance will use the same process
 658   // even if we haven't called GetProcess yet.  Make sure HasWrongProcessForURL
 659   // doesn't crash (http://crbug.com/137070).
 660   scoped_refptr<SiteInstanceImpl> webui_instance2(
 661       static_cast<SiteInstanceImpl*>(
 662           SiteInstance::Create(browser_context.get())));
 663   webui_instance2->SetSite(webui_url);
 664   EXPECT_FALSE(webui_instance2->HasWrongProcessForURL(webui_url));
 665   EXPECT_TRUE(
 666       webui_instance2->HasWrongProcessForURL(GURL("http://google.com")));
 667
 668   DrainMessageLoops();
 669 }
 670
 671 // Test to ensure that HasWrongProcessForURL behaves properly even when
 672 // --site-per-process is used (http://crbug.com/160671).
 673 TEST_F(SiteInstanceTest, HasWrongProcessForURLInSitePerProcess) {
 674   CommandLine::ForCurrentProcess()->AppendSwitch(
 675       switches::kSitePerProcess);
 676
 677   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 678   scoped_ptr<RenderProcessHost> host;
 679   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 680       SiteInstance::Create(browser_context.get())));
 681
 682   instance->SetSite(GURL("http://evernote.com/"));
 683   EXPECT_TRUE(instance->HasSite());
 684
 685   // Check prior to "assigning" a process to the instance, which is expected
 686   // to return false due to not being attached to any process yet.
 687   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://google.com")));
 688
 689   // The call to GetProcess actually creates a new real process, which works
 690   // fine, but might be a cause for problems in different contexts.
 691   host.reset(instance->GetProcess());
 692   EXPECT_TRUE(host.get() != NULL);
 693   EXPECT_TRUE(instance->HasProcess());
 694
 695   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://evernote.com")));
 696   EXPECT_FALSE(instance->HasWrongProcessForURL(
 697       GURL("javascript:alert(document.location.href);")));
 698
 699   EXPECT_TRUE(instance->HasWrongProcessForURL(GURL("chrome://settings")));
 700
 701   DrainMessageLoops();
 702 }
 703
 704 // Test that we do not reuse a process in process-per-site mode if it has the
 705 // wrong bindings for its URL.  http://crbug.com/174059.
 706 TEST_F(SiteInstanceTest, ProcessPerSiteWithWrongBindings) {
 707   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 708   scoped_ptr<RenderProcessHost> host;
 709   scoped_ptr<RenderProcessHost> host2;
 710   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 711       SiteInstance::Create(browser_context.get())));
 712
 713   EXPECT_FALSE(instance->HasSite());
 714   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 715
 716   // Simulate navigating to a WebUI URL in a process that does not have WebUI
 717   // bindings.  This already requires bypassing security checks.
 718   const GURL webui_url("chrome://settings");
 719   instance->SetSite(webui_url);
 720   EXPECT_TRUE(instance->HasSite());
 721
 722   // The call to GetProcess actually creates a new real process.
 723   host.reset(instance->GetProcess());
 724   EXPECT_TRUE(host.get() != NULL);
 725   EXPECT_TRUE(instance->HasProcess());
 726
 727   // Without bindings, this should look like the wrong process.
 728   EXPECT_TRUE(instance->HasWrongProcessForURL(webui_url));
 729
 730   // WebUI uses process-per-site, so another instance would normally use the
 731   // same process.  Make sure it doesn't use the same process if the bindings
 732   // are missing.
 733   scoped_refptr<SiteInstanceImpl> instance2(
 734       static_cast<SiteInstanceImpl*>(
 735           SiteInstance::Create(browser_context.get())));
 736   instance2->SetSite(webui_url);
 737   host2.reset(instance2->GetProcess());
 738   EXPECT_TRUE(host2.get() != NULL);
 739   EXPECT_TRUE(instance2->HasProcess());
 740   EXPECT_NE(host.get(), host2.get());
 741
 742   DrainMessageLoops();
 743 }
 744
 745 // Test that we do not register processes with empty sites for process-per-site
 746 // mode.
 747 TEST_F(SiteInstanceTest, NoProcessPerSiteForEmptySite) {
 748   CommandLine::ForCurrentProcess()->AppendSwitch(
 749       switches::kProcessPerSite);
 750   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 751   scoped_ptr<RenderProcessHost> host;
 752   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 753       SiteInstance::Create(browser_context.get())));
 754
 755   instance->SetSite(GURL());
 756   EXPECT_TRUE(instance->HasSite());
 757   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 758   host.reset(instance->GetProcess());
 759
 760   EXPECT_FALSE(RenderProcessHostImpl::GetProcessHostForSite(
 761       browser_context.get(), GURL()));
 762
 763   DrainMessageLoops();
 764 }
 765
 766 }  // namespace content