Use ChannelMojo in Pepper and NaCl processes.

components/nacl/loader/nacl_listener.cc

 // Copyright 2013 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 "components/nacl/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_renderer_messages.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "components/nacl/loader/nacl_ipc_adapter.h"
 #include "components/nacl/loader/nacl_validation_db.h"
 #include "components/nacl/loader/nacl_validation_query.h"
+#include "content/public/common/mojo_channel_switches.h"
 #include "ipc/attachment_broker_unprivileged.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message_filter.h"
+#include "ipc/mojo/ipc_channel_mojo.h"
+#include "ipc/mojo/scoped_ipc_support.h"
+#include "mojo/edk/embedder/embedder.h"
 #include "native_client/src/public/chrome_main.h"
 #include "native_client/src/public/nacl_app.h"
 #include "native_client/src/public/nacl_desc.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
+#include "base/posix/global_descriptors.h"
+#include "content/public/common/content_descriptors.h"
 #endif
 
 #if defined(OS_LINUX)
 #include "content/public/common/child_process_sandbox_support_linux.h"
 #endif
 
 #if defined(OS_WIN)
 #include <io.h>
 
 #include "content/public/common/sandbox_init.h"
+#include "mojo/edk/embedder/platform_channel_pair.h"
 #endif
 
 namespace {
 
 NaClListener* g_listener;
 
 void FatalLogHandler(const char* data, size_t bytes) {
   // We use uint32_t rather than size_t for the case when the browser and NaCl
   // processes are a mix of 32-bit and 64-bit processes.
   uint32_t copy_bytes = std::min<uint32_t>(static_cast<uint32_t>(bytes),
@@ skipping 103 matching lines @@
 #if defined(OS_POSIX)
       number_of_cores_(-1),  // unknown/error
 #endif
       main_loop_(NULL),
       is_started_(false) {
   IPC::AttachmentBrokerUnprivileged::CreateBrokerIfNeeded();
   io_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   DCHECK(g_listener == NULL);
   g_listener = this;
+
+  mojo::edk::Init();
+  mojo_ipc_support_.reset(new IPC::ScopedIPCSupport(
+      io_thread_.task_runner().get()));
 }
 
 NaClListener::~NaClListener() {
   NOTREACHED();
   shutdown_event_.Signal();
   g_listener = NULL;
 }
 
 bool NaClListener::Send(IPC::Message* msg) {
   DCHECK(main_loop_ != NULL);
@@ skipping 28 matching lines @@
       IPC::PlatformFileForTransit ipc_fd,
       base::FilePath file_path) {
     CHECK(g_listener);
     g_listener->OnFileTokenResolved(token_lo, token_hi, ipc_fd, file_path);
   }
  private:
   ~FileTokenMessageFilter() override {}
 };
 
 void NaClListener::Listen() {
-  std::string channel_name =
-      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          switches::kProcessChannelID);
+#if defined(OS_WIN)
+  mojo::edk::ScopedPlatformHandle platform_channel(
+      mojo::edk::PlatformChannelPair::PassClientHandleFromParentProcess(
+          *base::CommandLine::ForCurrentProcess());
+#else
+  mojo::edk::ScopedPlatformHandle platform_channel(
+      mojo::edk::PlatformHandle(
+          base::GlobalDescriptors::GetInstance()->Get(kMojoIPCChannel)));
+#endif
+
+  mojo::edk::SetParentPipeHandle(std::move(platform_channel));
+  mojo::ScopedMessagePipeHandle handle(
+      mojo::edk::CreateChildMessagePipe(
+          base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+              switches::kMojoChannelToken)));
+  DCHECK(handle.is_valid());
+
   channel_ = IPC::SyncChannel::Create(this, io_thread_.task_runner().get(),
                                       &shutdown_event_);
   filter_ = channel_->CreateSyncMessageFilter();
   channel_->AddFilter(new FileTokenMessageFilter());
   IPC::AttachmentBroker* global = IPC::AttachmentBroker::GetGlobal();
   if (global && !global->IsPrivilegedBroker())
     global->RegisterBrokerCommunicationChannel(channel_.get());
-  channel_->Init(channel_name, IPC::Channel::MODE_CLIENT, true);
+  channel_->Init(IPC::ChannelMojo::CreateClientFactory(std::move(handle)),
+                 true);
   main_loop_ = base::MessageLoop::current();
   main_loop_->Run();
 }
 
 bool NaClListener::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NaClListener, msg)
       IPC_MESSAGE_HANDLER(NaClProcessMsg_AddPrefetchedResource,
                           OnAddPrefetchedResource)
       IPC_MESSAGE_HANDLER(NaClProcessMsg_Start, OnStart)
@@ skipping 205 matching lines @@
 }
 
 void NaClListener::OnFileTokenResolved(
     uint64_t token_lo,
     uint64_t token_hi,
     IPC::PlatformFileForTransit ipc_fd,
     base::FilePath file_path) {
   resolved_cb_.Run(ipc_fd, file_path);
   resolved_cb_.Reset();
 }