webapk: Avoid overwriting default CreationParams

content/browser/site_instance_impl_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/site_instance_impl.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 135 matching lines @@
 };
 
 // Test to ensure no memory leaks for SiteInstance objects.
 TEST_F(SiteInstanceTest, SiteInstanceDestructor) {
   // The existence of this object will cause WebContentsImpl to create our
   // test one instead of the real one.
   RenderViewHostTestEnabler rvh_test_enabler;
   const GURL url("test:foo");
 
   // Ensure that instances are deleted when their NavigationEntries are gone.
-  scoped_refptr<SiteInstanceImpl> instance = SiteInstanceImpl::Create(nullptr);
+  constexpr int child_process_param_id = 0;
+  scoped_refptr<SiteInstanceImpl> instance =
+      SiteInstanceImpl::Create(nullptr, child_process_param_id);
   EXPECT_EQ(0, browser_client()->GetAndClearSiteInstanceDeleteCount());
 
   NavigationEntryImpl* e1 = new NavigationEntryImpl(
       instance, url, Referrer(), base::string16(), ui::PAGE_TRANSITION_LINK,
       false);
 
   // Redundantly setting e1's SiteInstance shouldn't affect the ref count.
   e1->set_site_instance(instance);
   EXPECT_EQ(0, browser_client()->GetAndClearSiteInstanceDeleteCount());
   EXPECT_EQ(0, browser_client()->GetAndClearBrowsingInstanceDeleteCount());
@@ skipping 36 matching lines @@
   EXPECT_EQ(1, browser_client()->GetAndClearBrowsingInstanceDeleteCount());
   // contents is now deleted, along with instance and browsing_instance
 }
 
 // Test that NavigationEntries with SiteInstances can be cloned, but that their
 // SiteInstances can be changed afterwards.  Also tests that the ref counts are
 // updated properly after the change.
 TEST_F(SiteInstanceTest, CloneNavigationEntry) {
   const GURL url("test:foo");
 
+  constexpr int child_process_param_id = 0;
   std::unique_ptr<NavigationEntryImpl> e1 =
       base::WrapUnique(new NavigationEntryImpl(
-          SiteInstanceImpl::Create(nullptr), url, Referrer(),
-          base::string16(), ui::PAGE_TRANSITION_LINK, false));
+          SiteInstanceImpl::Create(nullptr, child_process_param_id), url,
+          Referrer(), base::string16(), ui::PAGE_TRANSITION_LINK, false));
 
   // Clone the entry.
   std::unique_ptr<NavigationEntryImpl> e2 = e1->Clone();
 
   // Should be able to change the SiteInstance of the cloned entry.
-  e2->set_site_instance(SiteInstanceImpl::Create(nullptr));
+  e2->set_site_instance(
+      SiteInstanceImpl::Create(nullptr, child_process_param_id));
 
   EXPECT_EQ(0, browser_client()->GetAndClearSiteInstanceDeleteCount());
   EXPECT_EQ(0, browser_client()->GetAndClearBrowsingInstanceDeleteCount());
 
   // The first SiteInstance and BrowsingInstance should go away after resetting
   // e1, since e2 should no longer be referencing it.
   e1.reset();
   EXPECT_EQ(1, browser_client()->GetAndClearSiteInstanceDeleteCount());
   EXPECT_EQ(1, browser_client()->GetAndClearBrowsingInstanceDeleteCount());
 
   // The second SiteInstance should go away after resetting e2.
   e2.reset();
   EXPECT_EQ(1, browser_client()->GetAndClearSiteInstanceDeleteCount());
   EXPECT_EQ(1, browser_client()->GetAndClearBrowsingInstanceDeleteCount());
 
   DrainMessageLoop();
 }
 
 // Test to ensure GetProcess returns and creates processes correctly.
 TEST_F(SiteInstanceTest, GetProcess) {
   // Ensure that GetProcess returns a process.
   std::unique_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
   std::unique_ptr<RenderProcessHost> host1;
+  constexpr int child_process_param_id = 0;
   scoped_refptr<SiteInstanceImpl> instance(
-      SiteInstanceImpl::Create(browser_context.get()));
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id));
   host1.reset(instance->GetProcess());
   EXPECT_TRUE(host1.get() != nullptr);
 
   // Ensure that GetProcess creates a new process.
   scoped_refptr<SiteInstanceImpl> instance2(
-      SiteInstanceImpl::Create(browser_context.get()));
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id));
   std::unique_ptr<RenderProcessHost> host2(instance2->GetProcess());
   EXPECT_TRUE(host2.get() != nullptr);
   EXPECT_NE(host1.get(), host2.get());
 
   DrainMessageLoop();
 }
 
 // Test to ensure SetSite and site() work properly.
 TEST_F(SiteInstanceTest, SetSite) {
-  scoped_refptr<SiteInstanceImpl> instance(SiteInstanceImpl::Create(nullptr));
+  constexpr int child_process_param_id = 0;
+  scoped_refptr<SiteInstanceImpl> instance(
+      SiteInstanceImpl::Create(nullptr, child_process_param_id));
   EXPECT_FALSE(instance->HasSite());
   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 
   instance->SetSite(GURL("http://www.google.com/index.html"));
   EXPECT_EQ(GURL("http://google.com"), instance->GetSiteURL());
 
   EXPECT_TRUE(instance->HasSite());
 
   DrainMessageLoop();
 }
