Add extension event histogram values for messaging, webRequest, and webview.

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"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/messaging/extension_message_port.h"
 #include "chrome/browser/extensions/api/messaging/incognito_connectability.h"
 #include "chrome/browser/extensions/api/messaging/native_message_port.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "components/guest_view/common/guest_view_constants.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.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 "content/public/common/child_process_host.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/guest_view/web_view/web_view_guest.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/pref_names.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/externally_connectable.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "net/base/completion_callback.h"
 #include "url/gurl.h"
 
 using content::BrowserContext;
+using content::BrowserThread;
 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.
 #define IS_OPENER_PORT_ID(port_id) (((port_id) & 1) == 0)
 
 // Change even to odd and vice versa, to get the other side of a given channel.
 #define GET_OPPOSITE_PORT_ID(source_port_id) ((source_port_id) ^ 1)
 
 namespace extensions {
 
 MessageService::PolicyPermission MessageService::IsNativeMessagingHostAllowed(
     const PrefService* pref_service,
     const std::string& native_host_name) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   PolicyPermission allow_result = ALLOW_ALL;
   if (pref_service->IsManagedPreference(
           pref_names::kNativeMessagingUserLevelHosts)) {
     if (!pref_service->GetBoolean(pref_names::kNativeMessagingUserLevelHosts))
       allow_result = ALLOW_SYSTEM_ONLY;
   }
 
   // All native messaging hosts are allowed if there is no blacklist.
   if (!pref_service->IsManagedPreference(pref_names::kNativeMessagingBlacklist))
     return allow_result;
@@ skipping 99 matching lines @@
 
 }  // namespace
 
 content::RenderProcessHost*
     MessageService::MessagePort::GetRenderProcessHost() {
   return NULL;
 }
 
 // static
 void MessageService::AllocatePortIdPair(int* port1, int* port2) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   unsigned channel_id =
       static_cast<unsigned>(g_next_channel_id.GetNext()) % (kint32max/2);
   unsigned port1_id = channel_id * 2;
   unsigned port2_id = channel_id * 2 + 1;
 
   // Sanity checks to make sure our channel<->port converters are correct.
   DCHECK(IS_OPENER_PORT_ID(port1_id));
   DCHECK_EQ(GET_OPPOSITE_PORT_ID(port1_id), port2_id);
   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(BrowserContext* context)
     : lazy_background_task_queue_(
           LazyBackgroundTaskQueue::Get(context)),
       weak_factory_(this) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 MessageService::~MessageService() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
   channels_.clear();
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<MessageService> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<MessageService>*
 MessageService::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
 MessageService* MessageService::Get(BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<MessageService>::Get(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) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
   if (!source)
     return;
   BrowserContext* context = source->GetBrowserContext();
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(context);
   const Extension* target_extension =
       registry->enabled_extensions().GetByID(target_extension_id);
   if (!target_extension) {
@@ skipping 135 matching lines @@
 
   OnOpenChannelAllowed(params.Pass(), true);
 }
 
 void MessageService::OpenChannelToNativeApp(
     int source_process_id,
     int source_routing_id,
     int receiver_port_id,
     const std::string& source_extension_id,
     const std::string& native_app_name) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
   if (!source)
     return;
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
   Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
   ExtensionService* extension_service =
       ExtensionSystem::Get(profile)->extension_service();
   bool has_permission = false;
@@ skipping 58 matching lines @@
       source, receiver_port_id, kNativeMessagingNotSupportedError);
 #endif  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
 }
 
 void MessageService::OpenChannelToTab(int source_process_id,
                                       int receiver_port_id,
                                       int tab_id,
                                       int frame_id,
                                       const std::string& extension_id,
                                       const std::string& channel_name) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
   if (!source)
     return;
   Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
 
   WebContents* contents = NULL;
   scoped_ptr<MessagePort> receiver;
   if (!ExtensionTabUtil::GetTabById(tab_id, profile, true, NULL, NULL,
                                     &contents, NULL) ||
@@ skipping 19 matching lines @@
     // Frame ID 0 is main frame.
     receiver_routing_id = contents->GetMainFrame()->GetRoutingID();
   } else {
     DCHECK_EQ(-1, frame_id);
     // If the frame ID is not set (i.e. -1), then the channel has to be opened
     // in every frame.
     // TODO(robwu): Update logic so that frames that are not hosted in the main
     // frame's process can also receive the port.
     receiver_routing_id = MSG_ROUTING_CONTROL;
   }
