[Extensions] Extension Port Ids and Initialization 2.0

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 <stdint.h>
 #include <limits>
 #include <utility>
 
-#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/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/messaging/extension_message_port.h"
 #include "chrome/browser/extensions/api/messaging/incognito_connectability.h"
@@ skipping 34 matching lines @@
 #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)) {
@@ skipping 43 matching lines @@
   std::unique_ptr<MessagePort> opener;
   std::unique_ptr<MessagePort> receiver;
 };
 
 struct MessageService::OpenChannelParams {
   int source_process_id;
   int source_routing_id;
   std::unique_ptr<base::DictionaryValue> source_tab;
   int source_frame_id;
   std::unique_ptr<MessagePort> receiver;
-  int receiver_port_id;
+  PortId receiver_port_id;
   std::string source_extension_id;
   std::string target_extension_id;
   GURL source_url;
   std::string channel_name;
   bool include_tls_channel_id;
   std::string tls_channel_id;
   bool include_guest_process_info;
 
   // Takes ownership of receiver.
   OpenChannelParams(int source_process_id,
                     int source_routing_id,
                     std::unique_ptr<base::DictionaryValue> source_tab,
                     int source_frame_id,
                     MessagePort* receiver,
-                    int receiver_port_id,
+                    const PortId& 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,
                     bool include_guest_process_info)
       : source_process_id(source_process_id),
         source_routing_id(source_routing_id),
         source_frame_id(source_frame_id),
         receiver(receiver),
         receiver_port_id(receiver_port_id),
         source_extension_id(source_extension_id),
         target_extension_id(target_extension_id),
         source_url(source_url),
         channel_name(channel_name),
         include_tls_channel_id(include_tls_channel_id),
         include_guest_process_info(include_guest_process_info) {
     if (source_tab)
       this->source_tab = std::move(source_tab);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OpenChannelParams);
 };
 
 namespace {
 
-static base::StaticAtomicSequenceNumber g_next_channel_id;
-
 static content::RenderProcessHost* GetExtensionProcess(
     BrowserContext* context,
     const std::string& extension_id) {
   scoped_refptr<SiteInstance> site_instance =
       ProcessManager::Get(context)->GetSiteInstanceForURL(
           Extension::GetBaseURLFromExtensionId(extension_id));
   return site_instance->HasProcess() ? site_instance->GetProcess() : NULL;
 }
 
 }  // namespace
 
 void MessageService::MessagePort::RemoveCommonFrames(const MessagePort& port) {}
 
 bool MessageService::MessagePort::HasFrame(
     content::RenderFrameHost* rfh) const {
   return false;
 }
 
-// static
-void MessageService::AllocatePortIdPair(int* port1, int* port2) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  unsigned channel_id = static_cast<unsigned>(g_next_channel_id.GetNext()) %
-                        (std::numeric_limits<int32_t>::max() / 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);
 }
 
 MessageService::~MessageService() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   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,
+    int source_process_id,
+    int source_routing_id,
+    const PortId& source_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);
+  DCHECK(source_port_id.is_opener);
 
   content::RenderFrameHost* source =
       content::RenderFrameHost::FromID(source_process_id, source_routing_id);
   if (!source)
     return;
   BrowserContext* context = source->GetProcess()->GetBrowserContext();
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(context);
   const Extension* target_extension =
       registry->enabled_extensions().GetByID(target_extension_id);
+  PortId receiver_port_id(source_port_id.context_id, source_port_id.port_number,
+                          false);
   if (!target_extension) {
     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
@@ skipping 67 matching lines @@
       include_guest_process_info = true;
     }
   }
 
   std::unique_ptr<OpenChannelParams> params(new OpenChannelParams(
       source_process_id, source_routing_id, std::move(source_tab),
       source_frame_id, nullptr, receiver_port_id, source_extension_id,
       target_extension_id, source_url, channel_name, include_tls_channel_id,
       include_guest_process_info));
 
