Removal of Profile from content part 1.

content/browser/renderer_host/browser_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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/browser_render_process_host.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #if defined(OS_POSIX)
 #include <utility>  // for pair<>
 #endif
 
 #include "base/callback.h"
 #include "base/command_line.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/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
-#include "chrome/browser/profiles/profile.h"
 #include "content/browser/appcache/appcache_dispatcher_host.h"
 #include "content/browser/browser_child_process_host.h"
+#include "content/browser/browser_context.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/content_browser_client.h"
 #include "content/browser/device_orientation/message_filter.h"
 #include "content/browser/download/mhtml_generation_manager.h"
 #include "content/browser/file_system/file_system_dispatcher_host.h"
 #include "content/browser/geolocation/geolocation_dispatcher_host.h"
 #include "content/browser/gpu/gpu_data_manager.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/in_process_webkit/dom_storage_message_filter.h"
 #include "content/browser/in_process_webkit/indexed_db_dispatcher_host.h"
@@ skipping 102 matching lines @@
   RenderProcess* render_process_;
 };
 
 namespace {
 
 // Helper class that we pass to ResourceMessageFilter so that it can find the
 // right net::URLRequestContext for a request.
 class RendererURLRequestContextSelector
     : public ResourceMessageFilter::URLRequestContextSelector {
  public:
-  RendererURLRequestContextSelector(Profile* profile,
+  RendererURLRequestContextSelector(content::BrowserContext* context,
                                     int render_child_id)
-      : request_context_(profile->GetRequestContextForRenderProcess(
+      : request_context_(context->GetRequestContextForRenderProcess(
                              render_child_id)),
-        media_request_context_(profile->GetRequestContextForMedia()) {
+        media_request_context_(context->GetRequestContextForMedia()) {
   }
 
   virtual net::URLRequestContext* GetRequestContext(
       ResourceType::Type resource_type) {
     net::URLRequestContextGetter* request_context = request_context_;
     // If the request has resource type of ResourceType::MEDIA, we use a request
     // context specific to media for handling it because these resources have
     // specific needs for caching.
     if (resource_type == ResourceType::MEDIA)
       request_context = media_request_context_;
     return request_context->GetURLRequestContext();
   }
 
  private:
   virtual ~RendererURLRequestContextSelector() {}
 
   scoped_refptr<net::URLRequestContextGetter> request_context_;
   scoped_refptr<net::URLRequestContextGetter> media_request_context_;
 };
 
 }  // namespace
 
-BrowserRenderProcessHost::BrowserRenderProcessHost(Profile* profile)
-    : RenderProcessHost(profile),
-      visible_widgets_(0),
-      backgrounded_(true),
-      ALLOW_THIS_IN_INITIALIZER_LIST(cached_dibs_cleaner_(
-            base::TimeDelta::FromSeconds(5),
-            this, &BrowserRenderProcessHost::ClearTransportDIBCache)),
-      accessibility_enabled_(false),
-      is_initialized_(false) {
+BrowserRenderProcessHost::BrowserRenderProcessHost(
+    content::BrowserContext* context)
+        : RenderProcessHost(context),
+          visible_widgets_(0),
+          backgrounded_(true),
+          ALLOW_THIS_IN_INITIALIZER_LIST(cached_dibs_cleaner_(
+                base::TimeDelta::FromSeconds(5),
+                this, &BrowserRenderProcessHost::ClearTransportDIBCache)),
+          accessibility_enabled_(false),
+          is_initialized_(false) {
   widget_helper_ = new RenderWidgetHelper();
 
   ChildProcessSecurityPolicy::GetInstance()->Add(id());
 
   // Grant most file permissions to this renderer.
   // PLATFORM_FILE_TEMPORARY, PLATFORM_FILE_HIDDEN and
   // PLATFORM_FILE_DELETE_ON_CLOSE are not granted, because no existing API
   // requests them.
   // This is for the filesystem sandbox.
   ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-      id(), profile->GetPath().Append(
+      id(), context->GetPath().Append(
           fileapi::SandboxMountPointProvider::kNewFileSystemDirectory),
       base::PLATFORM_FILE_OPEN |
       base::PLATFORM_FILE_CREATE |
       base::PLATFORM_FILE_OPEN_ALWAYS |
       base::PLATFORM_FILE_CREATE_ALWAYS |
       base::PLATFORM_FILE_OPEN_TRUNCATED |
       base::PLATFORM_FILE_READ |
       base::PLATFORM_FILE_WRITE |
       base::PLATFORM_FILE_EXCLUSIVE_READ |
       base::PLATFORM_FILE_EXCLUSIVE_WRITE |
       base::PLATFORM_FILE_ASYNC |
       base::PLATFORM_FILE_WRITE_ATTRIBUTES |
       base::PLATFORM_FILE_ENUMERATE);
   // This is so that we can read and move stuff out of the old filesystem
   // sandbox.
   ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-      id(), profile->GetPath().Append(
+      id(), context->GetPath().Append(
           fileapi::SandboxMountPointProvider::kOldFileSystemDirectory),
       base::PLATFORM_FILE_READ | base::PLATFORM_FILE_WRITE |
       base::PLATFORM_FILE_WRITE_ATTRIBUTES | base::PLATFORM_FILE_ENUMERATE);
   // This is so that we can rename the old sandbox out of the way so that we
   // know we've taken care of it.
   ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-      id(), profile->GetPath().Append(
+      id(), context->GetPath().Append(
           fileapi::SandboxMountPointProvider::kRenamedOldFileSystemDirectory),
       base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_CREATE_ALWAYS |
       base::PLATFORM_FILE_WRITE);
 
   // Note: When we create the BrowserRenderProcessHost, it's technically
   //       backgrounded, because it has no visible listeners.  But the process
   //       doesn't actually exist yet, so we'll Background it later, after
   //       creation.
 }
 
@@ skipping 101 matching lines @@
 
   is_initialized_ = true;
   return true;
 }
 
 void BrowserRenderProcessHost::CreateMessageFilters() {
   scoped_refptr<RenderMessageFilter> render_message_filter(
       new RenderMessageFilter(
           id(),
           PluginService::GetInstance(),
-          profile(),
-          profile()->GetRequestContextForRenderProcess(id()),
+          context(),
+          context()->GetRequestContextForRenderProcess(id()),
           widget_helper_));
   channel_->AddFilter(render_message_filter);
 
   ResourceMessageFilter* resource_message_filter = new ResourceMessageFilter(
       id(), ChildProcessInfo::RENDER_PROCESS,
-      &profile()->GetResourceContext(),
-      new RendererURLRequestContextSelector(profile(), id()),
+      &context()->GetResourceContext(),
+      new RendererURLRequestContextSelector(context(), id()),
       content::GetContentClient()->browser()->GetResourceDispatcherHost());
 
   channel_->AddFilter(resource_message_filter);
   channel_->AddFilter(new AudioInputRendererHost());
-  channel_->AddFilter(new AudioRendererHost(&profile()->GetResourceContext()));
+  channel_->AddFilter(new AudioRendererHost(&context()->GetResourceContext()));
   channel_->AddFilter(new VideoCaptureHost());
   channel_->AddFilter(
-      new AppCacheDispatcherHost(&profile()->GetResourceContext(), id()));
+      new AppCacheDispatcherHost(&context()->GetResourceContext(), id()));
   channel_->AddFilter(new ClipboardMessageFilter());
   channel_->AddFilter(
-      new DOMStorageMessageFilter(id(), profile()->GetWebKitContext()));
+      new DOMStorageMessageFilter(id(), context()->GetWebKitContext()));
   channel_->AddFilter(
-      new IndexedDBDispatcherHost(id(), profile()->GetWebKitContext()));
+      new IndexedDBDispatcherHost(id(), context()->GetWebKitContext()));
   channel_->AddFilter(
       GeolocationDispatcherHost::New(
-          id(), profile()->GetGeolocationPermissionContext()));
+          id(), context()->GetGeolocationPermissionContext()));
   channel_->AddFilter(new GpuMessageFilter(id(), widget_helper_.get()));
   channel_->AddFilter(new media_stream::MediaStreamDispatcherHost(id()));
