Implement chrome.extension.connectExternal and fix various API inconsistencies.

chrome/browser/extensions/extension_message_service.cc

 // Copyright (c) 2009 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/extension_message_service.h"
 
 #include "base/json_writer.h"
 #include "base/singleton.h"
 #include "base/stl_util-inl.h"
 #include "base/values.h"
@@ skipping 42 matching lines @@
   ExtensionMessageService::MessagePort receiver;
 };
 
 
 namespace {
 
 static void DispatchOnConnect(const ExtensionMessageService::MessagePort& port,
                               int dest_port_id,
                               const std::string& channel_name,
                               const std::string& tab_json,
-                              const std::string& extension_id) {
+                              const std::string& source_extension_id,
+                              const std::string& target_extension_id) {
   ListValue args;
   args.Set(0, Value::CreateIntegerValue(dest_port_id));
   args.Set(1, Value::CreateStringValue(channel_name));
   args.Set(2, Value::CreateStringValue(tab_json));
-  args.Set(3, Value::CreateStringValue(extension_id));
+  args.Set(3, Value::CreateStringValue(source_extension_id));
+  args.Set(4, Value::CreateStringValue(target_extension_id));
   CHECK(port.sender);
   port.sender->Send(new ViewMsg_ExtensionMessageInvoke(
       port.routing_id, ExtensionMessageService::kDispatchOnConnect, args));
 }
 
 static void DispatchOnDisconnect(
     const ExtensionMessageService::MessagePort& port, int source_port_id) {
   ListValue args;
   args.Set(0, Value::CreateIntegerValue(source_port_id));
   port.sender->Send(new ViewMsg_ExtensionMessageInvoke(
@@ skipping 107 matching lines @@
 
   int channel_id = GET_CHANNEL_ID(port1_id);
   DCHECK(GET_CHANNEL_OPENER_ID(channel_id) == port1_id);
   DCHECK(GET_CHANNEL_RECEIVERS_ID(channel_id) == port2_id);
 
   *port1 = port1_id;
   *port2 = port2_id;
 }
 
 int ExtensionMessageService::OpenChannelToExtension(
-    int routing_id, const std::string& extension_id,
+    int routing_id, const std::string& source_extension_id,
+    const std::string& target_extension_id,
     const std::string& channel_name, ResourceMessageFilter* source) {
   DCHECK_EQ(MessageLoop::current(),
             ChromeThread::GetMessageLoop(ChromeThread::IO));
 
   // Create a channel ID for both sides of the channel.
   int port1_id = -1;
   int port2_id = -1;
   AllocatePortIdPair(&port1_id, &port2_id);
 
   // Each side of the port is given his own port ID.  When they send messages,
   // we convert to the opposite port ID.  See PostMessageFromRenderer.
   ui_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
           &ExtensionMessageService::OpenChannelToExtensionOnUIThread,
-          source->id(), routing_id, port2_id, extension_id, channel_name));
+          source->id(), routing_id, port2_id, source_extension_id,
+          target_extension_id, channel_name));
 
   return port1_id;
 }
 
 int ExtensionMessageService::OpenChannelToTab(int routing_id,
                                               int tab_id,
                                               const std::string& extension_id,
                                               const std::string& channel_name,
                                               ResourceMessageFilter* source) {
   DCHECK_EQ(MessageLoop::current(),
@@ skipping 10 matching lines @@
       NewRunnableMethod(this,
           &ExtensionMessageService::OpenChannelToTabOnUIThread,
           source->id(), routing_id, port2_id, tab_id, extension_id,
           channel_name));
 
   return port1_id;
 }
 
 void ExtensionMessageService::OpenChannelToExtensionOnUIThread(
     int source_process_id, int source_routing_id, int receiver_port_id,
-    const std::string& extension_id, const std::string& channel_name) {
+    const std::string& source_extension_id,
+    const std::string& target_extension_id,
+    const std::string& channel_name) {
   if (!profile_)
     return;
 
   RenderProcessHost* source = RenderProcessHost::FromID(source_process_id);
   MessagePort receiver(
-      profile_->GetExtensionProcessManager()->GetExtensionProcess(extension_id),
+      profile_->GetExtensionProcessManager()->GetExtensionProcess(
+          target_extension_id),
       MSG_ROUTING_CONTROL);
   receiver.debug_info = 1;
   TabContents* source_contents = tab_util::GetTabContentsByID(
       source_process_id, source_routing_id);
   OpenChannelOnUIThreadImpl(source, source_contents,
                             receiver, receiver_port_id,
-                            extension_id, channel_name);
+                            source_extension_id, target_extension_id,
+                            channel_name);
 }
 
 void ExtensionMessageService::OpenChannelToTabOnUIThread(
     int source_process_id, int source_routing_id, int receiver_port_id,
     int tab_id, const std::string& extension_id,
     const std::string& channel_name) {
   RenderProcessHost* source = RenderProcessHost::FromID(source_process_id);
   TabContents* contents;
   MessagePort receiver;
   receiver.debug_info = 2;
   if (ExtensionTabUtil::GetTabById(tab_id, source->profile(),
                                    NULL, NULL, &contents, NULL)) {
     receiver.sender = contents->render_view_host();
     receiver.routing_id = contents->render_view_host()->routing_id();
     receiver.debug_info = 3;
   }
   TabContents* source_contents = tab_util::GetTabContentsByID(
       source_process_id, source_routing_id);
   OpenChannelOnUIThreadImpl(source, source_contents,
                             receiver, receiver_port_id,
-                            extension_id, channel_name);
+                            extension_id, extension_id, channel_name);
 }
 
 bool ExtensionMessageService::OpenChannelOnUIThreadImpl(
     IPC::Message::Sender* source, TabContents* source_contents,
     const MessagePort& receiver, int receiver_port_id,
-    const std::string& extension_id, const std::string& channel_name) {
+    const std::string& source_extension_id,
+    const std::string& target_extension_id,
+    const std::string& channel_name) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   // TODO(mpcomplete): notify source if reciever doesn't exist
   if (!source)
     return false;  // Closed while in flight.
 
   if (!receiver.sender) {
     // Treat it as a disconnect.
     DispatchOnDisconnect(MessagePort(source, MSG_ROUTING_CONTROL),
                          GET_OPPOSITE_PORT_ID(receiver_port_id));
@@ skipping 20 matching lines @@
     DictionaryValue* tab_value =
         ExtensionTabUtil::CreateTabValue(source_contents);
     JSONWriter::Write(tab_value, false, &tab_json);
   }
 
   CHECK(receiver.sender);
 
   // Send the connect event to the receiver.  Give it the opener's port ID (the
   // opener has the opposite port ID).
   DispatchOnConnect(receiver, receiver_port_id, channel_name, tab_json,
-                    extension_id);
+                    source_extension_id, target_extension_id);
 
   return true;
 }
 
 int ExtensionMessageService::OpenSpecialChannelToExtension(
     const std::string& extension_id, const std::string& channel_name,
     IPC::Message::Sender* source) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
   DCHECK(profile_);
 
   int port1_id = -1;
   int port2_id = -1;
   // Create a channel ID for both sides of the channel.
   AllocatePortIdPair(&port1_id, &port2_id);
 
   MessagePort receiver(
       profile_->GetExtensionProcessManager()->
       GetExtensionProcess(extension_id),
       MSG_ROUTING_CONTROL);
   receiver.debug_info = 4;
   if (!OpenChannelOnUIThreadImpl(
-      source, NULL, receiver, port2_id, extension_id, channel_name))
+      source, NULL, receiver, port2_id, extension_id, extension_id,
+      channel_name))
     return -1;
 
   return port1_id;
 }
 
 int ExtensionMessageService::OpenSpecialChannelToTab(
     const std::string& extension_id, const std::string& channel_name,
     TabContents* target_tab_contents, IPC::Message::Sender* source) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
   DCHECK(target_tab_contents);
 
   int port1_id = -1;
   int port2_id = -1;
   // Create a channel ID for both sides of the channel.
   AllocatePortIdPair(&port1_id, &port2_id);
 
   MessagePort receiver(
       target_tab_contents->render_view_host(),
       target_tab_contents->render_view_host()->routing_id());
   receiver.debug_info = 5;
   if (!OpenChannelOnUIThreadImpl(source, NULL,
                                  receiver, port2_id,
-                                 extension_id, channel_name))
+                                 extension_id, extension_id, channel_name))
     return -1;
 
   return port1_id;
 }
 
 void ExtensionMessageService::CloseChannel(int port_id) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   // Note: The channel might be gone already, if the other side closed first.
   MessageChannelMap::iterator it = channels_.find(GET_CHANNEL_ID(port_id));
@@ skipping 118 matching lines @@
 
     if (current->second->opener.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_OPENER_ID(current->first),
                        notify_other_port);
     } else if (current->second->receiver.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_RECEIVERS_ID(current->first),
                        notify_other_port);
     }
   }
 }