Dump process type into breakpad.

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)
-const char kWebViewProcessType[] = "webview";
 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 15 matching lines @@
   void Initialize(const std::string& process_type,
                   const char* product_name,
                   const char* product_version,
                   const char* android_build_fp);
 
  private:
   base::ThreadChecker thread_checker_;
   const char* microdump_build_fingerprint_;
   const char* microdump_product_info_;
   const char* microdump_gpu_fingerprint_;
+  const char* microdump_process_type_;
 };
 
 base::LazyInstance<MicrodumpInfo> g_microdump_info =
     LAZY_INSTANCE_INITIALIZER;
 
 #endif
 
 CrashKeyStorage* g_crash_keys = nullptr;
 
 // Writes the value |v| as 16 hex characters to the memory pointed at by
@@ skipping 721 matching lines @@
     g_microdump->set_minidump_descriptor(minidump_descriptor);
   }
 }
 
 void MicrodumpInfo::Initialize(const std::string& process_type,
                                const char* product_name,
                                const char* product_version,
                                const char* android_build_fp) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!g_microdump);
-  bool is_browser_process =
-      process_type.empty() || process_type == kWebViewProcessType;
+  bool is_browser_process = process_type.empty() ||
+                            process_type == kWebViewSingleProcessType ||
+                            process_type == kWebViewBrowserProcessType;
 
   MinidumpDescriptor descriptor(MinidumpDescriptor::kMicrodumpOnConsole);
 
   if (product_name && product_version) {
     microdump_product_info_ =
         strdup((product_name + std::string(":") + product_version).c_str());
     ANNOTATE_LEAKING_OBJECT_PTR(microdump_product_info_);
     descriptor.microdump_extra_info()->product_info = microdump_product_info_;
   }
 
+  microdump_process_type_ =
+      strdup(process_type.empty() ? "browser" : process_type.c_str());

[Torne, 2016/07/14 10:29:09]

Just a nit: It looks a bit weird having the remapping from empty to hardcoded
"browser" here, but then having the webview codepath explicitly remap empty to a
different, constant-defined "browser". Maybe just make the constant called
kBrowserProcessType and use it in both places?

+  ANNOTATE_LEAKING_OBJECT_PTR(microdump_process_type_);
+  descriptor.microdump_extra_info()->process_type = microdump_process_type_;
+
   if (android_build_fp) {
     microdump_build_fingerprint_ = strdup(android_build_fp);
     ANNOTATE_LEAKING_OBJECT_PTR(microdump_build_fingerprint_);
     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,
                            reinterpret_cast<void*>(is_browser_process),
                            true,  // Install handlers.
                            -1);   // Server file descriptor. -1 for in-process.
 
-  if (process_type == kWebViewProcessType) {
+  if (process_type == kWebViewSingleProcessType ||
+      process_type == kWebViewBrowserProcessType) {
+    // TODO(tobiasjs): figure out what to do with on demand minidump on the
+    // renderer process of webview.
     // We do not use |DumpProcess()| for handling programatically
     // generated dumps for WebView because we only know the file
     // descriptor to which we are dumping at the time of the call to
     // |DumpWithoutCrashing()|. Therefore we need to construct the
     // |MinidumpDescriptor| and |ExceptionHandler| instances as
     // needed, instead of setting up |g_breakpad| at initialization
     // time.
     base::debug::SetDumpWithoutCrashingFunction(
         &GenerateMinidumpOnDemandForAndroid);
   } else if (!process_type.empty()) {
@@ skipping 1000 matching lines @@
     const std::string& gpu_fingerprint) {
   g_microdump_info.Get().SetGpuFingerprint(gpu_fingerprint);
 }
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }
 
 }  // namespace breakpad