-  channel_->AddFilter(new PepperFileMessageFilter(id(), profile()));
+  channel_->AddFilter(new PepperFileMessageFilter(id(), context()));
   channel_->AddFilter(
-      new PepperMessageFilter(&profile()->GetResourceContext()));
+      new PepperMessageFilter(&context()->GetResourceContext()));
   channel_->AddFilter(new speech_input::SpeechInputDispatcherHost(id()));
   channel_->AddFilter(
-      new FileSystemDispatcherHost(&profile()->GetResourceContext()));
+      new FileSystemDispatcherHost(&context()->GetResourceContext()));
   channel_->AddFilter(new device_orientation::MessageFilter());
   channel_->AddFilter(
-      new BlobMessageFilter(id(), profile()->GetBlobStorageContext()));
+      new BlobMessageFilter(id(), context()->GetBlobStorageContext()));
   channel_->AddFilter(new FileUtilitiesMessageFilter(id()));
   channel_->AddFilter(new MimeRegistryMessageFilter());
   channel_->AddFilter(new DatabaseMessageFilter(
-      profile()->GetDatabaseTracker()));
+      context()->GetDatabaseTracker()));
 
   SocketStreamDispatcherHost* socket_stream_dispatcher_host =
       new SocketStreamDispatcherHost(
-          new RendererURLRequestContextSelector(profile(), id()),
-          &profile()->GetResourceContext());
+          new RendererURLRequestContextSelector(context(), id()),
+          &context()->GetResourceContext());
   channel_->AddFilter(socket_stream_dispatcher_host);
 
   channel_->AddFilter(
       new WorkerMessageFilter(
           id(),
-          &profile()->GetResourceContext(),
+          &context()->GetResourceContext(),
           content::GetContentClient()->browser()->GetResourceDispatcherHost(),
           NewCallbackWithReturnValue(
               widget_helper_.get(), &RenderWidgetHelper::GetNextRoutingID)));
 
 #if defined(ENABLE_P2P_APIS)
   channel_->AddFilter(new P2PSocketDispatcherHost());
 #endif
 
   channel_->AddFilter(new TraceMessageFilter());
   channel_->AddFilter(new ResolveProxyMsgHelper(NULL));
   channel_->AddFilter(new QuotaDispatcherHost(
-      id(), profile()->GetQuotaManager(),
+      id(), context()->GetQuotaManager(),
       content::GetContentClient()->browser()->CreateQuotaPermissionContext()));
 }
 
 int BrowserRenderProcessHost::GetNextRoutingID() {
   return widget_helper_->GetNextRoutingID();
 }
 
 void BrowserRenderProcessHost::CancelResourceRequests(int render_widget_id) {
   widget_helper_->CancelResourceRequests(render_widget_id);
 }
