Linux: Clean up Breakpad code after r131662.

chrome/app/breakpad_linuxish.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.
 
 // For linux_syscall_support.h. This makes it safe to call embedded system
 // calls when in seccomp mode.
 #define SYS_SYSCALL_ENTRYPOINT "playground$syscallEntryPoint"
 
 #include "chrome/app/breakpad_linuxish.h"
 
@@ skipping 28 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info_posix.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/common/logging_chrome.h"
 #include "content/common/chrome_descriptors.h"
 
 #if defined(OS_ANDROID)
 #include <android/log.h>
 #include <sys/stat.h>
+
+#include "base/android/build_info.h"
 #include "base/android/path_utils.h"
-#include "base/android/build_info.h"
 #include "third_party/lss/linux_syscall_support.h"
 #else
 #include "seccompsandbox/linux_syscall_support.h"
 #endif
 
+#if defined(OS_ANDROID)
+#define STAT_STRUCT struct stat
+#define FSTAT_FUNC fstat
+#else
+#define STAT_STRUCT struct kernel_stat
+#define FSTAT_FUNC sys_fstat
+#endif
+
 #ifndef PR_SET_PTRACER
 #define PR_SET_PTRACER 0x59616d61
 #endif
 
 // Some versions of gcc are prone to warn about unused return values. In cases
 // where we either a) know the call cannot fail, or b) there is nothing we
 // can do when a call fails, we mark the return code as ignored. This avoids
 // spurious compiler warnings.
 #define IGNORE_RET(x) do { if (x); } while (0)
 
@@ skipping 71 matching lines @@
     *p++ = *src++;
     i--;
   }
   while (i != 0) {
     *p++ = '\0';
     i--;
   }
   return dst;
 }
 
-static char* my_strncat(char *dest, const char *src, size_t len) {
-  char *ret = dest;
+static char* my_strncat(char *dest, const char* src, size_t len) {
+  char* ret = dest;
   while (*dest)
       dest++;
   while (len--)
     if (!(*dest++ = *src++))
       return ret;
   *dest = 0;
   return ret;
 }
 #endif
 
 namespace {
 
 // MIME substrings.
-static const char g_rn[] = "\r\n";
-static const char g_form_data_msg[] = "Content-Disposition: form-data; name=\"";
-static const char g_quote_msg[] = "\"";
-static const char g_dashdash_msg[] = "--";
-static const char g_dump_msg[] = "upload_file_minidump\"; filename=\"dump\"";
-static const char g_content_type_msg[] =
-    "Content-Type: application/octet-stream";
+const char g_rn[] = "\r\n";
+const char g_form_data_msg[] = "Content-Disposition: form-data; name=\"";
+const char g_quote_msg[] = "\"";
+const char g_dashdash_msg[] = "--";
+const char g_dump_msg[] = "upload_file_minidump\"; filename=\"dump\"";
+const char g_content_type_msg[] = "Content-Type: application/octet-stream";
 
 // MimeWriter manages an iovec for writing MIMEs to a file.
 class MimeWriter {
  public:
   static const int kIovCapacity = 30;
   static const size_t kMaxCrashChunkSize = 64;
 
   MimeWriter(int fd, const char* const mime_boundary);
   ~MimeWriter();
 
@@ skipping 157 matching lines @@
     size--;
   }
   AddItem(base, size);
 }
 
 void DumpProcess() {
   if (g_breakpad)
     g_breakpad->WriteMinidump();
 }
 
+const char kGoogleBreakpad[] = "google-breakpad";
+
 size_t WriteLog(const char* buf, size_t nbytes) {
 #if defined(OS_ANDROID)
-  return __android_log_write(ANDROID_LOG_WARN, "google-breakpad", buf);
+  return __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad, buf);
 #else
   return sys_write(2, buf, nbytes);
 #endif
 }
 
 }  // namespace
 
 void HandleCrashDump(const BreakpadInfo& info) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
 
   const int dumpfd = sys_open(info.filename, O_RDONLY, 0);
   if (dumpfd < 0) {
     static const char msg[] = "Cannot upload crash dump: failed to open\n";
     WriteLog(msg, sizeof(msg));
     return;
   }
