Suppress browser microdump when renderer crashes in multiprocess WebView.

components/crash/content/app/breakpad_linux.cc

 // Copyright 2013 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.
 
 #include "components/crash/content/app/breakpad_linux.h"
 
 #include <fcntl.h>
@@ skipping 83 matching lines @@
 bool g_is_crash_reporter_enabled = false;
 uint64_t g_process_start_time = 0;
 pid_t g_pid = 0;
 char* g_crash_log_path = nullptr;
 ExceptionHandler* g_breakpad = nullptr;
 
 #if defined(ADDRESS_SANITIZER)
 const char* g_asan_report_str = nullptr;
 #endif
 #if defined(OS_ANDROID)
+#define G_DUMPS_SUPPRESSED_MAGIC 0x5AFECEDE
+uint32_t g_dumps_suppressed = 0;
 char* g_process_type = nullptr;
 ExceptionHandler* g_microdump = nullptr;
 int g_signal_code_pipe_fd = -1;
 
 class MicrodumpInfo {
  public:
   MicrodumpInfo()
       : microdump_build_fingerprint_(nullptr),
         microdump_product_info_(nullptr),
         microdump_gpu_fingerprint_(nullptr) {}
@@ skipping 454 matching lines @@
   my_strlcat(buf, " v", kMaxSize);
   my_strlcat(buf, android_build_info->package_version_code(), kMaxSize);
   my_strlcat(buf, " (", kMaxSize);
   my_strlcat(buf, android_build_info->package_version_name(), kMaxSize);
   my_strlcat(buf, ")", kMaxSize);
 
   writer.AddPairString("package", buf);
 }
 #endif  // defined(OS_ANDROID)
 
-void DumpProcess() {
-  if (g_breakpad)
-    g_breakpad->WriteMinidump();
-
-#if defined(OS_ANDROID)
-  // If microdumps are enabled write also a microdump on the system log.
-  if (g_microdump)
-    g_microdump->WriteMinidump();
-#endif
-}
-
 #if defined(OS_ANDROID)
 const char kGoogleBreakpad[] = "google-breakpad";
 #endif
 
 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
 }
 
 size_t WriteNewline() {
   return WriteLog("\n", 1);
 }
 
 #if defined(OS_ANDROID)
+bool ShouldGenerateDump(void *context) {
+  return g_dumps_suppressed != G_DUMPS_SUPPRESSED_MAGIC;
+}
+
 void AndroidLogWriteHorizontalRule() {
   __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad,
                       "### ### ### ### ### ### ### ### ### ### ### ### ###");
 }
 
 // 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 and the location of the archived Chrome symbols can
@@ skipping 21 matching lines @@
     // TODO(cjhopman): There should be some way to recover the crash stack from
     // non-uploading user clients. See http://crbug.com/273706.
     __android_log_write(ANDROID_LOG_WARN,
                         kGoogleBreakpad,
                         "Tombstones are disabled on JB MR2+ user builds.");
     AndroidLogWriteHorizontalRule();
     return true;
   }
   return false;
 }
-#endif
+
+bool MicrodumpCrashDone(const MinidumpDescriptor& minidump,
+                        void* context,
+                        bool succeeded) {
+  // WARNING: this code runs in a compromised context. It may not call into
+  // libc nor allocate memory normally.
+  if (!succeeded) {
+    static const char msg[] = "Microdump crash handler failed.\n";
+    WriteLog(msg, sizeof(msg) - 1);
+    return false;
+  }
+
+  const bool is_browser_process = (context != nullptr);
+  return FinalizeCrashDoneAndroid(is_browser_process);
+}
+#endif  // defined(OS_ANDROID)
 
 bool CrashDone(const MinidumpDescriptor& minidump,
                const bool upload,
                const bool should_finalize,
                const bool succeeded) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
   if (!succeeded) {
     const char msg[] = "Failed to generate minidump.";
     WriteLog(msg, sizeof(msg) - 1);
@@ skipping 50 matching lines @@
 
 #if !defined(OS_ANDROID)
 // Wrapper function, do not add more code here.
 bool CrashDoneUpload(const MinidumpDescriptor& minidump,
                      void* context,
                      bool succeeded) {
   return CrashDone(minidump, true, true, succeeded);
 }
 #endif
 
+void DumpProcess() {
+#if defined(OS_ANDROID)
+  // Don't use g_breakpad and g_microdump directly here, because their
+  // output might currently be suppressed.
+  if (g_breakpad) {
+    ExceptionHandler(g_breakpad->minidump_descriptor(),
+                     nullptr,
+                     CrashDoneNoUpload,
+                     nullptr,
+                     false, -1).WriteMinidump();
+  }
+  // If microdumps are enabled write also a microdump on the system log.
+  if (g_microdump) {
+    ExceptionHandler(g_microdump->minidump_descriptor(),
+                     nullptr,
+                     MicrodumpCrashDone,
+                     nullptr,
+                     false, -1).WriteMinidump();
+  }
+#else
+  if (g_breakpad)
+    g_breakpad->WriteMinidump();
+#endif
+}
+
 #if defined(ADDRESS_SANITIZER)
 extern "C"
 void __asan_set_error_report_callback(void (*cb)(const char*));
 
 extern "C"
 void AsanLinuxBreakpadCallback(const char* report) {
   g_asan_report_str = report;
   // Send minidump here.
   g_breakpad->SimulateSignalDelivery(SIGKILL);
 }
@@ skipping 21 matching lines @@
     minidump_descriptor.set_size_limit(-1);  // unlimited.
   } else {
     minidump_descriptor.set_size_limit(kMaxMinidumpFileSize);
   }
 #if defined(OS_ANDROID)
   unattended = true;  // Android never uploads directly.
 #endif
   if (unattended) {
     g_breakpad = new ExceptionHandler(
         minidump_descriptor,
+#if defined(OS_ANDROID)
+        ShouldGenerateDump,
+#else
         nullptr,
+#endif
         CrashDoneNoUpload,
         nullptr,
         true,  // Install handlers.
         -1);   // Server file descriptor. -1 for in-process.
     return;
   }
 
 #if !defined(OS_ANDROID)
   // Attended mode
   g_breakpad = new ExceptionHandler(
       minidump_descriptor,
       nullptr,
       CrashDoneUpload,
       nullptr,
       true,  // Install handlers.
       -1);   // Server file descriptor. -1 for in-process.
 #endif
 }
 
 #if defined(OS_ANDROID)