@@ skipping 141 matching lines @@
 
   DrainMessageLoop();
 }
 
 // Test to ensure that there is only one SiteInstance per site in a given
 // BrowsingInstance, when process-per-site is not in use.
 TEST_F(SiteInstanceTest, OneSiteInstancePerSite) {
   ASSERT_FALSE(base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kProcessPerSite));
   std::unique_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
+  constexpr int child_process_param_id = 0;
   BrowsingInstance* browsing_instance =
-      new BrowsingInstance(browser_context.get());
+      new BrowsingInstance(browser_context.get(), child_process_param_id);
 
   const GURL url_a1("http://www.google.com/1.html");
   scoped_refptr<SiteInstanceImpl> site_instance_a1(
       browsing_instance->GetSiteInstanceForURL(url_a1));
   EXPECT_TRUE(site_instance_a1.get() != nullptr);
 
   // A separate site should create a separate SiteInstance.
   const GURL url_b1("http://www.yahoo.com/");
   scoped_refptr<SiteInstanceImpl> site_instance_b1(
 
       browsing_instance->GetSiteInstanceForURL(url_b1));
   EXPECT_NE(site_instance_a1.get(), site_instance_b1.get());
   EXPECT_TRUE(site_instance_a1->IsRelatedSiteInstance(site_instance_b1.get()));
 
   // Getting the new SiteInstance from the BrowsingInstance and from another
   // SiteInstance in the BrowsingInstance should give the same result.
   EXPECT_EQ(site_instance_b1.get(),
             site_instance_a1->GetRelatedSiteInstance(url_b1));
 
   // A second visit to the original site should return the same SiteInstance.
   const GURL url_a2("http://www.google.com/2.html");
   EXPECT_EQ(site_instance_a1.get(),
             browsing_instance->GetSiteInstanceForURL(url_a2));
   EXPECT_EQ(site_instance_a1.get(),
             site_instance_a1->GetRelatedSiteInstance(url_a2));
 
   // A visit to the original site in a new BrowsingInstance (same or different
   // browser context) should return a different SiteInstance.
   BrowsingInstance* browsing_instance2 =
-      new BrowsingInstance(browser_context.get());
+      new BrowsingInstance(browser_context.get(), child_process_param_id);
   // Ensure the new SiteInstance is ref counted so that it gets deleted.
   scoped_refptr<SiteInstanceImpl> site_instance_a2_2(
       browsing_instance2->GetSiteInstanceForURL(url_a2));
   EXPECT_NE(site_instance_a1.get(), site_instance_a2_2.get());
   EXPECT_FALSE(
       site_instance_a1->IsRelatedSiteInstance(site_instance_a2_2.get()));
 
   // The two SiteInstances for http://google.com should not use the same process
   // if process-per-site is not enabled.
   std::unique_ptr<RenderProcessHost> process_a1(site_instance_a1->GetProcess());
@@ skipping 20 matching lines @@
 
   DrainMessageLoop();
 }
 
 // Test to ensure that there is only one RenderProcessHost per site for an
 // entire BrowserContext, if process-per-site is in use.
 TEST_F(SiteInstanceTest, OneSiteInstancePerSiteInBrowserContext) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kProcessPerSite);
   std::unique_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
+  constexpr int child_process_param_id = 0;
   scoped_refptr<BrowsingInstance> browsing_instance =
