Convert NaCl renderer-browser messages to mojo.

components/nacl/browser/nacl_process_host.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 "components/nacl/browser/nacl_process_host.h"
 
 #include <string.h>
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/process/process_iterator.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/browser/nacl_browser_delegate.h"
-#include "components/nacl/browser/nacl_host_message_filter.h"
 #include "components/nacl/common/nacl_cmd_line.h"
 #include "components/nacl/common/nacl_constants.h"
-#include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "components/url_formatter/url_formatter.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_ppapi_host.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "ipc/ipc_channel.h"
 #include "mojo/edk/embedder/embedder.h"
+#include "mojo/public/cpp/system/platform_handle.h"
 #include "net/socket/socket_descriptor.h"
 #include "ppapi/host/host_factory.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppapi_constants.h"
 #include "ppapi/shared_impl/ppapi_nacl_plugin_args.h"
 
 #if defined(OS_POSIX)
 
 #include <arpa/inet.h>
@@ skipping 129 matching lines @@
 
 unsigned NaClProcessHost::keepalive_throttle_interval_milliseconds_ =
     ppapi::kKeepaliveThrottleIntervalDefaultMilliseconds;
 
 NaClProcessHost::NaClProcessHost(
     const GURL& manifest_url,
     base::File nexe_file,
     const NaClFileToken& nexe_token,
     const std::vector<NaClResourcePrefetchResult>& prefetched_resource_files,
     ppapi::PpapiPermissions permissions,
+    int render_process_id,
     int render_view_id,
     uint32_t permission_bits,
     bool uses_nonsfi_mode,
     bool off_the_record,
     NaClAppProcessType process_type,
     const base::FilePath& profile_directory)
     : manifest_url_(manifest_url),
       nexe_file_(std::move(nexe_file)),
       nexe_token_(nexe_token),
       prefetched_resource_files_(prefetched_resource_files),
       permissions_(permissions),
 #if defined(OS_WIN)
       process_launched_by_broker_(false),
 #endif
-      reply_msg_(NULL),
 #if defined(OS_WIN)
       debug_exception_handler_requested_(false),
 #endif
       uses_nonsfi_mode_(uses_nonsfi_mode),
       enable_debug_stub_(false),
       enable_crash_throttling_(false),
       off_the_record_(off_the_record),
       process_type_(process_type),
       profile_directory_(profile_directory),
+      render_process_id_(render_process_id),
       render_view_id_(render_view_id),
       weak_factory_(this) {
   process_.reset(content::BrowserChildProcessHost::Create(
       static_cast<content::ProcessType>(PROCESS_TYPE_NACL_LOADER), this,
       kNaClLoaderServiceName));
 
   // Set the display name so the user knows what plugin the process is running.
   // We aren't on the UI thread so getting the pref locale for language
   // formatting isn't possible, so IDN will be lost, but this is probably OK
   // for this use case.
@@ skipping 34 matching lines @@
     content::BrowserThread::GetBlockingPool()->PostTask(
         FROM_HERE, base::Bind(&CloseFile, base::Passed(std::move(file))));
   }
 #endif
   // Open files need to be closed on the blocking pool.
   if (nexe_file_.IsValid()) {
     content::BrowserThread::GetBlockingPool()->PostTask(
         FROM_HERE, base::Bind(&CloseFile, base::Passed(std::move(nexe_file_))));
   }
 
