Add experiments info to crash dumps.

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 <algorithm>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/command_line.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/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/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"
 
+namespace breakpad_win {
+
+std::vector<google_breakpad::CustomInfoEntry>* g_custom_entries = NULL;
+size_t g_num_of_experiments_offset = 0;
+size_t g_experiment_chunks_offset = 0;
+
+}   // namespace breakpad_win
+
+using breakpad_win::g_custom_entries;
+using breakpad_win::g_experiment_chunks_offset;
+using breakpad_win::g_num_of_experiments_offset;
+
 namespace {
 
 // Minidump with stacks, PEB, TEB, and unloaded module list.
 const MINIDUMP_TYPE kSmallDumpType = static_cast<MINIDUMP_TYPE>(
     MiniDumpWithProcessThreadData |  // Get PEB and TEB.
     MiniDumpWithUnloadedModules);  // Get unloaded modules when available.
 
 // Minidump with all of the above, plus memory referenced from stack.
 const MINIDUMP_TYPE kLargerDumpType = static_cast<MINIDUMP_TYPE>(
     MiniDumpWithProcessThreadData |  // Get PEB and TEB.
@@ skipping 11 matching lines @@
 
 const wchar_t kGoogleUpdatePipeName[] = L"\\\\.\\pipe\\GoogleCrashServices\\";
 const wchar_t kChromePipeName[] = L"\\\\.\\pipe\\ChromeCrashServices";
 
 // This is the well known SID for the system principal.
 const wchar_t kSystemPrincipalSid[] =L"S-1-5-18";
 
 google_breakpad::ExceptionHandler* g_breakpad = NULL;
 google_breakpad::ExceptionHandler* g_dumphandler_no_crash = NULL;
 
-// A pointer to the custom entries that we send in the event of a crash. We need
-// this pointer, along with the offsets into it below, so that we can keep the
-// data updated as the state of the browser changes.
-static std::vector<google_breakpad::CustomInfoEntry>* g_custom_entries = NULL;
-static size_t g_url_chunks_offset;
-static size_t g_num_of_extensions_offset;
-static size_t g_extension_ids_offset;
-static size_t g_client_id_offset;
-static size_t g_gpu_info_offset;
-static size_t g_printer_info_offset;
-static size_t g_num_of_views_offset;
-static size_t g_num_switches_offset;
-static size_t g_switches_offset;
+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;
 
 // 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 155 matching lines @@
 
   if (!special_build.empty())
     g_custom_entries->push_back(
         google_breakpad::CustomInfoEntry(L"special", special_build.c_str()));
 
   g_num_of_extensions_offset = g_custom_entries->size();
   g_custom_entries->push_back(
       google_breakpad::CustomInfoEntry(L"num-extensions", L"N/A"));
 
   g_extension_ids_offset = g_custom_entries->size();
-  for (int i = 0; i < kMaxReportedActiveExtensions; ++i) {
+  // one-based index for the name suffix.
+  for (int i = 1; i <= kMaxReportedActiveExtensions; ++i) {
     g_custom_entries->push_back(google_breakpad::CustomInfoEntry(
-        base::StringPrintf(L"extension-%i", i + 1).c_str(), L""));
+        base::StringPrintf(L"extension-%i", i).c_str(), L""));
   }
 
   // Add empty values for the gpu_info. We'll put the actual values when we
   // collect them at this location.
   g_gpu_info_offset = g_custom_entries->size();
   static const wchar_t* const kGpuEntries[] = {
     L"gpu-venid",
     L"gpu-devid",
     L"gpu-driver",
     L"gpu-psver",
     L"gpu-vsver",
   };
   for (size_t i = 0; i < arraysize(kGpuEntries); ++i) {
     g_custom_entries->push_back(
         google_breakpad::CustomInfoEntry(kGpuEntries[i], L""));
   }
 
   // Add empty values for the prn_info-*. We'll put the actual values when we
   // collect them at this location.
   g_printer_info_offset = g_custom_entries->size();
-  for (size_t i = 0; i < kMaxReportedPrinterRecords; ++i) {
+  // one-based index for the name suffix.
+  for (size_t i = 1; i <= kMaxReportedPrinterRecords; ++i) {
     g_custom_entries->push_back(
         google_breakpad::CustomInfoEntry(
-            base::StringPrintf(L"prn-info-%d", i + 1).c_str(), L""));
+            base::StringPrintf(L"prn-info-%d", i).c_str(), L""));
   }
 
   // Read the id from registry. If reporting has never been enabled
   // the result will be empty string. Its OK since when user enables reporting
   // we will insert the new value at this location.
   std::wstring guid;
   GoogleUpdateSettings::GetMetricsId(&guid);
   g_client_id_offset = g_custom_entries->size();
   g_custom_entries->push_back(
       google_breakpad::CustomInfoEntry(L"guid", guid.c_str()));
 
   // Add empty values for the command line switches. We will fill them with
   // actual values as part of SetCommandLine().
   g_num_switches_offset = g_custom_entries->size();
   g_custom_entries->push_back(
       google_breakpad::CustomInfoEntry(L"num-switches", L""));
 
   g_switches_offset = g_custom_entries->size();
