Extension ports devtools remote service....

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 207 matching lines @@
 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) {
   if (!profile_)
     return;
 
   RenderProcessHost* source = RenderProcessHost::FromID(source_process_id);
   MessagePort receiver(
       profile_->GetExtensionProcessManager()->GetExtensionProcess(extension_id),
       MSG_ROUTING_CONTROL);
-  OpenChannelOnUIThreadImpl(source, source_process_id, source_routing_id,
-                            receiver, receiver_port_id, extension_id,
-                            channel_name);
+  TabContents* source_contents = tab_util::GetTabContentsByID(
+      source_process_id, source_routing_id);
+  OpenChannelOnUIThreadImpl(source, source_contents,
+                            receiver, receiver_port_id,
+                            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;
   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();
   }
-  OpenChannelOnUIThreadImpl(source, source_process_id, source_routing_id,
-                            receiver, receiver_port_id, extension_id,
-                            channel_name);
+  TabContents* source_contents = tab_util::GetTabContentsByID(
+      source_process_id, source_routing_id);
+  OpenChannelOnUIThreadImpl(source, source_contents,
+                            receiver, receiver_port_id,
+                            extension_id, channel_name);
 }
 
 bool ExtensionMessageService::OpenChannelOnUIThreadImpl(
-    IPC::Message::Sender* source, int source_process_id, int source_routing_id,
+    IPC::Message::Sender* source, TabContents* source_contents,
     const MessagePort& receiver, int receiver_port_id,
     const std::string& 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.
@@ skipping 11 matching lines @@
   channel->receiver = receiver;
 
   CHECK(receiver.sender);
 
   channels_[GET_CHANNEL_ID(receiver_port_id)] = channel;
 
   CHECK(receiver.sender);
 
   // Include info about the opener's tab (if it was a tab).
   std::string tab_json = "null";
-  TabContents* contents = tab_util::GetTabContentsByID(source_process_id,
-                                                       source_routing_id);
-  if (contents) {
-    DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(contents);
+  if (source_contents) {
+    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);
 
   return true;
 }
 
-int ExtensionMessageService::OpenAutomationChannelToExtension(
-    int source_process_id, int routing_id, const std::string& extension_id,
-    const std::string& channel_name, IPC::Message::Sender* source) {
+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);
 
-  // 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.
   MessagePort receiver(
-      profile_->GetExtensionProcessManager()->GetExtensionProcess(extension_id),
+      profile_->GetExtensionProcessManager()->
+      GetExtensionProcess(extension_id),
       MSG_ROUTING_CONTROL);
-  if (!OpenChannelOnUIThreadImpl(source, source_process_id, routing_id,
-                                 receiver, port2_id, extension_id,
-                                 channel_name))
+  if (!OpenChannelOnUIThreadImpl(
+      source, NULL, receiver, port2_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());
+  if (!OpenChannelOnUIThreadImpl(source, NULL,
+                                 receiver, port2_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 87 matching lines @@
   for (MessageChannelMap::iterator it = channels_.begin();
        it != channels_.end(); ) {
     MessageChannelMap::iterator current = it++;
     if (current->second->opener.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_OPENER_ID(current->first));
     } else if (current->second->receiver.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_RECEIVERS_ID(current->first));
     }
   }
 }