[Linux] Add field trial tuples to breakpad crash reports.

chrome/common/child_process_logging_posix.cc

Index: chrome/common/child_process_logging_posix.cc
===================================================================
--- chrome/common/child_process_logging_posix.cc	(revision 153734)
+++ chrome/common/child_process_logging_posix.cc	(working copy)
@@ -10,6 +10,7 @@
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/common/metrics/variations/variations_util.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "content/public/common/gpu_info.h"
 #include "googleurl/src/gurl.h"
@@ -42,6 +43,7 @@
 char g_num_extensions[kNumSize] = "";
 char g_num_switches[kNumSize] = "";
 char g_num_views[kNumSize] = "";
+char g_num_variations[kNumSize] = "";
 
 static const size_t kMaxExtensionSize =
     kExtensionLen * kMaxReportedActiveExtensions + 1;
@@ -51,10 +53,13 @@
 static const size_t kMaxSwitchesSize = kSwitchLen * kMaxSwitches + 1;
 char g_switches[kMaxSwitchesSize] = "";
 
+static const size_t kMaxVariationChunksSize =
+    kMaxVariationChunkSize * kMaxReportedVariationChunks + 1;
+char g_variation_chunks[kMaxVariationChunksSize] = "";
+
 void SetActiveURL(const GURL& url) {
-  base::strlcpy(g_active_url,
-                url.possibly_invalid_spec().c_str(),
-                kMaxActiveURLSize);
+  base::strlcpy(g_active_url, url.possibly_invalid_spec().c_str(),
+                arraysize(g_active_url));
 }
 
 void SetClientId(const std::string& client_id) {
@@ -74,8 +79,8 @@
 }
 
 void SetActiveExtensions(const std::set<std::string>& extension_ids) {
-  snprintf(g_num_extensions, kNumSize - 1, "%" PRIuS, extension_ids.size());
-  g_num_extensions[kNumSize - 1] = '\0';
+  snprintf(g_num_extensions, arraysize(g_num_extensions), "%" PRIuS,
+           extension_ids.size());
 
   std::string extension_str;
   std::set<std::string>::const_iterator iter = extension_ids.begin();
@@ -84,25 +89,21 @@
        ++i, ++iter) {
     extension_str += *iter;
   }
-  strncpy(g_extension_ids, extension_str.c_str(), kMaxExtensionSize - 1);
-  g_extension_ids[kMaxExtensionSize - 1] = '\0';
+  base::strlcpy(g_extension_ids, extension_str.c_str(),
+                arraysize(g_extension_ids));
 }
 
 void SetGpuInfo(const content::GPUInfo& gpu_info) {
-  snprintf(g_gpu_vendor_id, kGpuStringSize, "0x%04x", gpu_info.gpu.vendor_id);
-  snprintf(g_gpu_device_id, kGpuStringSize, "0x%04x", gpu_info.gpu.device_id);
-  strncpy(g_gpu_driver_ver,
-          gpu_info.driver_version.c_str(),
-          kGpuStringSize - 1);
-  g_gpu_driver_ver[kGpuStringSize - 1] = '\0';
-  strncpy(g_gpu_ps_ver,
-          gpu_info.pixel_shader_version.c_str(),
-          kGpuStringSize - 1);
-  g_gpu_ps_ver[kGpuStringSize - 1] = '\0';
-  strncpy(g_gpu_vs_ver,
-          gpu_info.vertex_shader_version.c_str(),
-          kGpuStringSize - 1);
-  g_gpu_vs_ver[kGpuStringSize - 1] = '\0';
+  snprintf(g_gpu_vendor_id, arraysize(g_gpu_vendor_id), "0x%04x",
+           gpu_info.gpu.vendor_id);
+  snprintf(g_gpu_device_id, arraysize(g_gpu_device_id), "0x%04x",
+           gpu_info.gpu.device_id);
+  base::strlcpy(g_gpu_driver_ver, gpu_info.driver_version.c_str(),
+                arraysize(g_gpu_driver_ver));
+  base::strlcpy(g_gpu_ps_ver, gpu_info.pixel_shader_version.c_str(),
+                arraysize(g_gpu_ps_ver));
+  base::strlcpy(g_gpu_vs_ver,  gpu_info.vertex_shader_version.c_str(),
+                arraysize(g_gpu_vs_ver));
 }
 
 void SetPrinterInfo(const char* printer_info) {
@@ -115,21 +116,19 @@
     // Truncate long switches, align short ones with spaces to be trimmed later.
     printer_info_str.resize((i + 1) * kPrinterInfoStrLen, ' ');
   }
