Convert NaCl renderer-loader messages to mojo.

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>
 #include <utility>
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
+#include "components/nacl/common/nacl.mojom.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/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"
@@ skipping 30 matching lines @@
   // We copy the length of the crash data to the start of the shared memory
   // segment so we know how much to copy.
   memcpy(g_listener->crash_info_shmem_memory(), &copy_bytes, sizeof(uint32_t));
 
   memcpy((char*)g_listener->crash_info_shmem_memory() + sizeof(uint32_t),
          data,
          copy_bytes);
 }
 
 void LoadStatusCallback(int load_status) {
-  g_listener->trusted_listener()->Send(
-      new NaClRendererMsg_ReportLoadStatus(
-          static_cast<NaClErrorCode>(load_status)));
+  g_listener->trusted_listener()->renderer_host()->ReportLoadStatus(
+      static_cast<NaClErrorCode>(load_status));
 }
 
 #if defined(OS_LINUX)
 
 int CreateMemoryObject(size_t size, int executable) {
   return content::MakeSharedMemorySegmentViaIPC(size, executable);
 }
 
 #elif defined(OS_WIN)
 int AttachDebugExceptionHandler(const void* info, size_t info_size) {
@@ skipping 251 matching lines @@
                   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(trusted_pipe.handle0.release(),
-                              io_thread_.task_runner().get(), &shutdown_event_);
+  trusted_listener_ = base::MakeUnique<NaClTrustedListener>(
+      mojo::MakeProxy(nacl::mojom::NaClRendererHostPtrInfo(
+          std::move(trusted_pipe.handle0),
+          nacl::mojom::NaClRendererHost::Version_)),

[dcheng, 2016/12/20 06:49:54]

Nit: can we document what "version" means somewhere? I looked at
InterfacePtrInfo, and don't really understand what it means for this to be 0 vs
something else. Perhaps it's related to mojom versioning?

[Sam McNally, 2016/12/20 10:02:19]

Yes, it's for mojom versioning.
https://www.chromium.org/developers/design-documents/mojo/versioning doesn't
seem to cover this part. Since this interface isn't versioned it doesn't
actually matter here.

In this case, since this is sending the pipe handle, it can start with the nice
type and extract the pipe handle instead of building the nice type from the pipe
handle. Once the other NaCl IPCs are converted, the pipe won't need to be
visible here.

+      io_thread_.task_runner().get());
   if (!Send(new NaClProcessHostMsg_PpapiChannelsCreated(
           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";
   }
 
@@ skipping 73 matching lines @@
       params.nexe_file);
   std::string file_path_str = params.nexe_file_path_metadata.AsUTF8Unsafe();
   args->nexe_desc = NaClDescCreateWithFilePathMetadata(nexe_file,
                                                        file_path_str.c_str());
 
   int exit_status;
   if (!NaClChromeMainStart(nap, args, &exit_status))
     NaClExit(1);
 
   // Report the plugin's exit status if the application started successfully.
-  trusted_listener_->Send(new NaClRendererMsg_ReportExitStatus(exit_status));
+  trusted_listener_->renderer_host()->ReportExitStatus(exit_status);
   NaClExit(exit_status);
 }
 
 void NaClListener::ResolveFileToken(
     uint64_t token_lo,
     uint64_t token_hi,
     base::Callback<void(IPC::PlatformFileForTransit, base::FilePath)> cb) {
   if (!Send(new NaClProcessMsg_ResolveFileToken(token_lo, token_hi))) {
     cb.Run(IPC::PlatformFileForTransit(), base::FilePath());
     return;
   }
   resolved_cb_ = cb;
 }
 
 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();
 }