Linux: Catch plugin crashes.

chrome/app/breakpad_linux.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.
 
 #include "chrome/app/breakpad_linux.h"
 
 #include <fcntl.h>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/time.h>
@@ skipping 432 matching lines @@
   //   --post-file=/tmp/...
   static const char post_file_msg[] = "--post-file=";
   char* const post_file = reinterpret_cast<char*>(allocator.Alloc(
        sizeof(post_file_msg) - 1 + sizeof(temp_file)));
   memcpy(post_file, post_file_msg, sizeof(post_file_msg) - 1);
   memcpy(post_file + sizeof(post_file_msg) - 1, temp_file, sizeof(temp_file));
 
   const pid_t child = sys_fork();
   if (!child) {
     // This code is called both when a browser is crashing (in which case,
-    // nothing really matters any more) and when a renderer crashes, in which
-    // case we need to continue.
+    // nothing really matters any more) and when a renderer/plugin crashes, in
+    // which case we need to continue.
     //
     // Since we are a multithreaded app, if we were just to fork(), we might
     // grab file descriptors which have just been created in another thread and
     // hold them open for too long.
     //
     // Thus, we have to loop and try and close everything.
     const int fd = sys_open("/proc/self/fd", O_DIRECTORY | O_RDONLY, 0);
     if (fd < 0) {
       for (unsigned i = 3; i < 8192; ++i)
         sys_close(i);
@@ skipping 136 matching lines @@
   }
 }
 
 // This is defined in chrome/common/child_process_logging_linux.cc, it's the
 // static string containing the current active URL. We send this in the crash
 // report.
 namespace child_process_logging {
 extern std::string active_url;
 }
 
+// Currently Non-Browser = Renderer and Plugins
 static bool
-RendererCrashHandler(const void* crash_context, size_t crash_context_size,
-             void* context) {
+NonBrowserCrashHandler(const void* crash_context, size_t crash_context_size,
+                       void* context) {
   const int fd = reinterpret_cast<intptr_t>(context);
   int fds[2];
   socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
   char guid[kGuidSize + 1] = {0};
   char crash_url[kMaxActiveURLSize + 1] = {0};
   char distro[kDistroSize + 1] = {0};
   const size_t guid_len = std::min(google_update::posix_guid.size(),
                                    kGuidSize);
   const size_t crash_url_len =
       std::min(child_process_logging::active_url.size(), kMaxActiveURLSize);
@@ skipping 33 matching lines @@
 
   HANDLE_EINTR(sys_sendmsg(fd, &msg, 0));
   sys_close(fds[1]);
 
   char b;
   HANDLE_EINTR(sys_read(fds[0], &b, 1));
 
   return true;
 }
 
-void EnableRendererCrashDumping() {
+void EnableNonBrowserCrashDumping() {
   const int fd = Singleton<base::GlobalDescriptors>()->Get(kCrashDumpSignal);
   // We deliberately leak this object.
   google_breakpad::ExceptionHandler* handler =
       new google_breakpad::ExceptionHandler("" /* unused */, NULL, NULL,
                                             (void*) fd, true);
-  handler->set_crash_handler(RendererCrashHandler);
+  handler->set_crash_handler(NonBrowserCrashHandler);
 }
 
 void InitCrashReporter() {
   // Determine the process type and take appropriate action.
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   const std::string process_type =
       parsed_command_line.GetSwitchValueASCII(switches::kProcessType);
   const bool unattended = (getenv("CHROME_HEADLESS") != NULL);
   if (process_type.empty()) {
     if (!(unattended || GoogleUpdateSettings::GetCollectStatsConsent()))
       return;
     EnableCrashDumping(unattended);
   } else if (process_type == switches::kRendererProcess ||
+             process_type == switches::kPluginProcess ||
              process_type == switches::kZygoteProcess) {
     // We might be chrooted in a zygote or renderer process so we cannot call
     // GetCollectStatsConsent because that needs access the the user's home
     // dir. Instead, we set a command line flag for these processes.
+    // Even though plugins are not chrooted, we share the same code path for
+    // simplicity.
     if (!parsed_command_line.HasSwitch(switches::kEnableCrashReporter))
       return;
     // Get the guid and linux distro from the command line switch.
     std::string switch_value = WideToASCII(
         parsed_command_line.GetSwitchValue(switches::kEnableCrashReporter));
     size_t separator = switch_value.find(",");
     if (separator != std::string::npos) {
       google_update::posix_guid = switch_value.substr(0, separator);
       base::linux_distro = switch_value.substr(separator + 1);
     } else {
       google_update::posix_guid = switch_value;
     }
-    EnableRendererCrashDumping();
+    EnableNonBrowserCrashDumping();
   }
 
   // Set the base process uptime value.
   struct timeval tv;
   if (!gettimeofday(&tv, NULL))
     uptime = tv.tv_sec;
   else
     uptime = 0;
 }