-      new BrowsingInstance(browser_context.get());
+      new BrowsingInstance(browser_context.get(), child_process_param_id);
 
   const GURL url_a1("http://www.google.com/1.html");
   scoped_refptr<SiteInstanceImpl> site_instance_a1(
       browsing_instance->GetSiteInstanceForURL(url_a1));
   EXPECT_TRUE(site_instance_a1.get() != nullptr);
   std::unique_ptr<RenderProcessHost> process_a1(site_instance_a1->GetProcess());
 
   // A separate site should create a separate SiteInstance.
   const GURL url_b1("http://www.yahoo.com/");
   scoped_refptr<SiteInstanceImpl> site_instance_b1(
       browsing_instance->GetSiteInstanceForURL(url_b1));
   EXPECT_NE(site_instance_a1.get(), site_instance_b1.get());
   EXPECT_TRUE(site_instance_a1->IsRelatedSiteInstance(site_instance_b1.get()));
 
   // Getting the new SiteInstance from the BrowsingInstance and from another
   // SiteInstance in the BrowsingInstance should give the same result.
   EXPECT_EQ(site_instance_b1.get(),
             site_instance_a1->GetRelatedSiteInstance(url_b1));
 
   // A second visit to the original site should return the same SiteInstance.
   const GURL url_a2("http://www.google.com/2.html");
   EXPECT_EQ(site_instance_a1.get(),
             browsing_instance->GetSiteInstanceForURL(url_a2));
   EXPECT_EQ(site_instance_a1.get(),
             site_instance_a1->GetRelatedSiteInstance(url_a2));
 
   // A visit to the original site in a new BrowsingInstance (same browser
   // context) should return a different SiteInstance with the same process.
   BrowsingInstance* browsing_instance2 =
-      new BrowsingInstance(browser_context.get());
+      new BrowsingInstance(browser_context.get(), child_process_param_id);
   scoped_refptr<SiteInstanceImpl> site_instance_a1_2(
       browsing_instance2->GetSiteInstanceForURL(url_a1));
   EXPECT_TRUE(site_instance_a1.get() != nullptr);
   EXPECT_NE(site_instance_a1.get(), site_instance_a1_2.get());
   EXPECT_EQ(process_a1.get(), site_instance_a1_2->GetProcess());
 
   // A visit to the original site in a new BrowsingInstance (different browser
   // context) should return a different SiteInstance with a different process.
   std::unique_ptr<TestBrowserContext> browser_context2(
       new TestBrowserContext());
   BrowsingInstance* browsing_instance3 =
