Native Messaging!

chrome/browser/extensions/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/message_service.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
+#include "chrome/browser/extensions/native_message_process.h"
 #include "chrome/browser/extensions/process_map.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/view_type.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 
 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 {
 
 struct MessageService::MessagePort {

[Matt Perry, 2012/08/09 02:13:00]

maybe we should turn this into an interface that does the right thing for both
renderers and native processes. it could have the Dispatch* and
Increment/Decrement* methods too, so that you don't have to check is_native.

[Aaron Boodman, 2012/08/09 18:36:12]

/me is shocked to here mpcomplete say 'interface'. Agree.

[eaugusti, 2012/08/13 23:22:34]

Done.

   content::RenderProcessHost* process;
   int routing_id;
   std::string extension_id;
   void* background_host_ptr;  // used in IncrementLazyKeepaliveCount
+  // HACK(eriq)
+  bool is_native;
+  linked_ptr<NativeMessageProcess> native_process;

[Aaron Boodman, 2012/08/09 18:36:12]

linked_ptr here is unfortunate, as it makes the lifetime of this process less
clear. Can you make this a scoped_ptr and wherever we pass MessagePort by copy
today, pass scoped_ptr instead?

[eaugusti, 2012/08/13 23:22:34]

Will now be a raw pointer.

 
   MessagePort()
      : process(NULL),
        routing_id(MSG_ROUTING_CONTROL),
-       background_host_ptr(NULL) {}
+       background_host_ptr(NULL),
+       is_native(false) {}
   MessagePort(content::RenderProcessHost* process,
               int routing_id,
               const std::string& extension_id)
      : process(process),
        routing_id(routing_id),
        extension_id(extension_id),
-       background_host_ptr(NULL) {}
+       background_host_ptr(NULL),
+       is_native(false) {}
 };
 
 struct MessageService::MessageChannel {
   MessageService::MessagePort opener;
   MessageService::MessagePort receiver;
 };
 
 struct MessageService::OpenChannelParams {
   content::RenderProcessHost* source;
   std::string tab_json;
@@ skipping 37 matching lines @@
 static void DispatchOnDisconnect(const MessageService::MessagePort& port,
                                  int source_port_id,
                                  bool connection_error) {
   port.process->Send(new ExtensionMsg_DispatchOnDisconnect(
       port.routing_id, source_port_id, connection_error));
 }
 
 static void DispatchOnMessage(const MessageService::MessagePort& port,
                               const std::string& message,
                               int target_port_id) {
-  port.process->Send(new ExtensionMsg_DeliverMessage(
-      port.routing_id, target_port_id, message));
+  if (port.is_native) {
+    port.native_process->Send(message);
+  } else {
+    port.process->Send(new ExtensionMsg_DeliverMessage(
+        port.routing_id, target_port_id, message));
+  }
 }
 
 static content::RenderProcessHost* GetExtensionProcess(
     Profile* profile, const std::string& extension_id) {
   SiteInstance* site_instance =
       profile->GetExtensionProcessManager()->GetSiteInstanceForURL(
           Extension::GetBaseURLFromExtensionId(extension_id));
 
   if (!site_instance->HasProcess())
     return NULL;
@@ skipping 94 matching lines @@
 
   // The target might be a lazy background page. In that case, we have to check
   // if it is loaded and ready, and if not, queue up the task and load the
   // page.
   if (MaybeAddPendingOpenChannelTask(profile, params))
     return;
 
   OpenChannelImpl(params);
 }
 
+void MessageService::OpenChannelToNativeApp(
+    int source_process_id,
+    int source_routing_id,
+    int receiver_port_id,
+    const std::string& source_extension_id,
+    const std::string& native_app_name,
+    const std::string& channel_name,
+    const std::string& connect_message) {
+  content::RenderProcessHost* source =
+      content::RenderProcessHost::FromID(source_process_id);
+  if (!source)
+    return;
+  Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
+
+  // Note: we use the source's profile here. If the source is an incognito
+  // process, we will use the incognito EPM to find the right extension process,
+  // which depends on whether the extension uses spanning or split mode.
+  MessagePort receiver(GetExtensionProcess(profile, source_extension_id),

[Matt Perry, 2012/08/09 02:13:00]

The receiver is the target of the connect event - in this case, a native app. So
you shouldn't be using the extension process here. I think it makes sense to
just make it NULL (or turn MessagePort into an interface like I mentioned above,
so there is no RenderProcessHost for the native case).

[eaugusti, 2012/08/13 23:22:34]

Done.

+                       MSG_ROUTING_CONTROL,
+                       "native");
+  WebContents* source_contents = tab_util::GetWebContentsByID(
+      source_process_id, source_routing_id);
+
+  // Include info about the opener's tab (if it was a tab).
+  std::string tab_json = "null";
+  if (source_contents) {
+    scoped_ptr<DictionaryValue> tab_value(
+        ExtensionTabUtil::CreateTabValue(source_contents));
+    base::JSONWriter::Write(tab_value.get(), &tab_json);
+  }
+
+  MessageChannel* channel(new MessageChannel);
+  channel->opener = MessagePort(source, MSG_ROUTING_CONTROL,
+                                source_extension_id);
+  channel->receiver = receiver;
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&MessageService::OpenChannelToNativeAppOnFileThread,
+                 base::Unretained(this),
+                 receiver_port_id,
+                 native_app_name,
+                 channel_name,
+                 connect_message,
+                 channel,
+                 tab_json));
+
+  // TODO(eriq): This should actually be called after the channel is opened
+  // successfully.
+  IncrementLazyKeepaliveCount(&channel->opener);
+}
+
+void MessageService::OpenChannelToNativeAppOnFileThread(

[Matt Perry, 2012/08/09 02:13:00]

This class is not threadsafe. Same goes for |channel|. They can only be accessed
on the FILE thread. This should be a static function. If you need to update
state after this runs, you should post a task from the FILE thread back to the
UI.

[eaugusti, 2012/08/13 23:22:34]

Done.

+    int receiver_port_id,
+    const std::string& native_app_name,
+    const std::string& channel_name,
+    const std::string& connect_message,
+    MessageChannel* channel,
+    const std::string& tab_json) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+
+  NativeMessageProcess::MessageType type = NativeMessageProcess::TYPE_CONNECT;
+  if (channel_name == "chrome.extension.sendNativeMessage")
+    type = NativeMessageProcess::TYPE_SEND_MESSAGE_REQUEST;
+
+  NativeMessageProcess* native_process = NativeMessageProcess::Create(
+      native_app_name, connect_message, this, receiver_port_id, type);

