Move process-per-site logic from BrowsingInstance to RenderProcessHost.

content/browser/web_contents/render_view_host_manager.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/web_contents/render_view_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/browser/web_ui_controller_factory.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::NavigationEntryImpl;
+using content::RenderProcessHost;
 using content::RenderViewHost;
 using content::RenderViewHostImpl;
 using content::RenderWidgetHostView;
 using content::RenderWidgetHostViewPort;
 using content::SiteInstance;
 using content::WebUIControllerFactory;
 
 RenderViewHostManager::RenderViewHostManager(
     content::RenderViewHostDelegate* render_view_delegate,
     content::RenderWidgetHostDelegate* render_widget_delegate,
@@ skipping 206 matching lines @@
   // leave the pending renderer around until the next navigation event
   // (Navigate, DidNavigate, etc), which will clean it up properly.
   // TODO(creis): All of this will go away when we move the cross-site logic
   // to ResourceDispatcherHost, so that we intercept responses rather than
   // navigation events.  (That's necessary to support onunload anyway.)  Once
   // we've made that change, we won't create a pending renderer until we know
   // the response is not a download.
 }
 
 void RenderViewHostManager::RendererProcessClosing(
-    content::RenderProcessHost* render_process_host) {
+    RenderProcessHost* render_process_host) {
   // Remove any swapped out RVHs from this process, so that we don't try to
   // swap them back in while the process is exiting.  Start by finding them,
   // since there could be more than one.
   std::list<int> ids_to_remove;
   for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
     if (iter->second->GetProcess() == render_process_host)
       ids_to_remove.push_back(iter->first);
   }
@@ skipping 68 matching lines @@
                                                            new_request_id);
 }
 
 void RenderViewHostManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSING:
       RendererProcessClosing(
-          content::Source<content::RenderProcessHost>(source).ptr());
+          content::Source<RenderProcessHost>(source).ptr());
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 bool RenderViewHostManager::ShouldTransitionCrossSite() {
   // True if we are using process-per-site-instance (default) or
   // process-per-site (kProcessPerSite).
@@ skipping 98 matching lines @@
   // for this entry.  We won't commit the SiteInstance to this site until the
   // navigation commits (in DidNavigate), unless the navigation entry was
   // restored or it's a Web UI as described below.
   if (!curr_site_instance->HasSite()) {
     // If we've already created a SiteInstance for our destination, we don't
     // want to use this unused SiteInstance; use the existing one.  (We don't
     // do this check if the curr_instance has a site, because for now, we want
     // to compare against the current URL and not the SiteInstance's site.  In
     // this case, there is no current URL, so comparing against the site is ok.
     // See additional comments below.)
-    if (curr_site_instance->HasRelatedSiteInstance(dest_url))
+    //
+    // Also, if the URL should use process-per-site mode and there is an
+    // existing process for the site, we should use it.  We can call
+    // GetRelatedSiteInstance for this, which will eagerly set the site and

[awong, 2012/06/27 00:26:54]

GetRelatedSiteInstance -> GetRelatedSiteInstance()

[Charlie Reis, 2012/06/27 20:53:43]

Done.

+    // thus use the correct process.
+    bool use_process_per_site =
+        RenderProcessHost::ShouldUseProcessPerSite(browser_context, dest_url) &&
+        RenderProcessHost::GetProcessHostForSite(browser_context, dest_url);
+    if (curr_site_instance->HasRelatedSiteInstance(dest_url) ||
+        use_process_per_site) {
       return curr_site_instance->GetRelatedSiteInstance(dest_url);
+    }
 
     // For extensions, Web UI URLs (such as the new tab page), and apps we do
     // not want to use the curr_instance if it has no site, since it will have a
     // RenderProcessHost of PRIV_NORMAL.  Create a new SiteInstance for this
     // URL instead (with the correct process type).
     if (curr_site_instance->HasWrongProcessForURL(dest_url))
       return curr_site_instance->GetRelatedSiteInstance(dest_url);
 
     // Normally the "site" on the SiteInstance is set lazily when the load
     // actually commits. This is to support better process sharing in case
@@ skipping 420 matching lines @@
 }
 
 RenderViewHost* RenderViewHostManager::GetSwappedOutRenderViewHost(
     SiteInstance* instance) {
   RenderViewHostMap::iterator iter = swapped_out_hosts_.find(instance->GetId());
   if (iter != swapped_out_hosts_.end())
     return iter->second;
 
   return NULL;
 }