-      new BrowsingInstance(browser_context2.get());
+      new BrowsingInstance(browser_context2.get(), child_process_param_id);
   scoped_refptr<SiteInstanceImpl> site_instance_a2_3(
       browsing_instance3->GetSiteInstanceForURL(url_a2));
   EXPECT_TRUE(site_instance_a2_3.get() != nullptr);
   std::unique_ptr<RenderProcessHost> process_a2_3(
       site_instance_a2_3->GetProcess());
   EXPECT_NE(site_instance_a1.get(), site_instance_a2_3.get());
   EXPECT_NE(process_a1.get(), process_a2_3.get());
 
   // Should be able to see that we do have SiteInstances.
   EXPECT_TRUE(browsing_instance->HasSiteInstance(
@@ skipping 13 matching lines @@
 
   // browsing_instances will be deleted when their SiteInstances are deleted.
   // The processes will be unregistered when the RPH scoped_ptrs go away.
 
   DrainMessageLoop();
 }
 
 static scoped_refptr<SiteInstanceImpl> CreateSiteInstance(
     BrowserContext* browser_context,
     const GURL& url) {
-  return SiteInstanceImpl::CreateForURL(browser_context, url);
+  constexpr int child_process_param_id = 0;
+  return SiteInstanceImpl::CreateForURL(browser_context, url,
+                                        child_process_param_id);
 }
 
 // Test to ensure that pages that require certain privileges are grouped
 // in processes with similar pages.
 TEST_F(SiteInstanceTest, ProcessSharingByType) {
   // This test shouldn't run with --site-per-process mode, which prohibits
   // the renderer process reuse this test explicitly exercises.
   if (AreAllSitesIsolatedForTesting())
     return;
 
@@ skipping 50 matching lines @@
 
   // Disable the process limit override.
   RenderProcessHost::SetMaxRendererProcessCount(0u);
 }
 
 // Test to ensure that HasWrongProcessForURL behaves properly for different
 // types of URLs.
 TEST_F(SiteInstanceTest, HasWrongProcessForURL) {
   std::unique_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
   std::unique_ptr<RenderProcessHost> host;
+  constexpr int child_process_param_id = 0;
   scoped_refptr<SiteInstanceImpl> instance(
-      SiteInstanceImpl::Create(browser_context.get()));
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id));
 
   EXPECT_FALSE(instance->HasSite());
   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 
   instance->SetSite(GURL("http://evernote.com/"));
   EXPECT_TRUE(instance->HasSite());
 
   // Check prior to "assigning" a process to the instance, which is expected
   // to return false due to not being attached to any process yet.
   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://google.com")));
 
   // The call to GetProcess actually creates a new real process, which works
   // fine, but might be a cause for problems in different contexts.
   host.reset(instance->GetProcess());
   EXPECT_TRUE(host.get() != nullptr);
   EXPECT_TRUE(instance->HasProcess());
 
   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://evernote.com")));
   EXPECT_FALSE(instance->HasWrongProcessForURL(
       GURL("javascript:alert(document.location.href);")));
 
   EXPECT_TRUE(instance->HasWrongProcessForURL(GURL("chrome://gpu")));
 
   // Test that WebUI SiteInstances reject normal web URLs.
   const GURL webui_url("chrome://gpu");
   scoped_refptr<SiteInstanceImpl> webui_instance(
-      SiteInstanceImpl::Create(browser_context.get()));
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id));
   webui_instance->SetSite(webui_url);
   std::unique_ptr<RenderProcessHost> webui_host(webui_instance->GetProcess());
 
   // Simulate granting WebUI bindings for the process.
   ChildProcessSecurityPolicyImpl::GetInstance()->GrantWebUIBindings(
       webui_host->GetID());
 
   EXPECT_TRUE(webui_instance->HasProcess());
   EXPECT_FALSE(webui_instance->HasWrongProcessForURL(webui_url));
   EXPECT_TRUE(webui_instance->HasWrongProcessForURL(GURL("http://google.com")));
   EXPECT_TRUE(webui_instance->HasWrongProcessForURL(GURL("http://gpu")));
 
   // WebUI uses process-per-site, so another instance will use the same process
   // even if we haven't called GetProcess yet.  Make sure HasWrongProcessForURL
   // doesn't crash (http://crbug.com/137070).
   scoped_refptr<SiteInstanceImpl> webui_instance2(
-      SiteInstanceImpl::Create(browser_context.get()));
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id));
   webui_instance2->SetSite(webui_url);
   EXPECT_FALSE(webui_instance2->HasWrongProcessForURL(webui_url));
   EXPECT_TRUE(
       webui_instance2->HasWrongProcessForURL(GURL("http://google.com")));
 
   DrainMessageLoop();
 }
 
 // Test to ensure that HasWrongProcessForURL behaves properly even when
 // --site-per-process is used (http://crbug.com/160671).
 TEST_F(SiteInstanceTest, HasWrongProcessForURLInSitePerProcess) {
   IsolateAllSitesForTesting(base::CommandLine::ForCurrentProcess());
 
   std::unique_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
   std::unique_ptr<RenderProcessHost> host;
+  constexpr int child_process_param_id = 0;
   scoped_refptr<SiteInstanceImpl> instance(
-      SiteInstanceImpl::Create(browser_context.get()));
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id));
 
   instance->SetSite(GURL("http://evernote.com/"));
   EXPECT_TRUE(instance->HasSite());
 
   // Check prior to "assigning" a process to the instance, which is expected
   // to return false due to not being attached to any process yet.
   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://google.com")));
 
   // The call to GetProcess actually creates a new real process, which works
   // fine, but might be a cause for problems in different contexts.
   host.reset(instance->GetProcess());
   EXPECT_TRUE(host.get() != nullptr);
   EXPECT_TRUE(instance->HasProcess());
 
   EXPECT_FALSE(instance->HasWrongProcessForURL(GURL("http://evernote.com")));
   EXPECT_FALSE(instance->HasWrongProcessForURL(
       GURL("javascript:alert(document.location.href);")));
 
   EXPECT_TRUE(instance->HasWrongProcessForURL(GURL("chrome://gpu")));
 
   DrainMessageLoop();
 }
 
 // Test that we do not reuse a process in process-per-site mode if it has the
 // wrong bindings for its URL.  http://crbug.com/174059.
 TEST_F(SiteInstanceTest, ProcessPerSiteWithWrongBindings) {
   std::unique_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
   std::unique_ptr<RenderProcessHost> host;
   std::unique_ptr<RenderProcessHost> host2;
+  constexpr int child_process_param_id = 0;
   scoped_refptr<SiteInstanceImpl> instance(
-      SiteInstanceImpl::Create(browser_context.get()));
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id));
 
   EXPECT_FALSE(instance->HasSite());
   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 
   // Simulate navigating to a WebUI URL in a process that does not have WebUI
   // bindings.  This already requires bypassing security checks.
   const GURL webui_url("chrome://gpu");
   instance->SetSite(webui_url);
   EXPECT_TRUE(instance->HasSite());
 
   // The call to GetProcess actually creates a new real process.
   host.reset(instance->GetProcess());
   EXPECT_TRUE(host.get() != nullptr);
   EXPECT_TRUE(instance->HasProcess());
 
   // Without bindings, this should look like the wrong process.
   EXPECT_TRUE(instance->HasWrongProcessForURL(webui_url));
 
   // WebUI uses process-per-site, so another instance would normally use the
   // same process.  Make sure it doesn't use the same process if the bindings
   // are missing.
   scoped_refptr<SiteInstanceImpl> instance2(
-      SiteInstanceImpl::Create(browser_context.get()));
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id));
   instance2->SetSite(webui_url);
   host2.reset(instance2->GetProcess());
   EXPECT_TRUE(host2.get() != nullptr);
   EXPECT_TRUE(instance2->HasProcess());
   EXPECT_NE(host.get(), host2.get());
 
   DrainMessageLoop();
 }
 
 // Test that we do not register processes with empty sites for process-per-site
 // mode.
 TEST_F(SiteInstanceTest, NoProcessPerSiteForEmptySite) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kProcessPerSite);
   std::unique_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
   std::unique_ptr<RenderProcessHost> host;