[Matt Perry, 2012/08/09 02:13:00]

What if an extension opens 2 channels to the same process? Do we spawn 2
processes, or try to keep track of whether it's running?

[Aaron Boodman, 2012/08/09 18:36:12]

I think we should just create two. The extension should use connect/send if they
want to have a long-lived conversation with a single process.

Or if the app would like to share connections, it can implement that on its end,
too.

[eaugusti, 2012/08/13 23:22:34]

I agree with spawning multiple processes, the native application may be
stateful.

+  if (!native_process) {
+    LOG(ERROR) << "Failed to create native process.";
+    return;
+  }
+  channel->receiver.is_native = true;
+  channel->receiver.native_process.reset(native_process);
+
+  int channel_id = GET_CHANNEL_ID(receiver_port_id);
+  CHECK(channels_.find(channel_id) == channels_.end());
+  channels_[channel_id] = channel;
+  pending_channels_.erase(channel_id);
+
+  // Send the connect event to the receiver.  Give it the opener's port ID (the
+  // opener has the opposite port ID).
+  DispatchOnConnect(channel->receiver, receiver_port_id,

[Matt Perry, 2012/08/09 02:13:00]

I don't think this call makes sense. You're dispatching a "connect" event to the
receiver, which is a native app. It's actually sent to the opener extension,
though, since that's what you used when initializing the receiver.

[eaugusti, 2012/08/13 23:22:34]

You're right, it doesn't make sense.

+                    channel_name, tab_json,
+                    channel->opener.extension_id, "native");
+}
+
 void MessageService::OpenChannelToTab(
     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) {
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
   if (!source)
     return;
   Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
 
@@ skipping 91 matching lines @@
 
 void MessageService::CloseChannelImpl(
     MessageChannelMap::iterator channel_iter, int closing_port_id,
     bool connection_error, bool notify_other_port) {
   MessageChannel* channel = channel_iter->second;
 
   // Notify the other side.
   if (notify_other_port) {
     const MessagePort& port = IS_OPENER_PORT_ID(closing_port_id) ?
         channel->receiver : channel->opener;
-    DispatchOnDisconnect(port, GET_OPPOSITE_PORT_ID(closing_port_id),
-                         connection_error);
+
+    if (!port.is_native) {
+      DispatchOnDisconnect(port, GET_OPPOSITE_PORT_ID(closing_port_id),
+                           connection_error);
+    }
   }
 
   // Balance the addrefs in OpenChannelImpl.
   DecrementLazyKeepaliveCount(&channel->opener);
-  DecrementLazyKeepaliveCount(&channel->receiver);
+  // The reciever may be native.
+  if (!channel->receiver.is_native) {
+    DecrementLazyKeepaliveCount(&channel->receiver);
+  }
 
   delete channel_iter->second;
   channels_.erase(channel_iter);
 }
 
 void MessageService::PostMessageFromRenderer(
     int source_port_id, const std::string& message) {
   int channel_id = GET_CHANNEL_ID(source_port_id);
   MessageChannelMap::iterator iter = channels_.find(channel_id);
   if (iter == channels_.end()) {
@@ skipping 94 matching lines @@
   if (!params.source)
     return;
 
   params.receiver = MessagePort(host->render_process_host(),
                                 MSG_ROUTING_CONTROL,
                                 params.target_extension_id);
   OpenChannelImpl(params);
 }
 
 }  // namespace extensions