Prepare CrashHandlerHostLinux for move to breakpad component

chrome/browser/crash_handler_host_linux.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 "chrome/browser/crash_handler_host_linux.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/format_macros.h"
 #include "base/linux_util.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "breakpad/src/client/linux/handler/exception_handler.h"
 #include "breakpad/src/client/linux/minidump_writer/linux_dumper.h"
 #include "breakpad/src/client/linux/minidump_writer/minidump_writer.h"
 #include "chrome/app/breakpad_linux_impl.h"

[Nico, 2013/10/19 01:28:46]

This is for a folllow-up I suppose.

[jochen (gone - plz use gerrit), 2013/10/19 02:38:36]

Right, those files will be moved all together to the component

-#include "chrome/common/chrome_paths.h"
-#include "chrome/common/env_vars.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_ANDROID)
 #include <sys/linux-syscalls.h>
 
 #define SYS_read __NR_read
 #endif
 
 using content::BrowserThread;
 using google_breakpad::ExceptionHandler;
@@ skipping 14 matching lines @@
   HandleCrashDump(*info);
   delete[] info->filename;
   delete[] info->process_type;
   delete[] info->distro;
   delete info->crash_keys;
   delete info;
 }
 
 }  // namespace
 
-// Since classes derived from CrashHandlerHostLinux are singletons, it's only
-// destroyed at the end of the processes lifetime, which is greater in span than
-// the lifetime of the IO message loop. Thus, all calls to base::Bind() use
+// Since instances of CrashHandlerHostLinux are leaked, it's only destroyed at

[Nico, 2013/10/19 01:28:46]

s/it's/they are/ :-P

[jochen (gone - plz use gerrit), 2013/10/19 02:38:36]

Done.

+// the end of the processes lifetime, which is greater in span than the
+// lifetime of the IO message loop. Thus, all calls to base::Bind() use
 // non-refcounted pointers.
 
-CrashHandlerHostLinux::CrashHandlerHostLinux()
-    : shutting_down_(false),
+CrashHandlerHostLinux::CrashHandlerHostLinux(const std::string& process_type,
+                                             const base::FilePath& dumps_path,
+                                             bool upload)
+    : process_type_(process_type),
+      dumps_path_(dumps_path),
+      upload_(upload),
+      shutting_down_(false),
       worker_pool_token_(BrowserThread::GetBlockingPool()->GetSequenceToken()) {
   int fds[2];
   // We use SOCK_SEQPACKET rather than SOCK_DGRAM to prevent the process from
   // sending datagrams to other sockets on the system. The sandbox may prevent
   // the process from calling socket() to create new sockets, but it'll still
   // inherit some sockets. With PF_UNIX+SOCK_DGRAM, it can call sendmsg to send
   // a datagram to any (abstract) socket on the same system. With
   // SOCK_SEQPACKET, this is prevented.
   CHECK_EQ(socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds), 0);
   static const int on = 1;
 
   // Enable passcred on the server end of the socket
   CHECK_EQ(setsockopt(fds[1], SOL_SOCKET, SO_PASSCRED, &on, sizeof(on)), 0);
 
   process_socket_ = fds[0];
   browser_socket_ = fds[1];
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CrashHandlerHostLinux::Init, base::Unretained(this)));
+
+  uploader_thread_.reset(
+      new base::Thread(std::string(process_type_ + "_crash_uploader").c_str()));
+  uploader_thread_->Start();

[Nico, 2013/10/19 01:28:46]

Can this stay in a method? Constructors that start threads are not exactly best
practice.

[jochen (gone - plz use gerrit), 2013/10/19 02:38:36]

Done.

 }
 
 CrashHandlerHostLinux::~CrashHandlerHostLinux() {
   (void) HANDLE_EINTR(close(process_socket_));
   (void) HANDLE_EINTR(close(browser_socket_));
 }
 
 void CrashHandlerHostLinux::Init() {
   base::MessageLoopForIO* ml = base::MessageLoopForIO::current();
   CHECK(ml->WatchFileDescriptor(
       browser_socket_, true /* persistent */,
       base::MessageLoopForIO::WATCH_READ,
       &file_descriptor_watcher_, this));
   ml->AddDestructionObserver(this);
 }
 
-void CrashHandlerHostLinux::InitCrashUploaderThread() {
-  SetProcessType();
-  uploader_thread_.reset(
-      new base::Thread(std::string(process_type_ + "_crash_uploader").c_str()));
-  uploader_thread_->Start();
-}
-
 void CrashHandlerHostLinux::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
 void CrashHandlerHostLinux::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK_EQ(fd, browser_socket_);
 
   // A process has crashed and has signaled us by writing a datagram
   // to the death signal socket. The datagram contains the crash context needed
   // for writing the minidump as well as a file descriptor and a credentials
