The Windows portion of Native Messagaing

chrome/browser/extensions/api/messaging/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/api/messaging/message_service.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
@@ skipping 198 matching lines @@
   scoped_ptr<MessageChannel> channel(new MessageChannel());
   channel->opener.reset(new ExtensionMessagePort(source, MSG_ROUTING_CONTROL,
                                                  source_extension_id));
 
   NativeMessageProcessHost::MessageType type =
       channel_name == "chrome.extension.sendNativeMessage" ?
       NativeMessageProcessHost::TYPE_SEND_MESSAGE_REQUEST :
       NativeMessageProcessHost::TYPE_CONNECT;
 
   content::BrowserThread::PostTask(
-      content::BrowserThread::FILE,
+      content::BrowserThread::IO,

[rvargas (doing something else), 2012/11/29 01:19:23]

Why the IO thread?

[eaugusti, 2012/12/07 02:21:08]

Because Windows' FILE thread has a MessageLoopForIO that has a type of TYPE_UI
(because of some restrictions with Windows notifications) and we need to do
async IO that requires a MessageLoopForIO with TYPE_IO. See
http://code.google.com/searchframe#OAMlx_jo-ck/src/content/browser/browser_ma...

On 2012/11/29 01:19:23, rvargas wrote:

       FROM_HERE,
       base::Bind(&NativeMessageProcessHost::Create,
                  base::WeakPtr<NativeMessageProcessHost::Client>(
                     weak_factory_.GetWeakPtr()),
                  native_app_name, connect_message, receiver_port_id,
                  type,
                  base::Bind(&MessageService::FinalizeOpenChannelToNativeApp,
                             weak_factory_.GetWeakPtr(),
                             receiver_port_id,
                             channel_name,
                             base::Passed(&channel),
                             tab_json)));
 }
 
 void MessageService::FinalizeOpenChannelToNativeApp(
     int receiver_port_id,
     const std::string& channel_name,
     scoped_ptr<MessageChannel> channel,
     const std::string& tab_json,
     NativeMessageProcessHost::ScopedHost native_process) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // Abandon the channel
   if (!native_process.get()) {
     LOG(ERROR) << "Failed to create native process.";
+    channel->opener->DispatchOnDisconnect(
+        GET_OPPOSITE_PORT_ID(receiver_port_id), true);
     return;
   }
   channel->receiver.reset(new NativeMessagePort(native_process.release()));
 
   // Keep the opener alive until the channel is closed.
   channel->opener->IncrementLazyKeepaliveCount();
 
   AddChannel(channel.release(), receiver_port_id);
 }
 
@@ skipping 245 matching lines @@
     return;
 
   params->source = source;
   params->receiver.reset(new ExtensionMessagePort(host->render_process_host(),
                                                   MSG_ROUTING_CONTROL,
                                                   params->target_extension_id));
   OpenChannelImpl(params.Pass());
 }
 
 }  // namespace extensions