Get rid of the ProfileId. It was added for ceee. I reverted the original change, since it led to ...

chrome/browser/extensions/extension_function_dispatcher.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 "chrome/browser/extensions/extension_function_dispatcher.h"
 
 #include <map>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
@@ skipping 409 matching lines @@
   return FactoryRegistry::GetInstance()->OverrideFunction(name, factory);
 }
 
 void ExtensionFunctionDispatcher::ResetFunctions() {
   FactoryRegistry::GetInstance()->ResetFunctions();
 }
 
 // static
 void ExtensionFunctionDispatcher::DispatchOnIOThread(
     const ExtensionInfoMap* extension_info_map,
-    ProfileId profile_id,
+    void* profile,
     int render_process_id,
     base::WeakPtr<ChromeRenderMessageFilter> ipc_sender,
     int routing_id,
     const ExtensionHostMsg_Request_Params& params) {
   const Extension* extension =
       extension_info_map->extensions().GetByURL(params.source_url);
 
   scoped_refptr<ExtensionFunction> function(
-      CreateExtensionFunction(params, extension, profile_id, render_process_id,
+      CreateExtensionFunction(params, extension, profile, render_process_id,
                               ipc_sender, routing_id));
   if (!function)
     return;
 
   IOThreadExtensionFunction* function_io =
       function->AsIOThreadExtensionFunction();
   if (!function_io) {
     NOTREACHED();
     return;
   }
@@ skipping 53 matching lines @@
     return;
   }
 
   // TODO(aa): When we allow content scripts to call extension APIs, we will
   // have to pass the extension ID explicitly here, not use the source URL.
   const Extension* extension = service->GetExtensionByURL(params.source_url);
   if (!extension)
     extension = service->GetExtensionByWebExtent(params.source_url);
 
   scoped_refptr<ExtensionFunction> function(CreateExtensionFunction(
-      params, extension, profile_->GetRuntimeId(),
+      params, extension, profile_,
       render_view_host->process()->id(),
       render_view_host, render_view_host->routing_id()));
   if (!function)
     return;
 
   UIThreadExtensionFunction* function_ui =
       function->AsUIThreadExtensionFunction();
   if (!function_ui) {
     NOTREACHED();
     return;
@@ skipping 14 matching lines @@
     render_view_host->Send(new ExtensionMsg_Response(
         render_view_host->routing_id(), function->request_id(), false,
         std::string(), QuotaLimitHeuristic::kGenericOverQuotaError));
   }
 }
 
 // static
 ExtensionFunction* ExtensionFunctionDispatcher::CreateExtensionFunction(
     const ExtensionHostMsg_Request_Params& params,
     const Extension* extension,
-    ProfileId profile_id,
+    void* profile,
     int render_process_id,
     IPC::Message::Sender* ipc_sender,
     int routing_id) {
   // TODO(aa): It would be cool to use ExtensionProcessManager to track which
   // processes are extension processes rather than ChildProcessSecurityPolicy.
   // EPM has richer information: it not only knows which processes contain
   // at least one extension, but it knows which extensions are inside and what
   // permissions the have. So we would be able to enforce permissions more
   // granularly.
   if (!ChildProcessSecurityPolicy::GetInstance()->HasExtensionBindings(
@@ skipping 20 matching lines @@
   }
 
   ExtensionFunction* function =
       FactoryRegistry::GetInstance()->NewFunction(params.name);
   function->SetArgs(&params.arguments);
   function->set_source_url(params.source_url);
   function->set_request_id(params.request_id);
   function->set_has_callback(params.has_callback);
   function->set_user_gesture(params.user_gesture);
   function->set_extension(extension);
-  function->set_profile_id(profile_id);
+  function->set_profile(profile);
   return function;
 }
 
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     IPC::Message::Sender* ipc_sender, int routing_id, int request_id) {
   ipc_sender->Send(new ExtensionMsg_Response(
       routing_id, request_id, false, std::string(),
       "Access to extension API denied."));
 }