Adding support for sampling crashes in Chrome on Windows.

chrome/install_static/install_util.cc

 // Copyright 2014 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/install_static/install_util.h"
 
 #include <windows.h>
 #include <assert.h>
 #include <algorithm>
 #include <iostream>
@@ skipping 69 matching lines @@
 #else
 const wchar_t kChromiumInstallSubDir[] = L"Chromium";
 #endif  // defined(GOOGLE_CHROME_BUILD)
 
 const wchar_t kUserDataDirname[] = L"User Data";
 const wchar_t kBrowserCrashDumpMetricsSubKey[] = L"\\BrowserCrashDumpAttempts";
 
 const wchar_t kRegPathGoogleUpdate[] = L"Software\\Google\\Update";
 const wchar_t kRegGoogleUpdateVersion[] = L"version";
 
+// Registry key to store the stats/crash sampling state of Chrome. If set to 1,
+// stats and crash reports will be uploaded in line with the user's consent,
+// otherwise, uploads will be disabled. It is used to sample clients, to reduce
+// server load for metics and crashes. This is controlled by the
+// MetricsReporting feature in chrome_metrics_services_manager_client.cc and is
+// written when metrics services are started up and when consent changes.
+const wchar_t kRegValueChromeStatsSample[] = L"UsageStatsInSample";
+
 void Trace(const wchar_t* format_string, ...) {
   static const int kMaxLogBufferSize = 1024;
   static wchar_t buffer[kMaxLogBufferSize] = {};
 
   va_list args = {};
 
   va_start(args, format_string);
   vswprintf(buffer, kMaxLogBufferSize, format_string, args);
   OutputDebugStringW(buffer);
   va_end(args);
@@ skipping 127 matching lines @@
       } else {
         Trace(L"Failed to create directory %ls, last error is %d\n",
               full_path_str, error_code);
         return false;
       }
     }
   }
   return true;
 }
 
+std::wstring GetChromeInstallRegistryPath() {
+  std::wstring registry_path = L"Software\\";
+  registry_path += GetChromeInstallSubDirectory();
+  return registry_path;
+}
+
 bool GetCollectStatsConsentImpl(const std::wstring& exe_path) {
   bool enabled = true;
   bool controlled_by_policy = ReportingIsEnforcedByPolicy(&enabled);
 
   if (controlled_by_policy && !enabled)
     return false;
 
   bool system_install = IsSystemInstall(exe_path.c_str());
   std::wstring app_guid;
 
@@ skipping 158 matching lines @@
 }
 
 bool GetCollectStatsConsent() {
   return GetCollectStatsConsentImpl(GetCurrentProcessExePath());
 }
 
 bool GetCollectStatsConsentForTesting(const std::wstring& exe_path) {
   return GetCollectStatsConsentImpl(exe_path);
 }
 
+bool GetCollectStatsInSample() {
+  std::wstring registry_path = GetChromeInstallRegistryPath();
+
+  DWORD out_value = 0;
+  if (!nt::QueryRegValueDWORD(nt::HKCU, registry_path.c_str(),
+                              kRegValueChromeStatsSample, &out_value)) {
+    // If reading the value failed, treat it as though sampling isn't in effect,
+    // implicitly meaning this install is in the sample.
+    return true;
+  }
+  return out_value == 1;
+}
+
+bool SetCollectStatsInSample(bool in_sample) {
+  std::wstring registry_path = GetChromeInstallRegistryPath();
+
+  HANDLE key_handle = INVALID_HANDLE_VALUE;
+  if (!nt::CreateRegKey(nt::HKCU, registry_path.c_str(), KEY_SET_VALUE,
+                        &key_handle)) {
+    nt::CloseRegKey(key_handle);
+    return false;
+  }
+
+  return nt::SetRegValueDWORD(key_handle, kRegValueChromeStatsSample,
+                              in_sample ? 1 : 0);
+}
+
 bool ReportingIsEnforcedByPolicy(bool* metrics_is_enforced_by_policy) {
   DWORD value = 0;
 
   // First, try HKLM.
   if (nt::QueryRegValueDWORD(nt::HKLM, kRegPathChromePolicy,
                              kMetricsReportingEnabled, &value)) {
     *metrics_is_enforced_by_policy = (value != 0);
     return true;
   }
 
@@ skipping 246 matching lines @@
   result += kGoogleChromeInstallSubDir2;
   if (IsSxSChrome(GetCurrentProcessExePath().c_str()))
     result += kSxSSuffix;
   return result;
 #else
   return std::wstring(kChromiumInstallSubDir);
 #endif
 }
 
 std::wstring GetBrowserCrashDumpAttemptsRegistryPath() {
-  std::wstring registry_path = L"Software\\";
-  registry_path += GetChromeInstallSubDirectory();
+  std::wstring registry_path = GetChromeInstallRegistryPath();
   registry_path += kBrowserCrashDumpMetricsSubKey;
   return registry_path;
 }
 
 bool MatchPattern(const std::wstring& source, const std::wstring& pattern) {
   assert(pattern.find(L"**") == std::wstring::npos);
   return MatchPatternImpl(source, pattern, 0, 0);
 }
 
 std::string UTF16ToUTF8(const std::wstring& source) {
@@ skipping 156 matching lines @@
     switch_value_end_offset = command_line_copy.length();
 
   std::string switch_value = command_line_copy.substr(
       switch_value_start_offset,
       switch_value_end_offset - (switch_offset + switch_token.length()));
   TrimT<std::string>(&switch_value);
   return switch_value;
 }
 
 }  // namespace install_static