-  receiver.reset(new ExtensionMessagePort(
-          contents->GetRenderProcessHost(), receiver_routing_id, extension_id));
+  receiver.reset(new ExtensionMessagePort(contents->GetRenderProcessHost(),
+                                          receiver_routing_id, extension_id));
 
   scoped_ptr<OpenChannelParams> params(new OpenChannelParams(
       source_process_id,
       scoped_ptr<base::DictionaryValue>(),  // Source tab doesn't make sense
                                             // for opening to tabs.
       -1,  // If there is no tab, then there is no frame either.
       frame_id,
       receiver.release(), receiver_port_id, extension_id, extension_id,
       GURL(),  // Source URL doesn't make sense for opening to tabs.
       channel_name,
       false,  // Connections to tabs don't get TLS channel IDs.
       false));  // Connections to tabs aren't webview guests.
-  OpenChannelImpl(params.Pass());
+  OpenChannelImpl(contents->GetBrowserContext(), params.Pass(),
+                  nullptr /* extension */, false /* did_enqueue */);
 }
 
-void MessageService::OpenChannelImpl(scoped_ptr<OpenChannelParams> params) {
+void MessageService::OpenChannelImpl(BrowserContext* browser_context,
+                                     scoped_ptr<OpenChannelParams> params,
+                                     const Extension* target_extension,
+                                     bool did_enqueue) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);

[Devlin, 2015/08/07 21:25:47]

DCHECK_EQ(target_extension != nullptr, params->extension_id.empty())?

[not at google - send to devlin, 2015/08/10 20:48:33]

Alright, though it's !empty() not empty. I.e. presence of a target extension
must correlate with there being a target extension ID.

+
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(params->source_process_id);
   if (!source)
     return;  // Closed while in flight.
 
   if (!params->receiver || !params->receiver->GetRenderProcessHost()) {
     DispatchOnDisconnect(source, params->receiver_port_id,
                          kReceivingEndDoesntExistError);
     return;
   }
 
-  // Add extra paranoid CHECKs, since we have crash reports of this being NULL.
-  // http://code.google.com/p/chromium/issues/detail?id=19067
-  CHECK(params->receiver->GetRenderProcessHost());
-
   MessageChannel* channel(new MessageChannel);
   channel->opener.reset(new ExtensionMessagePort(source, MSG_ROUTING_CONTROL,
                                                  params->source_extension_id));
   channel->receiver.reset(params->receiver.release());
-
-  CHECK(channel->receiver->GetRenderProcessHost());
-
   AddChannel(channel, params->receiver_port_id);
 
-  CHECK(channel->receiver->GetRenderProcessHost());
-
   int guest_process_id = content::ChildProcessHost::kInvalidUniqueID;
   int guest_render_frame_routing_id = MSG_ROUTING_NONE;
   if (params->include_guest_process_info) {
     guest_process_id = params->source_process_id;
     guest_render_frame_routing_id = params->source_frame_id;
     auto* guest_rfh = content::RenderFrameHost::FromID(
         guest_process_id, guest_render_frame_routing_id);
     // Reset the |source_frame_id| parameter.
     params->source_frame_id = -1;
 
     DCHECK(guest_rfh == nullptr ||
            WebViewGuest::FromWebContents(
                WebContents::FromRenderFrameHost(guest_rfh)) != nullptr);
   }
 
   // Send the connect event to the receiver.  Give it the opener's port ID (the
   // opener has the opposite port ID).
