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);
 }
 
+#if defined(OS_MACOSX)
+
+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;
+
+  base::debug::SetCrashKeyValue(kMetricsClientId, stripped_guid);
+}
+
+void ClearMetricsClientId() {
+  base::debug::ClearCrashKey(kMetricsClientId);
+}
+
+#else
+
 void SetCrashClientIdFromGUID(const std::string& client_guid) {
   std::string stripped_guid(client_guid);
   // Remove all instance of '-' char from the GUID. So BCD-WXY becomes BCDWXY.
   ReplaceSubstringsAfterOffset(&stripped_guid, 0, "-", "");
   if (stripped_guid.empty())
     return;
 
   base::debug::SetCrashKeyValue(kClientId, stripped_guid);
 }
 
+#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