@@ skipping 196 matching lines @@
   process_type_.copy(process_type_str, info->process_type_length);
   process_type_str[info->process_type_length] = '\0';
   info->process_type = process_type_str;
 
   info->distro_length = strlen(distro);
   info->distro = distro;
 #if defined(OS_ANDROID)
   // Nothing gets uploaded in android.
   info->upload = false;
 #else
-  info->upload = (getenv(env_vars::kHeadless) == NULL);
+  info->upload = upload_;
 #endif
 
   info->crash_keys = crash_keys;
 
 #if defined(ADDRESS_SANITIZER)
   info->asan_report_str = asan_report_str_;
   info->asan_report_length = strlen(asan_report_str_);
 #endif
   info->process_start_time = uptime;
   info->oom_size = oom_size;
@@ skipping 12 matching lines @@
 void CrashHandlerHostLinux::WriteDumpFile(BreakpadInfo* info,
                                           pid_t crashing_pid,
                                           char* crash_context,
                                           int signal_fd) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       worker_pool_token_));
 
   base::FilePath dumps_path("/tmp");
   PathService::Get(base::DIR_TEMP, &dumps_path);
   if (!info->upload)
-    PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path);
+    dumps_path = dumps_path_;
   const uint64 rand = base::RandUint64();
   const std::string minidump_filename =
       base::StringPrintf("%s/chromium-%s-minidump-%016" PRIx64 ".dmp",
                          dumps_path.value().c_str(),
                          process_type_.c_str(),
                          rand);
 
   if (!google_breakpad::WriteMinidump(minidump_filename.c_str(),
                                       kMaxMinidumpFileSize,
                                       crashing_pid, crash_context,
@@ skipping 64 matching lines @@
 
   // If we are quitting and there are crash dumps in the queue, turn them into
   // no-ops.
   shutting_down_ = true;
   uploader_thread_->Stop();
 }
 
 bool CrashHandlerHostLinux::IsShuttingDown() const {
   return shutting_down_;
 }
-
-ExtensionCrashHandlerHostLinux::ExtensionCrashHandlerHostLinux() {

[Nico, 2013/10/19 01:28:46]

These classes were weird.

-  InitCrashUploaderThread();
-}
-
-ExtensionCrashHandlerHostLinux::~ExtensionCrashHandlerHostLinux() {
-}
-
-void ExtensionCrashHandlerHostLinux::SetProcessType() {
-  process_type_ = "extension";
-}
-
-// static
-ExtensionCrashHandlerHostLinux* ExtensionCrashHandlerHostLinux::GetInstance() {
-  return Singleton<ExtensionCrashHandlerHostLinux>::get();
-}
-
-GpuCrashHandlerHostLinux::GpuCrashHandlerHostLinux() {
-  InitCrashUploaderThread();
-}
-
-GpuCrashHandlerHostLinux::~GpuCrashHandlerHostLinux() {
-}
-
-void GpuCrashHandlerHostLinux::SetProcessType() {
-  process_type_ = "gpu-process";
-}
-
-// static
-GpuCrashHandlerHostLinux* GpuCrashHandlerHostLinux::GetInstance() {
-  return Singleton<GpuCrashHandlerHostLinux>::get();
-}
-
-PluginCrashHandlerHostLinux::PluginCrashHandlerHostLinux() {
-  InitCrashUploaderThread();
-}
-
-PluginCrashHandlerHostLinux::~PluginCrashHandlerHostLinux() {
-}
-
-void PluginCrashHandlerHostLinux::SetProcessType() {
-  process_type_ = "plugin";
-}
-
-// static
-PluginCrashHandlerHostLinux* PluginCrashHandlerHostLinux::GetInstance() {
-  return Singleton<PluginCrashHandlerHostLinux>::get();
-}
-
-PpapiCrashHandlerHostLinux::PpapiCrashHandlerHostLinux() {
-  InitCrashUploaderThread();
-}
-
-PpapiCrashHandlerHostLinux::~PpapiCrashHandlerHostLinux() {
-}
-
-void PpapiCrashHandlerHostLinux::SetProcessType() {
-  process_type_ = "ppapi";
-}
-
-// static
-PpapiCrashHandlerHostLinux* PpapiCrashHandlerHostLinux::GetInstance() {
-  return Singleton<PpapiCrashHandlerHostLinux>::get();
-}
-
-RendererCrashHandlerHostLinux::RendererCrashHandlerHostLinux() {
-  InitCrashUploaderThread();
-}
-
-RendererCrashHandlerHostLinux::~RendererCrashHandlerHostLinux() {
-}
-
-void RendererCrashHandlerHostLinux::SetProcessType() {
-  process_type_ = "renderer";
-}
-
-// static
-RendererCrashHandlerHostLinux* RendererCrashHandlerHostLinux::GetInstance() {
-  return Singleton<RendererCrashHandlerHostLinux>::get();
-}