Fix some issues with extension messaging:

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 25 matching lines @@
 typedef std::map<URLRequestContext*, ExtensionMessageService*> InstanceMap;
 struct SingletonData {
   ~SingletonData() {
     STLDeleteContainerPairSecondPointers(map.begin(), map.end());
   }
   Lock lock;
   InstanceMap map;
 };
 
 static void DispatchOnConnect(IPC::Message::Sender* channel, int source_port_id,
-                              const std::string& tab_json) {
+                              const std::string& tab_json,
+                              const std::string& extension_id) {
   ListValue args;
   args.Set(0, Value::CreateIntegerValue(source_port_id));
   args.Set(1, Value::CreateStringValue(tab_json));
+  args.Set(2, Value::CreateStringValue(extension_id));
   channel->Send(new ViewMsg_ExtensionMessageInvoke(
       ExtensionMessageService::kDispatchOnConnect, args));
 }
 
 static void DispatchOnDisconnect(IPC::Message::Sender* channel,
                                  int source_port_id) {
   ListValue args;
   args.Set(0, Value::CreateIntegerValue(source_port_id));
   channel->Send(new ViewMsg_ExtensionMessageInvoke(
       ExtensionMessageService::kDispatchOnDisconnect, args));
@@ skipping 154 matching lines @@
 
   DCHECK(initialized_);
 
   // Create a channel ID for both sides of the channel.
   int port1_id = -1;
   int port2_id = -1;
   AllocatePortIdPair(&port1_id, &port2_id);
 
   ui_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &ExtensionMessageService::OpenChannelOnUIThread,
-          routing_id, port1_id, source->GetProcessId(), port2_id, process_id));
+          routing_id, port1_id, source->GetProcessId(), port2_id, process_id,
+          extension_id));
 
   return port2_id;
 }
 
 void ExtensionMessageService::OpenChannelOnUIThread(
     int source_routing_id, int source_port_id, int source_process_id,
-    int dest_port_id, int dest_process_id) {
+    int dest_port_id, int dest_process_id, const std::string& extension_id) {
   RenderProcessHost* source = RenderProcessHost::FromID(source_process_id);
   OpenChannelOnUIThreadImpl(source_routing_id, source_port_id,
-                            source, dest_port_id, dest_process_id,
-                            source_process_id);
+                            source_process_id, source, dest_port_id,
+                            dest_process_id, extension_id);
 }
 
 void ExtensionMessageService::OpenChannelOnUIThreadImpl(
-    int source_routing_id, int source_port_id, IPC::Message::Sender* source,
-    int dest_port_id, int dest_process_id, int source_process_id) {
+    int source_routing_id, int source_port_id, int source_process_id,
+    IPC::Message::Sender* source, int dest_port_id, int dest_process_id,
+    const std::string& extension_id) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   MessageChannel channel;
   channel.port1 = source;
   channel.port2 = RenderProcessHost::FromID(dest_process_id);
   if (!channel.port1 || !channel.port2) {
     // One of the processes could have been closed while posting this task.
     return;
   }
 
   channels_[GET_CHANNEL_ID(source_port_id)] = channel;
 
   std::string tab_json = "null";
   TabContents* contents = tab_util::GetTabContentsByID(source_process_id,
                                                        source_routing_id);
   if (contents) {
     DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(contents);
     JSONWriter::Write(tab_value, false, &tab_json);
   }
 
   // Send the process the id for the opposite port.
-  DispatchOnConnect(channel.port2, source_port_id, tab_json);
+  DispatchOnConnect(channel.port2, source_port_id, tab_json, extension_id);
 }
 
 int ExtensionMessageService::OpenAutomationChannelToExtension(
     int source_process_id, int routing_id, const std::string& extension_id,
     IPC::Message::Sender* source) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   // Lookup the targeted extension process.
   int process_id = GetProcessIdForExtension(extension_id);
   if (process_id == -1)
     return -1;
 
   DCHECK(initialized_);
 
   int port1_id = -1;
   int port2_id = -1;
   // Create a channel ID for both sides of the channel.
   AllocatePortIdPair(&port1_id, &port2_id);
 
   // TODO(siggi): The source process- and routing ids are used to
   //      describe the originating tab to the target extension.
   //      This isn't really appropriate here, the originating tab
   //      information should be supplied by the caller for
   //      automation-initiated ports.
-  OpenChannelOnUIThreadImpl(routing_id, port1_id, source, port2_id,
-                            process_id, source_process_id);
+  OpenChannelOnUIThreadImpl(routing_id, port1_id, source_process_id,
+                            source, port2_id, process_id, extension_id);
 
   return port2_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));
   if (it != channels_.end())
     CloseChannelImpl(it, port_id);
 }
 
 void ExtensionMessageService::CloseChannelImpl(
     MessageChannelMap::iterator channel_iter, int port_id) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   // Notify the other side.
   if (port_id == GET_CHANNEL_PORT1(channel_iter->first)) {
-    DispatchOnDisconnect(channel_iter->second.port2, port_id);
+    DispatchOnDisconnect(channel_iter->second.port2,
+                         GET_OPPOSITE_PORT_ID(port_id));
   } else {
     DCHECK_EQ(port_id, GET_CHANNEL_PORT2(channel_iter->first));
-    DispatchOnDisconnect(channel_iter->second.port1, port_id);
+    DispatchOnDisconnect(channel_iter->second.port1,
+                         GET_OPPOSITE_PORT_ID(port_id));
   }
 
   channels_.erase(channel_iter);
 }
 
 void ExtensionMessageService::PostMessageFromRenderer(
     int port_id, const std::string& message) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   MessageChannelMap::iterator iter =
@@ skipping 57 matching lines @@
   for (MessageChannelMap::iterator it = channels_.begin();
        it != channels_.end(); ) {
     MessageChannelMap::iterator current = it++;
     if (current->second.port1 == renderer) {
       CloseChannelImpl(current, GET_CHANNEL_PORT1(current->first));
     } else if (current->second.port2 == renderer) {
       CloseChannelImpl(current, GET_CHANNEL_PORT2(current->first));
     }
   }
 }