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());

[boliu, 2017/02/23 00:51:30]

I think this is the thing being discussed in the bug.

So subframes by default inherit from parent (so webapk subframe would be in
webapk). The other choice was to always have subframes always under chrome, in
which case should use default here.

 }
 
 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