Convert NaCl renderer-browser messages to mojo.

components/nacl/renderer/nexe_load_manager.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 "components/nacl/renderer/nexe_load_manager.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
-#include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_types.h"
 #include "components/nacl/renderer/histogram.h"
 #include "components/nacl/renderer/manifest_service_channel.h"
 #include "components/nacl/renderer/platform_info.h"
 #include "components/nacl/renderer/pnacl_translation_resource_host.h"
 #include "components/nacl/renderer/progress_event.h"
 #include "components/nacl/renderer/trusted_plugin_channel.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/sandbox_init.h"
@@ skipping 49 matching lines @@
 std::string LookupAttribute(const std::map<std::string, std::string>& args,
                             const std::string& key) {
   std::map<std::string, std::string>::const_iterator it = args.find(key);
   if (it != args.end())
     return it->second;
   return std::string();
 }
 
 }  // namespace
 
-NexeLoadManager::NexeLoadManager(
-    PP_Instance pp_instance)
+NexeLoadManager::NexeLoadManager(PP_Instance pp_instance, mojom::NaClHost* host)
     : pp_instance_(pp_instance),
       nacl_ready_state_(PP_NACL_READY_STATE_UNSENT),
       nexe_error_reported_(false),
       is_installed_(false),
       exit_status_(-1),
       nexe_size_(0),
       plugin_instance_(content::PepperPluginInstance::Get(pp_instance)),
       nonsfi_(false),
-      crash_info_shmem_handle_(base::SharedMemory::NULLHandle()),
+      host_(host),
       weak_factory_(this) {
   set_exit_status(-1);
   SetLastError("");
   HistogramEnumerateOsArch(GetSandboxArch());
   if (plugin_instance_) {
     plugin_base_url_ =
         plugin_instance_->GetContainer()->document().url();
   }
 }
 
 NexeLoadManager::~NexeLoadManager() {
   if (!nexe_error_reported_) {
     base::TimeDelta uptime = base::Time::Now() - ready_time_;
     HistogramTimeLarge("NaCl.ModuleUptime.Normal", uptime.InMilliseconds());
   }
-  if (base::SharedMemory::IsHandleValid(crash_info_shmem_handle_))
-    base::SharedMemory::CloseHandle(crash_info_shmem_handle_);
 }
 
 void NexeLoadManager::NexeFileDidOpen(int32_t pp_error,
                                       const base::File& file,
                                       int32_t http_status,
                                       int64_t nexe_bytes_read,
                                       const std::string& url,
                                       base::TimeDelta time_since_open) {
   // Check that we are on the main renderer thread.
   DCHECK(content::RenderThread::Get());
@@ skipping 67 matching lines @@
 
 void NexeLoadManager::ReportLoadError(PP_NaClError error,
                                       const std::string& error_message,
                                       const std::string& console_message) {
   // Check that we are on the main renderer thread.
   DCHECK(content::RenderThread::Get());
 
   if (error == PP_NACL_ERROR_MANIFEST_PROGRAM_MISSING_ARCH) {
     // A special case: the manifest may otherwise be valid but is missing
     // a program/file compatible with the user's sandbox.
-    IPC::Sender* sender = content::RenderThread::Get();
-    sender->Send(
-        new NaClHostMsg_MissingArchError(GetRoutingID(pp_instance_)));
+    host_->MissingArchError(GetRoutingID(pp_instance_));
   }
   set_nacl_ready_state(PP_NACL_READY_STATE_DONE);
   nexe_error_reported_ = true;
 
   // We must set all properties before calling DispatchEvent so that when an
   // event handler runs, the properties reflect the current load state.
   std::string error_string = std::string("NaCl module load failed: ") +
       std::string(error_message);
   SetLastError(error_string);
 
@@ skipping 47 matching lines @@
                       "Nexe crashed during startup");
     }
   }
   // In all cases, try to grab the crash log.  The first error
   // reported may have come from the start_module RPC reply indicating
   // a validation error or something similar, which wouldn't grab the
   // crash log.  In the event that this is called twice, the second
   // invocation will just be a no-op, since the entire crash log will
   // have been received and we'll just get an EOF indication.
 
-  base::SharedMemory shmem(crash_info_shmem_handle_, true);
-  if (shmem.Map(kNaClCrashInfoShmemSize)) {
+  mojo::ScopedSharedBufferMapping mapping =
+      crash_info_shmem_handle_->Map(kNaClCrashInfoShmemSize);
+  if (mapping) {
     uint32_t crash_log_length;
     // We cast the length value to volatile here to prevent the compiler from
     // reordering instructions in a way that could introduce a TOCTTOU race.
-    crash_log_length = *(static_cast<volatile uint32_t*>(shmem.memory()));
+    crash_log_length = *(static_cast<volatile uint32_t*>(mapping.get()));
     crash_log_length = std::min<uint32_t>(crash_log_length,
                                           kNaClCrashInfoMaxLogSize);
 
     std::unique_ptr<char[]> crash_log_data(new char[kNaClCrashInfoShmemSize]);
     memcpy(crash_log_data.get(),
-           static_cast<char*>(shmem.memory()) + sizeof(uint32_t),
+           static_cast<char*>(mapping.get()) + sizeof(uint32_t),
            crash_log_length);
     std::string crash_log(crash_log_data.get(), crash_log_length);
     CopyCrashLogToJsConsole(crash_log);
   }
 }
 
 void NexeLoadManager::set_trusted_plugin_channel(
     std::unique_ptr<TrustedPluginChannel> channel) {
   trusted_plugin_channel_ = std::move(channel);
 }
@@ skipping 152 matching lines @@
   // to provide error handling.
 }
 
 void NexeLoadManager::CopyCrashLogToJsConsole(const std::string& crash_log) {
   base::StringTokenizer t(crash_log, "\n");
   while (t.GetNext())
     LogToConsole(t.token());
 }
 
 }  // namespace nacl