[win] Don't initialize the crash reporter on windows if disabled by configuration management.

chrome/app/breakpad_win.cc

 // Copyright (c) 2010 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/file_util.h"
 #include "base/file_version_info.h"
 #include "base/registry.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "base/win_util.h"
 #include "breakpad/src/client/windows/handler/exception_handler.h"
 #include "chrome/app/hard_error_handler_win.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/common/result_codes.h"
+#include "chrome/common/policy_constants.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"
 
 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.
@@ skipping 342 matching lines @@
   // If the UI layout is right-to-left, we need to pass the appropriate MB_XXX
   // flags so that an RTL message box is displayed.
   UINT flags = MB_OKCANCEL | MB_ICONWARNING;
   if (dlg_strings[2] == ASCIIToWide(env_vars::kRtlLocale))
     flags |= MB_RIGHT | MB_RTLREADING;
 
   return WrapMessageBoxWithSEH(dlg_strings[1].c_str(), dlg_strings[0].c_str(),
                                flags, exit_now);
 }
 
+// Determine whether configuration management allows loading the crash reporter.
+// Since the configuration management infrastructure is not initialized at this
+// point, we read the corresponding registry key directly. The return status
+// indicates whether policy data was successfully read. If it is true, |result|
+// contains the value set by policy.
+static bool MetricsReportingControlledByPolicy(bool* result) {
+  std::wstring key_name = UTF8ToWide(policy::key::kMetricsReportingEnabled);
+  DWORD value;
+  RegKey hkcu_policy_key(HKEY_LOCAL_MACHINE, policy::kRegistrySubKey);
+  if (hkcu_policy_key.ReadValueDW(key_name.c_str(), &value)) {
+    *result = value != 0;
+    return true;
+  }
+
+  RegKey hklm_policy_key(HKEY_CURRENT_USER, policy::kRegistrySubKey);
+  if (hklm_policy_key.ReadValueDW(key_name.c_str(), &value)) {
+    *result = value != 0;
+    return true;
+  }
+
+  return false;
+}
+
 static DWORD __stdcall InitCrashReporterThread(void* param) {
   scoped_ptr<CrashReporterInfo> info(
       reinterpret_cast<CrashReporterInfo*>(param));
 
   // GetCustomInfo can take a few milliseconds to get the file information, so
   // we do it here so it can run in a separate thread.
   info->custom_info = GetCustomInfo(info->dll_path, info->process_type);
 
   google_breakpad::ExceptionHandler::MinidumpCallback callback = NULL;
   if (info->process_type == L"browser") {
     // We install the post-dump callback only for the browser process. It
     // spawns a new browser process.
     callback = &DumpDoneCallback;
   }
 
+  // Check whether configuration management controls crash reporting.
+  bool crash_reporting_enabled = true;
+  bool controlled_by_policy =
+      MetricsReportingControlledByPolicy(&crash_reporting_enabled);
+
   const CommandLine& command = *CommandLine::ForCurrentProcess();
-  bool use_crash_service = command.HasSwitch(switches::kNoErrorDialogs) ||
-      GetEnvironmentVariable(ASCIIToWide(env_vars::kHeadless).c_str(), NULL, 0);
+  bool use_crash_service = !controlled_by_policy &&

[nsylvain, 2010/07/30 17:12:49]

I'm not sure when/how the registry value is going to be set, but if it is
remotely possible that it gets set on the buildbot, then this code it wrong. 
Even if it's control by policy, if the HEADLESS env variable is set, we should
use the crash_service.

People need that to debug too.

[Mattias Nissler (ping if slow), 2010/07/30 18:14:06]

The registry value is the hook administrators use to lock down Chrome on their
client machines. It wouldn't make sense to allow users to work around the
configuration policy by setting an environment variable. The registry value will
never be set on the buildbots, unless admins try to lock down chrome on those
machines. But that parameter we (or you, technically) control.

+      ((command.HasSwitch(switches::kNoErrorDialogs) ||
+      GetEnvironmentVariable(
+          ASCIIToWide(env_vars::kHeadless).c_str(), NULL, 0)));
   bool is_per_user_install =
       InstallUtil::IsPerUserInstall(info->dll_path.c_str());
 
   std::wstring pipe_name;
   if (use_crash_service) {
     // Crash reporting is done by crash_service.exe.
     pipe_name = kChromePipeName;
   } else {
     // We want to use the Google Update crash reporting. We need to check if the
-    // user allows it first.
-    if (!GoogleUpdateSettings::GetCollectStatsConsent()) {
-      // The user did not allow Google Update to send crashes, we need to use
-      // our default crash handler instead, but only for the browser process.
+    // user allows it first (in case the administrator didn't already decide
+    // via policy).
+    if (!controlled_by_policy)
+      crash_reporting_enabled = GoogleUpdateSettings::GetCollectStatsConsent();
+
+    LOG(ERROR) << "crash reporting enabled " << crash_reporting_enabled;
+
+    if (!crash_reporting_enabled) {
+      // Configuration managed or the user did not allow Google Update to send
+      // crashes, we need to use our default crash handler instead, but only
+      // for the browser process.
       if (callback)
         InitDefaultCrashCallback();
       return 0;
     }
 
     // Build the pipe name. It can be either:
     // System-wide install: "NamedPipe\GoogleCrashServices\S-1-5-18"
     // Per-user install: "NamedPipe\GoogleCrashServices\<user SID>"
     std::wstring user_sid;
     if (is_per_user_install) {
@@ skipping 77 matching lines @@
       if (QueueUserWorkItem(
               &InitCrashReporterThread,
               info,
               WT_EXECUTELONGFUNCTION) == 0) {
         // We failed to queue to the worker pool, initialize in this thread.
         InitCrashReporterThread(info);
       }
     }
   }
 }