Add Windows implementation for base/debug/crash_logging.h.

chrome/app/breakpad_win.cc

 // Copyright (c) 2012 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/app/breakpad_win.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <tchar.h>
 #include <userenv.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
+#include "base/debug/crash_logging.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/string16.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/win_util.h"
 #include "breakpad/src/client/windows/handler/exception_handler.h"
 #include "chrome/app/breakpad_field_trial_win.h"
 #include "chrome/app/crash_analysis_win.h"
 #include "chrome/app/hard_error_handler_win.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/crash_keys.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/installer/util/google_chrome_sxs_distribution.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/install_util.h"
 #include "policy/policy_constants.h"
 
 // userenv.dll is required for GetProfileType().
 #pragma comment(lib, "userenv.lib")
 
 namespace breakpad_win {
@@ skipping 51 matching lines @@
 
 static size_t g_url_chunks_offset = 0;
 static size_t g_num_of_extensions_offset = 0;
 static size_t g_extension_ids_offset = 0;
 static size_t g_client_id_offset = 0;
 static size_t g_gpu_info_offset = 0;
 static size_t g_printer_info_offset = 0;
 static size_t g_num_of_views_offset = 0;
 static size_t g_num_switches_offset = 0;
 static size_t g_switches_offset = 0;
+static size_t g_dynamic_keys_offset = 0;
+typedef std::map<std::string, google_breakpad::CustomInfoEntry*>
+    DynamicEntriesMap;
+DynamicEntriesMap* g_dynamic_entries = NULL;

[Nico, 2013/01/24 18:01:14]

nit: Why is this not static too?

(I realize it's in an unnamed namespace, but so is the rest.)

+static size_t g_dynamic_entries_count = 0;
 
 // Maximum length for plugin path to include in plugin crash reports.
 const size_t kMaxPluginPathLength = 256;
 
 // Dumps the current process memory.
 extern "C" void __declspec(dllexport) __cdecl DumpProcess() {
   if (g_breakpad)
     g_breakpad->WriteMinidump();
 }
 
@@ skipping 341 matching lines @@
   // We depend on this in UpdateExperiments...
   DCHECK_NE(0UL, g_experiment_chunks_offset);
   // And the test code depends on this.
   DCHECK_EQ(g_num_of_experiments_offset + 1, g_experiment_chunks_offset);
   // one-based index for the name suffix.
   for (int i = 1; i <= kMaxReportedVariationChunks; ++i) {
     g_custom_entries->push_back(google_breakpad::CustomInfoEntry(
         base::StringPrintf(L"experiment-chunk-%i", i).c_str(), L""));
   }
 
+  // Create space for dynamic ad-hoc keys. The names and values are set using
+  // the API defined in base/debug/crash_logging.h.
+  g_dynamic_entries_count = crash_keys::RegisterChromeCrashKeys();
+  g_dynamic_keys_offset = g_custom_entries->size();
+  for (size_t i = 0; i < g_dynamic_entries_count; ++i) {
+    g_custom_entries->push_back(google_breakpad::CustomInfoEntry());
+  }
+  g_dynamic_entries = new DynamicEntriesMap;
+
   static google_breakpad::CustomClientInfo custom_client_info;
   custom_client_info.entries = &g_custom_entries->front();
   custom_client_info.count = g_custom_entries->size();
 
   return &custom_client_info;
 }
 
 // This callback is used when we want to get a dump without crashing the
 // process.
 bool DumpDoneCallbackWhenNoCrash(const wchar_t*, const wchar_t*, void*,
@@ skipping 181 matching lines @@
                 info[i].c_str(),
                 google_breakpad::CustomInfoEntry::kValueMaxLength);
   }
 }
 
 extern "C" void __declspec(dllexport) __cdecl SetNumberOfViews(
     int number_of_views) {
   SetIntegerValue(g_num_of_views_offset, number_of_views);
 }
 
+void SetCrashKeyValue(const base::StringPiece& key,
+                      const base::StringPiece& value) {
+  std::string key_string = key.as_string();
+
+  DynamicEntriesMap::iterator it = g_dynamic_entries->find(key_string);
+  google_breakpad::CustomInfoEntry* entry = NULL;
+  if (it == g_dynamic_entries->end()) {

[eroman, 2013/01/24 00:47:13]

There is nothing to stop callers from inserting a key which was not enumerated
in RegisterChromeCrashKeys(), and then run out of slots.

Is that intentional?

[Robert Sesek, 2013/01/24 01:03:45]

For now, yes. The base::debug API will prevent this in the near future.

https://code.google.com/searchframe#OAMlx_jo-ck/src/base/debug/crash_logging....

+    if (g_dynamic_keys_offset >= g_dynamic_entries_count)
+      return;
+    entry = &(*g_custom_entries)[g_dynamic_keys_offset++];
+    g_dynamic_entries->insert(std::make_pair(key_string, entry));
+  } else {
+    entry = it->second;
+  }
+
+  entry->set(UTF8ToWide(key).data(), UTF8ToWide(value).data());
+}
+
+void ClearCrashKeyValue(const base::StringPiece& key) {
+  DynamicEntriesMap::iterator it = g_dynamic_entries->find(key.as_string());
+  if (it == g_dynamic_entries->end())
+    return;
+
+  it->second->set(NULL, NULL);
+}
+
 }  // namespace
 
 namespace testing {
 
 // Access to namespace protected functions for testing purposes.
 void InitCustomInfoEntries() {
   GetCustomInfo(L"", L"", L"");
 }
 
 }  // namespace testing
@@ skipping 181 matching lines @@
   wchar_t exe_path[MAX_PATH];
   exe_path[0] = 0;
   GetModuleFileNameW(NULL, exe_path, MAX_PATH);
 
   bool is_per_user_install = InstallUtil::IsPerUserInstall(exe_path);
 
   std::wstring channel_string;
   GoogleUpdateSettings::GetChromeChannelAndModifiers(!is_per_user_install,
                                                      &channel_string);
 
+  base::debug::SetCrashKeyReportingFunctions(
+      &SetCrashKeyValue, &ClearCrashKeyValue);
+
   google_breakpad::CustomClientInfo* custom_info =
-    GetCustomInfo(exe_path, process_type, channel_string);
+      GetCustomInfo(exe_path, process_type, channel_string);
 
   google_breakpad::ExceptionHandler::MinidumpCallback callback = NULL;
   LPTOP_LEVEL_EXCEPTION_FILTER default_filter = NULL;
   // We install the post-dump callback only for the browser and service
   // processes. It spawns a new browser/service process.
   if (process_type == L"browser") {
     callback = &DumpDoneCallback;
     default_filter = &ChromeExceptionFilter;
   } else if (process_type == L"service") {
     callback = &DumpDoneCallback;
@@ skipping 75 matching lines @@
   previous_filter = SetUnhandledExceptionFilter(filter);
 }
 
 void StringVectorToCStringVector(const std::vector<std::wstring>& wstrings,
                                  std::vector<const wchar_t*>* cstrings) {
   cstrings->clear();
   cstrings->reserve(wstrings.size());
   for (size_t i = 0; i < wstrings.size(); ++i)
     cstrings->push_back(wstrings[i].c_str());
 }