src/chrome/browser/extensions/api/messaging/message_service.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/messaging/message_service.h"
   6
   7 #include "base/atomic_sequence_num.h"
   8 #include "base/bind.h"
   9 #include "base/callback.h"
  10 #include "base/json/json_writer.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/stl_util.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/chrome_notification_types.h"
  16 #include "chrome/browser/extensions/api/messaging/extension_message_port.h"
  17 #include "chrome/browser/extensions/api/messaging/incognito_connectability.h"
  18 #include "chrome/browser/extensions/api/messaging/native_message_port.h"
  19 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
  20 #include "chrome/browser/extensions/extension_service.h"
  21 #include "chrome/browser/extensions/extension_tab_util.h"
  22 #include "chrome/browser/extensions/extension_util.h"
  23 #include "chrome/browser/profiles/profile.h"
  24 #include "chrome/browser/tab_contents/tab_util.h"
  25 #include "content/public/browser/notification_service.h"
  26 #include "content/public/browser/render_process_host.h"
  27 #include "content/public/browser/render_view_host.h"
  28 #include "content/public/browser/render_widget_host.h"
  29 #include "content/public/browser/render_widget_host_view.h"
  30 #include "content/public/browser/site_instance.h"
  31 #include "content/public/browser/web_contents.h"
  32 #include "extensions/browser/extension_host.h"
  33 #include "extensions/browser/extension_system.h"
  34 #include "extensions/browser/extensions_browser_client.h"
  35 #include "extensions/browser/lazy_background_task_queue.h"
  36 #include "extensions/browser/process_manager.h"
  37 #include "extensions/common/extension.h"
  38 #include "extensions/common/manifest_constants.h"
  39 #include "extensions/common/manifest_handlers/background_info.h"
  40 #include "extensions/common/manifest_handlers/externally_connectable.h"
  41 #include "extensions/common/manifest_handlers/incognito_info.h"
  42 #include "extensions/common/permissions/permissions_data.h"
  43 #include "net/base/completion_callback.h"
  44 #include "url/gurl.h"
  45
  46 using content::BrowserContext;
  47 using content::SiteInstance;
  48 using content::WebContents;
  49
  50 // Since we have 2 ports for every channel, we just index channels by half the
  51 // port ID.
  52 #define GET_CHANNEL_ID(port_id) ((port_id) / 2)
  53 #define GET_CHANNEL_OPENER_ID(channel_id) ((channel_id) * 2)
  54 #define GET_CHANNEL_RECEIVERS_ID(channel_id) ((channel_id) * 2 + 1)
  55
  56 // Port1 is always even, port2 is always odd.
  57 #define IS_OPENER_PORT_ID(port_id) (((port_id) & 1) == 0)
  58
  59 // Change even to odd and vice versa, to get the other side of a given channel.
  60 #define GET_OPPOSITE_PORT_ID(source_port_id) ((source_port_id) ^ 1)
  61
  62 namespace extensions {
  63
  64 const char kReceivingEndDoesntExistError[] =
  65     "Could not establish connection. Receiving end does not exist.";
  66 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
  67 const char kMissingPermissionError[] =
  68     "Access to native messaging requires nativeMessaging permission.";
  69 const char kProhibitedByPoliciesError[] =
  70     "Access to the native messaging host was disabled by the system "
  71     "administrator.";
  72 #endif
  73
  74 struct MessageService::MessageChannel {
  75   scoped_ptr<MessagePort> opener;
  76   scoped_ptr<MessagePort> receiver;
  77 };
  78
  79 struct MessageService::OpenChannelParams {
  80   content::RenderProcessHost* source;
  81   base::DictionaryValue source_tab;
  82   scoped_ptr<MessagePort> receiver;
  83   int receiver_port_id;
  84   std::string source_extension_id;
  85   std::string target_extension_id;
  86   GURL source_url;
  87   std::string channel_name;
  88   bool include_tls_channel_id;
  89   std::string tls_channel_id;
  90
  91   // Takes ownership of receiver.
  92   OpenChannelParams(content::RenderProcessHost* source,
  93                     scoped_ptr<base::DictionaryValue> source_tab,
  94                     MessagePort* receiver,
  95                     int receiver_port_id,
  96                     const std::string& source_extension_id,
  97                     const std::string& target_extension_id,
  98                     const GURL& source_url,
  99                     const std::string& channel_name,
 100                     bool include_tls_channel_id)
 101       : source(source),
 102         receiver(receiver),
 103         receiver_port_id(receiver_port_id),
 104         source_extension_id(source_extension_id),
 105         target_extension_id(target_extension_id),
 106         source_url(source_url),
 107         channel_name(channel_name),
 108         include_tls_channel_id(include_tls_channel_id) {
 109     if (source_tab)
 110       this->source_tab.Swap(source_tab.get());
 111   }
 112
 113  private:
 114   DISALLOW_COPY_AND_ASSIGN(OpenChannelParams);
 115 };
 116
 117 namespace {
 118
 119 static base::StaticAtomicSequenceNumber g_next_channel_id;
 120 static base::StaticAtomicSequenceNumber g_channel_id_overflow_count;
 121
 122 static content::RenderProcessHost* GetExtensionProcess(
 123     BrowserContext* context,
 124     const std::string& extension_id) {
 125   SiteInstance* site_instance =
 126       ExtensionSystem::Get(context)->process_manager()->GetSiteInstanceForURL(
 127           Extension::GetBaseURLFromExtensionId(extension_id));
 128   return site_instance->HasProcess() ? site_instance->GetProcess() : NULL;
 129 }
 130
 131 }  // namespace
 132
 133 content::RenderProcessHost*
 134     MessageService::MessagePort::GetRenderProcessHost() {
 135   return NULL;
 136 }
 137
 138 // static
 139 void MessageService::AllocatePortIdPair(int* port1, int* port2) {
 140   unsigned channel_id =
 141       static_cast<unsigned>(g_next_channel_id.GetNext()) % (kint32max/2);
 142
 143   if (channel_id == 0) {
 144     int overflow_count = g_channel_id_overflow_count.GetNext();
 145     if (overflow_count > 0)
 146       UMA_HISTOGRAM_BOOLEAN("Extensions.AllocatePortIdPairOverflow", true);
 147   }
 148
 149   unsigned port1_id = channel_id * 2;
 150   unsigned port2_id = channel_id * 2 + 1;
 151
 152   // Sanity checks to make sure our channel<->port converters are correct.
 153   DCHECK(IS_OPENER_PORT_ID(port1_id));
 154   DCHECK_EQ(GET_OPPOSITE_PORT_ID(port1_id), port2_id);
 155   DCHECK_EQ(GET_OPPOSITE_PORT_ID(port2_id), port1_id);
 156   DCHECK_EQ(GET_CHANNEL_ID(port1_id), GET_CHANNEL_ID(port2_id));
 157   DCHECK_EQ(GET_CHANNEL_ID(port1_id), channel_id);
 158   DCHECK_EQ(GET_CHANNEL_OPENER_ID(channel_id), port1_id);
 159   DCHECK_EQ(GET_CHANNEL_RECEIVERS_ID(channel_id), port2_id);
 160
 161   *port1 = port1_id;
 162   *port2 = port2_id;
 163 }
 164
 165 MessageService::MessageService(BrowserContext* context)
 166     : lazy_background_task_queue_(
 167           ExtensionSystem::Get(context)->lazy_background_task_queue()),
 168       weak_factory_(this) {
 169   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
 170                  content::NotificationService::AllBrowserContextsAndSources());
 171   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
 172                  content::NotificationService::AllBrowserContextsAndSources());
 173 }
 174
 175 MessageService::~MessageService() {
 176   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
 177   channels_.clear();
 178 }
 179
 180 static base::LazyInstance<BrowserContextKeyedAPIFactory<MessageService> >
 181     g_factory = LAZY_INSTANCE_INITIALIZER;
 182
 183 // static
 184 BrowserContextKeyedAPIFactory<MessageService>*
 185 MessageService::GetFactoryInstance() {
 186   return g_factory.Pointer();
 187 }
 188
 189 // static
 190 MessageService* MessageService::Get(BrowserContext* context) {
 191   return BrowserContextKeyedAPIFactory<MessageService>::Get(context);
 192 }
 193
 194 void MessageService::OpenChannelToExtension(
 195     int source_process_id, int source_routing_id, int receiver_port_id,
 196     const std::string& source_extension_id,
 197     const std::string& target_extension_id,
 198     const GURL& source_url,
 199     const std::string& channel_name,
 200     bool include_tls_channel_id) {
 201   content::RenderProcessHost* source =
 202       content::RenderProcessHost::FromID(source_process_id);
 203   if (!source)
 204     return;
 205   BrowserContext* context = source->GetBrowserContext();
 206
 207   ExtensionSystem* extension_system = ExtensionSystem::Get(context);
 208   DCHECK(extension_system);
 209   const Extension* target_extension = extension_system->extension_service()->
 210       extensions()->GetByID(target_extension_id);
 211   if (!target_extension) {
 212     DispatchOnDisconnect(
 213         source, receiver_port_id, kReceivingEndDoesntExistError);
 214     return;
 215   }
 216
 217   bool is_web_connection = false;
 218
 219   if (source_extension_id != target_extension_id) {
 220     // It's an external connection. Check the externally_connectable manifest
 221     // key if it's present. If it's not, we allow connection from any extension
 222     // but not webpages.
 223     ExternallyConnectableInfo* externally_connectable =
 224         static_cast<ExternallyConnectableInfo*>(
 225             target_extension->GetManifestData(
 226                 manifest_keys::kExternallyConnectable));
 227     bool is_externally_connectable = false;
 228
 229     if (externally_connectable) {
 230       if (source_extension_id.empty()) {
 231         // No source extension ID so the source was a web page. Check that the
 232         // URL matches.
 233         is_web_connection = true;
 234         is_externally_connectable =
 235             externally_connectable->matches.MatchesURL(source_url);
 236         // Only include the TLS channel ID for externally connected web pages.
 237         include_tls_channel_id &=
 238             is_externally_connectable &&
 239             externally_connectable->accepts_tls_channel_id;
 240       } else {
 241         // Source extension ID so the source was an extension. Check that the
 242         // extension matches.
 243         is_externally_connectable =
 244             externally_connectable->IdCanConnect(source_extension_id);
 245       }
 246     } else {
 247       // Default behaviour. Any extension, no webpages.
 248       is_externally_connectable = !source_extension_id.empty();
 249     }
 250
 251     if (!is_externally_connectable) {
 252       // Important: use kReceivingEndDoesntExistError here so that we don't
 253       // leak information about this extension to callers. This way it's
 254       // indistinguishable from the extension just not existing.
 255       DispatchOnDisconnect(
 256           source, receiver_port_id, kReceivingEndDoesntExistError);
 257       return;
 258     }
 259   }
 260
 261   WebContents* source_contents = tab_util::GetWebContentsByID(
 262       source_process_id, source_routing_id);
 263
 264   if (context->IsOffTheRecord() &&
 265       !util::IsIncognitoEnabled(target_extension_id, context)) {
 266     // Give the user a chance to accept an incognito connection from the web if
 267     // they haven't already, with the conditions:
 268     // - Only for spanning-mode incognito. We don't want the complication of
 269     //   spinning up an additional process here which might need to do some
 270     //   setup that we're not expecting.
 271     // - Only for extensions that can't normally be enabled in incognito, since
 272     //   that surface (e.g. chrome://extensions) should be the only one for
 273     //   enabling in incognito. In practice this means platform apps only.
 274     if (!is_web_connection || IncognitoInfo::IsSplitMode(target_extension) ||
 275         target_extension->can_be_incognito_enabled() ||
 276         // This check may show a dialog.
 277         !IncognitoConnectability::Get(context)
 278              ->Query(target_extension, source_contents, source_url)) {
 279       DispatchOnDisconnect(
 280           source, receiver_port_id, kReceivingEndDoesntExistError);
 281       return;
 282     }
 283   }
 284
 285   // Note: we use the source's profile here. If the source is an incognito
 286   // process, we will use the incognito EPM to find the right extension process,
 287   // which depends on whether the extension uses spanning or split mode.
 288   MessagePort* receiver = new ExtensionMessagePort(
 289       GetExtensionProcess(context, target_extension_id),
 290       MSG_ROUTING_CONTROL,
 291       target_extension_id);
 292
 293   // Include info about the opener's tab (if it was a tab).
 294   scoped_ptr<base::DictionaryValue> source_tab;
 295   GURL source_url_for_tab;
 296
 297   if (source_contents && ExtensionTabUtil::GetTabId(source_contents) >= 0) {
 298     // Only the tab id is useful to platform apps for internal use. The
 299     // unnecessary bits will be stripped out in
 300     // MessagingBindings::DispatchOnConnect().
 301     source_tab.reset(ExtensionTabUtil::CreateTabValue(source_contents));
 302     source_url_for_tab = source_url;
 303   }
 304
 305   OpenChannelParams* params = new OpenChannelParams(source,
 306                                                     source_tab.Pass(),
 307                                                     receiver,
 308                                                     receiver_port_id,
 309                                                     source_extension_id,
 310                                                     target_extension_id,
 311                                                     source_url_for_tab,
 312                                                     channel_name,
 313                                                     include_tls_channel_id);
 314
 315   // If the target requests the TLS channel id, begin the lookup for it.
 316   // The target might also be a lazy background page, checked next, but the
 317   // loading of lazy background pages continues asynchronously, so enqueue
 318   // messages awaiting TLS channel ID first.
 319   if (include_tls_channel_id) {
 320     pending_tls_channel_id_channels_[GET_CHANNEL_ID(params->receiver_port_id)]
 321         = PendingMessagesQueue();
 322     property_provider_.GetChannelID(
 323         Profile::FromBrowserContext(context),
 324         source_url,
 325         base::Bind(&MessageService::GotChannelID,
 326                    weak_factory_.GetWeakPtr(),
 327                    base::Passed(make_scoped_ptr(params))));
 328     return;
 329   }
 330
 331   // The target might be a lazy background page. In that case, we have to check
 332   // if it is loaded and ready, and if not, queue up the task and load the
 333   // page.
 334   if (MaybeAddPendingLazyBackgroundPageOpenChannelTask(
 335           context, target_extension, params)) {
 336     return;
 337   }
 338
 339   OpenChannelImpl(make_scoped_ptr(params));
 340 }
 341
 342 void MessageService::OpenChannelToNativeApp(
 343     int source_process_id,
 344     int source_routing_id,
 345     int receiver_port_id,
 346     const std::string& source_extension_id,
 347     const std::string& native_app_name) {
 348   content::RenderProcessHost* source =
 349       content::RenderProcessHost::FromID(source_process_id);
 350   if (!source)
 351     return;
 352
 353 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
 354   Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
 355   ExtensionService* extension_service =
 356       ExtensionSystem::Get(profile)->extension_service();
 357   bool has_permission = false;
 358   if (extension_service) {
 359     const Extension* extension =
 360         extension_service->GetExtensionById(source_extension_id, false);
 361     has_permission = extension &&
 362                      extension->permissions_data()->HasAPIPermission(
 363                          APIPermission::kNativeMessaging);
 364   }
 365
 366   if (!has_permission) {
 367     DispatchOnDisconnect(source, receiver_port_id, kMissingPermissionError);
 368     return;
 369   }
 370
 371   PrefService* pref_service = profile->GetPrefs();
 372
 373   // Verify that the host is not blocked by policies.
 374   NativeMessageProcessHost::PolicyPermission policy_permission =
 375       NativeMessageProcessHost::IsHostAllowed(pref_service, native_app_name);
 376   if (policy_permission == NativeMessageProcessHost::DISALLOW) {
 377     DispatchOnDisconnect(source, receiver_port_id, kProhibitedByPoliciesError);
 378     return;
 379   }
 380
 381   scoped_ptr<MessageChannel> channel(new MessageChannel());
 382   channel->opener.reset(new ExtensionMessagePort(source, MSG_ROUTING_CONTROL,
 383                                                  source_extension_id));
 384
 385   // Get handle of the native view and pass it to the native messaging host.
 386   gfx::NativeView native_view =
 387       content::RenderWidgetHost::FromID(source_process_id, source_routing_id)->
 388           GetView()->GetNativeView();
 389
 390   scoped_ptr<NativeMessageProcessHost> native_process =
 391       NativeMessageProcessHost::Create(
 392           native_view,
 393           base::WeakPtr<NativeMessageProcessHost::Client>(
 394               weak_factory_.GetWeakPtr()),
 395           source_extension_id, native_app_name, receiver_port_id,
 396           policy_permission == NativeMessageProcessHost::ALLOW_ALL);
 397
 398   // Abandon the channel.
 399   if (!native_process.get()) {
 400     LOG(ERROR) << "Failed to create native process.";
 401     DispatchOnDisconnect(
 402         source, receiver_port_id, kReceivingEndDoesntExistError);
 403     return;
 404   }
 405   channel->receiver.reset(new NativeMessagePort(native_process.release()));
 406
 407   // Keep the opener alive until the channel is closed.
 408   channel->opener->IncrementLazyKeepaliveCount();
 409
 410   AddChannel(channel.release(), receiver_port_id);
 411 #else  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
 412   const char kNativeMessagingNotSupportedError[] =
 413       "Native Messaging is not supported on this platform.";
 414   DispatchOnDisconnect(
 415       source, receiver_port_id, kNativeMessagingNotSupportedError);
 416 #endif  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
 417 }
 418
 419 void MessageService::OpenChannelToTab(
 420     int source_process_id, int source_routing_id, int receiver_port_id,
 421     int tab_id, const std::string& extension_id,
 422     const std::string& channel_name) {
 423   content::RenderProcessHost* source =
 424       content::RenderProcessHost::FromID(source_process_id);
 425   if (!source)
 426     return;
 427   Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
 428
 429   WebContents* contents = NULL;
 430   scoped_ptr<MessagePort> receiver;
 431   if (ExtensionTabUtil::GetTabById(tab_id, profile, true,
 432                                    NULL, NULL, &contents, NULL)) {
 433     receiver.reset(new ExtensionMessagePort(
 434         contents->GetRenderProcessHost(),
 435         contents->GetRenderViewHost()->GetRoutingID(),
 436         extension_id));
 437   }
 438
 439   if (contents && contents->GetController().NeedsReload()) {
 440     // The tab isn't loaded yet. Don't attempt to connect.
 441     DispatchOnDisconnect(
 442         source, receiver_port_id, kReceivingEndDoesntExistError);
 443     return;
 444   }
 445
 446   scoped_ptr<OpenChannelParams> params(new OpenChannelParams(
 447         source,
 448         scoped_ptr<base::DictionaryValue>(),  // Source tab doesn't make sense
 449                                               // for opening to tabs.
 450         receiver.release(),
 451         receiver_port_id,
 452         extension_id,
 453         extension_id,
 454         GURL(),  // Source URL doesn't make sense for opening to tabs.
 455         channel_name,
 456         false));  // Connections to tabs don't get TLS channel IDs.
 457   OpenChannelImpl(params.Pass());
 458 }
 459
 460 bool MessageService::OpenChannelImpl(scoped_ptr<OpenChannelParams> params) {
 461   if (!params->source)
 462     return false;  // Closed while in flight.
 463
 464   if (!params->receiver || !params->receiver->GetRenderProcessHost()) {
 465     DispatchOnDisconnect(params->source,
 466                          params->receiver_port_id,
 467                          kReceivingEndDoesntExistError);
 468     return false;
 469   }
 470
 471   // Add extra paranoid CHECKs, since we have crash reports of this being NULL.
 472   // http://code.google.com/p/chromium/issues/detail?id=19067
 473   CHECK(params->receiver->GetRenderProcessHost());
 474
 475   MessageChannel* channel(new MessageChannel);
 476   channel->opener.reset(new ExtensionMessagePort(params->source,
 477                                                  MSG_ROUTING_CONTROL,
 478                                                  params->source_extension_id));
 479   channel->receiver.reset(params->receiver.release());
 480
 481   CHECK(channel->receiver->GetRenderProcessHost());
 482
 483   AddChannel(channel, params->receiver_port_id);
 484
 485   CHECK(channel->receiver->GetRenderProcessHost());
 486
 487   // Send the connect event to the receiver.  Give it the opener's port ID (the
 488   // opener has the opposite port ID).
 489   channel->receiver->DispatchOnConnect(params->receiver_port_id,
 490                                        params->channel_name,
 491                                        params->source_tab,
 492                                        params->source_extension_id,
 493                                        params->target_extension_id,
 494                                        params->source_url,
 495                                        params->tls_channel_id);
 496
 497   // Keep both ends of the channel alive until the channel is closed.
 498   channel->opener->IncrementLazyKeepaliveCount();
 499   channel->receiver->IncrementLazyKeepaliveCount();
 500   return true;
 501 }
 502
 503 void MessageService::AddChannel(MessageChannel* channel, int receiver_port_id) {
 504   int channel_id = GET_CHANNEL_ID(receiver_port_id);
 505   CHECK(channels_.find(channel_id) == channels_.end());
 506   channels_[channel_id] = channel;
 507   pending_lazy_background_page_channels_.erase(channel_id);
 508 }
 509
 510 void MessageService::CloseChannel(int port_id,
 511                                   const std::string& error_message) {
 512   // Note: The channel might be gone already, if the other side closed first.
 513   int channel_id = GET_CHANNEL_ID(port_id);
 514   MessageChannelMap::iterator it = channels_.find(channel_id);
 515   if (it == channels_.end()) {
 516     PendingLazyBackgroundPageChannelMap::iterator pending =
 517         pending_lazy_background_page_channels_.find(channel_id);
 518     if (pending != pending_lazy_background_page_channels_.end()) {
 519       lazy_background_task_queue_->AddPendingTask(
 520           pending->second.first, pending->second.second,
 521           base::Bind(&MessageService::PendingLazyBackgroundPageCloseChannel,
 522                      weak_factory_.GetWeakPtr(), port_id, error_message));
 523     }
 524     return;
 525   }
 526   CloseChannelImpl(it, port_id, error_message, true);
 527 }
 528
 529 void MessageService::CloseChannelImpl(
 530     MessageChannelMap::iterator channel_iter,
 531     int closing_port_id,
 532     const std::string& error_message,
 533     bool notify_other_port) {
 534   MessageChannel* channel = channel_iter->second;
 535
 536   // Notify the other side.
 537   if (notify_other_port) {
 538     MessagePort* port = IS_OPENER_PORT_ID(closing_port_id) ?
 539         channel->receiver.get() : channel->opener.get();
 540     port->DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(closing_port_id),
 541                                error_message);
 542   }
 543
 544   // Balance the IncrementLazyKeepaliveCount() in OpenChannelImpl.
 545   channel->opener->DecrementLazyKeepaliveCount();
 546   channel->receiver->DecrementLazyKeepaliveCount();
 547
 548   delete channel_iter->second;
 549   channels_.erase(channel_iter);
 550 }
 551
 552 void MessageService::PostMessage(int source_port_id, const Message& message) {
 553   int channel_id = GET_CHANNEL_ID(source_port_id);
 554   MessageChannelMap::iterator iter = channels_.find(channel_id);
 555   if (iter == channels_.end()) {
 556     // If this channel is pending, queue up the PostMessage to run once
 557     // the channel opens.
 558     EnqueuePendingMessage(source_port_id, channel_id, message);
 559     return;
 560   }
 561
 562   DispatchMessage(source_port_id, iter->second, message);
 563 }
 564
 565 void MessageService::PostMessageFromNativeProcess(int port_id,
 566                                                   const std::string& message) {
 567   PostMessage(port_id, Message(message, false /* user_gesture */));
 568 }
 569
 570 void MessageService::Observe(int type,
 571                              const content::NotificationSource& source,
 572                              const content::NotificationDetails& details) {
 573   switch (type) {
 574     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
 575     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
 576       content::RenderProcessHost* renderer =
 577           content::Source<content::RenderProcessHost>(source).ptr();
 578       OnProcessClosed(renderer);
 579       break;
 580     }
 581     default:
 582       NOTREACHED();
 583       return;
 584   }
 585 }
 586
 587 void MessageService::OnProcessClosed(content::RenderProcessHost* process) {
 588   // Close any channels that share this renderer.  We notify the opposite
 589   // port that his pair has closed.
 590   for (MessageChannelMap::iterator it = channels_.begin();
 591        it != channels_.end(); ) {
 592     MessageChannelMap::iterator current = it++;
 593
 594     content::RenderProcessHost* opener_process =
 595         current->second->opener->GetRenderProcessHost();
 596     content::RenderProcessHost* receiver_process =
 597         current->second->receiver->GetRenderProcessHost();
 598
 599     // Only notify the other side if it has a different porocess host.
 600     bool notify_other_port = opener_process && receiver_process &&
 601         opener_process != receiver_process;
 602
 603     if (opener_process == process) {
 604       CloseChannelImpl(current, GET_CHANNEL_OPENER_ID(current->first),
 605                        std::string(), notify_other_port);
 606     } else if (receiver_process == process) {
 607       CloseChannelImpl(current, GET_CHANNEL_RECEIVERS_ID(current->first),
 608                        std::string(), notify_other_port);
 609     }
 610   }
 611 }
 612
 613 void MessageService::EnqueuePendingMessage(int source_port_id,
 614                                            int channel_id,
 615                                            const Message& message) {
 616   PendingTlsChannelIdMap::iterator pending_for_tls_channel_id =
 617       pending_tls_channel_id_channels_.find(channel_id);
 618   if (pending_for_tls_channel_id != pending_tls_channel_id_channels_.end()) {
 619     pending_for_tls_channel_id->second.push_back(
 620         PendingMessage(source_port_id, message));
 621     // Pending messages must only be pending the TLS channel ID or lazy
 622     // background page loading, never both.
 623     return;
 624   }
 625   EnqueuePendingMessageForLazyBackgroundLoad(source_port_id,
 626                                              channel_id,
 627                                              message);
 628 }
 629
 630 void MessageService::EnqueuePendingMessageForLazyBackgroundLoad(
 631     int source_port_id,
 632     int channel_id,
 633     const Message& message) {
 634   PendingLazyBackgroundPageChannelMap::iterator pending =
 635       pending_lazy_background_page_channels_.find(channel_id);
 636   if (pending != pending_lazy_background_page_channels_.end()) {
 637     lazy_background_task_queue_->AddPendingTask(
 638         pending->second.first, pending->second.second,
 639         base::Bind(&MessageService::PendingLazyBackgroundPagePostMessage,
 640                    weak_factory_.GetWeakPtr(), source_port_id, message));
 641   }
 642 }
 643
 644 void MessageService::DispatchMessage(int source_port_id,
 645                                      MessageChannel* channel,
 646                                      const Message& message) {
 647   // Figure out which port the ID corresponds to.
 648   int dest_port_id = GET_OPPOSITE_PORT_ID(source_port_id);
 649   MessagePort* port = IS_OPENER_PORT_ID(dest_port_id) ?
 650       channel->opener.get() : channel->receiver.get();
 651
 652   port->DispatchOnMessage(message, dest_port_id);
 653 }
 654
 655 bool MessageService::MaybeAddPendingLazyBackgroundPageOpenChannelTask(
 656     BrowserContext* context,
 657     const Extension* extension,
 658     OpenChannelParams* params) {
 659   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
 660     return false;
 661
 662   // If the extension uses spanning incognito mode, make sure we're always
 663   // using the original profile since that is what the extension process
 664   // will use.
 665   if (!IncognitoInfo::IsSplitMode(extension))
 666     context = ExtensionsBrowserClient::Get()->GetOriginalContext(context);
 667
 668   if (!lazy_background_task_queue_->ShouldEnqueueTask(context, extension))
 669     return false;
 670
 671   pending_lazy_background_page_channels_
 672       [GET_CHANNEL_ID(params->receiver_port_id)] =
 673           PendingLazyBackgroundPageChannel(context, extension->id());
 674   scoped_ptr<OpenChannelParams> scoped_params(params);
 675   lazy_background_task_queue_->AddPendingTask(
 676       context,
 677       extension->id(),
 678       base::Bind(&MessageService::PendingLazyBackgroundPageOpenChannel,
 679                  weak_factory_.GetWeakPtr(),
 680                  base::Passed(&scoped_params),
 681                  params->source->GetID()));
 682   return true;
 683 }
 684
 685 void MessageService::GotChannelID(scoped_ptr<OpenChannelParams> params,
 686                                   const std::string& tls_channel_id) {
 687   params->tls_channel_id.assign(tls_channel_id);
 688   int channel_id = GET_CHANNEL_ID(params->receiver_port_id);
 689
 690   PendingTlsChannelIdMap::iterator pending_for_tls_channel_id =
 691       pending_tls_channel_id_channels_.find(channel_id);
 692   if (pending_for_tls_channel_id == pending_tls_channel_id_channels_.end()) {
 693     NOTREACHED();
 694     return;
 695   }
 696
 697   BrowserContext* context = params->source->GetBrowserContext();
 698
 699   const Extension* target_extension =
 700       ExtensionSystem::Get(context)->extension_service()->extensions()->GetByID(
 701           params->target_extension_id);
 702   if (!target_extension) {
 703     pending_tls_channel_id_channels_.erase(channel_id);
 704     DispatchOnDisconnect(
 705         params->source, params->receiver_port_id,
 706         kReceivingEndDoesntExistError);
 707     return;
 708   }
 709   PendingMessagesQueue& pending_messages = pending_for_tls_channel_id->second;
 710   if (MaybeAddPendingLazyBackgroundPageOpenChannelTask(
 711           context, target_extension, params.get())) {
 712     // Lazy background queue took ownership. Release ours.
 713     ignore_result(params.release());
 714     // Messages queued up waiting for the TLS channel ID now need to be queued
 715     // up for the lazy background page to load.
 716     for (PendingMessagesQueue::iterator it = pending_messages.begin();
 717          it != pending_messages.end();
 718          it++) {
 719       EnqueuePendingMessageForLazyBackgroundLoad(it->first, channel_id,
 720                                                  it->second);
 721     }
 722   } else {
 723     OpenChannelImpl(params.Pass());
 724     // Messages queued up waiting for the TLS channel ID can be posted now.
 725     MessageChannelMap::iterator channel_iter = channels_.find(channel_id);
 726     if (channel_iter != channels_.end()) {
 727       for (PendingMessagesQueue::iterator it = pending_messages.begin();
 728            it != pending_messages.end();
 729            it++) {
 730         DispatchMessage(it->first, channel_iter->second, it->second);
 731       }
 732     }
 733   }
 734   pending_tls_channel_id_channels_.erase(channel_id);
 735 }
 736
 737 void MessageService::PendingLazyBackgroundPageOpenChannel(
 738     scoped_ptr<OpenChannelParams> params,
 739     int source_process_id,
 740     ExtensionHost* host) {
 741   if (!host)
 742     return;  // TODO(mpcomplete): notify source of disconnect?
 743
 744   // Re-lookup the source process since it may no longer be valid.
 745   content::RenderProcessHost* source =
 746       content::RenderProcessHost::FromID(source_process_id);
 747   if (!source)
 748     return;
 749
 750   params->source = source;
 751   params->receiver.reset(new ExtensionMessagePort(host->render_process_host(),
 752                                                   MSG_ROUTING_CONTROL,
 753                                                   params->target_extension_id));
 754   OpenChannelImpl(params.Pass());
 755 }
 756
 757 void MessageService::DispatchOnDisconnect(content::RenderProcessHost* source,
 758                                           int port_id,
 759                                           const std::string& error_message) {
 760   ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, "");
 761   port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(port_id), error_message);
 762 }
 763
 764 }  // namespace extensions