base::Bind() conversion for crash handler/uploader.

chrome/browser/crash_handler_host_linux.cc

 // Copyright (c) 2011 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/eintr_wrapper.h"
 #include "base/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.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
-#include "base/task.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.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/env_vars.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
@@ skipping 18 matching lines @@
   delete[] info->crash_url;
   delete[] info->guid;
   delete[] info->distro;
   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.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(CrashHandlerHostLinux);
+// the lifetime of the IO message loop. Thus, all calls to base::Bind() use
+// non-refcounted pointers.
 
 CrashHandlerHostLinux::CrashHandlerHostLinux()
     : shutting_down_(false) {
   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,
-      NewRunnableMethod(this, &CrashHandlerHostLinux::Init));
+      base::Bind(&CrashHandlerHostLinux::Init, base::Unretained(this)));
 }
 
 CrashHandlerHostLinux::~CrashHandlerHostLinux() {
   HANDLE_EINTR(close(process_socket_));
   HANDLE_EINTR(close(browser_socket_));
 }
 
 void CrashHandlerHostLinux::Init() {
   MessageLoopForIO* ml = MessageLoopForIO::current();
   CHECK(ml->WatchFileDescriptor(
@@ skipping 213 matching lines @@
   info->guid = guid;
 
   info->distro_length = strlen(distro);
   info->distro = distro;
 
   info->upload = (getenv(env_vars::kHeadless) == NULL);
   info->process_start_time = uptime;
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(this,
-                        &CrashHandlerHostLinux::WriteDumpFile,
-                        info,
-                        crashing_pid,
-                        crash_context,
-                        signal_fd));
+      base::Bind(&CrashHandlerHostLinux::WriteDumpFile,
+                 base::Unretained(this),
+                 info,
+                 crashing_pid,
+                 crash_context,
+                 signal_fd));
 }
 
 void CrashHandlerHostLinux::WriteDumpFile(BreakpadInfo* info,
                                           pid_t crashing_pid,
                                           char* crash_context,
                                           int signal_fd) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   FilePath dumps_path("/tmp");
   PathService::Get(base::DIR_TEMP, &dumps_path);
@@ skipping 13 matching lines @@
   delete[] crash_context;
 
   // Freed in CrashDumpTask();
   char* minidump_filename_str = new char[minidump_filename.length() + 1];
   minidump_filename.copy(minidump_filename_str, minidump_filename.length());
   minidump_filename_str[minidump_filename.length()] = '\0';
   info->filename = minidump_filename_str;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this,
-                        &CrashHandlerHostLinux::QueueCrashDumpTask,
-                        info,
-                        signal_fd));
+      base::Bind(&CrashHandlerHostLinux::QueueCrashDumpTask,
+                 base::Unretained(this),
+                 info,
+                 signal_fd));
 }
 
 void CrashHandlerHostLinux::QueueCrashDumpTask(BreakpadInfo* info,
                                                int signal_fd) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Send the done signal to the process: it can exit now.
   struct msghdr msg = {0};
   struct iovec done_iov;
   done_iov.iov_base = const_cast<char*>("\x42");
   done_iov.iov_len = 1;
   msg.msg_iov = &done_iov;
   msg.msg_iovlen = 1;
 
   HANDLE_EINTR(sendmsg(signal_fd, &msg, MSG_DONTWAIT | MSG_NOSIGNAL));
   HANDLE_EINTR(close(signal_fd));
 
   uploader_thread_->message_loop()->PostTask(
       FROM_HERE,
-      NewRunnableFunction(&CrashDumpTask, this, info));
+      base::Bind(&CrashDumpTask, base::Unretained(this), info));
 }
 
 void CrashHandlerHostLinux::WillDestroyCurrentMessageLoop() {
   file_descriptor_watcher_.StopWatchingFileDescriptor();
 
   // If we are quitting and there are crash dumps in the queue, turn them into
   // no-ops.
   shutting_down_ = true;
   uploader_thread_->Stop();
 }
@@ skipping 74 matching lines @@
 }
 
 void RendererCrashHandlerHostLinux::SetProcessType() {
   process_type_ = "renderer";
 }
 
 // static
 RendererCrashHandlerHostLinux* RendererCrashHandlerHostLinux::GetInstance() {
   return Singleton<RendererCrashHandlerHostLinux>::get();
 }