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   GURL url_blank = GURL(url::kAboutBlankURL);
 376
 377   // Same scheme and port -> same site.
 378   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo, url_foo2));
 379
 380   // Different scheme -> different site.
 381   EXPECT_FALSE(SiteInstance::IsSameWebSite(NULL, url_foo, url_foo_https));
 382
 383   // Different port -> same site.
 384   // (Changes to document.domain make renderer ignore the port.)
 385   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo, url_foo_port));
 386
 387   // JavaScript links should be considered same site for anything.
 388   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_javascript, url_foo));
 389   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_javascript, url_foo_https));
 390   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_javascript, url_foo_port));
 391
 392   // Navigating to a blank page is considered the same site.
 393   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo, url_blank));
 394   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo_https, url_blank));
 395   EXPECT_TRUE(SiteInstance::IsSameWebSite(NULL, url_foo_port, url_blank));
 396
 397   // Navigating from a blank site is not considered to be the same site.
 398   EXPECT_FALSE(SiteInstance::IsSameWebSite(NULL, url_blank, url_foo));
 399   EXPECT_FALSE(SiteInstance::IsSameWebSite(NULL, url_blank, url_foo_https));
 400   EXPECT_FALSE(SiteInstance::IsSameWebSite(NULL, url_blank, url_foo_port));
 401
 402   DrainMessageLoops();
 403 }
 404
 405 // Test to ensure that there is only one SiteInstance per site in a given
 406 // BrowsingInstance, when process-per-site is not in use.
 407 TEST_F(SiteInstanceTest, OneSiteInstancePerSite) {
 408   ASSERT_FALSE(base::CommandLine::ForCurrentProcess()->HasSwitch(
 409       switches::kProcessPerSite));
 410   int delete_counter = 0;
 411   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 412   TestBrowsingInstance* browsing_instance =
 413       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 414
 415   const GURL url_a1("http://www.google.com/1.html");
 416   scoped_refptr<SiteInstanceImpl> site_instance_a1(
 417       static_cast<SiteInstanceImpl*>(
 418           browsing_instance->GetSiteInstanceForURL(url_a1)));
 419   EXPECT_TRUE(site_instance_a1.get() != NULL);
 420
 421   // A separate site should create a separate SiteInstance.
 422   const GURL url_b1("http://www.yahoo.com/");
 423   scoped_refptr<SiteInstanceImpl> site_instance_b1(
 424       static_cast<SiteInstanceImpl*>(
 425           browsing_instance->GetSiteInstanceForURL(url_b1)));
 426   EXPECT_NE(site_instance_a1.get(), site_instance_b1.get());
 427   EXPECT_TRUE(site_instance_a1->IsRelatedSiteInstance(site_instance_b1.get()));
 428
 429   // Getting the new SiteInstance from the BrowsingInstance and from another
 430   // SiteInstance in the BrowsingInstance should give the same result.
 431   EXPECT_EQ(site_instance_b1.get(),
 432             site_instance_a1->GetRelatedSiteInstance(url_b1));
 433
 434   // A second visit to the original site should return the same SiteInstance.
 435   const GURL url_a2("http://www.google.com/2.html");
 436   EXPECT_EQ(site_instance_a1.get(),
 437             browsing_instance->GetSiteInstanceForURL(url_a2));
 438   EXPECT_EQ(site_instance_a1.get(),
 439             site_instance_a1->GetRelatedSiteInstance(url_a2));
 440
 441   // A visit to the original site in a new BrowsingInstance (same or different
 442   // browser context) should return a different SiteInstance.
 443   TestBrowsingInstance* browsing_instance2 =
 444       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 445   // Ensure the new SiteInstance is ref counted so that it gets deleted.
 446   scoped_refptr<SiteInstanceImpl> site_instance_a2_2(
 447       static_cast<SiteInstanceImpl*>(
 448           browsing_instance2->GetSiteInstanceForURL(url_a2)));
 449   EXPECT_NE(site_instance_a1.get(), site_instance_a2_2.get());
 450   EXPECT_FALSE(
 451       site_instance_a1->IsRelatedSiteInstance(site_instance_a2_2.get()));
 452
 453   // The two SiteInstances for http://google.com should not use the same process
 454   // if process-per-site is not enabled.
 455   scoped_ptr<RenderProcessHost> process_a1(site_instance_a1->GetProcess());
 456   scoped_ptr<RenderProcessHost> process_a2_2(site_instance_a2_2->GetProcess());
 457   EXPECT_NE(process_a1.get(), process_a2_2.get());
 458
 459   // Should be able to see that we do have SiteInstances.
 460   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 461       GURL("http://mail.google.com")));
 462   EXPECT_TRUE(browsing_instance2->HasSiteInstance(
 463       GURL("http://mail.google.com")));
 464   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 465       GURL("http://mail.yahoo.com")));
 466
 467   // Should be able to see that we don't have SiteInstances.
 468   EXPECT_FALSE(browsing_instance->HasSiteInstance(
 469       GURL("https://www.google.com")));
 470   EXPECT_FALSE(browsing_instance2->HasSiteInstance(
 471       GURL("http://www.yahoo.com")));
 472
 473   // browsing_instances will be deleted when their SiteInstances are deleted.
 474   // The processes will be unregistered when the RPH scoped_ptrs go away.
 475
 476   DrainMessageLoops();
 477 }
 478
 479 // Test to ensure that there is only one RenderProcessHost per site for an
 480 // entire BrowserContext, if process-per-site is in use.
 481 TEST_F(SiteInstanceTest, OneSiteInstancePerSiteInBrowserContext) {
 482   base::CommandLine::ForCurrentProcess()->AppendSwitch(
 483       switches::kProcessPerSite);
 484   int delete_counter = 0;
 485   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 486   TestBrowsingInstance* browsing_instance =
 487       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 488
 489   const GURL url_a1("http://www.google.com/1.html");
 490   scoped_refptr<SiteInstanceImpl> site_instance_a1(
 491       static_cast<SiteInstanceImpl*>(
 492           browsing_instance->GetSiteInstanceForURL(url_a1)));
 493   EXPECT_TRUE(site_instance_a1.get() != NULL);
 494   scoped_ptr<RenderProcessHost> process_a1(site_instance_a1->GetProcess());
 495
 496   // A separate site should create a separate SiteInstance.
 497   const GURL url_b1("http://www.yahoo.com/");
 498   scoped_refptr<SiteInstanceImpl> site_instance_b1(
 499       static_cast<SiteInstanceImpl*>(
 500           browsing_instance->GetSiteInstanceForURL(url_b1)));
 501   EXPECT_NE(site_instance_a1.get(), site_instance_b1.get());
 502   EXPECT_TRUE(site_instance_a1->IsRelatedSiteInstance(site_instance_b1.get()));
 503
 504   // Getting the new SiteInstance from the BrowsingInstance and from another
 505   // SiteInstance in the BrowsingInstance should give the same result.
 506   EXPECT_EQ(site_instance_b1.get(),
 507             site_instance_a1->GetRelatedSiteInstance(url_b1));
 508
 509   // A second visit to the original site should return the same SiteInstance.
 510   const GURL url_a2("http://www.google.com/2.html");
 511   EXPECT_EQ(site_instance_a1.get(),
 512             browsing_instance->GetSiteInstanceForURL(url_a2));
 513   EXPECT_EQ(site_instance_a1.get(),
 514             site_instance_a1->GetRelatedSiteInstance(url_a2));
 515
 516   // A visit to the original site in a new BrowsingInstance (same browser
 517   // context) should return a different SiteInstance with the same process.
 518   TestBrowsingInstance* browsing_instance2 =
 519       new TestBrowsingInstance(browser_context.get(), &delete_counter);
 520   scoped_refptr<SiteInstanceImpl> site_instance_a1_2(
 521       static_cast<SiteInstanceImpl*>(
 522           browsing_instance2->GetSiteInstanceForURL(url_a1)));
 523   EXPECT_TRUE(site_instance_a1.get() != NULL);
 524   EXPECT_NE(site_instance_a1.get(), site_instance_a1_2.get());
 525   EXPECT_EQ(process_a1.get(), site_instance_a1_2->GetProcess());
 526
 527   // A visit to the original site in a new BrowsingInstance (different browser
 528   // context) should return a different SiteInstance with a different process.
 529   scoped_ptr<TestBrowserContext> browser_context2(new TestBrowserContext());
 530   TestBrowsingInstance* browsing_instance3 =
 531       new TestBrowsingInstance(browser_context2.get(), &delete_counter);
 532   scoped_refptr<SiteInstanceImpl> site_instance_a2_3(
 533       static_cast<SiteInstanceImpl*>(
 534           browsing_instance3->GetSiteInstanceForURL(url_a2)));
 535   EXPECT_TRUE(site_instance_a2_3.get() != NULL);
 536   scoped_ptr<RenderProcessHost> process_a2_3(site_instance_a2_3->GetProcess());
 537   EXPECT_NE(site_instance_a1.get(), site_instance_a2_3.get());
 538   EXPECT_NE(process_a1.get(), process_a2_3.get());
 539
 540   // Should be able to see that we do have SiteInstances.
 541   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 542       GURL("http://mail.google.com")));  // visited before
 543   EXPECT_TRUE(browsing_instance2->HasSiteInstance(
 544       GURL("http://mail.google.com")));  // visited before
 545   EXPECT_TRUE(browsing_instance->HasSiteInstance(
 546       GURL("http://mail.yahoo.com")));  // visited before
 547
 548   // Should be able to see that we don't have SiteInstances.
 549   EXPECT_FALSE(browsing_instance2->HasSiteInstance(
 550       GURL("http://www.yahoo.com")));  // different BI, same browser context
 551   EXPECT_FALSE(browsing_instance->HasSiteInstance(
 552       GURL("https://www.google.com")));  // not visited before
 553   EXPECT_FALSE(browsing_instance3->HasSiteInstance(
 554       GURL("http://www.yahoo.com")));  // different BI, different context
 555
 556   // browsing_instances will be deleted when their SiteInstances are deleted.
 557   // The processes will be unregistered when the RPH scoped_ptrs go away.
 558
 559   DrainMessageLoops();
 560 }
 561
 562 static SiteInstanceImpl* CreateSiteInstance(BrowserContext* browser_context,
 563                                             const GURL& url) {
 564   return static_cast<SiteInstanceImpl*>(
 565       SiteInstance::CreateForURL(browser_context, url));
 566 }
 567
 568 // Test to ensure that pages that require certain privileges are grouped
 569 // in processes with similar pages.
 570 TEST_F(SiteInstanceTest, ProcessSharingByType) {
 571   // This test shouldn't run with --site-per-process mode, since it doesn't
 572   // allow render process reuse, which this test explicitly exercises.
 573   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
 574           switches::kSitePerProcess))
 575     return;
 576
 577   // On Android by default the number of renderer hosts is unlimited and process
 578   // sharing doesn't happen. We set the override so that the test can run
 579   // everywhere.
 580   RenderProcessHost::SetMaxRendererProcessCount(kMaxRendererProcessCount);
 581
 582   ChildProcessSecurityPolicyImpl* policy =
 583       ChildProcessSecurityPolicyImpl::GetInstance();
 584
 585   // Make a bunch of mock renderers so that we hit the limit.
 586   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 587   ScopedVector<MockRenderProcessHost> hosts;
 588   for (size_t i = 0; i < kMaxRendererProcessCount; ++i)
 589     hosts.push_back(new MockRenderProcessHost(browser_context.get()));
 590
 591   // Create some extension instances and make sure they share a process.
 592   scoped_refptr<SiteInstanceImpl> extension1_instance(
 593       CreateSiteInstance(browser_context.get(),
 594           GURL(kPrivilegedScheme + std::string("://foo/bar"))));
 595   set_privileged_process_id(extension1_instance->GetProcess()->GetID());
 596
 597   scoped_refptr<SiteInstanceImpl> extension2_instance(
 598       CreateSiteInstance(browser_context.get(),
 599           GURL(kPrivilegedScheme + std::string("://baz/bar"))));
 600
 601   scoped_ptr<RenderProcessHost> extension_host(
 602       extension1_instance->GetProcess());
 603   EXPECT_EQ(extension1_instance->GetProcess(),
 604             extension2_instance->GetProcess());
 605
 606   // Create some WebUI instances and make sure they share a process.
 607   scoped_refptr<SiteInstanceImpl> webui1_instance(CreateSiteInstance(
 608       browser_context.get(), GURL(kChromeUIScheme + std::string("://newtab"))));
 609   policy->GrantWebUIBindings(webui1_instance->GetProcess()->GetID());
 610
 611   scoped_refptr<SiteInstanceImpl> webui2_instance(
 612       CreateSiteInstance(browser_context.get(),
 613                          GURL(kChromeUIScheme + std::string("://history"))));
 614
 615   scoped_ptr<RenderProcessHost> dom_host(webui1_instance->GetProcess());
 616   EXPECT_EQ(webui1_instance->GetProcess(), webui2_instance->GetProcess());
 617
 618   // Make sure none of differing privilege processes are mixed.
 619   EXPECT_NE(extension1_instance->GetProcess(), webui1_instance->GetProcess());
 620
 621   for (size_t i = 0; i < kMaxRendererProcessCount; ++i) {
 622     EXPECT_NE(extension1_instance->GetProcess(), hosts[i]);
 623     EXPECT_NE(webui1_instance->GetProcess(), hosts[i]);
 624   }
 625
 626   DrainMessageLoops();
 627
 628   // Disable the process limit override.
 629   RenderProcessHost::SetMaxRendererProcessCount(0u);
 630 }
 631
 632 // Test to ensure that HasWrongProcessForURL behaves properly for different
 633 // types of URLs.
 634 TEST_F(SiteInstanceTest, HasWrongProcessForURL) {
 635   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 636   scoped_ptr<RenderProcessHost> host;
 637   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 638       SiteInstance::Create(browser_context.get())));
 639
 640   EXPECT_FALSE(instance->HasSite());
 641   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 642
 643   instance->SetSite(GURL("http://evernote.com/"));
 644   EXPECT_TRUE(instance->HasSite());
 645
 646   // Check prior to "assigning" a process to the instance, which is expected
 647   // to return false due to not being attached to any process yet.
 648   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://google.com")));
 649
 650   // The call to GetProcess actually creates a new real process, which works
 651   // fine, but might be a cause for problems in different contexts.
 652   host.reset(instance->GetProcess());
 653   EXPECT_TRUE(host.get() != NULL);
 654   EXPECT_TRUE(instance->HasProcess());
 655
 656   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://evernote.com")));
 657   EXPECT_FALSE(instance->HasWrongProcessForURL(
 658       GURL("javascript:alert(document.location.href);")));
 659
 660   EXPECT_TRUE(instance->HasWrongProcessForURL(GURL("chrome://settings")));
 661
 662   // Test that WebUI SiteInstances reject normal web URLs.
 663   const GURL webui_url("chrome://settings");
 664   scoped_refptr<SiteInstanceImpl> webui_instance(static_cast<SiteInstanceImpl*>(
 665       SiteInstance::Create(browser_context.get())));
 666   webui_instance->SetSite(webui_url);
 667   scoped_ptr<RenderProcessHost> webui_host(webui_instance->GetProcess());
 668
 669   // Simulate granting WebUI bindings for the process.
 670   ChildProcessSecurityPolicyImpl::GetInstance()->GrantWebUIBindings(
 671       webui_host->GetID());
 672
 673   EXPECT_TRUE(webui_instance->HasProcess());
 674   EXPECT_FALSE(webui_instance->HasWrongProcessForURL(webui_url));
 675   EXPECT_TRUE(webui_instance->HasWrongProcessForURL(GURL("http://google.com")));
 676
 677   // WebUI uses process-per-site, so another instance will use the same process
 678   // even if we haven't called GetProcess yet.  Make sure HasWrongProcessForURL
 679   // doesn't crash (http://crbug.com/137070).
 680   scoped_refptr<SiteInstanceImpl> webui_instance2(
 681       static_cast<SiteInstanceImpl*>(
 682           SiteInstance::Create(browser_context.get())));
 683   webui_instance2->SetSite(webui_url);
 684   EXPECT_FALSE(webui_instance2->HasWrongProcessForURL(webui_url));
 685   EXPECT_TRUE(
 686       webui_instance2->HasWrongProcessForURL(GURL("http://google.com")));
 687
 688   DrainMessageLoops();
 689 }
 690
 691 // Test to ensure that HasWrongProcessForURL behaves properly even when
 692 // --site-per-process is used (http://crbug.com/160671).
 693 TEST_F(SiteInstanceTest, HasWrongProcessForURLInSitePerProcess) {
 694   base::CommandLine::ForCurrentProcess()->AppendSwitch(
 695       switches::kSitePerProcess);
 696
 697   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 698   scoped_ptr<RenderProcessHost> host;
 699   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 700       SiteInstance::Create(browser_context.get())));
 701
 702   instance->SetSite(GURL("http://evernote.com/"));
 703   EXPECT_TRUE(instance->HasSite());
 704
 705   // Check prior to "assigning" a process to the instance, which is expected
 706   // to return false due to not being attached to any process yet.
 707   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://google.com")));
 708
 709   // The call to GetProcess actually creates a new real process, which works
 710   // fine, but might be a cause for problems in different contexts.
 711   host.reset(instance->GetProcess());
 712   EXPECT_TRUE(host.get() != NULL);
 713   EXPECT_TRUE(instance->HasProcess());
 714
 715   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://evernote.com")));
 716   EXPECT_FALSE(instance->HasWrongProcessForURL(
 717       GURL("javascript:alert(document.location.href);")));
 718
 719   EXPECT_TRUE(instance->HasWrongProcessForURL(GURL("chrome://settings")));
 720
 721   DrainMessageLoops();
 722 }
 723
 724 // Test that we do not reuse a process in process-per-site mode if it has the
 725 // wrong bindings for its URL.  http://crbug.com/174059.
 726 TEST_F(SiteInstanceTest, ProcessPerSiteWithWrongBindings) {
 727   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 728   scoped_ptr<RenderProcessHost> host;
 729   scoped_ptr<RenderProcessHost> host2;
 730   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 731       SiteInstance::Create(browser_context.get())));
 732
 733   EXPECT_FALSE(instance->HasSite());
 734   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 735
 736   // Simulate navigating to a WebUI URL in a process that does not have WebUI
 737   // bindings.  This already requires bypassing security checks.
 738   const GURL webui_url("chrome://settings");
 739   instance->SetSite(webui_url);
 740   EXPECT_TRUE(instance->HasSite());
 741
 742   // The call to GetProcess actually creates a new real process.
 743   host.reset(instance->GetProcess());
 744   EXPECT_TRUE(host.get() != NULL);
 745   EXPECT_TRUE(instance->HasProcess());
 746
 747   // Without bindings, this should look like the wrong process.
 748   EXPECT_TRUE(instance->HasWrongProcessForURL(webui_url));
 749
 750   // WebUI uses process-per-site, so another instance would normally use the
 751   // same process.  Make sure it doesn't use the same process if the bindings
 752   // are missing.
 753   scoped_refptr<SiteInstanceImpl> instance2(
 754       static_cast<SiteInstanceImpl*>(
 755           SiteInstance::Create(browser_context.get())));
 756   instance2->SetSite(webui_url);
 757   host2.reset(instance2->GetProcess());
 758   EXPECT_TRUE(host2.get() != NULL);
 759   EXPECT_TRUE(instance2->HasProcess());
 760   EXPECT_NE(host.get(), host2.get());
 761
 762   DrainMessageLoops();
 763 }
 764
 765 // Test that we do not register processes with empty sites for process-per-site
 766 // mode.
 767 TEST_F(SiteInstanceTest, NoProcessPerSiteForEmptySite) {
 768   base::CommandLine::ForCurrentProcess()->AppendSwitch(
 769       switches::kProcessPerSite);
 770   scoped_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
 771   scoped_ptr<RenderProcessHost> host;
 772   scoped_refptr<SiteInstanceImpl> instance(static_cast<SiteInstanceImpl*>(
 773       SiteInstance::Create(browser_context.get())));
 774
 775   instance->SetSite(GURL());
 776   EXPECT_TRUE(instance->HasSite());
 777   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 778   host.reset(instance->GetProcess());
 779
 780   EXPECT_FALSE(RenderProcessHostImpl::GetProcessHostForSite(
 781       browser_context.get(), GURL()));
 782
 783   DrainMessageLoops();
 784 }
 785
 786 }  // namespace content