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";
+const char kWebViewSingleProcessType[] = "webview-singleprocess";

[hush (inactive), 2016/06/22 21:34:19]

I hope this change does not break anything that tries to strictly match
"webview" (like somewhere in the server side?)

[Torne, 2016/06/23 13:40:10]

Since we don't upload the string currently I don't think this can break anything
on the server side.

I'm not sure "webview-singleprocess" is a good string here, though. It seems
like it would make more sense to either:
1) have *all* the webview process types identify that they're webview,  for the
avoidance of doubt, or
2) have the string just be "singleprocess" or "single" or similar, and *also*
use it for chrome if chrome is running with kSingleProcess set (and then
possibly also change minidumps similarly)?

I'd lean toward 2.. what do you think?

[hush (inactive), 2016/06/23 19:13:14]

Does chrome actually run in single process mode in any production distribution?
I'm just not sure what the benefit is. It seems to be doing #1 is enough (and
easiest, least amount of work)

[hush (inactive), 2016/06/24 20:18:46]

Anyway... I went with #1 in the next patch set. Let me know if you have any
problems..

 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 726 matching lines @@
   }
 }
 
 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;
+      process_type.empty() || process_type == kWebViewSingleProcessType;
 
   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_;
   }
 
+  // MicroDumpExtraInfo::process_type will have 3 possible values:
+  // webview-singleprocess, browser, renderer
+  microdump_process_type_ =
+      strdup(process_type.empty() ? "browser" : process_type.c_str());
+  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) {

[Torne, 2016/06/23 13:40:10]

There's a problem here, which is not introduced by your change (it's already
wrong), but we should probably address it - I'm fairly sure that the special
handling of DumpWithoutCrashing needs to *always* be applied to WebView, not
just when it's running in single-process mode, which is currently what happens
here. You might want to check with Toby about this. If that's the case, then we
can't rely on process_type to know whether to do something special for webview
and would need to configure this in some other way.

[hush (inactive), 2016/06/23 19:13:14]

Added Toby to the CL.
Toby, should SetDumpWithoutCrashingFunction be always called for webview instead
of singleprocess webview only?

[Tobias Sargeant, 2016/06/24 15:39:08]

We should definitely set this for both single and multiprocess webview. At the
moment GSA really only care about getting minidumps on demand from the browser
process, so although we need to work out what to do for the renderer at some
point, doing this in single process and multiprocess-browser should be enough.

[hush (inactive), 2016/06/24 20:18:46]

All right. I uploaded new patch set with a todo in your name for the renderer
process.

     // 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 996 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