-  channel->receiver->DispatchOnConnect(params->receiver_port_id,
-                                       params->channel_name,
-                                       params->source_tab.Pass(),
-                                       params->source_frame_id,
-                                       params->target_frame_id,
-                                       guest_process_id,
-                                       guest_render_frame_routing_id,
-                                       params->source_extension_id,
-                                       params->target_extension_id,
-                                       params->source_url,
-                                       params->tls_channel_id);
+  channel->receiver->DispatchOnConnect(
+      params->receiver_port_id, params->channel_name, params->source_tab.Pass(),
+      params->source_frame_id, params->target_frame_id, guest_process_id,
+      guest_render_frame_routing_id, params->source_extension_id,
+      params->target_extension_id, params->source_url, params->tls_channel_id);
+
+  // Report the event to the event router, if the target is an extension.
+  //
+  // First, determine what event this will be (runtime.onConnect vs
+  // runtime.onMessage etc), and what the event target is (view vs background
+  // page etc).
+  //
+  // Yes - even though this is opening a channel, they may actually be
+  // runtime.onRequest/onMessage events because those single-use events are
+  // built using the connect framework (see messaging.js).
+  //
+  // Likewise, if you're wondering about native messaging events, these are
+  // only initiated *by* the extension, so aren't really events, just the
+  // endpoint of a communication channel.
+  if (target_extension) {
+    events::HistogramValue histogram_value = events::UNKNOWN;
+    bool is_external =
+        params->source_extension_id != params->target_extension_id;
+    if (params->channel_name == "chrome.runtime.onRequest") {
+      histogram_value = is_external ? events::RUNTIME_ON_REQUEST_EXTERNAL
+                                    : events::RUNTIME_ON_REQUEST;
+    } else if (params->channel_name == "chrome.runtime.onMessage") {
+      histogram_value = is_external ? events::RUNTIME_ON_MESSAGE_EXTERNAL
+                                    : events::RUNTIME_ON_MESSAGE;
+    } else {
+      histogram_value = is_external ? events::RUNTIME_ON_CONNECT_EXTERNAL
+                                    : events::RUNTIME_ON_CONNECT;
+    }
+    EventRouter::Get(browser_context)
+        ->ReportEvent(histogram_value, target_extension, did_enqueue);
+  }
 
   // Keep both ends of the channel alive until the channel is closed.
   channel->opener->IncrementLazyKeepaliveCount();
   channel->receiver->IncrementLazyKeepaliveCount();
 }
 
 void MessageService::AddChannel(MessageChannel* channel, int receiver_port_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   int channel_id = GET_CHANNEL_ID(receiver_port_id);
   CHECK(channels_.find(channel_id) == channels_.end());
   channels_[channel_id] = channel;
   pending_lazy_background_page_channels_.erase(channel_id);
 }
 
 void MessageService::CloseChannel(int port_id,
                                   const std::string& error_message) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   // Note: The channel might be gone already, if the other side closed first.
   int channel_id = GET_CHANNEL_ID(port_id);
   MessageChannelMap::iterator it = channels_.find(channel_id);
   if (it == channels_.end()) {
     PendingLazyBackgroundPageChannelMap::iterator pending =
         pending_lazy_background_page_channels_.find(channel_id);
     if (pending != pending_lazy_background_page_channels_.end()) {
       lazy_background_task_queue_->AddPendingTask(
           pending->second.first, pending->second.second,
           base::Bind(&MessageService::PendingLazyBackgroundPageCloseChannel,
                      weak_factory_.GetWeakPtr(), port_id, error_message));
     }
     return;
   }
   CloseChannelImpl(it, port_id, error_message, true);
 }
 
 void MessageService::CloseChannelImpl(
     MessageChannelMap::iterator channel_iter,
     int closing_port_id,
     const std::string& error_message,
     bool notify_other_port) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   MessageChannel* channel = channel_iter->second;
 
   // Notify the other side.
   if (notify_other_port) {
     MessagePort* port = IS_OPENER_PORT_ID(closing_port_id) ?
         channel->receiver.get() : channel->opener.get();
     port->DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(closing_port_id),
                                error_message);
   }
 
   // Balance the IncrementLazyKeepaliveCount() in OpenChannelImpl.
   channel->opener->DecrementLazyKeepaliveCount();
   channel->receiver->DecrementLazyKeepaliveCount();
 
   delete channel_iter->second;
   channels_.erase(channel_iter);
 }
 
 void MessageService::PostMessage(int source_port_id, const Message& message) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   int channel_id = GET_CHANNEL_ID(source_port_id);
   MessageChannelMap::iterator iter = channels_.find(channel_id);
   if (iter == channels_.end()) {
     // If this channel is pending, queue up the PostMessage to run once
     // the channel opens.
     EnqueuePendingMessage(source_port_id, channel_id, message);
     return;
   }
 
   DispatchMessage(source_port_id, iter->second, message);
 }
 
 void MessageService::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
       content::RenderProcessHost* renderer =
           content::Source<content::RenderProcessHost>(source).ptr();
       OnProcessClosed(renderer);
       break;
     }
     default:
       NOTREACHED();
       return;
   }
 }
 
 void MessageService::OnProcessClosed(content::RenderProcessHost* process) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   // Close any channels that share this renderer.  We notify the opposite
