Use FrameTreeNode ID as frameId in extension APIs

chrome/browser/renderer_host/chrome_extension_message_filter.cc

 // Copyright 2014 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/renderer_host/chrome_extension_message_filter.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 66 matching lines @@
 
 bool ChromeExtensionMessageFilter::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ChromeExtensionMessageFilter, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToExtension,
                         OnOpenChannelToExtension)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToTab, OnOpenChannelToTab)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToNativeApp,
                         OnOpenChannelToNativeApp)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenMessagePort, OnOpenMessagePort)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_CloseMessagePort, OnCloseMessagePort)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_PostMessage, OnPostMessage)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ExtensionHostMsg_GetMessageBundle,
                                     OnGetExtMessageBundle)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_CloseChannel, OnExtensionCloseChannel)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddAPIActionToActivityLog,
                         OnAddAPIActionToExtensionActivityLog);
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddDOMActionToActivityLog,
                         OnAddDOMActionToExtensionActivityLog);
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddEventToActivityLog,
                         OnAddEventToExtensionActivityLog);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void ChromeExtensionMessageFilter::OverrideThreadForMessage(
     const IPC::Message& message, BrowserThread::ID* thread) {
   switch (message.type()) {
+    case ExtensionHostMsg_OpenMessagePort::ID:
+    case ExtensionHostMsg_CloseMessagePort::ID:
     case ExtensionHostMsg_PostMessage::ID:
-    case ExtensionHostMsg_CloseChannel::ID:
     case ExtensionHostMsg_AddAPIActionToActivityLog::ID:
     case ExtensionHostMsg_AddDOMActionToActivityLog::ID:
     case ExtensionHostMsg_AddEventToActivityLog::ID:
       *thread = BrowserThread::UI;
       break;
     default:
       break;
   }
 }
 
@@ skipping 67 matching lines @@
     extensions::MessageService::Get(profile_)
         ->OpenChannelToNativeApp(render_process_id_,
                                  source_routing_id,
                                  receiver_port_id,
                                  source_extension_id,
                                  native_app_name);
   }
 }
 
 void ChromeExtensionMessageFilter::OnOpenChannelToTab(
+    int routing_id,
     const ExtensionMsg_TabTargetConnectionInfo& info,
     const std::string& extension_id,
     const std::string& channel_name,
     int* port_id) {
   int port2_id;
   extensions::MessageService::AllocatePortIdPair(port_id, &port2_id);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ChromeExtensionMessageFilter::OpenChannelToTabOnUIThread,
-                 this, render_process_id_, port2_id, info, extension_id,
-                 channel_name));
+                 this, render_process_id_, routing_id, port2_id, info,
+                 extension_id, channel_name));
 }
 
 void ChromeExtensionMessageFilter::OpenChannelToTabOnUIThread(
     int source_process_id,
+    int source_routing_id,
     int receiver_port_id,
     const ExtensionMsg_TabTargetConnectionInfo& info,
     const std::string& extension_id,
     const std::string& channel_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (profile_) {
     extensions::MessageService::Get(profile_)
         ->OpenChannelToTab(source_process_id,
+                           source_routing_id,
                            receiver_port_id,
                            info.tab_id,
                            info.frame_id,
                            extension_id,
                            channel_name);
   }
 }
 
+void ChromeExtensionMessageFilter::OnOpenMessagePort(int routing_id,
+                                                     int port_id) {
+  if (!profile_)
+    return;
+
+  extensions::MessageService::Get(profile_)->OpenPort(
+      port_id, render_process_id_, routing_id);
+}
+
+void ChromeExtensionMessageFilter::OnCloseMessagePort(int routing_id,
+                                                      int port_id,
+                                                      bool force_close) {
+  if (!profile_)
+    return;
+
+  extensions::MessageService::Get(profile_)->ClosePort(
+      port_id, render_process_id_, routing_id, force_close);
+}
+
 void ChromeExtensionMessageFilter::OnPostMessage(
     int port_id,
     const extensions::Message& message) {
   if (!profile_)
     return;
 
   extensions::MessageService::Get(profile_)->PostMessage(port_id, message);
 }
 
 void ChromeExtensionMessageFilter::OnGetExtMessageBundle(
@@ skipping 15 matching lines @@
 
   scoped_ptr<extensions::MessageBundle::SubstitutionMap> dictionary_map(
       extensions::file_util::LoadMessageBundleSubstitutionMapWithImports(
           extension_id, extension_set));
 
   ExtensionHostMsg_GetMessageBundle::WriteReplyParams(reply_msg,
                                                       *dictionary_map);
   Send(reply_msg);
 }
 
-void ChromeExtensionMessageFilter::OnExtensionCloseChannel(
-    int port_id,
-    const std::string& error_message) {
-  if (!profile_)
-    return;
-
-  if (!content::RenderProcessHost::FromID(render_process_id_))
-    return;  // To guard against crash in browser_tests shutdown.
-
-  extensions::MessageService* message_service =
-      extensions::MessageService::Get(profile_);
-  if (message_service)
-    message_service->CloseChannel(port_id, error_message);
-}
-
 void ChromeExtensionMessageFilter::OnAddAPIActionToExtensionActivityLog(
     const std::string& extension_id,
     const ExtensionHostMsg_APIActionOrEvent_Params& params) {
   scoped_refptr<extensions::Action> action = new extensions::Action(
       extension_id, base::Time::Now(), extensions::Action::ACTION_API_CALL,
       params.api_call);
   action->set_args(make_scoped_ptr(params.arguments.DeepCopy()));
   if (!params.extra.empty()) {
     action->mutable_other()->SetString(
         activity_log_constants::kActionExtra, params.extra);
@@ skipping 29 matching lines @@
   AddActionToExtensionActivityLog(profile_, action);
 }
 
 void ChromeExtensionMessageFilter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
   profile_ = NULL;
 }