-  strncpy(g_printer_info, printer_info_str.c_str(),
-          arraysize(g_printer_info) - 1);
-  g_printer_info[arraysize(g_printer_info) - 1] = '\0';
+  base::strlcpy(g_printer_info, printer_info_str.c_str(),
+                arraysize(g_printer_info));
 }
 
 void SetNumberOfViews(int number_of_views) {
-  snprintf(g_num_views, kNumSize - 1, "%d", number_of_views);
-  g_num_views[kNumSize - 1] = '\0';
+  snprintf(g_num_views, arraysize(g_num_views), "%d", number_of_views);
 }
 
 void SetCommandLine(const CommandLine* command_line) {
   const CommandLine::StringVector& argv = command_line->argv();
 
-  snprintf(g_num_switches, kNumSize - 1, "%" PRIuS, argv.size() - 1);
-  g_num_switches[kNumSize - 1] = '\0';
+  snprintf(g_num_switches, arraysize(g_num_switches), "%" PRIuS,
+           argv.size() - 1);
 
   std::string command_line_str;
   for (size_t argv_i = 1;
@@ -139,17 +138,35 @@
     // Truncate long switches, align short ones with spaces to be trimmed later.
     command_line_str.resize(argv_i * kSwitchLen, ' ');
   }
-  strncpy(g_switches, command_line_str.c_str(), kMaxSwitchesSize - 1);
-  g_switches[kMaxSwitchesSize - 1] = '\0';
+  base::strlcpy(g_switches, command_line_str.c_str(), arraysize(g_switches));
 }
 
-void SetExperimentList(const std::vector<string16>& state) {
-  // TODO(mad): Implement this.
+void SetExperimentList(const std::vector<string16>& experiments) {
+  std::vector<string16> chunks;
+  chrome_variations::GenerateVariationChunks(experiments, &chunks);
+
+  // Store up to |kMaxReportedVariationChunks| chunks.
+  std::string chunks_str;
+  const size_t number_of_chunks_to_report =
+      std::min<size_t>(chunks.size(), kMaxReportedVariationChunks);

[Lei Zhang, 2012/08/28 23:10:22]

do you need the <size_t> part?

[Alexei Svitkine (slow), 2012/08/29 14:05:25]

Yes, because chunks.size() and kMaxReportedVariationChunks are different types 
(size_t equivalent and int).

[Lei Zhang, 2012/08/29 18:33:13]

Shouldn't kMaxReportedVariationChunks be size_t?

[Alexei Svitkine (slow), 2012/08/29 18:41:25]

My CL wasn't introducing that constant, so I wasn't going to change it
originally. However, you're right that it makes sense to change its type to
size_t.

Done now.

I've also updated kMaxReportedActiveExtensions similarly to be consistent.

+  for (size_t i = 0; i < number_of_chunks_to_report; ++i) {
+    chunks_str += UTF16ToUTF8(chunks[i]);
+    // Align short chunks with spaces to be trimmed later.
+    chunks_str.resize(i * kMaxVariationChunkSize, ' ');
+  }
+  base::strlcpy(g_variation_chunks, chunks_str.c_str(),
+                arraysize(g_variation_chunks));
+
+  // Make note of the total number of experiments, which may be greater than
+  // what was able to fit in |kMaxReportedVariationChunks|. This is useful when
+  // correlating stability with the number of experiments running
+  // simultaneously.
+  snprintf(g_num_variations, arraysize(g_num_variations), "%" PRIuS,
+           experiments.size());
 }
 
 void SetChannel(const std::string& channel) {
-  strncpy(g_channel, channel.c_str(), kChannelSize - 1);
-  g_channel[kChannelSize - 1] = '\0';
+  base::strlcpy(g_channel, channel.c_str(), arraysize(g_channel));
 }
 
 }  // namespace child_process_logging