+  constexpr int child_process_param_id = 0;
   scoped_refptr<SiteInstanceImpl> instance(
-      SiteInstanceImpl::Create(browser_context.get()));
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id));
 
   instance->SetSite(GURL());
   EXPECT_TRUE(instance->HasSite());
   EXPECT_TRUE(instance->GetSiteURL().is_empty());
   host.reset(instance->GetProcess());
 
   EXPECT_FALSE(RenderProcessHostImpl::GetProcessHostForSite(
       browser_context.get(), GURL()));
 
   DrainMessageLoop();
 }
 
 TEST_F(SiteInstanceTest, DefaultSubframeSiteInstance) {
   if (AreAllSitesIsolatedForTesting())
     return;  // --top-document-isolation is not possible.
 
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kTopDocumentIsolation);
 
   std::unique_ptr<TestBrowserContext> browser_context(new TestBrowserContext());
+  constexpr int child_process_param_id = 0;
   scoped_refptr<SiteInstanceImpl> main_instance =
-      SiteInstanceImpl::Create(browser_context.get());
+      SiteInstanceImpl::Create(browser_context.get(), child_process_param_id);
   scoped_refptr<SiteInstanceImpl> subframe_instance =
       main_instance->GetDefaultSubframeSiteInstance();
   int subframe_instance_id = subframe_instance->GetId();
 
   EXPECT_NE(main_instance, subframe_instance);
   EXPECT_EQ(subframe_instance, main_instance->GetDefaultSubframeSiteInstance());
   EXPECT_FALSE(main_instance->IsDefaultSubframeSiteInstance());
   EXPECT_TRUE(subframe_instance->IsDefaultSubframeSiteInstance());
 
   EXPECT_EQ(0, browser_client()->GetAndClearSiteInstanceDeleteCount());
@@ skipping 20 matching lines @@
   EXPECT_EQ(1, browser_client()->GetAndClearSiteInstanceDeleteCount());
   EXPECT_EQ(0, browser_client()->GetAndClearBrowsingInstanceDeleteCount());
 
   // Free the subframe instance, which should free the browsing instance.
   subframe_instance = nullptr;
   EXPECT_EQ(1, browser_client()->GetAndClearSiteInstanceDeleteCount());
   EXPECT_EQ(1, browser_client()->GetAndClearBrowsingInstanceDeleteCount());
 }
 
 }  // namespace content