Switch chrome_elf exception handling from breakpad to crashpad.

chrome/app/chrome_crash_reporter_client_win.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.
 
 // TODO(ananta/scottmg)
 // Add test coverage for Crashpad.
 #include "chrome/app/chrome_crash_reporter_client_win.h"
 
 #include <assert.h>
 #include <windows.h>
@@ skipping 51 matching lines @@
              _Printf_format_string_ const char* format,
              ...) {
   va_list arguments;
   va_start(arguments, format);
   int result = vsnprintf(buffer, size, format, arguments);
   va_end(arguments);
   return result;
 }
 
 size_t RegisterCrashKeysHelper() {
+  // Crash keys should be registered only once for the duration of the

[scottmg, 2016/06/27 19:37:46]

Why is this getting called multiple times now?

[ananta, 2016/06/27 20:00:26]

Can get called from child_process_logging_win.cc which is part of this patchset.
Don't want to register keys twice as that fires DCHECK's

+  // process.
+  static size_t registered_keys_size = 0;
+  if (registered_keys_size)
+    return registered_keys_size;
+
   // The following keys may be chunked by the underlying crash logging system,
   // but ultimately constitute a single key-value pair.
   //
   // If you're adding keys here, please also add them to the list in
   // //blimp/engine/app/blimp_engine_crash_keys.cc
   constexpr base::debug::CrashKey fixed_keys[] = {
       {kMetricsClientId, kSmallSize},
       {kChannel, kSmallSize},
       {kActiveURL, kLargeSize},
       {kNumVariations, kSmallSize},
@@ skipping 83 matching lines @@
                               [sizeof(kPrinterInfo) + 1] = {{0}};
     const size_t formatted_key_len = sizeof(formatted_keys[0]);
     for (size_t i = 0; i < kPrinterInfoCount; ++i) {
       // Key names are 1-indexed.
       snprintf(formatted_keys[i], formatted_key_len, kPrinterInfo, i + 1);
       base::debug::CrashKey crash_key = {formatted_keys[i], kSmallSize};
       keys.push_back(crash_key);
     }
   }
 
-  return base::debug::InitCrashKeys(&keys[0], keys.size(), kChunkMaxLength);
+  registered_keys_size =
+      base::debug::InitCrashKeys(&keys[0], keys.size(), kChunkMaxLength);
+  return registered_keys_size;
 }
 
 }  // namespace
 
 ChromeCrashReporterClient::ChromeCrashReporterClient() {}
 
 ChromeCrashReporterClient::~ChromeCrashReporterClient() {}
 
 #if !defined(NACL_WIN64)
 // static
 void ChromeCrashReporterClient::InitializeCrashReportingForProcess() {
   static ChromeCrashReporterClient* instance = nullptr;
   if (instance)
     return;
 
   instance = new ChromeCrashReporterClient();
   ANNOTATE_LEAKING_OBJECT_PTR(instance);
 
   std::string process_type = install_static::GetSwitchValueFromCommandLine(
       ::GetCommandLineA(), install_static::kProcessType);
   if (process_type != install_static::kCrashpadHandler) {
     crash_reporter::SetCrashReporterClient(instance);
     crash_reporter::InitializeCrashpadWithEmbeddedHandler(process_type.empty(),
                                                           process_type);
   }
 }
 #endif  // NACL_WIN64
 
+// static
+void ChromeCrashReporterClient::RegisterCrashKeysForDebugging() {
+  RegisterCrashKeysHelper();
+}
+
 bool ChromeCrashReporterClient::GetAlternativeCrashDumpLocation(
     base::string16* crash_dir) {
   // By setting the BREAKPAD_DUMP_LOCATION environment variable, an alternate
   // location to write breakpad crash dumps can be set.
   *crash_dir =
       install_static::GetEnvironmentString16(L"BREAKPAD_DUMP_LOCATION");
   return !crash_dir->empty();
 }
 
 void ChromeCrashReporterClient::GetProductNameAndVersion(
@@ skipping 117 matching lines @@
 bool ChromeCrashReporterClient::GetCollectStatsConsent() {
   return install_static::GetCollectStatsConsent();
 }
 
 bool ChromeCrashReporterClient::EnableBreakpadForProcess(
     const std::string& process_type) {
   return process_type == install_static::kRendererProcess ||
          process_type == install_static::kPpapiPluginProcess ||
          process_type == install_static::kGpuProcess;
 }