Move ProfileKeyedAPI implementations to take BrowserContext in the constructor (part 2).

chrome/browser/extensions/api/messaging/message_service.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 "chrome/browser/extensions/api/messaging/message_service.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
@@ skipping 15 matching lines @@
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/manifest_handlers/externally_connectable.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
 #include "net/base/completion_callback.h"
 #include "url/gurl.h"
 
+using content::BrowserContext;
 using content::SiteInstance;
 using content::WebContents;
 
 // Since we have 2 ports for every channel, we just index channels by half the
 // port ID.
 #define GET_CHANNEL_ID(port_id) ((port_id) / 2)
 #define GET_CHANNEL_OPENER_ID(channel_id) ((channel_id) * 2)
 #define GET_CHANNEL_RECEIVERS_ID(channel_id) ((channel_id) * 2 + 1)
 
 // Port1 is always even, port2 is always odd.
@@ skipping 56 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(OpenChannelParams);
 };
 
 namespace {
 
 static base::StaticAtomicSequenceNumber g_next_channel_id;
 static base::StaticAtomicSequenceNumber g_channel_id_overflow_count;
 
 static content::RenderProcessHost* GetExtensionProcess(
-    Profile* profile, const std::string& extension_id) {
+    BrowserContext* context,
+    const std::string& extension_id) {
   SiteInstance* site_instance =
-      ExtensionSystem::Get(profile)->process_manager()->GetSiteInstanceForURL(
+      ExtensionSystem::Get(context)->process_manager()->GetSiteInstanceForURL(
           Extension::GetBaseURLFromExtensionId(extension_id));
   return site_instance->HasProcess() ? site_instance->GetProcess() : NULL;
 }
 
 }  // namespace
 
 content::RenderProcessHost*
     MessageService::MessagePort::GetRenderProcessHost() {
   return NULL;
 }
@@ skipping 18 matching lines @@
   DCHECK_EQ(GET_OPPOSITE_PORT_ID(port2_id), port1_id);
   DCHECK_EQ(GET_CHANNEL_ID(port1_id), GET_CHANNEL_ID(port2_id));
   DCHECK_EQ(GET_CHANNEL_ID(port1_id), channel_id);
   DCHECK_EQ(GET_CHANNEL_OPENER_ID(channel_id), port1_id);
   DCHECK_EQ(GET_CHANNEL_RECEIVERS_ID(channel_id), port2_id);
 
   *port1 = port1_id;
   *port2 = port2_id;
 }
 
-MessageService::MessageService(Profile* profile)
+MessageService::MessageService(BrowserContext* context)
     : lazy_background_task_queue_(
-          ExtensionSystem::Get(profile)->lazy_background_task_queue()),
+          ExtensionSystem::Get(context)->lazy_background_task_queue()),
       weak_factory_(this) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 MessageService::~MessageService() {
   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
   channels_.clear();
 }
 
 static base::LazyInstance<ProfileKeyedAPIFactory<MessageService> >
 g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 ProfileKeyedAPIFactory<MessageService>* MessageService::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