-#if defined(OS_ANDROID)
-  struct stat st;
-  if (fstat(dumpfd, &st) != 0) {
-#else
-  struct kernel_stat st;
-  if (sys_fstat(dumpfd, &st) != 0) {
-#endif
+  STAT_STRUCT st;
+  if (FSTAT_FUNC(dumpfd, &st) != 0) {
     static const char msg[] = "Cannot upload crash dump: stat failed\n";
     WriteLog(msg, sizeof(msg));
     IGNORE_RET(sys_close(dumpfd));
     return;
   }
 
   google_breakpad::PageAllocator allocator;
 
   uint8_t* dump_data = reinterpret_cast<uint8_t*>(allocator.Alloc(st.st_size));
   if (!dump_data) {
@@ skipping 150 matching lines @@
     static const char chrome_product_msg[] = "Chrome_ChromeOS";
 #else  // OS_LINUX
     static const char chrome_product_msg[] = "Chrome_Linux";
 #endif
 
 #if defined (OS_ANDROID)
     base::android::BuildInfo* android_build_info =
         base::android::BuildInfo::GetInstance();
     static const char* version_msg =
         android_build_info->package_version_code();
-    static const char android_build_id[] = "android_build_id";
-    static const char android_build_fp[] = "android_build_fp";
-    static const char device[] = "device";
-    static const char model[] = "model";
-    static const char brand[] = "brand";
 #else
     static const char version_msg[] = PRODUCT_VERSION;
 #endif
 
     writer.AddBoundary();
     writer.AddPairString("prod", chrome_product_msg);
     writer.AddBoundary();
     writer.AddPairString("ver", version_msg);
     writer.AddBoundary();
     writer.AddPairString("guid", info.guid);
     writer.AddBoundary();
     if (info.pid > 0) {
+      char pid_buf[kUint64StringSize];
       uint64_t pid_str_len = my_uint64_len(info.pid);
-      char* pid_buf = reinterpret_cast<char*>(allocator.Alloc(pid_str_len));
       my_uint64tos(pid_buf, info.pid, pid_str_len);
       writer.AddPairString("pid", pid_buf);
       writer.AddBoundary();
     }
 #if defined(OS_ANDROID)
     // Addtional MIME blocks are added for logging on Android devices.
+    static const char android_build_id[] = "android_build_id";
+    static const char android_build_fp[] = "android_build_fp";
+    static const char device[] = "device";
+    static const char model[] = "model";
+    static const char brand[] = "brand";
+
     writer.AddPairString(
         android_build_id, android_build_info->android_build_id());
     writer.AddBoundary();
     writer.AddPairString(
         android_build_fp, android_build_info->android_build_fp());
     writer.AddBoundary();
     writer.AddPairString(device, android_build_info->device());
     writer.AddBoundary();
     writer.AddPairString(model, android_build_info->model());
     writer.AddBoundary();
@@ skipping 140 matching lines @@
                        oom_size_str, oom_size_len);
     writer.AddBoundary();
     writer.Flush();
   }
 
   writer.AddFileDump(dump_data, st.st_size);
   writer.AddEnd();
   writer.Flush();
 
   IGNORE_RET(sys_close(temp_file_fd));
+
 #if defined(OS_ANDROID)
+  __android_log_write(ANDROID_LOG_WARN,
+                      kGoogleBreakpad,
+                      "Output crash dump file:");
+  __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad, info.filename);
+
+  char pid_buf[kUint64StringSize];
   uint64_t pid_str_len = my_uint64_len(info.pid);
-  char* pid_buf = reinterpret_cast<char*>(allocator.Alloc(pid_str_len));
   my_uint64tos(pid_buf, info.pid, pid_str_len);
 
-  static const char* output_msg = "Output crash dump file:";
-  WriteLog(output_msg, my_strlen(output_msg));
-  unsigned filename_len = my_strlen(info.filename);
-  WriteLog(info.filename, filename_len);
   // -1 because we won't need the null terminator on the original filename.
-  size_t done_filename_len = filename_len - 1 + pid_str_len;
+  size_t done_filename_len = my_strlen(info.filename) + pid_str_len - 1;
   char* done_filename = reinterpret_cast<char*>(
       allocator.Alloc(done_filename_len));
   // Rename the file such that the pid is the suffix in order to signal other
   // processes that the minidump is complete. The advantage of using the pid as
   // the suffix is that it is trivial to associate the minidump with the
   // crashed process.
   // Finally, note strncpy prevents null terminators from
   // being copied. Pad the rest with 0's.
   my_strncpy(done_filename, info.filename, done_filename_len);
   // Append the suffix a null terminator should be added.
   my_strncat(done_filename, pid_buf, pid_str_len);
   // Rename the minidump file to signal that it is complete.
   if (rename(info.filename, done_filename)) {
-    __android_log_write(ANDROID_LOG_WARN, "chromium", "Failed to rename:");
-    __android_log_write(ANDROID_LOG_WARN, "chromium", info.filename);
-    __android_log_write(ANDROID_LOG_WARN, "chromium", "to");
-    __android_log_write(ANDROID_LOG_WARN, "chromium", done_filename);
+    __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad, "Failed to rename:");
+    __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad, info.filename);
+    __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad, "to");
+    __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad, done_filename);
   }
 #endif
 
   if (!info.upload)
     return;
 
   // The --header argument to wget looks like:
   //   --header=Content-Type: multipart/form-data; boundary=XYZ
   // where the boundary has two fewer leading '-' chars
   static const char header_msg[] =
