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

content/browser/renderer_host/render_process_host_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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #if defined(OS_WIN)
@@ skipping 17 matching lines @@
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
+#include "base/supports_user_data.h"
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/tracked_objects.h"
 #include "content/browser/appcache/appcache_dispatcher_host.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/browser_main.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/device_orientation/message_filter.h"
@@ skipping 36 matching lines @@
 #include "content/browser/trace_message_filter.h"
 #include "content/browser/worker_host/worker_message_filter.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/resource_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/render_process_host_factory.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui_controller_factory.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/url_constants.h"
 #include "content/renderer/render_process_impl.h"
 #include "content/renderer/render_thread_impl.h"
@@ skipping 11 matching lines @@
 
 #if defined(OS_WIN)
 #include "base/synchronization/waitable_event.h"
 #include "content/common/font_cache_dispatcher_win.h"
 #endif
 
 #include "third_party/skia/include/core/SkBitmap.h"
 
 extern bool g_exited_main_message_loop;
 
+static const char* kSiteProcessMapKeyName = "content_site_process_map";
+
 namespace content {
 
 // This class creates the IO thread for the renderer when running in
 // single-process mode.  It's not used in multi-process mode.
 class RendererMainThread : public base::Thread {
  public:
   explicit RendererMainThread(const std::string& channel_id)
       : base::Thread("Chrome_InProcRendererThread"),
         channel_id_(channel_id),
         render_process_(NULL) {
@@ skipping 66 matching lines @@
   virtual ~RendererURLRequestContextSelector() {}
 
   scoped_refptr<net::URLRequestContextGetter> request_context_;
   scoped_refptr<net::URLRequestContextGetter> media_request_context_;
 };
 
 // the global list of all renderer processes
 base::LazyInstance<IDMap<RenderProcessHost> >::Leaky
     g_all_hosts = LAZY_INSTANCE_INITIALIZER;
 
+// Map of site to process, to ensure we only have one RenderProcessHost per
+// site in process-per-site mode.  Each map is specific to a BrowserContext.
+class SiteProcessMap : public base::SupportsUserData::Data {
+ public:
+  typedef base::hash_map<std::string, RenderProcessHost*> SiteToProcessMap;
+  SiteProcessMap() {}
+
+  void RegisterProcess(std::string site, RenderProcessHost* process) {
+    map_[site] = process;
+  }
+
+  RenderProcessHost* FindProcess(std::string site) {
+    SiteToProcessMap::iterator i = map_.find(site);
+    if (i != map_.end())
+      return i->second;
+    return NULL;
+  }
+
+  void RemoveProcess(RenderProcessHost* host) {
+    // Find all instances of this process in the map, then separately remove
+    // them.
+    std::set<std::string> sites;
+    for (SiteToProcessMap::const_iterator i = map_.begin();
+         i != map_.end();
+         i++) {
+      if (i->second == host)
+        sites.insert(i->first);
+    }
+    for (std::set<std::string>::iterator i = sites.begin();
+         i != sites.end();
+         i++) {
+      SiteToProcessMap::iterator iter = map_.find(*i);
+      if (iter != map_.end()) {
+        DCHECK_EQ(iter->second, host);
+        map_.erase(iter);
+      }
+    }
+  }
+
+ private:
+  SiteToProcessMap map_;
+};
+
+// Find the SiteProcessMap specific to the given context.
+SiteProcessMap* GetSiteProcessMapForBrowserContext(BrowserContext* context) {
+  DCHECK(context);
+  SiteProcessMap* map = static_cast<SiteProcessMap*>(
+      context->GetUserData(kSiteProcessMapKeyName));
+  if (!map) {
+    map = new SiteProcessMap();
+    context->SetUserData(kSiteProcessMapKeyName, map);
+  }
+  return map;
+}
+
 }  // namespace
 
 // Stores the maximum number of renderer processes the content module can
 // create.
 static size_t g_max_renderer_count_override = 0;
 
 // static
 size_t RenderProcessHost::GetMaxRendererProcessCount() {
   if (g_max_renderer_count_override)
     return g_max_renderer_count_override;
@@ skipping 843 matching lines @@
     // It's important not to wait for the DeleteTask to delete the channel
     // proxy. Kill it off now. That way, in case the profile is going away, the
     // rest of the objects attached to this RenderProcessHost start going
     // away first, since deleting the channel proxy will post a
     // OnChannelClosed() to IPC::ChannelProxy::Context on the IO thread.
     channel_.reset();
     gpu_message_filter_ = NULL;
 
     // Remove ourself from the list of renderer processes so that we can't be
     // reused in between now and when the Delete task runs.
-    g_all_hosts.Get().Remove(GetID());
+    UnregisterHost(GetID());
   }
 }
 
 void RenderProcessHostImpl::AddPendingView() {
   pending_views_++;
 }
 
 void RenderProcessHostImpl::RemovePendingView() {
   DCHECK(pending_views_);
   pending_views_--;
@@ skipping 39 matching lines @@
   return fast_shutdown_started_;
 }
 
 // static
 void RenderProcessHostImpl::RegisterHost(int host_id, RenderProcessHost* host) {
   g_all_hosts.Get().AddWithID(host, host_id);
 }
 
 // static
 void RenderProcessHostImpl::UnregisterHost(int host_id) {
-  if (g_all_hosts.Get().Lookup(host_id))
-    g_all_hosts.Get().Remove(host_id);
+  RenderProcessHost* host = g_all_hosts.Get().Lookup(host_id);
+  if (!host)
+    return;
+
+  g_all_hosts.Get().Remove(host_id);
+
+  // Look up the map of site to process for the given browser_context,
+  // in case we need to remove this process from it.  It will be registered
+  // under any sites it rendered that use process-per-site mode.
+  SiteProcessMap* map =
+      GetSiteProcessMapForBrowserContext(host->GetBrowserContext());
+  map->RemoveProcess(host);
 }
 
 // static
 bool RenderProcessHostImpl::IsSuitableHost(
     RenderProcessHost* host,
     BrowserContext* browser_context,
     const GURL& site_url) {
   if (run_renderer_in_process())
     return true;
 
@@ skipping 82 matching lines @@
   // Now pick a random suitable renderer, if we have any.
   if (!suitable_renderers.empty()) {
     int suitable_count = static_cast<int>(suitable_renderers.size());
     int random_index = base::RandInt(0, suitable_count - 1);
     return suitable_renderers[random_index];
   }
 
   return NULL;
 }
 
