Removal of Profile from content part 1.

content/browser/renderer_host/render_process_host.cc

 // Copyright (c) 2011 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/renderer_host/render_process_host.h"
 
 #include "base/rand_util.h"
 #include "base/sys_info.h"
+#include "chrome/browser/profiles/profile.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/common/child_process_info.h"
 #include "content/common/content_constants.h"
 #include "content/common/notification_service.h"
 
 namespace {
 
 size_t max_renderer_count_override = 0;
 
@@ skipping 33 matching lines @@
     size_t memory_tier = base::SysInfo::AmountOfPhysicalMemoryMB() / 256;
     if (memory_tier >= arraysize(kMaxRenderersByRamTier))
       max_count = content::kMaxRendererProcessCount;
     else
       max_count = kMaxRenderersByRamTier[memory_tier];
   }
   return max_count;
 }
 
 // Returns true if the given host is suitable for launching a new view
-// associated with the given profile.
-static bool IsSuitableHost(RenderProcessHost* host, Profile* profile,
+// associated with the given browser context.
+static bool IsSuitableHost(RenderProcessHost* host,
+                           content::BrowserContext* browser_context,
                            RenderProcessHost::Type type) {
-  if (host->profile() != profile)
+  if (host->browser_context() != browser_context)
     return false;
 
   RenderProcessHost::Type host_type = RenderProcessHost::TYPE_NORMAL;
   if (ChildProcessSecurityPolicy::GetInstance()->HasWebUIBindings(host->id()))
     host_type = RenderProcessHost::TYPE_WEBUI;
   if (ChildProcessSecurityPolicy::GetInstance()->
         HasExtensionBindings(host->id()))
     host_type = RenderProcessHost::TYPE_EXTENSION;
 
   return host_type == type;
 }
 
 // the global list of all renderer processes
 IDMap<RenderProcessHost> all_hosts;
 
 }  // namespace
 
 extern bool g_log_bug53991;
 
 // static
 bool RenderProcessHost::run_renderer_in_process_ = false;
 
 // static
 void RenderProcessHost::SetMaxRendererProcessCount(size_t count) {
   max_renderer_count_override = count;
 }
 
-RenderProcessHost::RenderProcessHost(Profile* profile)
+RenderProcessHost::RenderProcessHost(content::BrowserContext* browser_context)
     : max_page_id_(-1),
       fast_shutdown_started_(false),
       deleting_soon_(false),
       is_extension_process_(false),
       pending_views_(0),
       id_(ChildProcessInfo::GenerateChildProcessUniqueId()),
-      profile_(profile),
+      browser_context_(browser_context),
       sudden_termination_allowed_(true),
       ignore_input_events_(false) {
   all_hosts.AddWithID(this, id());
   all_hosts.set_check_on_null_data(true);
   // Initialize |child_process_activity_time_| to a reasonable value.
   mark_child_process_activity_time();
 }
 
 RenderProcessHost::~RenderProcessHost() {
   // In unit tests, Release() might not have been called.
@@ skipping 65 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return all_hosts.Lookup(render_process_id);
 }
 
 // static
 bool RenderProcessHost::ShouldTryToUseExistingProcessHost() {
   size_t renderer_process_count = all_hosts.size();
 
   // NOTE: Sometimes it's necessary to create more render processes than
   //       GetMaxRendererProcessCount(), for instance when we want to create
-  //       a renderer process for a profile that has no existing renderers.
-  //       This is OK in moderation, since the GetMaxRendererProcessCount()
-  //       is conservative.
+  //       a renderer process for a browser context that has no existing
+  //       renderers. This is OK in moderation, since the
+  //       GetMaxRendererProcessCount() is conservative.
 
   return run_renderer_in_process() ||
          (renderer_process_count >= GetMaxRendererProcessCount());
 }
 
 // static
-RenderProcessHost* RenderProcessHost::GetExistingProcessHost(Profile* profile,
-                                                             Type type) {
+RenderProcessHost* RenderProcessHost::GetExistingProcessHost(
+    content::BrowserContext* browser_context, Type type) {
   // First figure out which existing renderers we can use.
   std::vector<RenderProcessHost*> suitable_renderers;
   suitable_renderers.reserve(all_hosts.size());
 
   iterator iter(AllHostsIterator());
   while (!iter.IsAtEnd()) {
     if (run_renderer_in_process() ||
-        IsSuitableHost(iter.GetCurrentValue(), profile, type))
+        IsSuitableHost(iter.GetCurrentValue(), browser_context, type))
       suitable_renderers.push_back(iter.GetCurrentValue());
 
     iter.Advance();
   }
 
   // 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;
 }