-  pending_incognito_channels_[GET_CHANNEL_ID(params->receiver_port_id)] =
+  pending_incognito_channels_[params->receiver_port_id.GetChannelId()] =
       PendingMessagesQueue();
   if (context->IsOffTheRecord() &&
       !util::IsIncognitoEnabled(target_extension_id, context)) {
     // Give the user a chance to accept an incognito connection from the web if
     // they haven't already, with the conditions:
     // - 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.
     // - Only for extensions that can't normally be enabled in incognito, since
     //   that surface (e.g. chrome://extensions) should be the only one for
@@ skipping 29 matching lines @@
                            weak_factory_.GetWeakPtr(), base::Passed(&params)));
     return;
   }
 
   OnOpenChannelAllowed(std::move(params), true);
 }
 
 void MessageService::OpenChannelToNativeApp(
     int source_process_id,
     int source_routing_id,
-    int receiver_port_id,
+    const PortId& source_port_id,
     const std::string& native_app_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(source_port_id.is_opener);
 
   content::RenderFrameHost* source =
       content::RenderFrameHost::FromID(source_process_id, source_routing_id);
   if (!source)
     return;
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(source);
   ExtensionWebContentsObserver* extension_web_contents_observer =
       web_contents ?
           ExtensionWebContentsObserver::GetForWebContents(web_contents) :
           nullptr;
   const Extension* extension =
       extension_web_contents_observer ?
           extension_web_contents_observer->GetExtensionFromFrame(source, true) :
           nullptr;
 
   bool has_permission = extension &&
                         extension->permissions_data()->HasAPIPermission(
                             APIPermission::kNativeMessaging);
 
+  PortId receiver_port_id(source_port_id.context_id, source_port_id.port_number,
+                          false);
   if (!has_permission) {
     DispatchOnDisconnect(source, receiver_port_id, kMissingPermissionError);
     return;
   }
 
   PrefService* pref_service =
       Profile::FromBrowserContext(source->GetProcess()->GetBrowserContext())->
           GetPrefs();
 
   // Verify that the host is not blocked by policies.
   PolicyPermission policy_permission =
       IsNativeMessagingHostAllowed(pref_service, native_app_name);
   if (policy_permission == DISALLOW) {
     DispatchOnDisconnect(source, receiver_port_id, kProhibitedByPoliciesError);
     return;
   }
 
   std::unique_ptr<MessageChannel> channel(new MessageChannel());
   channel->opener.reset(
-      new ExtensionMessagePort(weak_factory_.GetWeakPtr(),
-                               GET_OPPOSITE_PORT_ID(receiver_port_id),
+      new ExtensionMessagePort(weak_factory_.GetWeakPtr(), source_port_id,
                                extension->id(), source, false));
   if (!channel->opener->IsValidPort())
     return;
   channel->opener->OpenPort(source_process_id, source_routing_id);
 
   // Get handle of the native view and pass it to the native messaging host.
   gfx::NativeView native_view = source ? source->GetNativeView() : nullptr;
 
   std::string error = kReceivingEndDoesntExistError;
   std::unique_ptr<NativeMessageHost> native_host = NativeMessageHost::Create(
@@ skipping 16 matching lines @@
 #else  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
   const char kNativeMessagingNotSupportedError[] =
       "Native Messaging is not supported on this platform.";
   DispatchOnDisconnect(
       source, receiver_port_id, kNativeMessagingNotSupportedError);
 #endif  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
 }
 
 void MessageService::OpenChannelToTab(int source_process_id,
                                       int source_routing_id,
-                                      int receiver_port_id,
+                                      const PortId& source_port_id,
                                       int tab_id,
                                       int frame_id,
                                       const std::string& extension_id,
                                       const std::string& channel_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_GE(frame_id, -1);
+  DCHECK(source_port_id.is_opener);
 
   content::RenderFrameHost* source =
       content::RenderFrameHost::FromID(source_process_id, source_routing_id);
   if (!source)
     return;
   Profile* profile =
       Profile::FromBrowserContext(source->GetProcess()->GetBrowserContext());
 
   WebContents* contents = NULL;
   std::unique_ptr<MessagePort> receiver;
+  PortId receiver_port_id(source_port_id.context_id, source_port_id.port_number,
+                          false);
   if (!ExtensionTabUtil::GetTabById(tab_id, profile, true, NULL, NULL,
                                     &contents, NULL) ||
       contents->GetController().NeedsReload()) {
     // The tab isn't loaded yet. Don't attempt to connect.
     DispatchOnDisconnect(
         source, receiver_port_id, kReceivingEndDoesntExistError);
     return;
   }
 
   // Frame ID -1 is every frame in the tab.
@@ skipping 50 matching lines @@
     return;  // Closed while in flight.
 
   if (!params->receiver || !params->receiver->IsValidPort()) {
     DispatchOnDisconnect(source, params->receiver_port_id,
                          kReceivingEndDoesntExistError);
     return;
   }
 
   std::unique_ptr<ExtensionMessagePort> opener(
       new ExtensionMessagePort(weak_factory_.GetWeakPtr(),
-                               GET_OPPOSITE_PORT_ID(params->receiver_port_id),
+                               params->receiver_port_id.GetOppositePortId(),
                                params->source_extension_id, source, false));
   if (!opener->IsValidPort())
     return;
   opener->OpenPort(params->source_process_id, params->source_routing_id);
   opener->RevalidatePort();
 
   params->receiver->RemoveCommonFrames(*opener);
   if (!params->receiver->IsValidPort()) {
     opener->DispatchOnDisconnect(kReceivingEndDoesntExistError);
     return;
@@ skipping 59 matching lines @@
     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(std::unique_ptr<MessageChannel> channel,
-                                int receiver_port_id) {
+                                const PortId& receiver_port_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  int channel_id = GET_CHANNEL_ID(receiver_port_id);
+  ChannelId channel_id = receiver_port_id.GetChannelId();
   CHECK(channels_.find(channel_id) == channels_.end());
   channels_[channel_id] = std::move(channel);
   pending_lazy_background_page_channels_.erase(channel_id);
 }
 
-void MessageService::OpenPort(int port_id, int process_id, int routing_id) {
+void MessageService::OpenPort(const PortId& port_id,
+                              int process_id,
+                              int routing_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(!IS_OPENER_PORT_ID(port_id));
+  DCHECK(!port_id.is_opener);
 
-  int channel_id = GET_CHANNEL_ID(port_id);
+  ChannelId channel_id = port_id.GetChannelId();
   MessageChannelMap::iterator it = channels_.find(channel_id);
   if (it == channels_.end())
     return;
 
   it->second->receiver->OpenPort(process_id, routing_id);
 }
 
-void MessageService::ClosePort(
-    int port_id, int process_id, int routing_id, bool force_close) {
+void MessageService::ClosePort(const PortId& port_id,
+                               int process_id,
+                               int routing_id,
+                               bool force_close) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ClosePortImpl(port_id, process_id, routing_id, force_close, std::string());
 }
 
-void MessageService::CloseChannel(int port_id,
+void MessageService::CloseChannel(const PortId& port_id,
                                   const std::string& error_message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ClosePortImpl(port_id, content::ChildProcessHost::kInvalidUniqueID,
                 MSG_ROUTING_NONE, true, error_message);
 }
 
-void MessageService::ClosePortImpl(int port_id,
+void MessageService::ClosePortImpl(const PortId& port_id,
                                    int process_id,
                                    int routing_id,
                                    bool force_close,
                                    const std::string& error_message) {
   // Note: The channel might be gone already, if the other side closed first.
-  int channel_id = GET_CHANNEL_ID(port_id);
+  ChannelId channel_id = port_id.GetChannelId();
   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::PendingLazyBackgroundPageClosePort,
                      weak_factory_.GetWeakPtr(), port_id, process_id,
                      routing_id, force_close, error_message));
     }
     return;
   }
 
   // The difference between closing a channel and port is that closing a port
   // does not necessarily have to destroy the channel if there are multiple
   // receivers, whereas closing a channel always forces all ports to be closed.
   if (force_close) {
     CloseChannelImpl(it, port_id, error_message, true);
-  } else if (IS_OPENER_PORT_ID(port_id)) {
+  } else if (port_id.is_opener) {
     it->second->opener->ClosePort(process_id, routing_id);
   } else {
     it->second->receiver->ClosePort(process_id, routing_id);
   }
 }
 
-void MessageService::CloseChannelImpl(
-    MessageChannelMap::iterator channel_iter,
-    int closing_port_id,
-    const std::string& error_message,
-    bool notify_other_port) {
+void MessageService::CloseChannelImpl(MessageChannelMap::iterator channel_iter,
+                                      const PortId& closing_port_id,
+                                      const std::string& error_message,
+                                      bool notify_other_port) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::unique_ptr<MessageChannel> channel = std::move(channel_iter->second);
   // Remove from map to make sure that it is impossible for CloseChannelImpl to
   // run twice for the same channel.
   channels_.erase(channel_iter);
 
   // Notify the other side.
   if (notify_other_port) {
-    MessagePort* port = IS_OPENER_PORT_ID(closing_port_id) ?
-        channel->receiver.get() : channel->opener.get();
+    MessagePort* port = closing_port_id.is_opener ? channel->receiver.get()
+                                                  : channel->opener.get();
     port->DispatchOnDisconnect(error_message);
   }
 
   // Balance the IncrementLazyKeepaliveCount() in OpenChannelImpl.
   channel->opener->DecrementLazyKeepaliveCount();
   channel->receiver->DecrementLazyKeepaliveCount();
 }
 
-void MessageService::PostMessage(int source_port_id, const Message& message) {
+void MessageService::PostMessage(const PortId& source_port_id,
+                                 const Message& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  int channel_id = GET_CHANNEL_ID(source_port_id);
+  ChannelId channel_id = source_port_id.GetChannelId();
   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.get(), message);
 }
 
-void MessageService::EnqueuePendingMessage(int source_port_id,
-                                           int channel_id,
+void MessageService::EnqueuePendingMessage(const PortId& source_port_id,
+                                           const ChannelId& 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.
@@ skipping 12 matching lines @@
     DCHECK(
         !base::ContainsKey(pending_lazy_background_page_channels_, channel_id));
     return;
   }
   EnqueuePendingMessageForLazyBackgroundLoad(source_port_id,
                                              channel_id,
                                              message);
 }
 
 void MessageService::EnqueuePendingMessageForLazyBackgroundLoad(
-    int source_port_id,
-    int channel_id,
+    const PortId& source_port_id,
+    const ChannelId& 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,
+void MessageService::DispatchMessage(const PortId& 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();
+  MessagePort* dest_port = source_port_id.is_opener ? channel->receiver.get()
+                                                    : channel->opener.get();
 
-  port->DispatchOnMessage(message);
+  dest_port->DispatchOnMessage(message);
 }
 
 bool MessageService::MaybeAddPendingLazyBackgroundPageOpenChannelTask(
     BrowserContext* context,
     const Extension* extension,
     std::unique_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))
     return false;
 
-  int channel_id = GET_CHANNEL_ID((*params)->receiver_port_id);
+  ChannelId channel_id = (*params)->receiver_port_id.GetChannelId();
   pending_lazy_background_page_channels_[channel_id] =
       PendingLazyBackgroundPageChannel(context, extension->id());
   int source_id = (*params)->source_process_id;
   lazy_background_task_queue_->AddPendingTask(
       context, extension->id(),
       base::Bind(&MessageService::PendingLazyBackgroundPageOpenChannel,
                  weak_factory_.GetWeakPtr(), base::Passed(params), source_id));
 
   for (const PendingMessage& message : pending_messages) {
     EnqueuePendingMessageForLazyBackgroundLoad(message.first, channel_id,
                                                message.second);
   }
   return true;
 }
 
 void MessageService::OnOpenChannelAllowed(
     std::unique_ptr<OpenChannelParams> params,
     bool allowed) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  int channel_id = GET_CHANNEL_ID(params->receiver_port_id);
+  ChannelId channel_id = params->receiver_port_id.GetChannelId();
 
   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);
   pending_incognito_channels_.erase(pending_for_incognito);
@@ skipping 61 matching lines @@
                     false /* did_enqueue */);
     DispatchPendingMessages(pending_messages, channel_id);
   }
 }
 
 void MessageService::GotChannelID(std::unique_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);