-  // port that his pair has closed.
+  // port that its pair has closed.
   for (MessageChannelMap::iterator it = channels_.begin();
        it != channels_.end(); ) {
     MessageChannelMap::iterator current = it++;
 
     content::RenderProcessHost* opener_process =
         current->second->opener->GetRenderProcessHost();
     content::RenderProcessHost* receiver_process =
         current->second->receiver->GetRenderProcessHost();
 
     // Only notify the other side if it has a different porocess host.
     bool notify_other_port = opener_process && receiver_process &&
         opener_process != receiver_process;
 
     if (opener_process == process) {
       CloseChannelImpl(current, GET_CHANNEL_OPENER_ID(current->first),
                        std::string(), notify_other_port);
     } else if (receiver_process == process) {
       CloseChannelImpl(current, GET_CHANNEL_RECEIVERS_ID(current->first),
                        std::string(), notify_other_port);
     }
   }
 }
 
 void MessageService::EnqueuePendingMessage(int source_port_id,
                                            int channel_id,
                                            const Message& message) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   PendingChannelMap::iterator pending_for_incognito =
       pending_incognito_channels_.find(channel_id);
   if (pending_for_incognito != pending_incognito_channels_.end()) {
     pending_for_incognito->second.push_back(
         PendingMessage(source_port_id, message));
     // A channel should only be holding pending messages because it is in one
     // of these states.
     DCHECK(!ContainsKey(pending_tls_channel_id_channels_, channel_id));
     DCHECK(!ContainsKey(pending_lazy_background_page_channels_, channel_id));
     return;
@@ skipping 10 matching lines @@
   }
   EnqueuePendingMessageForLazyBackgroundLoad(source_port_id,
                                              channel_id,
                                              message);
 }
 
 void MessageService::EnqueuePendingMessageForLazyBackgroundLoad(
     int source_port_id,
     int channel_id,
     const Message& message) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   PendingLazyBackgroundPageChannelMap::iterator pending =
       pending_lazy_background_page_channels_.find(channel_id);
   if (pending != pending_lazy_background_page_channels_.end()) {
     lazy_background_task_queue_->AddPendingTask(
         pending->second.first, pending->second.second,
         base::Bind(&MessageService::PendingLazyBackgroundPagePostMessage,
                    weak_factory_.GetWeakPtr(), source_port_id, message));
   }
 }
 
 void MessageService::DispatchMessage(int source_port_id,
                                      MessageChannel* channel,
                                      const Message& message) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   // 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(
     BrowserContext* context,
     const Extension* extension,
     scoped_ptr<OpenChannelParams>* params,
     const PendingMessagesQueue& pending_messages) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   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))
     context = ExtensionsBrowserClient::Get()->GetOriginalContext(context);
 
   if (!lazy_background_task_queue_->ShouldEnqueueTask(context, extension))