+// static
+bool RenderProcessHostImpl::ShouldUseProcessPerSite(
+    BrowserContext* browser_context,
+    const GURL& url) {
+  // Returns true if we should use the process-per-site model.  This will be
+  // the case if the --process-per-site switch is specified, or in
+  // process-per-site-instance for particular sites (e.g., WebUI).
+
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(switches::kProcessPerSite))
+    return true;
+
+  // We want to consolidate particular sites like WebUI when we are using
+  // process-per-tab or process-per-site-instance models.
+  // Note that --single-process is handled in ShouldTryToUseExistingProcessHost.
+
+  if (content::GetContentClient()->browser()->
+          ShouldUseProcessPerSite(browser_context, url)) {
+    return true;
+  }
+
+  // DevTools pages have WebUI type but should not reuse the same host.
+  WebUIControllerFactory* factory =
+      content::GetContentClient()->browser()->GetWebUIControllerFactory();
+  if (factory &&
+      factory->UseWebUIForURL(browser_context, url) &&
+      !url.SchemeIs(chrome::kChromeDevToolsScheme)) {
+    return true;
+  }
+
+  // In all other cases, don't use process-per-site logic.
+  return false;
+}
+
+// static
+RenderProcessHost* RenderProcessHostImpl::GetProcessHostForSite(
+    BrowserContext* browser_context,
+    const GURL& url) {
+  // Look up the map of site to process for the given browser_context.
+  SiteProcessMap* map =
+      GetSiteProcessMapForBrowserContext(browser_context);
+
+  // See if we have an existing process for this site.  If not, the caller
+  // should create a new process and register it.
+  std::string site = SiteInstanceImpl::GetSiteForURL(browser_context, url)
+      .possibly_invalid_spec();
+  return map->FindProcess(site);
+}
+
+void RenderProcessHostImpl::RegisterProcessHostForSite(
+    BrowserContext* browser_context,
+    RenderProcessHost* process,
+    const GURL& url) {
+  // Look up the map of site to process for the given browser_context.
+  SiteProcessMap* map =
+      GetSiteProcessMapForBrowserContext(browser_context);
+
+  // TODO(creis): Determine if it's better to allow registration of
+  // empty sites or not.  For now, group anything from which we can't parse
+  // a site into the same process, when using --process-per-site.
+  std::string site = SiteInstanceImpl::GetSiteForURL(browser_context, url)
+      .possibly_invalid_spec();
+  map->RegisterProcess(site, process);
+}
+
 void RenderProcessHostImpl::ProcessDied(base::ProcessHandle handle,
-                                           base::TerminationStatus status,
-                                           int exit_code,
-                                           bool was_alive) {
+                                        base::TerminationStatus status,
+                                        int exit_code,
+                                        bool was_alive) {
   // Our child process has died.  If we didn't expect it, it's a crash.
   // In any case, we need to let everyone know it's gone.
   // The OnChannelError notification can fire multiple times due to nested sync
   // calls to a renderer. If we don't have a valid channel here it means we
   // already handled the error.
 
   RendererClosedDetails details(handle, status, exit_code, was_alive);
   NotificationService::current()->Notify(
       NOTIFICATION_RENDERER_PROCESS_CLOSED,
       Source<RenderProcessHost>(this),
@@ skipping 139 matching lines @@
       uint64 surface_handle,
       int32 route_id,
       int32 gpu_process_host_id) {
   TRACE_EVENT0("renderer_host",
                "RenderWidgetHostImpl::OnCompositorSurfaceBuffersSwappedNoHost");
   RenderWidgetHostImpl::AcknowledgeSwapBuffers(route_id,
                                                gpu_process_host_id);
 }
 
 }  // namespace content