@@ skipping 47 matching lines @@
 
     // Leave one end of a pipe in the wget process and watch for it getting
     // closed by the wget process exiting.
     int fds[2];
     if (sys_pipe(fds) >= 0) {
       const pid_t wget_child = sys_fork();
       if (!wget_child) {
         // Wget process.
         IGNORE_RET(sys_close(fds[0]));
         IGNORE_RET(sys_dup2(fds[1], 3));
-        static const char* const kWgetBinary = "/usr/bin/wget";
+        static const char kWgetBinary[] = "/usr/bin/wget";
         const char* args[] = {
           kWgetBinary,
           header,
           post_file,
           kUploadURL,
           "--timeout=10",  // Set a timeout so we don't hang forever.
           "--tries=1",     // Don't retry if the upload fails.
           "-O",  // output reply to fd 3
           "/dev/fd/3",
           NULL,
@@ skipping 109 matching lines @@
   info.upload = upload;
   info.process_start_time = g_process_start_time;
   info.oom_size = base::g_oom_size;
   info.pid = 0;
   HandleCrashDump(info);
   return true;
 }
 
 // Wrapper function, do not add more code here.
 static bool CrashDoneNoUpload(const char* dump_path,
-                      const char* minidump_id,
-                      void* context,
-                      bool succeeded) {
+                              const char* minidump_id,
+                              void* context,
+                              bool succeeded) {
   return CrashDone(dump_path, minidump_id, false, succeeded);
 }
 
 #if !defined(OS_ANDROID)
 // Wrapper function, do not add more code here.
 static bool CrashDoneUpload(const char* dump_path,
-                      const char* minidump_id,
-                      void* context,
-                      bool succeeded) {
+                            const char* minidump_id,
+                            void* context,
+                            bool succeeded) {
   return CrashDone(dump_path, minidump_id, true, succeeded);
 }
 #endif
 
-void EnableCrashDumping(bool unattended) {
+static void EnableCrashDumping(bool unattended) {
   g_is_crash_reporter_enabled = true;
 
   FilePath tmp_path("/tmp");
   PathService::Get(base::DIR_TEMP, &tmp_path);
 
   FilePath dumps_path(tmp_path);
   if (PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path)) {
     FilePath logfile =
         dumps_path.AppendASCII(CrashUploadList::kReporterLogFilename);
     std::string logfile_str = logfile.value();
     const size_t crash_log_path_len = logfile_str.size() + 1;
     g_crash_log_path = new char[crash_log_path_len];
     strncpy(g_crash_log_path, logfile_str.c_str(), crash_log_path_len);
   }
   DCHECK(!g_breakpad);
 #if defined(OS_ANDROID)
-  unattended = true;
+  unattended = true;  // Android never uploads directly.
 #endif
   if (unattended) {
     g_breakpad = new google_breakpad::ExceptionHandler(
         dumps_path.value().c_str(),
         NULL,
         CrashDoneNoUpload,
         NULL,
         true /* install handlers */);
-  } else {
-    g_breakpad = new google_breakpad::ExceptionHandler(
-        tmp_path.value().c_str(),
-        NULL,
-        CrashDoneUpload,
-        NULL,
-        true /* install handlers */);
+    return;
   }
+
+#if !defined(OS_ANDROID)
+  // Attended mode
+  g_breakpad = new google_breakpad::ExceptionHandler(
+      tmp_path.value().c_str(),
+      NULL,
+      CrashDoneUpload,
+      NULL,
+      true /* install handlers */);
+#endif
 }
 
 // Non-Browser = Extension, Gpu, Plugins, Ppapi and Renderer
 static bool NonBrowserCrashHandler(const void* crash_context,
                                    size_t crash_context_size,
                                    void* context) {
   const int fd = reinterpret_cast<intptr_t>(context);
   int fds[2] = { -1, -1 };
   if (sys_socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {
     static const char msg[] = "Failed to create socket for crash dumping.\n";
@@ skipping 81 matching lines @@
   IGNORE_RET(sys_close(fds[1]));
 
   if (HANDLE_EINTR(sys_read(fds[0], &b, 1)) != 1) {
     static const char errmsg[] = "Parent failed to complete crash dump.\n";
     WriteLog(errmsg, sizeof(errmsg)-1);
   }
 
   return true;
 }
 
-void EnableNonBrowserCrashDumping() {
+static void EnableNonBrowserCrashDumping() {
   const int fd = base::GlobalDescriptors::GetInstance()->Get(kCrashDumpSignal);
   g_is_crash_reporter_enabled = true;
   // We deliberately leak this object.
   DCHECK(!g_breakpad);
   g_breakpad = new google_breakpad::ExceptionHandler(
       "" /* unused */, NULL, NULL, reinterpret_cast<void*>(fd), true);
   g_breakpad->set_crash_handler(NonBrowserCrashHandler);
 }
 
 void InitCrashReporter() {
@@ skipping 45 matching lines @@
     g_process_start_time = timeval_to_ms(&tv);
   else
     g_process_start_time = 0;
 
   logging::SetDumpWithoutCrashingFunction(&DumpProcess);
 }
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }