Add a Mojo EDK for Chrome that uses one OS pipe per message pipe.

ipc/mojo/ipc_mojo_bootstrap.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 "ipc/mojo/ipc_mojo_bootstrap.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/process/process_handle.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/ipc_platform_file.h"
+
+#if defined(USE_CHROME_EDK)
+#include "mojo/edk/embedder/platform_channel_pair.h"
+#else
 #include "third_party/mojo/src/mojo/edk/embedder/platform_channel_pair.h"
+#endif
 
 namespace IPC {
 
 namespace {
 
 // MojoBootstrap for the server process. You should create the instance
 // using MojoBootstrap::Create().
 class MojoServerBootstrap : public MojoBootstrap {
  public:
   MojoServerBootstrap();
 
  private:
   void SendClientPipe(int32_t peer_pid);
 
   // Listener implementations
   bool OnMessageReceived(const Message& message) override;
   void OnChannelConnected(int32_t peer_pid) override;
 
+#if defined(USE_CHROME_EDK)
+  mojo::edk::ScopedPlatformHandle server_pipe_;
+#else
   mojo::embedder::ScopedPlatformHandle server_pipe_;
+#endif
   bool connected_;
+  int32_t peer_pid_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoServerBootstrap);
 };
 
-MojoServerBootstrap::MojoServerBootstrap() : connected_(false) {
+MojoServerBootstrap::MojoServerBootstrap() : connected_(false), peer_pid_(0) {
 }
 
 void MojoServerBootstrap::SendClientPipe(int32_t peer_pid) {
   DCHECK_EQ(state(), STATE_INITIALIZED);
   DCHECK(connected_);
 
+#if defined(USE_CHROME_EDK)
+  mojo::edk::PlatformChannelPair channel_pair;
+#else
   mojo::embedder::PlatformChannelPair channel_pair;
+#endif
   server_pipe_ = channel_pair.PassServerHandle();
 
   base::Process peer_process =
 #if defined(OS_WIN)
       base::Process::OpenWithAccess(peer_pid, PROCESS_DUP_HANDLE);
 #else
       base::Process::Open(peer_pid);
 #endif
   PlatformFileForTransit client_pipe = GetFileHandleForProcess(
 #if defined(OS_POSIX)
@@ skipping 15 matching lines @@
   scoped_ptr<Message> message(new Message());
   ParamTraits<PlatformFileForTransit>::Write(message.get(), client_pipe);
   Send(message.release());
 
   set_state(STATE_WAITING_ACK);
 }
 
 void MojoServerBootstrap::OnChannelConnected(int32_t peer_pid) {
   DCHECK_EQ(state(), STATE_INITIALIZED);
   connected_ = true;
+  peer_pid_ = peer_pid;
   SendClientPipe(peer_pid);
 }
 
 bool MojoServerBootstrap::OnMessageReceived(const Message&) {
   if (state() != STATE_WAITING_ACK) {
     set_state(STATE_ERROR);
     LOG(ERROR) << "Got inconsistent message from client.";
     return false;
   }
 
   set_state(STATE_READY);
   CHECK(server_pipe_.is_valid());
+#if defined(USE_CHROME_EDK)
   delegate()->OnPipeAvailable(
-      mojo::embedder::ScopedPlatformHandle(server_pipe_.release()));
+      mojo::edk::ScopedPlatformHandle(server_pipe_.release()), peer_pid_);
+#else
+  delegate()->OnPipeAvailable(
+      mojo::embedder::ScopedPlatformHandle(server_pipe_.release()), peer_pid_);
+#endif
 
   return true;
 }
 
 // MojoBootstrap for client processes. You should create the instance
 // using MojoBootstrap::Create().
 class MojoClientBootstrap : public MojoBootstrap {
  public:
   MojoClientBootstrap();
 
  private:
   // Listener implementations
   bool OnMessageReceived(const Message& message) override;
   void OnChannelConnected(int32_t peer_pid) override;
 
+  int32 peer_pid_;
+
   DISALLOW_COPY_AND_ASSIGN(MojoClientBootstrap);
 };
 
-MojoClientBootstrap::MojoClientBootstrap() {
+MojoClientBootstrap::MojoClientBootstrap() : peer_pid_(0) {
 }
 
 bool MojoClientBootstrap::OnMessageReceived(const Message& message) {
   if (state() != STATE_INITIALIZED) {
     set_state(STATE_ERROR);
     LOG(ERROR) << "Got inconsistent message from server.";
     return false;
   }
 
   PlatformFileForTransit pipe;
   base::PickleIterator iter(message);
   if (!ParamTraits<PlatformFileForTransit>::Read(&message, &iter, &pipe)) {
     LOG(WARNING) << "Failed to read a file handle from bootstrap channel.";
     message.set_dispatch_error();
     return false;
   }
 
   // Sends ACK back.
   Send(new Message());
   set_state(STATE_READY);
+#if defined(USE_CHROME_EDK)
+  delegate()->OnPipeAvailable(
+      mojo::edk::ScopedPlatformHandle(mojo::edk::PlatformHandle(
+          PlatformFileForTransitToPlatformFile(pipe))), peer_pid_);
+#else
   delegate()->OnPipeAvailable(
       mojo::embedder::ScopedPlatformHandle(mojo::embedder::PlatformHandle(
-          PlatformFileForTransitToPlatformFile(pipe))));
+          PlatformFileForTransitToPlatformFile(pipe))), peer_pid_);
+#endif
 
   return true;
 }
 
 void MojoClientBootstrap::OnChannelConnected(int32_t peer_pid) {
+  peer_pid_ = peer_pid;
 }
 
 }  // namespace
 
 // MojoBootstrap
 
 // static
 scoped_ptr<MojoBootstrap> MojoBootstrap::Create(ChannelHandle handle,
                                                 Channel::Mode mode,
                                                 Delegate* delegate,
@@ skipping 57 matching lines @@
 int MojoBootstrap::GetClientFileDescriptor() const {
   return channel_->GetClientFileDescriptor();
 }
 
 base::ScopedFD MojoBootstrap::TakeClientFileDescriptor() {
   return channel_->TakeClientFileDescriptor();
 }
 #endif  // defined(OS_POSIX) && !defined(OS_NACL)
 
 }  // namespace IPC