-  if (reply_msg_) {
+  if (!launch_callback_.is_null()) {
     // The process failed to launch for some reason.
     // Don't keep the renderer hanging.
-    reply_msg_->set_reply_error();
-    nacl_host_message_filter_->Send(reply_msg_);
+    SendMessageToRenderer(mojom::NaClLaunchResultPtr(), "");
   }
 #if defined(OS_WIN)
   if (process_launched_by_broker_) {
     NaClBrokerService::GetInstance()->OnLoaderDied();
   }
 #endif
 }
 
 void NaClProcessHost::OnProcessCrashed(int exit_status) {
   if (enable_crash_throttling_ &&
@@ skipping 42 matching lines @@
 }
 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
 
 // static
 void NaClProcessHost::SetPpapiKeepAliveThrottleForTesting(
     unsigned milliseconds) {
   keepalive_throttle_interval_milliseconds_ = milliseconds;
 }
 
 void NaClProcessHost::Launch(
-    NaClHostMessageFilter* nacl_host_message_filter,
-    IPC::Message* reply_msg,
-    const base::FilePath& manifest_path) {
-  nacl_host_message_filter_ = nacl_host_message_filter;
-  reply_msg_ = reply_msg;
+    const base::FilePath& manifest_path,
+    const mojom::NaClHost::LaunchNaClCallback& callback) {
+  launch_callback_ = callback;
   manifest_path_ = manifest_path;
 
   // Do not launch the requested NaCl module if NaCl is marked "unstable" due
   // to too many crashes within a given time period.
   if (enable_crash_throttling_ &&
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePnaclCrashThrottling) &&
       NaClBrowser::GetInstance()->IsThrottled()) {
     SendErrorToRenderer("Process creation was throttled due to excessive"
                         " crashes");
@@ skipping 30 matching lines @@
 
   if (uses_nonsfi_mode_) {
     bool nonsfi_mode_forced_by_command_line = false;
     bool nonsfi_mode_allowed = false;
 #if defined(OS_LINUX)
     nonsfi_mode_forced_by_command_line =
         cmd->HasSwitch(switches::kEnableNaClNonSfiMode);
 #if defined(OS_CHROMEOS) && \
     (defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARMEL))
     nonsfi_mode_allowed = NaClBrowser::GetDelegate()->IsNonSfiModeAllowed(
-        nacl_host_message_filter->profile_directory(), manifest_url_);
+        profile_directory_, manifest_url_);
 #endif
 #endif
     bool nonsfi_mode_enabled =
         nonsfi_mode_forced_by_command_line || nonsfi_mode_allowed;
 
     if (!nonsfi_mode_enabled) {
       SendErrorToRenderer(
           "NaCl non-SFI mode is not available for this platform"
           " and NaCl module.");
       delete this;
@@ skipping 209 matching lines @@
     delete this;
   } else if (!StartNaClExecution()) {
     delete this;
   }
 }
 
 void NaClProcessHost::ReplyToRenderer(
     mojo::ScopedMessagePipeHandle ppapi_channel_handle,
     mojo::ScopedMessagePipeHandle trusted_channel_handle,
     mojo::ScopedMessagePipeHandle manifest_service_channel_handle) {
-  // Hereafter, we always send an IPC message with handles created above
-  // which, on Windows, are not closable in this process.
-  std::string error_message;
-  base::SharedMemoryHandle crash_info_shmem_renderer_handle;
-  if (!crash_info_shmem_.ShareToProcess(nacl_host_message_filter_->PeerHandle(),
-                                        &crash_info_shmem_renderer_handle)) {
-    // On error, we do not send "IPC::ChannelHandle"s to the renderer process.
-    // Note that some other FDs/handles still get sent to the renderer, but
-    // will be closed there.
-    ppapi_channel_handle.reset();
-    trusted_channel_handle.reset();
-    manifest_service_channel_handle.reset();
-    error_message = "ShareToProcess() failed";
-  }
-
   const ChildProcessData& data = process_->GetData();
-  SendMessageToRenderer(
-      NaClLaunchResult(ppapi_channel_handle.release(),
-                       trusted_channel_handle.release(),
-                       manifest_service_channel_handle.release(),
-                       base::GetProcId(data.handle),
-                       data.id,
-                       crash_info_shmem_renderer_handle),
-      error_message);
+  auto result = mojom::NaClLaunchResult::New();
+  result->ppapi_ipc_channel_handle = std::move(ppapi_channel_handle);
+  result->trusted_ipc_channel_handle =
+      mojo::MakeRequest<mojom::NaClRendererHost>(
+          std::move(trusted_channel_handle));
+  result->manifest_service_ipc_channel_handle =
+      std::move(manifest_service_channel_handle);
+  result->plugin_pid = base::GetProcId(data.handle);
+  result->plugin_child_id = data.id;
+  result->crash_info_shmem_handle = mojo::WrapSharedMemoryHandle(
+      crash_info_shmem_.TakeHandle(), kNaClCrashInfoShmemSize, false);
+  SendMessageToRenderer(std::move(result), "");
 
   // Now that the crash information shmem handles have been shared with the
   // plugin and the renderer, the browser can close its handle.
   crash_info_shmem_.Close();
 }
 
 void NaClProcessHost::SendErrorToRenderer(const std::string& error_message) {
   LOG(ERROR) << "NaCl process launch failed: " << error_message;
-  SendMessageToRenderer(NaClLaunchResult(), error_message);
+  SendMessageToRenderer(mojom::NaClLaunchResultPtr(), error_message);
 }
 
