Linux: Catch plugin crashes.

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2009 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 
-#include "build/build_config.h"
-
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #if defined(OS_POSIX)
 #include <utility>  // for pair<>
 #endif
 
 #include "app/app_switches.h"
 #include "base/command_line.h"
@@ skipping 37 matching lines @@
 #include "grit/generated_resources.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_switches.h"
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
 #include "chrome/browser/sandbox_policy.h"
 #elif defined(OS_LINUX)
 #include "base/singleton.h"
+#include "chrome/browser/crash_handler_host_linux.h"
 #include "chrome/browser/zygote_host_linux.h"
-#include "chrome/browser/renderer_host/render_crash_handler_host_linux.h"
 #include "chrome/browser/renderer_host/render_sandbox_host_linux.h"
 #endif
 
 using WebKit::WebCache;
 
 #include "third_party/skia/include/core/SkBitmap.h"
 
 
 // This class creates the IO thread for the renderer when running in
 // single-process mode.  It's not used in multi-process mode.
@@ skipping 505 matching lines @@
     bool has_cmd_prefix) {
 #if defined(OS_LINUX)
   // On Linux, normally spawn processes with zygotes. We can't do this when
   // we're spawning child processes through an external program (i.e. there is a
   // command prefix) like GDB so fall through to the POSIX case then.
   if (!has_cmd_prefix) {
     base::GlobalDescriptors::Mapping mapping;
     const int ipcfd = channel_->GetClientFileDescriptor();
     mapping.push_back(std::pair<uint32_t, int>(kPrimaryIPCChannel, ipcfd));
     const int crash_signal_fd =
-        Singleton<RenderCrashHandlerHostLinux>()->GetDeathSignalSocket();
+        Singleton<RendererCrashHandlerHostLinux>()->GetDeathSignalSocket();
     if (crash_signal_fd >= 0) {
       mapping.push_back(std::pair<uint32_t, int>(kCrashDumpSignal,
                                                  crash_signal_fd));
     }
     zygote_child_ = true;
     return Singleton<ZygoteHost>()->ForkRenderer(cmd_line->argv(), mapping);
   }
 #endif  // defined(OS_LINUX)
 
   // NOTE: This code is duplicated with plugin_process_host.cc, but
   // there's not a good place to de-duplicate it.
   base::file_handle_mapping_vector fds_to_map;
   const int ipcfd = channel_->GetClientFileDescriptor();
   fds_to_map.push_back(std::make_pair(ipcfd, kPrimaryIPCChannel + 3));
 
 #if defined(OS_LINUX)
   // On Linux, we need to add some extra file descriptors for crash handling and
   // the sandbox.
   const int crash_signal_fd =
-      Singleton<RenderCrashHandlerHostLinux>()->GetDeathSignalSocket();
+      Singleton<RendererCrashHandlerHostLinux>()->GetDeathSignalSocket();
   if (crash_signal_fd >= 0) {
     fds_to_map.push_back(std::make_pair(crash_signal_fd,
                                         kCrashDumpSignal + 3));
   }
   const int sandbox_fd =
       Singleton<RenderSandboxHostLinux>()->GetRendererSocket();
   fds_to_map.push_back(std::make_pair(sandbox_fd, kSandboxIPCChannel + 3));
 #endif  // defined(OS_LINUX)
 
   // Actually launch the app.
@@ skipping 279 matching lines @@
       CHECK(peer_pid == process_.pid()) << peer_pid << " " << process_.pid();
 #endif
     }
     mark_child_process_activity_time();
   }
 
 #if defined(IPC_MESSAGE_LOG_ENABLED)
   bool enabled = IPC::Logging::current()->Enabled();
   Send(new ViewMsg_SetIPCLoggingEnabled(enabled));
 #endif
-
 }
 
 // Static. This function can be called from any thread.
 void BrowserRenderProcessHost::BadMessageTerminateProcess(
     uint16 msg_type, base::ProcessHandle process) {
   LOG(ERROR) << "bad message " << msg_type << " terminating renderer.";
   if (BrowserRenderProcessHost::run_renderer_in_process()) {
     // In single process mode it is better if we don't suicide but just crash.
     CHECK(false);
   }
@@ skipping 196 matching lines @@
     channel_->Send(new ViewMsg_SpellChecker_Init(
         base::FileDescriptor(), std::vector<std::string>(), std::string(),
         false));
   }
 }
 
 void BrowserRenderProcessHost::EnableAutoSpellCorrect(bool enable) {
   channel_->Send(new ViewMsg_SpellChecker_EnableAutoSpellCorrect(enable));
 }
 #endif