-  for (int i = 0; i < kMaxSwitches; ++i) {
+  // one-based index for the name suffix.
+  for (int i = 1; i <= kMaxSwitches; ++i) {
     g_custom_entries->push_back(google_breakpad::CustomInfoEntry(
-        base::StringPrintf(L"switch-%i", i + 1).c_str(), L""));
+        base::StringPrintf(L"switch-%i", i).c_str(), L""));
   }
 
   // Fill in the command line arguments using CommandLine::ForCurrentProcess().
   // The browser process may call SetCommandLine() again later on with a command
   // line that has been augmented with the about:flags experiments.
   SetCommandLine(CommandLine::ForCurrentProcess());
 
   if (type == L"renderer" || type == L"plugin" || type == L"gpu-process") {
     g_num_of_views_offset = g_custom_entries->size();
     g_custom_entries->push_back(
         google_breakpad::CustomInfoEntry(L"num-views", L""));
     // Create entries for the URL. Currently we only allow each chunk to be 64
     // characters, which isn't enough for a URL. As a hack we create 8 entries
     // and split the URL across the g_custom_entries.
     g_url_chunks_offset = g_custom_entries->size();
-    for (int i = 0; i < kMaxUrlChunks; ++i) {
+    // one-based index for the name suffix.
+    for (int i = 1; i <= kMaxUrlChunks; ++i) {
       g_custom_entries->push_back(google_breakpad::CustomInfoEntry(
-          base::StringPrintf(L"url-chunk-%i", i + 1).c_str(), L""));
+          base::StringPrintf(L"url-chunk-%i", i).c_str(), L""));
     }
 
     if (type == L"plugin") {
       std::wstring plugin_path =
           CommandLine::ForCurrentProcess()->GetSwitchValueNative("plugin-path");
       if (!plugin_path.empty())
         SetPluginPath(plugin_path);
     }
   } else {
     g_custom_entries->push_back(
         google_breakpad::CustomInfoEntry(L"num-views", L"N/A"));
   }
 
+  g_num_of_experiments_offset = g_custom_entries->size();
+  g_custom_entries->push_back(
+      google_breakpad::CustomInfoEntry(L"num-experiments", L"N/A"));
+
+  g_experiment_chunks_offset = g_custom_entries->size();
+  // 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 <= kMaxReportedExperimentChunks; ++i) {
+    g_custom_entries->push_back(google_breakpad::CustomInfoEntry(
+        base::StringPrintf(L"experiment-chunk-%i", i).c_str(), L""));
+  }
+
   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 183 matching lines @@
   }
 }
 
 extern "C" void __declspec(dllexport) __cdecl SetNumberOfViews(
     int number_of_views) {
   SetIntegerValue(g_num_of_views_offset, number_of_views);
 }
 
 }  // namespace
 
+namespace testing {
+
+// Access to namespace protected functions for testing purposes.
+void InitCustomInfoEntries() {
+  GetCustomInfo(L"", L"", L"");
+}
+
+}  // namespace testing
+
 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 {
     *exit_now = (IDOK != ::MessageBoxW(NULL, text, caption, flags));
   } __except(EXCEPTION_EXECUTE_HANDLER) {
     // Its not safe to continue executing, exit silently here.
     ::TerminateProcess(::GetCurrentProcess(),
@@ skipping 230 matching lines @@
     // Tells breakpad to handle breakpoint and single step exceptions.
     // This might break JIT debuggers, but at least it will always
     // generate a crashdump for these exceptions.
     g_breakpad->set_handle_debug_exceptions(true);
   }
 }
 
 void InitDefaultCrashCallback(LPTOP_LEVEL_EXCEPTION_FILTER filter) {
   previous_filter = SetUnhandledExceptionFilter(filter);
 }