+  ChannelId channel_id = params->receiver_port_id.GetChannelId();
 
   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;
   pending_messages.swap(pending_for_tls_channel_id->second);
   pending_tls_channel_id_channels_.erase(pending_for_tls_channel_id);
@@ skipping 35 matching lines @@
 
   params->receiver.reset(
       new ExtensionMessagePort(
           weak_factory_.GetWeakPtr(), params->receiver_port_id,
           params->target_extension_id, host->render_process_host()));
   OpenChannelImpl(host->browser_context(), std::move(params), host->extension(),
                   true /* did_enqueue */);
 }
 
 void MessageService::DispatchOnDisconnect(content::RenderFrameHost* source,
-                                          int port_id,
+                                          const PortId& port_id,
                                           const std::string& error_message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ExtensionMessagePort port(weak_factory_.GetWeakPtr(),
-                            GET_OPPOSITE_PORT_ID(port_id), "", source, false);
+                            port_id.GetOppositePortId(), "", source, false);
   if (!port.IsValidPort())
     return;
   port.DispatchOnDisconnect(error_message);
 }
 
 void MessageService::DispatchPendingMessages(const PendingMessagesQueue& queue,
-                                             int channel_id) {
+                                             const ChannelId& 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.get(),
                       message.second);
     }
   }
 }
 
 }  // namespace extensions