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