[Windows] Include the about:flags experiments in crash reports.

chrome/app/breakpad_win.cc

 // Copyright (c) 2011 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>
 
@@ skipping 54 matching lines @@
 // 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_num_of_views_offset;
+static size_t g_num_switches_offset;
+static size_t g_switches_offset;
+
+// The maximum number of command line switches to include in the crash
+// report's metadata. Note that the mini-dump itself will also contain the
+// (original) command line arguments within the PEB.
+const size_t kMaxSwitches = 15;
 
 // Dumps the current process memory.
 extern "C" void __declspec(dllexport) __cdecl DumpProcess() {
   if (g_breakpad)
     g_breakpad->WriteMinidump();
 }
 
 // Reduces the size of the string |str| to a max of 64 chars. Required because
 // breakpad's CustomInfoEntry raises an invalid_parameter error if the string
 // we want to set is longer.
 std::wstring TrimToBreakpadMax(const std::wstring& str) {
   std::wstring shorter(str);
   return shorter.substr(0,
       google_breakpad::CustomInfoEntry::kValueMaxLength - 1);
 }
 
+static void SetIntegerValue(size_t offset, int value) {
+  if (!g_custom_entries)
+    return;
+
+  wcscpy_s((*g_custom_entries)[offset].value,
+           google_breakpad::CustomInfoEntry::kValueMaxLength,
+           base::StringPrintf(L"%d", value).c_str());
+}
+
+extern "C" void __declspec(dllexport) __cdecl SetCommandLineFromCurrent(void) {
+  if (!g_custom_entries)
+    return;
+
+  // Note that CommandLine may be different from the argc/argv that the
+  // application was launched with. We intentionally use CommandLine in order
+  // to pick up the experiments that about:flags shoved into the CommandLine.
+  const CommandLine::StringVector& argv =
+      CommandLine::ForCurrentProcess()->argv();
+
+  // Copy up to the kMaxSwitches arguments into the custom entries array. Skip
+  // past the first argument, as it is just the executable path.
+  size_t argv_i = 1;
+  size_t num_added = 0;
+
+  for (; argv_i < argv.size() && num_added < kMaxSwitches; ++argv_i) {

[Nico, 2011/09/13 23:04:41]

Increment num_added in the for loop instead of in the loop body

[eroman, 2011/09/13 23:27:32]

Done.

The reason I was doing it in the body rather than the for loop was to make it
easy to skip over adding certain flags. When I address the TODO, I will move the
increment back out of the for loop.

+    wcscpy_s((*g_custom_entries)[g_switches_offset + num_added++].value,
+             google_breakpad::CustomInfoEntry::kValueMaxLength,
+             argv[argv_i].c_str());
+  }
+
+  // Make note of the total number of switches. This is useful in case we have
+  // truncated at kMaxSwitches, to see how many were unaccounted for.
+  SetIntegerValue(g_num_switches_offset, static_cast<int>(argv.size()) - 1);
+}
+
 // Returns the custom info structure based on the dll in parameter and the
 // process type.
 google_breakpad::CustomClientInfo* GetCustomInfo(const std::wstring& dll_path,
                                                  const std::wstring& type) {
   scoped_ptr<FileVersionInfo>
       version_info(FileVersionInfo::CreateFileVersionInfo(FilePath(dll_path)));
 
   std::wstring version, product;
   std::wstring special_build;
   if (version_info.get()) {
@@ skipping 60 matching lines @@
 
   // 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 SetCommandLineFromCurrent().
+  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) {
+    g_custom_entries->push_back(google_breakpad::CustomInfoEntry(
+        base::StringPrintf(L"switch-%i", i + 1).c_str(), L""));
+  }
+
+  // Fill in the command line arguments using CommandLine::ForCurrentProcess().
+  // The browser process will call SetCommandLineFromCurrent() again later on,
+  // once it has augmented CommandLine with the about:flags experiments.
+  SetCommandLineFromCurrent();
+
   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) {
       g_custom_entries->push_back(google_breakpad::CustomInfoEntry(
           base::StringPrintf(L"url-chunk-%i", i + 1).c_str(), L""));
     }
   } else {
     g_custom_entries->push_back(
         google_breakpad::CustomInfoEntry(L"num-views", L"N/A"));
-
-    // Browser-specific g_custom_entries.
-    google_breakpad::CustomInfoEntry switch1(L"switch-1", L"");
-    google_breakpad::CustomInfoEntry switch2(L"switch-2", L"");
-
-    // Get the first two command line switches if they exist. The CommandLine
-    // class does not allow to enumerate the switches so we do it by hand.
-    int num_args = 0;
-    wchar_t** args = ::CommandLineToArgvW(::GetCommandLineW(), &num_args);
-    if (args) {
-      if (num_args > 1)
-        switch1.set_value(TrimToBreakpadMax(args[1]).c_str());
-      if (num_args > 2)
-        switch2.set_value(TrimToBreakpadMax(args[2]).c_str());
-      // The caller must free the memory allocated for |args|.
-      ::LocalFree(args);
-    }
-
-    g_custom_entries->push_back(switch1);
-    g_custom_entries->push_back(switch2);
   }
 
   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;
 }
 
 // Contains the information needed by the worker thread.
@@ skipping 114 matching lines @@
     return;
 
   if (!g_custom_entries)
     return;
 
   wcscpy_s((*g_custom_entries)[g_client_id_offset].value,
            google_breakpad::CustomInfoEntry::kValueMaxLength,
            client_id);
 }
 
-static void SetIntegerValue(size_t offset, int value) {
-  if (!g_custom_entries)
-    return;
-
-  wcscpy_s((*g_custom_entries)[offset].value,
-           google_breakpad::CustomInfoEntry::kValueMaxLength,
-           base::StringPrintf(L"%d", value).c_str());
-}
-
 extern "C" void __declspec(dllexport) __cdecl SetNumberOfExtensions(
     int number_of_extensions) {
   SetIntegerValue(g_num_of_extensions_offset, number_of_extensions);
 }
 
 extern "C" void __declspec(dllexport) __cdecl SetExtensionID(
     int index, const wchar_t* id) {
   DCHECK(id);
   DCHECK(index < kMaxReportedActiveExtensions);
 
@@ skipping 271 matching lines @@
       if (QueueUserWorkItem(
               &InitCrashReporterThread,
               info,
               WT_EXECUTELONGFUNCTION) == 0) {
         // We failed to queue to the worker pool, initialize in this thread.
         InitCrashReporterThread(info);
       }
     }
   }
 }