@@ skipping 172 matching lines @@
     switches::kUserAgent,
     switches::kV,
     switches::kVideoThreads,
     switches::kVModule,
     switches::kWebCoreLogChannels,
   };
   renderer_cmd->CopySwitchesFrom(browser_cmd, kSwitchNames,
                                  arraysize(kSwitchNames));
 
   // Disable databases in incognito mode.
-  if (profile()->IsOffTheRecord() &&
+  if (context()->IsOffTheRecord() &&
       !browser_cmd.HasSwitch(switches::kDisableDatabases)) {
     renderer_cmd->AppendSwitch(switches::kDisableDatabases);
   }
 }
 
 base::ProcessHandle BrowserRenderProcessHost::GetHandle() {
   // child_process_launcher_ is null either because we're in single process
   // mode, we have done fast termination, or the process has crashed.
   if (run_renderer_in_process() || !child_process_launcher_.get())
     return base::Process::Current().handle();
@@ skipping 109 matching lines @@
 
   if (child_process_launcher_.get() && child_process_launcher_->IsStarting()) {
     queued_messages_.push(msg);
     return true;
   }
 
   return channel_->Send(msg);
 }
 
 bool BrowserRenderProcessHost::OnMessageReceived(const IPC::Message& msg) {
-  // If we're about to be deleted, we can no longer trust that our profile is
+  // If we're about to be deleted, we can no longer trust that our context is
   // valid, so we ignore incoming messages.
   if (deleting_soon_)
     return false;
 
   mark_child_process_activity_time();
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     // Dispatch control messages.
     bool msg_is_ok = true;
     IPC_BEGIN_MESSAGE_MAP_EX(BrowserRenderProcessHost, msg, msg_is_ok)
       IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ShutdownRequest,
@@ skipping 174 matching lines @@
 void BrowserRenderProcessHost::OnRevealFolderInOS(const FilePath& path) {
   // Only honor the request if appropriate persmissions are granted.
   if (ChildProcessSecurityPolicy::GetInstance()->CanReadFile(id(), path))
     content::GetContentClient()->browser()->RevealFolderInOS(path);
 }
 
 void BrowserRenderProcessHost::OnSavedPageAsMHTML(int job_id, bool success) {
   content::GetContentClient()->browser()->GetMHTMLGenerationManager()->
       MHTMLGenerated(job_id, success);
 }