-bool MicrodumpCrashDone(const MinidumpDescriptor& minidump,
-                        void* context,
-                        bool succeeded) {
-  // WARNING: this code runs in a compromised context. It may not call into
-  // libc nor allocate memory normally.
-  if (!succeeded) {
-    static const char msg[] = "Microdump crash handler failed.\n";
-    WriteLog(msg, sizeof(msg) - 1);
-    return false;
-  }
-
-  const bool is_browser_process = (context != nullptr);
-  return FinalizeCrashDoneAndroid(is_browser_process);
-}
-
 bool WriteSignalCodeToPipe(const void* crash_context,
                            size_t crash_context_size,
                            void* context) {
   if (g_signal_code_pipe_fd == -1)
     return false;
   int signo = INT_MAX;
   if (crash_context_size == sizeof(ExceptionHandler::CrashContext)) {
     const ExceptionHandler::CrashContext* eh_context =
         static_cast<const ExceptionHandler::CrashContext*>(crash_context);
     signo = eh_context->siginfo.si_signo;
@@ skipping 53 matching lines @@
     return;
   }
   SetProcessStartTime();
   g_pid = getpid();
 
   g_is_crash_reporter_enabled = true;
   // Save the process type (it is leaked).
   const size_t process_type_len = process_type.size() + 1;
   g_process_type = new char[process_type_len];
   strncpy(g_process_type, process_type.c_str(), process_type_len);
-  new google_breakpad::ExceptionHandler(MinidumpDescriptor(minidump_fd),
-      nullptr, CrashDoneInProcessNoUpload, nullptr, true, -1);
+  new ExceptionHandler(MinidumpDescriptor(minidump_fd), ShouldGenerateDump,
+                       CrashDoneInProcessNoUpload, nullptr, true, -1);
 }
 
 void MicrodumpInfo::SetGpuFingerprint(const std::string& gpu_fingerprint) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!microdump_gpu_fingerprint_);
   microdump_gpu_fingerprint_ = strdup(gpu_fingerprint.c_str());
   ANNOTATE_LEAKING_OBJECT_PTR(microdump_gpu_fingerprint_);
 
   if (g_microdump) {
     MinidumpDescriptor minidump_descriptor(g_microdump->minidump_descriptor());
@@ skipping 36 matching lines @@
     descriptor.microdump_extra_info()->build_fingerprint =
         microdump_build_fingerprint_;
   }
 
   if (microdump_gpu_fingerprint_) {
     descriptor.microdump_extra_info()->gpu_fingerprint =
         microdump_gpu_fingerprint_;
   }
 
   g_microdump =
-      new ExceptionHandler(descriptor, nullptr, MicrodumpCrashDone,
+      new ExceptionHandler(descriptor, ShouldGenerateDump, MicrodumpCrashDone,
                            reinterpret_cast<void*>(is_browser_process),
                            true,  // Install handlers.
                            -1);   // Server file descriptor. -1 for in-process.
 
   if (process_type != kWebViewSingleProcessType &&
       process_type != kBrowserProcessType &&
       !process_type.empty()) {
     g_signal_code_pipe_fd =
         GetCrashReporterClient()->GetAndroidCrashSignalFD();
     if (g_signal_code_pipe_fd != -1)
@@ skipping 1002 matching lines @@
 
 void GenerateMinidumpOnDemandForAndroid(int dump_fd) {
   if (dump_fd >= 0) {
     MinidumpDescriptor minidump_descriptor(dump_fd);
     minidump_descriptor.set_size_limit(-1);
     ExceptionHandler(minidump_descriptor, nullptr, MinidumpGenerated, nullptr,
                      false, -1)
         .WriteMinidump();
   }
 }
+
+void SuppressDumpGeneration() {
+  g_dumps_suppressed = G_DUMPS_SUPPRESSED_MAGIC;
+}
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }
 
 }  // namespace breakpad