-void NaClProcessHost::SendMessageToRenderer(
-    const NaClLaunchResult& result,
-    const std::string& error_message) {
-  DCHECK(nacl_host_message_filter_.get());
-  DCHECK(reply_msg_);
-  if (nacl_host_message_filter_.get() == NULL || reply_msg_ == NULL) {
+void NaClProcessHost::SendMessageToRenderer(mojom::NaClLaunchResultPtr result,
+                                            const std::string& error_message) {
+  DCHECK(!launch_callback_.is_null());
+  if (launch_callback_.is_null()) {
     // As DCHECKed above, this case should not happen in general.
-    // Though, in this case, unfortunately there is no proper way to release
-    // resources which are already created in |result|. We just give up on
-    // releasing them, and leak them.
     return;
   }
 
-  NaClHostMsg_LaunchNaCl::WriteReplyParams(reply_msg_, result, error_message);
-  nacl_host_message_filter_->Send(reply_msg_);
-  nacl_host_message_filter_ = NULL;
-  reply_msg_ = NULL;
+  base::ResetAndReturn(&launch_callback_).Run(std::move(result), error_message);
 }
 
 void NaClProcessHost::SetDebugStubPort(int port) {
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   nacl_browser->SetProcessGdbDebugStubPort(process_->GetData().id, port);
 }
 
 #if defined(OS_POSIX)
 // TCP port we chose for NaCl debug stub. It can be any other number.
 static const uint16_t kInitialDebugStubPort = 4014;
@@ skipping 220 matching lines @@
 
   DCHECK_EQ(PROCESS_TYPE_NACL_LOADER, process_->GetData().process_type);
 
   ipc_proxy_channel_ = IPC::ChannelProxy::Create(
       channel_handle.release(), IPC::Channel::MODE_CLIENT, NULL,
       base::ThreadTaskRunnerHandle::Get().get());
   // Create the browser ppapi host and enable PPAPI message dispatching to the
   // browser process.
   ppapi_host_.reset(content::BrowserPpapiHost::CreateExternalPluginProcess(
       ipc_proxy_channel_.get(),  // sender
-      permissions_,
-      process_->GetData().handle,
-      ipc_proxy_channel_.get(),
-      nacl_host_message_filter_->render_process_id(),
-      render_view_id_,
-      profile_directory_));
+      permissions_, process_->GetData().handle, ipc_proxy_channel_.get(),
+      render_process_id_, render_view_id_, profile_directory_));
   ppapi_host_->SetOnKeepaliveCallback(
       NaClBrowser::GetDelegate()->GetOnKeepaliveCallback());
 
   ppapi::PpapiNaClPluginArgs args;
-  args.off_the_record = nacl_host_message_filter_->off_the_record();
+  args.off_the_record = off_the_record_;
   args.permissions = permissions_;
   args.keepalive_throttle_interval_milliseconds =
       keepalive_throttle_interval_milliseconds_;
   base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
   DCHECK(cmdline);
   std::string flag_whitelist[] = {
     switches::kV,
     switches::kVModule,
   };
   for (size_t i = 0; i < arraysize(flag_whitelist); ++i) {
@@ skipping 214 matching lines @@
     NaClStartDebugExceptionHandlerThread(
         std::move(process), info, base::ThreadTaskRunnerHandle::Get(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl