webapk: Avoid overwriting default CreationParams

content/browser/site_instance_impl.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 "content/browser/browsing_instance.h"
+#include "content/browser/child_process_launcher.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/frame_host/debug_urls.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host_factory.h"
 #include "content/public/browser/web_ui_controller_factory.h"
 #include "content/public/common/url_constants.h"
@@ skipping 22 matching lines @@
     process_->RemoveObserver(this);
 
   // Now that no one is referencing us, we can safely remove ourselves from
   // the BrowsingInstance.  Any future visits to a page from this site
   // (within the same BrowsingInstance) can safely create a new SiteInstance.
   if (has_site_)
     browsing_instance_->UnregisterSiteInstance(this);
 }
 
 scoped_refptr<SiteInstanceImpl> SiteInstanceImpl::Create(
-    BrowserContext* browser_context) {
-  return make_scoped_refptr(
-      new SiteInstanceImpl(new BrowsingInstance(browser_context)));
+    BrowserContext* browser_context,
+    int child_process_param_id) {
+  return make_scoped_refptr(new SiteInstanceImpl(
+      new BrowsingInstance(browser_context, child_process_param_id)));
 }
 
 scoped_refptr<SiteInstanceImpl> SiteInstanceImpl::CreateForURL(
     BrowserContext* browser_context,
-    const GURL& url) {
+    const GURL& url,
+    int child_process_param_id) {
   // This will create a new SiteInstance and BrowsingInstance.
   scoped_refptr<BrowsingInstance> instance(
-      new BrowsingInstance(browser_context));
+      new BrowsingInstance(browser_context, child_process_param_id));
   return instance->GetSiteInstanceForURL(url);
 }
 
 int32_t SiteInstanceImpl::GetId() {
   return id_;
 }
 
 bool SiteInstanceImpl::HasProcess() const {
   if (process_ != NULL)
     return true;
@@ skipping 18 matching lines @@
 
 class DefaultSubframeProcessHostHolder : public base::SupportsUserData::Data,
                                          public RenderProcessHostObserver {
  public:
   explicit DefaultSubframeProcessHostHolder(BrowserContext* browser_context)
       : browser_context_(browser_context) {}
   ~DefaultSubframeProcessHostHolder() override {}
 
   // Gets the correct render process to use for this SiteInstance.
   RenderProcessHost* GetProcessHost(SiteInstance* site_instance,
-                                    bool is_for_guests_only) {
+                                    bool is_for_guests_only,
+                                    int child_process_param_id) {
     StoragePartition* default_partition =
         BrowserContext::GetDefaultStoragePartition(browser_context_);
     StoragePartition* partition =
         BrowserContext::GetStoragePartition(browser_context_, site_instance);
 
     // Is this the default storage partition? If it isn't, then just give it its
     // own non-shared process.
     if (partition != default_partition || is_for_guests_only) {
       RenderProcessHostImpl* host = new RenderProcessHostImpl(
           browser_context_, static_cast<StoragePartitionImpl*>(partition),
-          is_for_guests_only);
+          is_for_guests_only, child_process_param_id);
       host->SetIsNeverSuitableForReuse();
       return host;
     }
 
     if (host_) {
       // If we already have a shared host for the default storage partition, use
       // it.
       return host_;
     }
 
     host_ = new RenderProcessHostImpl(
         browser_context_, static_cast<StoragePartitionImpl*>(partition),
-        false /* for guests only */);
+        false /* for guests only */, child_process_param_id);
     host_->SetIsNeverSuitableForReuse();
     host_->AddObserver(this);
 
     return host_;
   }
 
   void RenderProcessHostDestroyed(RenderProcessHost* host) override {
     DCHECK_EQ(host_, host);
     host_->RemoveObserver(this);
     host_ = nullptr;
@@ skipping 13 matching lines @@
     BrowserContext* browser_context,
     bool is_for_guests_only) {
   DefaultSubframeProcessHostHolder* holder =
       static_cast<DefaultSubframeProcessHostHolder*>(
           browser_context->GetUserData(&kDefaultSubframeProcessHostHolderKey));
   if (!holder) {
     holder = new DefaultSubframeProcessHostHolder(browser_context);
     browser_context->SetUserData(kDefaultSubframeProcessHostHolderKey, holder);
   }
 
-  return holder->GetProcessHost(this, is_for_guests_only);
+  return holder->GetProcessHost(this, is_for_guests_only,
+                                browsing_instance_->child_process_param_id());
 }
 
 RenderProcessHost* SiteInstanceImpl::GetProcess() {
   // TODO(erikkay) It would be nice to ensure that the renderer type had been
   // properly set before we get here.  The default tab creation case winds up
   // with no site set at this point, so it will default to TYPE_NORMAL.  This
   // may not be correct, so we'll wind up potentially creating a process that
   // we then throw away, or worse sharing a process with the wrong process type.
   // See crbug.com/43448.
 
@@ skipping 26 matching lines @@
 
     // Otherwise (or if that fails), create a new one.
     if (!process_) {
       if (g_render_process_host_factory_) {
         process_ = g_render_process_host_factory_->CreateRenderProcessHost(
             browser_context, this);
       } else {
         StoragePartitionImpl* partition =
             static_cast<StoragePartitionImpl*>(
                 BrowserContext::GetStoragePartition(browser_context, this));
-        process_ = new RenderProcessHostImpl(browser_context, partition,
-                                             is_for_guests_only);
+        process_ = new RenderProcessHostImpl(
+            browser_context, partition, is_for_guests_only,
+            browsing_instance_->child_process_param_id());
       }
     }
     CHECK(process_);
     process_->AddObserver(this);
 
     // If we are using process-per-site, we need to register this process
     // for the current site so that we can find it again.  (If no site is set
     // at this time, we will register it in SetSite().)
     if (use_process_per_site) {
       RenderProcessHostImpl::RegisterProcessHostForSite(browser_context,
@@ skipping 139 matching lines @@
     const RenderProcessHostFactory* rph_factory) {
   g_render_process_host_factory_ = rph_factory;
 }
 
 BrowserContext* SiteInstanceImpl::GetBrowserContext() const {
   return browsing_instance_->browser_context();
 }
 
 // static
 scoped_refptr<SiteInstance> SiteInstance::Create(
-    BrowserContext* browser_context) {
-  return SiteInstanceImpl::Create(browser_context);
+    BrowserContext* browser_context,
+    int child_process_param_id) {
+  return SiteInstanceImpl::Create(browser_context, child_process_param_id);
 }
 
 // static
 scoped_refptr<SiteInstance> SiteInstance::CreateForURL(
     BrowserContext* browser_context,
     const GURL& url) {
-  return SiteInstanceImpl::CreateForURL(browser_context, url);
+  return SiteInstanceImpl::CreateForURL(browser_context, url,
+                                        ChildProcessLauncher::DEFAULT_PARAM_ID);
 }
 
 // static
 bool SiteInstance::IsSameWebSite(BrowserContext* browser_context,
                                  const GURL& real_src_url,
                                  const GURL& real_dest_url) {
   GURL src_url = SiteInstanceImpl::GetEffectiveURL(browser_context,
                                                    real_src_url);
   GURL dest_url = SiteInstanceImpl::GetEffectiveURL(browser_context,
                                                     real_dest_url);
@@ skipping 137 matching lines @@
             browsing_instance_->browser_context(), site_))
       return;
 
     ChildProcessSecurityPolicyImpl* policy =
         ChildProcessSecurityPolicyImpl::GetInstance();
     policy->LockToOrigin(process_->GetID(), site_);
   }
 }
 
 }  // namespace content