Always drop a tombstone

chrome/app/breakpad_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.
 
 // 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_linux.h"
 
@@ skipping 358 matching lines @@
 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, kGoogleBreakpad, buf);
 #else
   return sys_write(2, buf, nbytes);
 #endif
 }
 
+#if defined(OS_ANDROID)
+// Android's native crash handler outputs a diagnostic tombstone to the device
+// log. By returning false from the HandlerCallbacks, breakpad will reinstall
+// the previous (i.e. native) signal handlers before returning from its own
+// handler. A Chrome build fingerprint is written to the log, so that the
+// specific build of Chrome can be determined directly from it.
+bool FinalizeCrashDoneAndroid() {
+  base::android::BuildInfo* android_build_info =
+      base::android::BuildInfo::GetInstance();
+
+  __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad,
+                      "### ### ### ### ### ### ### ### ### ### ### ### ###");
+  __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad,
+                      "Chrome build fingerprint:");
+  __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad,
+                      android_build_info->package_version_name());
+  __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad,
+                      android_build_info->package_version_code());

[Mark Mentovai, 2012/09/07 20:22:36]

Isn’t the name and version number of an official build enough?

+  __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad,
+                      CHROME_SYMBOLS_LOCATION);
+  __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad,
+                      "### ### ### ### ### ### ### ### ### ### ### ### ###");
+  return false;
+}
+
+bool CrashDoneNonBrowserAndroid(const MinidumpDescriptor& minidump,
+                                void* context,
+                                bool succeeded) {
+  return FinalizeCrashDoneAndroid();
+}
+#endif
 
 bool CrashDone(const MinidumpDescriptor& minidump,
                const bool upload,
                const bool succeeded) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
   if (!succeeded)
     return false;
 
   DCHECK(!minidump.IsFD());
@@ skipping 15 matching lines @@
   info.crash_url_length = 0;
   info.guid = child_process_logging::g_client_id;
   info.guid_length = my_strlen(child_process_logging::g_client_id);
   info.distro = base::g_linux_distro;
   info.distro_length = my_strlen(base::g_linux_distro);
   info.upload = upload;
   info.process_start_time = g_process_start_time;
   info.oom_size = base::g_oom_size;
   info.pid = 0;
   HandleCrashDump(info);
+#if defined(OS_ANDROID)
+  return FinalizeCrashDoneAndroid();
+#else
   return true;
+#endif
 }
 
 // Wrapper function, do not add more code here.
 bool CrashDoneNoUpload(const MinidumpDescriptor& minidump,
                        void* context,
                        bool succeeded) {
   return CrashDone(minidump, false, succeeded);
 }
 
 #if !defined(OS_ANDROID)
@@ skipping 146 matching lines @@
     IGNORE_RET(sys_close(fds[1]));
     return false;
   }
   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);
   }
 
+#if defined(OS_ANDROID)
+  // When false is returned, breakpad will continue to its minidump generator
+  // and then to the HandlerCallback, which, in this case, is
+  // CrashDoneNonBrowserAndroid().
+  return false;
+#else
   return true;

[Yaron, 2012/09/07 20:15:17]

Just wondering why other ports return true here as opposed to false like us.

+#endif
 }
 
 void EnableNonBrowserCrashDumping() {
   const int fd = base::GlobalDescriptors::GetInstance()->Get(kCrashDumpSignal);
   g_is_crash_reporter_enabled = true;
   // We deliberately leak this object.
   DCHECK(!g_breakpad);
+
+  ExceptionHandler::MinidumpCallback crash_done_callback = NULL;
+#if defined(OS_ANDROID)
+  crash_done_callback = CrashDoneNonBrowserAndroid;
+#endif
+
   g_breakpad = new ExceptionHandler(
       MinidumpDescriptor("/tmp"),  // Unused but needed or Breakpad will assert.
       NULL,
-      NULL,
+      crash_done_callback,
       reinterpret_cast<void*>(fd),  // Param passed to the crash handler.
       true,
       -1);
   g_breakpad->set_crash_handler(NonBrowserCrashHandler);
 }
 
 }  // namespace
 
 void LoadDataFromFile(google_breakpad::PageAllocator& allocator,
                       const BreakpadInfo& info, const char* filename,
@@ skipping 650 matching lines @@
   logging::SetDumpWithoutCrashingFunction(&DumpProcess);
 #if defined(ADDRESS_SANITIZER)
   // Register the callback for AddressSanitizer error reporting.
   __asan_set_error_report_callback(AsanLinuxBreakpadCallback);
 #endif
 }
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }