Change NaCl IPC PPAPI proxy startup to support a NaCl-Browser process

chrome/nacl/nacl_ipc_adapter.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/nacl/nacl_ipc_adapter.h"
 
 #include <limits.h>
 #include <string.h>
 
 #include "base/basictypes.h"
@@ skipping 71 matching lines @@
   funcs.SendMsg = NaClDescCustomSendMsg;
   funcs.RecvMsg = NaClDescCustomRecvMsg;
   // NaClDescMakeCustomDesc gives us a reference on the returned NaClDesc.
   return NaClDescMakeCustomDesc(new DescThunker(adapter), &funcs);
 }
 
 void DeleteChannel(IPC::Channel* channel) {
   delete channel;
 }
 
-void WriteFileDescriptor(int handle_index,
-                         const ppapi::proxy::SerializedHandle& handle,
-                         IPC::Message* message) {
+void WriteHandle(int handle_index,
+                 const ppapi::proxy::SerializedHandle& handle,
+                 IPC::Message* message) {
   ppapi::proxy::SerializedHandle::WriteHeader(handle.header(), message);
 
   // Now write the handle itself in POSIX style.
   message->WriteBool(true);  // valid == true
   message->WriteInt(handle_index);
 }
 
 typedef std::vector<ppapi::proxy::SerializedHandle> Handles;
 
 // We define one overload for catching SerializedHandles, so that we can share
 // them correctly to the untrusted side, and another for handling all other
 // parameters. See ConvertHandlesImpl for how these get used.
 void ConvertHandle(const ppapi::proxy::SerializedHandle& handle,
                    Handles* handles, IPC::Message* msg, int* handle_index) {
   handles->push_back(handle);
   if (msg)
-    WriteFileDescriptor((*handle_index)++, handle, msg);
+    WriteHandle((*handle_index)++, handle, msg);
 }
 
 // This overload is to catch all types other than SerializedHandle. On Windows,
 // |msg| will be a valid pointer, and we must write |param| to it
 template <class T>
 void ConvertHandle(const T& param, Handles* /* handles */, IPC::Message* msg,
                    int* /* handle_index */) {
   // It's not a handle, so just write to the output message, if necessary.
   if (msg)
     IPC::WriteParam(msg, param);
@@ skipping 305 matching lines @@
       }
 #define CASE_FOR_REPLY(MESSAGE_TYPE) \
       case MESSAGE_TYPE::ID: { \
         HandleConverter<MESSAGE_TYPE> extractor(&msg); \
         if (!extractor.ConvertReply( \
                 &handles, \
                 static_cast<IPC::SyncMessage*>(new_msg_ptr))) \
           return false; \
         break; \
       }
+
 bool NaClIPCAdapter::OnMessageReceived(const IPC::Message& msg) {
   {
     base::AutoLock lock(lock_);
 
     scoped_refptr<RewrittenMessage> rewritten_msg(new RewrittenMessage);
 
     // Pointer to the "new" message we will rewrite on Windows. On posix, this
     // isn't necessary, so it will stay NULL.
     IPC::Message* new_msg_ptr = NULL;
+    IPC::Message new_msg(msg.routing_id(), msg.type(), msg.priority());
 #if defined(OS_WIN)
-    IPC::Message new_msg(msg.routing_id(), msg.type(), msg.priority());
     new_msg_ptr = &new_msg;
+#else
+    // Even on POSIX, we have to rewrite messages to create channels, because
+    // these contain a handle with an invalid (place holder) descriptor. The
+    // message sending code sees this and doesn't pass the descriptor over
+    // correctly.
+    if (msg.type() == PpapiMsg_CreateNaClChannel::ID)
+      new_msg_ptr = &new_msg;
 #endif
+
     Handles handles;
     switch (msg.type()) {
+      CASE_FOR_MESSAGE(PpapiMsg_CreateNaClChannel)
       CASE_FOR_MESSAGE(PpapiMsg_PPBAudio_NotifyAudioStreamCreated)
       CASE_FOR_MESSAGE(PpapiMsg_PPBAudioInput_OpenACK)
       case IPC_REPLY_ID: {
         int id = IPC::SyncMessage::GetMessageId(msg);
         LockedData::PendingSyncMsgMap::iterator iter(
             locked_data_.pending_sync_msgs_.find(id));
         if (iter == locked_data_.pending_sync_msgs_.end()) {
           NOTREACHED();
           return false;
         }
@@ skipping 33 matching lines @@
           break;
         }
         case ppapi::proxy::SerializedHandle::SOCKET: {
           nacl_desc.reset(factory.ImportSyncSocketHandle(
 #if defined(OS_WIN)
               reinterpret_cast<const NaClHandle>(iter->descriptor())
 #else
               iter->descriptor().fd
 #endif
           ));
+          break;
+        }
+        case ppapi::proxy::SerializedHandle::CHANNEL_HANDLE: {
+          // Check that this came from a PpapiMsg_CreateNaClChannel message.
+          // This code here is only appropriate for that message.
+          DCHECK(msg.type() == PpapiMsg_CreateNaClChannel::ID);
+          IPC::ChannelHandle channel_handle =
+              IPC::Channel::GenerateVerifiedChannelID("nacl");
+          scoped_refptr<NaClIPCAdapter> ipc_adapter(
+              new NaClIPCAdapter(channel_handle, task_runner_));
+#if defined(OS_POSIX)
+          channel_handle.socket = base::FileDescriptor(
+              ipc_adapter->TakeClientFileDescriptor(), true);
+#endif
+          nacl_desc.reset(factory.MakeGeneric(ipc_adapter->MakeNaClDesc()));
+          // Send back a message that the channel was created.
+          scoped_ptr<IPC::Message> response(
+              new PpapiHostMsg_ChannelCreated(channel_handle));
+          task_runner_->PostTask(FROM_HERE,
+              base::Bind(&NaClIPCAdapter::SendMessageOnIOThread, this,
+                         base::Passed(&response)));
+          break;
         }
         case ppapi::proxy::SerializedHandle::INVALID: {
           // Nothing to do. TODO(dmichael): Should we log this? Or is it
           // sometimes okay to pass an INVALID handle?
+          break;
         }
         // No default, so the compiler will warn us if new types get added.
       }
       if (nacl_desc.get())
         rewritten_msg->AddDescriptor(nacl_desc.release());
     }
     if (new_msg_ptr && !handles.empty())
       SaveMessage(*new_msg_ptr, rewritten_msg.get());
     else
       SaveMessage(msg, rewritten_msg.get());
@@ skipping 116 matching lines @@
   header.payload_size = static_cast<uint32>(msg.payload_size());
   header.routing = msg.routing_id();
   header.type = msg.type();
   header.flags = msg.flags();
   header.num_fds = static_cast<int>(rewritten_msg->desc_count());
 
   rewritten_msg->SetData(header, msg.payload(), msg.payload_size());
   locked_data_.to_be_received_.push(rewritten_msg);
 }