Use ChannelMojo for NaCl PPAPI channels.

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>
@@ skipping 24 matching lines @@
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/scoped_ipc_support.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>
@@ skipping 54 matching lines @@
 // the given task runner runs.
 // Also, creates and sets the corresponding NaClDesc to the given nap with
 // the FD #.
 void SetUpIPCAdapter(
     IPC::ChannelHandle* handle,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     struct NaClApp* nap,
     int nacl_fd,
     NaClIPCAdapter::ResolveFileTokenCallback resolve_file_token_cb,
     NaClIPCAdapter::OpenResourceCallback open_resource_cb) {
-  scoped_refptr<NaClIPCAdapter> ipc_adapter(new NaClIPCAdapter(
-      *handle, task_runner.get(), resolve_file_token_cb, open_resource_cb));
+  mojo::MessagePipe pipe;
+  scoped_refptr<NaClIPCAdapter> ipc_adapter(
+      new NaClIPCAdapter(pipe.handle0.release(), task_runner,
+                         resolve_file_token_cb, open_resource_cb));
   ipc_adapter->ConnectChannel();
-#if defined(OS_POSIX)
-  handle->socket =
-      base::FileDescriptor(ipc_adapter->TakeClientFileDescriptor());
-#endif
+  *handle = pipe.handle1.release();
 
   // Pass a NaClDesc to the untrusted side. This will hold a ref to the
   // NaClIPCAdapter.
   NaClAppSetDesc(nap, nacl_fd, ipc_adapter->MakeNaClDesc());
 }
 
 }  // namespace
 
 class BrowserValidationDBProxy : public NaClValidationDB {
  public:
@@ skipping 102 matching lines @@
  private:
   ~FileTokenMessageFilter() override {}
 };
 
 void NaClListener::Listen() {
   mojo::ScopedMessagePipeHandle handle(
       mojo::edk::CreateChildMessagePipe(
           base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
               switches::kMojoChannelToken)));
   DCHECK(handle.is_valid());
-  IPC::ChannelHandle channel_handle(handle.release());
 
   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_handle, IPC::Channel::MODE_CLIENT, true);
+  channel_->Init(handle.release(), IPC::Channel::MODE_CLIENT, true);
   main_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   base::RunLoop().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 60 matching lines @@
   crash_info_shmem_.reset(new base::SharedMemory(
       params.crash_info_shmem_handle, false /* not readonly */));
   CHECK(crash_info_shmem_->Map(nacl::kNaClCrashInfoShmemSize));
   NaClSetFatalErrorCallback(&FatalLogHandler);
 
   nap = NaClAppCreate();
   if (nap == NULL) {
     LOG(FATAL) << "NaClAppCreate() failed";
   }
 
-  IPC::ChannelHandle browser_handle =
-      IPC::Channel::GenerateVerifiedChannelID("nacl");
-  IPC::ChannelHandle ppapi_renderer_handle =
-      IPC::Channel::GenerateVerifiedChannelID("nacl");
-  IPC::ChannelHandle manifest_service_handle =
-      IPC::Channel::GenerateVerifiedChannelID("nacl");
+  IPC::ChannelHandle browser_handle;
+  IPC::ChannelHandle ppapi_renderer_handle;
+  IPC::ChannelHandle manifest_service_handle;
 
   // Create the PPAPI IPC channels between the NaCl IRT and the host
   // (browser/renderer) processes. The IRT uses these channels to
   // communicate with the host and to initialize the IPC dispatchers.
   SetUpIPCAdapter(&browser_handle, io_thread_.task_runner(), nap,
                   NACL_CHROME_DESC_BASE,
                   NaClIPCAdapter::ResolveFileTokenCallback(),
                   NaClIPCAdapter::OpenResourceCallback());
   SetUpIPCAdapter(&ppapi_renderer_handle, io_thread_.task_runner(), nap,
                   NACL_CHROME_DESC_BASE + 1,
                   NaClIPCAdapter::ResolveFileTokenCallback(),
                   NaClIPCAdapter::OpenResourceCallback());
   SetUpIPCAdapter(
       &manifest_service_handle, io_thread_.task_runner(), nap,
       NACL_CHROME_DESC_BASE + 2,
       base::Bind(&NaClListener::ResolveFileToken, base::Unretained(this)),
       base::Bind(&NaClListener::OnOpenResource, base::Unretained(this)));
 
+  mojo::MessagePipe trusted_pipe;
   trusted_listener_ =
-      new NaClTrustedListener(IPC::Channel::GenerateVerifiedChannelID("nacl"),
+      new NaClTrustedListener(trusted_pipe.handle0.release(),
                               io_thread_.task_runner().get(), &shutdown_event_);
   if (!Send(new NaClProcessHostMsg_PpapiChannelsCreated(
-          browser_handle,
-          ppapi_renderer_handle,
-          trusted_listener_->TakeClientChannelHandle(),
+          browser_handle, ppapi_renderer_handle, trusted_pipe.handle1.release(),
           manifest_service_handle)))
     LOG(FATAL) << "Failed to send IPC channel handle to NaClProcessHost.";
 
   struct NaClChromeMainArgs* args = NaClChromeMainArgsCreate();
   if (args == NULL) {
     LOG(FATAL) << "NaClChromeMainArgsCreate() failed";
   }
 
 #if defined(OS_POSIX)
   args->number_of_cores = number_of_cores_;
@@ skipping 94 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();
 }