Set a "metrics_client_id" crash key instead of "guid" on Mac OS X

chrome/common/crash_keys.cc

 // Copyright (c) 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.
 
 #include "chrome/common/crash_keys.h"
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_split.h"
@@ skipping 37 matching lines @@
 #endif
 
 // Guarantees for crash key sizes.
 static_assert(kSmallSize <= kSingleChunkLength,
               "crash key chunk size too small");
 #if defined(OS_MACOSX)
 static_assert(kMediumSize <= kSingleChunkLength,
               "mac has medium size crash key chunks");
 #endif
 
+#if defined(OS_MACOSX)
+// Crashpad owns the "guid" key. Chrome's metrics client ID is a separate ID
+// carried in a distinct "metrics_client_id" field.
+const char kMetricsClientId[] = "metrics_client_id";
+#else
 const char kClientId[] = "guid";
+#endif
 
 const char kChannel[] = "channel";
 
 const char kActiveURL[] = "url-chunk";
 
 const char kFontKeyName[] = "font_key_name";
 
 const char kSwitch[] = "switch-%" PRIuS;
 const char kNumSwitches[] = "num-switches";
 
@@ skipping 47 matching lines @@
 
 #if defined(KASKO)
 const char kKaskoGuid[] = "kasko-guid";
 const char kKaskoEquivalentGuid[] = "kasko-equivalent-guid";
 #endif
 
 size_t RegisterChromeCrashKeys() {
   // The following keys may be chunked by the underlying crash logging system,
   // but ultimately constitute a single key-value pair.
   base::debug::CrashKey fixed_keys[] = {
+#if defined(OS_MACOSX)
+    { kMetricsClientId, kSmallSize },
+#else
     { kClientId, kSmallSize },
+#endif
     { kChannel, kSmallSize },
     { kActiveURL, kLargeSize },
     { kNumSwitches, kSmallSize },
     { kNumVariations, kSmallSize },
     { kVariations, kLargeSize },
     { kNumExtensionsCount, kSmallSize },
     { kShutdownType, kSmallSize },
 #if !defined(OS_ANDROID)
     { kGPUVendorID, kSmallSize },
     { kGPUDeviceID, kSmallSize },
@@ skipping 90 matching lines @@
       DCHECK_GT(n, 0);
       base::debug::CrashKey crash_key = { formatted_keys[i], kSmallSize };
       keys.push_back(crash_key);
     }
   }
 
   return base::debug::InitCrashKeys(&keys.at(0), keys.size(),
                                     kSingleChunkLength);
 }
 
-void SetCrashClientIdFromGUID(const std::string& client_guid) {
-  std::string stripped_guid(client_guid);
+void SetMetricsClientIdFromGUID(const std::string& metrics_client_guid) {
+  std::string stripped_guid(metrics_client_guid);
   // Remove all instance of '-' char from the GUID. So BCD-WXY becomes BCDWXY.
   ReplaceSubstringsAfterOffset(&stripped_guid, 0, "-", "");
   if (stripped_guid.empty())
     return;
 
+#if defined(OS_MACOSX)
+  // The crash client ID is maintained by Crashpad and is distinct from the
+  // metrics client ID, which is carried in its own key.
+  base::debug::SetCrashKeyValue(kMetricsClientId, stripped_guid);
+#else
+  // The crash client ID is set by the application when Breakpad is in use.
+  // The same ID as the metrics client ID is used.
   base::debug::SetCrashKeyValue(kClientId, stripped_guid);
+#endif
+}
+
+void ClearMetricsClientId() {
+#if defined(OS_MACOSX)
+  // Crashpad always monitors for crashes, but doesn't upload them when
+  // crash reporting is disabled. The preference to upload crash reports is
+  // linked to the preference for metrics reporting. When metrics reporting is
+  // disabled, don't put the metrics client ID into crash dumps. This way, crash
+  // reports that are saved but not uploaded will not have a metrics client ID
+  // from the time that metrics reporting was disabled even if they are uploaded
+  // by user action at a later date.
+  //
+  // Breakpad cannot be enabled or disabled without an application restart, and
+  // it needs to use the metrics client ID as its stable crash client ID, so
+  // leave its client ID intact even when metrics reporting is disabled while
+  // the application is running.
+  base::debug::ClearCrashKey(kMetricsClientId);
+#endif
 }
 
 static bool IsBoringSwitch(const std::string& flag) {
 #if defined(OS_WIN)
   return StartsWithASCII(flag, "--channel=", true) ||
 
          // No point to including this since we already have a ptype field.
          StartsWithASCII(flag, "--type=", true) ||
 
          // Not particularly interesting
          StartsWithASCII(flag, "--flash-broker=", true) ||
 
          // Just about everything has this, don't bother.
          StartsWithASCII(flag, "/prefetch:", true) ||
 
          // We handle the plugin path separately since it is usually too big
          // to fit in the switches (limited to 63 characters).
          StartsWithASCII(flag, "--plugin-path=", true) ||
 
          // This is too big so we end up truncating it anyway.
          StartsWithASCII(flag, "--force-fieldtrials=", true) ||
 
          // These surround the flags that were added by about:flags, it lets
          // you distinguish which flags were added manually via the command
          // line versus those added through about:flags. For the most part
          // we don't care how an option was enabled, so we strip these.
          // (If you need to know can always look at the PEB).
          flag == "--flag-switches-begin" ||
          flag == "--flag-switches-end";
+#elif defined(OS_MACOSX)
+  // These are carried in their own fields.
+  return StartsWithASCII(flag, "--channel=", true) ||
+         StartsWithASCII(flag, "--type=", true) ||
+         StartsWithASCII(flag, "--metrics-client-id=", true);
 #elif defined(OS_CHROMEOS)
   static const char* const kIgnoreSwitches[] = {
     ::switches::kEnableLogging,
     ::switches::kFlagSwitchesBegin,
     ::switches::kFlagSwitchesEnd,
     ::switches::kLoggingLevel,
     ::switches::kPpapiFlashArgs,
     ::switches::kPpapiFlashPath,
     ::switches::kRegisterPepperPlugins,
     ::switches::kUIPrioritizeInGpuProcess,
@@ skipping 119 matching lines @@
 }
 
 ScopedPrinterInfo::~ScopedPrinterInfo() {
   for (size_t i = 0; i < kPrinterInfoCount; ++i) {
     std::string key = base::StringPrintf(kPrinterInfo, i + 1);
     base::debug::ClearCrashKey(key);
   }
 }
 
 }  // namespace crash_keys