NaCl: Send fatal log messages via shared memory.

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 <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 456 matching lines @@
       SendErrorToRenderer("NaClSocketPair() failed");
       delete this;
       return;
     }
     internal_->socket_for_renderer = pair[0];
     internal_->socket_for_sel_ldr = pair[1];
     SetCloseOnExec(pair[0]);
     SetCloseOnExec(pair[1]);
   }
 
+  // Create a shared memory region that the renderer and plugin share for
+  // reporting crash information.
+  crash_info_shmem_.CreateAnonymous(kNaClCrashInfoShmemSize);
+
   // Launch the process
   if (!LaunchSelLdr()) {
     delete this;
   }
 }
 
 void NaClProcessHost::OnChannelConnected(int32 peer_pid) {
   if (!CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kNaClGdb).empty()) {
     LaunchNaClGdb();
@@ skipping 242 matching lines @@
 #else
   // No need to dup the imc_handle - we don't pass it anywhere else so
   // it cannot be closed.
   FileDescriptor imc_handle;
   imc_handle.fd = internal_->socket_for_renderer;
   imc_handle.auto_close = true;
   imc_handle_for_renderer = imc_handle;
 #endif
 
   const ChildProcessData& data = process_->GetData();
+  base::SharedMemoryHandle crash_info_shmem_renderer_handle;
+  if (!crash_info_shmem_.ShareToProcess(nacl_host_message_filter_->PeerHandle(),
+                                        &crash_info_shmem_renderer_handle)) {
+    SendErrorToRenderer("ShareToProcess() failed");
+    return false;
+  }

[Mark Seaborn, 2014/08/18 19:04:08]

How about doing
  crash_info_shmem_.Close()
to unref the handle after we've sent it to both child processes?

[teravest, 2014/08/19 19:58:16]

Done.

+
   SendMessageToRenderer(
       NaClLaunchResult(imc_handle_for_renderer,
                        ppapi_channel_handle,
                        trusted_channel_handle,
                        manifest_service_channel_handle,
                        base::GetProcId(data.handle),
-                       data.id),
+                       data.id,
+                       crash_info_shmem_renderer_handle),
       std::string() /* error_message */);
   internal_->socket_for_renderer = NACL_INVALID_HANDLE;
   return true;
 }
 
 void NaClProcessHost::SendErrorToRenderer(const std::string& error_message) {
   LOG(ERROR) << "NaCl process launch failed: " << error_message;
   SendMessageToRenderer(NaClLaunchResult(), error_message);
 }
 
@@ skipping 136 matching lines @@
     }
 #endif
   }
 
   if (!uses_nonsfi_mode_) {
     internal_->socket_for_sel_ldr = NACL_INVALID_HANDLE;
   }
 
   params.nexe_file = IPC::TakeFileHandleForProcess(nexe_file_.Pass(),
                                                    process_->GetData().handle);
+  if (!crash_info_shmem_.ShareToProcess(process_->GetData().handle,
+                                        &params.crash_info_shmem_handle)) {
+    DLOG(ERROR) << "Failed to ShareToProcess() a shared memory buffer";
+    return false;
+  }
 
   process_->Send(new NaClProcessMsg_Start(params));
   return true;
 }
 
 // This method is called when NaClProcessHostMsg_PpapiChannelCreated is
 // received.
 void NaClProcessHost::OnPpapiChannelsCreated(
     const IPC::ChannelHandle& browser_channel_handle,
     const IPC::ChannelHandle& ppapi_renderer_channel_handle,
@@ skipping 235 matching lines @@
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl