Add instrumentation help figure out why the client ID is sometimes

components/breakpad/app/breakpad_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.
 
 #include "components/breakpad/app/breakpad_win.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <tchar.h>
 #include <userenv.h>
@@ skipping 378 matching lines @@
 }
 
 // Exception filter for the service process used when breakpad is not enabled.
 // We just display the "Do you want to restart" message and then die
 // (without calling the previous filter).
 long WINAPI ServiceExceptionFilter(EXCEPTION_POINTERS* info) {
   DumpDoneCallback(NULL, NULL, NULL, info, NULL, false);
   return EXCEPTION_EXECUTE_HANDLER;
 }
 
+// Sets |key| to |value|, g_dynamic_entries_lock must be held.
+static void SetCrashKeyValueLocked(const std::wstring& safe_key,
+                                   const std::wstring& safe_value) {
+  DCHECK(g_dynamic_entries && g_dynamic_entries_lock);
+  DCHECK(safe_key.length() < google_breakpad::CustomInfoEntry::kNameMaxLength);
+  DCHECK(safe_value.length() <
+         google_breakpad::CustomInfoEntry::kValueMaxLength);
+  g_dynamic_entries_lock->AssertAcquired();
+
+  DynamicEntriesMap::iterator it = g_dynamic_entries->find(safe_key);
+  google_breakpad::CustomInfoEntry* entry = NULL;
+  if (it == g_dynamic_entries->end()) {
+    if (g_dynamic_entries->size() >= kMaxDynamicEntries)
+      return;
+    entry = &(*g_custom_entries)[g_dynamic_keys_offset++];
+    g_dynamic_entries->insert(std::make_pair(safe_key, entry));
+  } else {
+    entry = it->second;
+  }
+
+  entry->set(safe_key.data(), safe_value.data());
+}
+
 // NOTE: This function is used by SyzyASAN to annotate crash reports. If you
 // change the name or signature of this function you will break SyzyASAN
 // instrumented releases of Chrome. Please contact syzygy-team@chromium.org
 // before doing so!
 extern "C" void __declspec(dllexport) __cdecl SetCrashKeyValueImpl(
     const wchar_t* key, const wchar_t* value) {
   if (!g_dynamic_entries)
     return;
 
   // CustomInfoEntry limits the length of key and value. If they exceed
   // their maximum length the underlying string handling functions raise
   // an exception and prematurely trigger a crash. Truncate here.
   std::wstring safe_key(std::wstring(key).substr(
       0, google_breakpad::CustomInfoEntry::kNameMaxLength  - 1));
   std::wstring safe_value(std::wstring(value).substr(
       0, google_breakpad::CustomInfoEntry::kValueMaxLength - 1));
 
   // If we already have a value for this key, update it; otherwise, insert
   // the new value if we have not exhausted the pre-allocated slots for dynamic
   // entries.
   DCHECK(g_dynamic_entries_lock);
   base::AutoLock lock(*g_dynamic_entries_lock);
 
-  DynamicEntriesMap::iterator it = g_dynamic_entries->find(safe_key);
-  google_breakpad::CustomInfoEntry* entry = NULL;
-  if (it == g_dynamic_entries->end()) {
-    if (g_dynamic_entries->size() >= kMaxDynamicEntries)
-      return;
-    entry = &(*g_custom_entries)[g_dynamic_keys_offset++];
-    g_dynamic_entries->insert(std::make_pair(safe_key, entry));
-  } else {
-    entry = it->second;
+  SetCrashKeyValueLocked(safe_key, safe_value);
+
+  // TODO(siggi): remove this code, see http://crbug.com/371817.
+  static size_t guid_set_count = 0;
+  if (safe_key == L"guid") {
+    // Bracket the value to get something recorded if it's set to the empty
+    // string. Truncate to 61 char max, to allow for brackets and terminating
+    // zero in the allotted 64 chars.
+    std::wstring bracketed_guid = base::StringPrintf(L"{%.61ls}", value);
+    if (guid_set_count == 0) {
+      // Keep track of the first GUID set.
+      SetCrashKeyValueLocked(L"first-guid", bracketed_guid);
+    } else {
+      // Keep track of the last GUID set.
+      SetCrashKeyValueLocked(L"last-guid", bracketed_guid);
+    }
+
+    // Bump the set count and record the latest.
+    ++guid_set_count;
+    SetCrashKeyValueLocked(L"guid-set-count",
+                           base::StringPrintf(L"%d", guid_set_count));
   }
-
-  entry->set(safe_key.data(), safe_value.data());
 }
 
 extern "C" void __declspec(dllexport) __cdecl ClearCrashKeyValueImpl(
     const wchar_t* key) {
   if (!g_dynamic_entries)
     return;
 
   DCHECK(g_dynamic_entries_lock);
   base::AutoLock lock(*g_dynamic_entries_lock);
 
   std::wstring key_string(key);
   DynamicEntriesMap::iterator it = g_dynamic_entries->find(key_string);
   if (it == g_dynamic_entries->end())
     return;
 
   it->second->set_value(NULL);
+
+  // TODO(siggi): remove this code, see http://crbug.com/371817.
+  static size_t guid_clear_count = 0;
+  if (key_string == L"guid") {
+    // Bump the clear count and record the latest.
+    ++guid_clear_count;
+    SetCrashKeyValueLocked(L"guid-clear-count",
+                           base::StringPrintf(L"%d", guid_clear_count));
+  }
 }
 
 }  // namespace
 
 static bool WrapMessageBoxWithSEH(const wchar_t* text, const wchar_t* caption,
                                   UINT flags, bool* exit_now) {
   // We wrap the call to MessageBoxW with a SEH handler because it some
   // machines with CursorXP, PeaDict or with FontExplorer installed it crashes
   // uncontrollably here. Being this a best effort deal we better go away.
   __try {
@@ skipping 286 matching lines @@
     if (process_type != L"browser" &&
         !GetBreakpadClient()->IsRunningUnattended()) {
       // Initialize the hook TerminateProcess to catch unexpected exits.
       InitTerminateProcessHooks();
     }
 #endif
   }
 }
 
 }  // namespace breakpad