@@ skipping 10 matching lines @@
 
   for (const PendingMessage& message : pending_messages) {
     EnqueuePendingMessageForLazyBackgroundLoad(message.first, channel_id,
                                                message.second);
   }
   return true;
 }
 
 void MessageService::OnOpenChannelAllowed(scoped_ptr<OpenChannelParams> params,
                                           bool allowed) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   int channel_id = GET_CHANNEL_ID(params->receiver_port_id);
 
   PendingChannelMap::iterator pending_for_incognito =
       pending_incognito_channels_.find(channel_id);
   if (pending_for_incognito == pending_incognito_channels_.end()) {
     NOTREACHED();
     return;
   }
   PendingMessagesQueue pending_messages;
   pending_messages.swap(pending_for_incognito->second);
@@ skipping 44 matching lines @@
     DispatchOnDisconnect(source, params->receiver_port_id,
                          kReceivingEndDoesntExistError);
     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(
           context, target_extension, &params, pending_messages)) {
-    OpenChannelImpl(params.Pass());
+    OpenChannelImpl(context, params.Pass(), target_extension,
+                    false /* did_enqueue */);
     DispatchPendingMessages(pending_messages, channel_id);
   }
 }
 
 void MessageService::GotChannelID(scoped_ptr<OpenChannelParams> params,
                                   const std::string& tls_channel_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   params->tls_channel_id.assign(tls_channel_id);
   int channel_id = GET_CHANNEL_ID(params->receiver_port_id);
 
   PendingChannelMap::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;
   }
   PendingMessagesQueue pending_messages;
@@ skipping 12 matching lines @@
   const Extension* target_extension =
       registry->enabled_extensions().GetByID(params->target_extension_id);
   if (!target_extension) {
     DispatchOnDisconnect(source, params->receiver_port_id,
                          kReceivingEndDoesntExistError);
     return;
   }
 
   if (!MaybeAddPendingLazyBackgroundPageOpenChannelTask(
           context, target_extension, &params, pending_messages)) {
-    OpenChannelImpl(params.Pass());
+    OpenChannelImpl(context, params.Pass(), target_extension,
+                    false /* did_enqueue */);
     DispatchPendingMessages(pending_messages, channel_id);
   }
 }
 
 void MessageService::PendingLazyBackgroundPageOpenChannel(
     scoped_ptr<OpenChannelParams> params,
     int source_process_id,
     ExtensionHost* host) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   if (!host)
     return;  // TODO(mpcomplete): notify source of disconnect?
 
   params->receiver.reset(new ExtensionMessagePort(host->render_process_host(),
                                                   MSG_ROUTING_CONTROL,
                                                   params->target_extension_id));
-  OpenChannelImpl(params.Pass());
+  OpenChannelImpl(host->browser_context(), params.Pass(), host->extension(),
+                  true /* did_enqueue */);
 }
 
 void MessageService::DispatchOnDisconnect(content::RenderProcessHost* source,
                                           int port_id,
                                           const std::string& error_message) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, "");
   port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(port_id), error_message);
 }
 
 void MessageService::DispatchPendingMessages(const PendingMessagesQueue& queue,
                                              int channel_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   MessageChannelMap::iterator channel_iter = channels_.find(channel_id);
   if (channel_iter != channels_.end()) {
     for (const PendingMessage& message : queue) {
       DispatchMessage(message.first, channel_iter->second, message.second);
     }
   }
 }
 
 }  // namespace extensions