-MessageService* MessageService::Get(content::BrowserContext* context) {
-  Profile* profile = Profile::FromBrowserContext(context);
-  return ProfileKeyedAPIFactory<MessageService>::GetForProfile(profile);
+MessageService* MessageService::Get(BrowserContext* context) {
+  return ProfileKeyedAPIFactory<MessageService>::GetForProfile(context);
 }
 
 void MessageService::OpenChannelToExtension(
     int source_process_id, int source_routing_id, int receiver_port_id,
     const std::string& source_extension_id,
     const std::string& target_extension_id,
     const GURL& source_url,
     const std::string& channel_name,
     bool include_tls_channel_id) {
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
   if (!source)
     return;
-  Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
+  BrowserContext* context = source->GetBrowserContext();
 
-  ExtensionSystem* extension_system = ExtensionSystem::Get(profile);
+  ExtensionSystem* extension_system = ExtensionSystem::Get(context);
   DCHECK(extension_system);
   const Extension* target_extension = extension_system->extension_service()->
       extensions()->GetByID(target_extension_id);
   if (!target_extension) {
     DispatchOnDisconnect(
         source, receiver_port_id, kReceivingEndDoesntExistError);
     return;
   }
 
   // Only running ephemeral apps can receive messages. Idle cached ephemeral
   // apps are invisible and should not be connectable.
   if (target_extension->is_ephemeral() &&
-      util::IsExtensionIdle(target_extension_id, profile)) {
+      util::IsExtensionIdle(target_extension_id, context)) {
     DispatchOnDisconnect(
         source, receiver_port_id, kReceivingEndDoesntExistError);
     return;
   }
 
   bool is_web_connection = false;
 
   if (source_extension_id != target_extension_id) {
     // It's an external connection. Check the externally_connectable manifest
     // key if it's present. If it's not, we allow connection from any extension
@@ skipping 32 matching lines @@
       // indistinguishable from the extension just not existing.
       DispatchOnDisconnect(
           source, receiver_port_id, kReceivingEndDoesntExistError);
       return;
     }
   }
 
   WebContents* source_contents = tab_util::GetWebContentsByID(
       source_process_id, source_routing_id);
 
-  if (profile->IsOffTheRecord() &&
-      !util::IsIncognitoEnabled(target_extension_id, profile)) {
+  if (context->IsOffTheRecord() &&
+      !util::IsIncognitoEnabled(target_extension_id, context)) {
     // Give the user a chance to accept an incognito connection if they haven't
     // already - but only for spanning-mode incognito. We don't want the
     // complication of spinning up an additional process here which might need
     // to do some setup that we're not expecting.
-    if (!is_web_connection ||
-        IncognitoInfo::IsSplitMode(target_extension) ||
-        !IncognitoConnectability::Get(profile)->Query(target_extension,
-                                                      source_contents,
-                                                      source_url)) {
+    if (!is_web_connection || IncognitoInfo::IsSplitMode(target_extension) ||
+        !IncognitoConnectability::Get(context)
+             ->Query(target_extension, source_contents, source_url)) {
       DispatchOnDisconnect(
           source, receiver_port_id, kReceivingEndDoesntExistError);
       return;
     }
   }
 
   // Note: we use the source's profile here. If the source is an incognito
   // process, we will use the incognito EPM to find the right extension process,
   // which depends on whether the extension uses spanning or split mode.
   MessagePort* receiver = new ExtensionMessagePort(
-      GetExtensionProcess(profile, target_extension_id), MSG_ROUTING_CONTROL,
+      GetExtensionProcess(context, target_extension_id),
+      MSG_ROUTING_CONTROL,
       target_extension_id);
 
   // Include info about the opener's tab (if it was a tab).
   scoped_ptr<base::DictionaryValue> source_tab;
   GURL source_url_for_tab;
 
   if (source_contents && ExtensionTabUtil::GetTabId(source_contents) >= 0) {
     // Only the tab id is useful to platform apps for internal use. The
     // unnecessary bits will be stripped out in
     // MessagingBindings::DispatchOnConnect().
@@ skipping 12 matching lines @@
                                                     include_tls_channel_id);
 
   // If the target requests the TLS channel id, begin the lookup for it.
   // The target might also be a lazy background page, checked next, but the
   // loading of lazy background pages continues asynchronously, so enqueue
   // messages awaiting TLS channel ID first.
   if (include_tls_channel_id) {
     pending_tls_channel_id_channels_[GET_CHANNEL_ID(params->receiver_port_id)]
         = PendingMessagesQueue();
     property_provider_.GetDomainBoundCert(
-        profile,
+        Profile::FromBrowserContext(context),
         source_url,
         base::Bind(&MessageService::GotDomainBoundCert,
                    weak_factory_.GetWeakPtr(),
                    base::Passed(make_scoped_ptr(params))));
     return;
   }
 
   // The target might be a lazy background page. In that case, we have to check
   // if it is loaded and ready, and if not, queue up the task and load the
   // page.
-  if (MaybeAddPendingLazyBackgroundPageOpenChannelTask(profile,
-                                                       target_extension,
-                                                       params)) {
+  if (MaybeAddPendingLazyBackgroundPageOpenChannelTask(
+          context, target_extension, params)) {
     return;
   }
 
   OpenChannelImpl(make_scoped_ptr(params));
 }
 
 void MessageService::OpenChannelToNativeApp(
     int source_process_id,
     int source_routing_id,
     int receiver_port_id,
@@ skipping 299 matching lines @@
                                      const Message& message) {
   // Figure out which port the ID corresponds to.
   int dest_port_id = GET_OPPOSITE_PORT_ID(source_port_id);
   MessagePort* port = IS_OPENER_PORT_ID(dest_port_id) ?
       channel->opener.get() : channel->receiver.get();
 
   port->DispatchOnMessage(message, dest_port_id);
 }
 
 bool MessageService::MaybeAddPendingLazyBackgroundPageOpenChannelTask(
-    Profile* profile,
+    BrowserContext* context,
     const Extension* extension,
     OpenChannelParams* params) {
   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
     return false;
 
   // If the extension uses spanning incognito mode, make sure we're always
   // using the original profile since that is what the extension process
   // will use.
   if (!IncognitoInfo::IsSplitMode(extension))
-    profile = profile->GetOriginalProfile();
+    context = ExtensionsBrowserClient::Get()->GetOriginalContext(context);
 
-  if (!lazy_background_task_queue_->ShouldEnqueueTask(profile, extension))
+  if (!lazy_background_task_queue_->ShouldEnqueueTask(context, extension))
     return false;
 
-  pending_lazy_background_page_channels_[
-      GET_CHANNEL_ID(params->receiver_port_id)] =
-      PendingLazyBackgroundPageChannel(profile, extension->id());
+  pending_lazy_background_page_channels_
+      [GET_CHANNEL_ID(params->receiver_port_id)] =
+          PendingLazyBackgroundPageChannel(context, extension->id());
   scoped_ptr<OpenChannelParams> scoped_params(params);
-  lazy_background_task_queue_->AddPendingTask(profile, extension->id(),
+  lazy_background_task_queue_->AddPendingTask(
+      context,
+      extension->id(),
       base::Bind(&MessageService::PendingLazyBackgroundPageOpenChannel,
-                 weak_factory_.GetWeakPtr(), base::Passed(&scoped_params),
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(&scoped_params),
                  params->source->GetID()));
   return true;
 }
 
 void MessageService::GotDomainBoundCert(scoped_ptr<OpenChannelParams> params,
                                         const std::string& tls_channel_id) {
   params->tls_channel_id.assign(tls_channel_id);
   int channel_id = GET_CHANNEL_ID(params->receiver_port_id);
 
   PendingTlsChannelIdMap::iterator pending_for_tls_channel_id =
       pending_tls_channel_id_channels_.find(channel_id);
   if (pending_for_tls_channel_id == pending_tls_channel_id_channels_.end()) {
     NOTREACHED();
     return;
   }
 
-  Profile* profile = Profile::FromBrowserContext(
-      params->source->GetBrowserContext());
+  BrowserContext* context = params->source->GetBrowserContext();
 
-  const Extension* target_extension = ExtensionSystem::Get(profile)->
-      extension_service()->extensions()->GetByID(params->target_extension_id);
+  const Extension* target_extension =
+      ExtensionSystem::Get(context)->extension_service()->extensions()->GetByID(
+          params->target_extension_id);
   if (!target_extension) {
     pending_tls_channel_id_channels_.erase(channel_id);
     DispatchOnDisconnect(
         params->source, params->receiver_port_id,
         kReceivingEndDoesntExistError);
     return;
   }
   PendingMessagesQueue& pending_messages = pending_for_tls_channel_id->second;
-  if (MaybeAddPendingLazyBackgroundPageOpenChannelTask(profile,
-                                                       target_extension,
-                                                       params.get())) {
+  if (MaybeAddPendingLazyBackgroundPageOpenChannelTask(
+          context, target_extension, params.get())) {
     // Lazy background queue took ownership. Release ours.
     ignore_result(params.release());
     // Messages queued up waiting for the TLS channel ID now need to be queued
     // up for the lazy background page to load.
     for (PendingMessagesQueue::iterator it = pending_messages.begin();
          it != pending_messages.end();
          it++) {
       EnqueuePendingMessageForLazyBackgroundLoad(it->first, channel_id,
                                                  it->second);
     }
@@ skipping 33 matching lines @@
 }
 
 void MessageService::DispatchOnDisconnect(content::RenderProcessHost* source,
                                           int port_id,
                                           const std::string& error_message) {
   ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, "");
   port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(port_id), error_message);
 }
 
 }  // namespace extensions