Make Chromoting Host report crashes to Breakpad (Windows only). The user must enable crash dumps co…

remoting/host/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.

[Wez, 2012/06/06 15:52:03]

Is this implementation based on some existing code, e.g. in Chrome?

[alexeypa (please no reviews), 2012/06/06 16:53:56]

It is based on:

- src/chrome/app/breakpad_win.cc
- src/chrome_frame/crash_server_init.cc
- src/chrome/installer/setup/setup_main.cc
- src/chrome_frame/crash_reporting/crash_report.cc

All four covered by the same license.

[Wez, 2012/06/07 16:56:47]

OK.  I'm guessing the first one is the one this file is most directly derived
from?  Please consider adding a comment to clarify that this is based on the
Chrome [and Chrome Frame] crash reporting implementations.

[alexeypa (please no reviews), 2012/06/08 17:26:17]

Done.

+
+#include "remoting/host/breakpad.h"
+
+#include <windows.h>
+
+#include "base/atomicops.h"
+#include "base/logging.h"
+#include "base/file_version_info.h"
+#include "base/lazy_instance.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/process_util.h"
+#include "base/string16.h"
+#include "base/stringprintf.h"
+#include "base/win/registry.h"
+#include "base/win/wrapped_window_proc.h"
+#include "breakpad/src/client/windows/handler/exception_handler.h"
+#include "remoting/host/constants.h"
+
+namespace remoting {
+void InitializeCrashReportingForTest(const wchar_t*);
+}  // namespace remoting
+
+namespace {
+
+const wchar_t kBreakpadProductName[] = L"Chromoting";
+const wchar_t kBreakpadVersionEntry[] = L"ver";
+const wchar_t kBreakpadVersionDefault[] = L"0.1.0.0";
+const wchar_t kBreakpadProdEntry[] = L"prod";
+const wchar_t kBreakpadPlatformEntry[] = L"plat";
+const wchar_t kBreakpadPlatformWin32[] = L"Win32";
+
+// The following strings are used to construct the registry key names where
+// the user's consent to collect crash dumps is recorded.
+const wchar_t kOmahaClientStateKeyFormat[] = L"Google\\Update\\%ls\\%ls";
+const wchar_t kOmahaClientState[] = L"ClientState";
+const wchar_t kOmahaClientStateMedium[] = L"ClientStateMedium";
+const wchar_t kOmahaUsagestatsValue[] = L"usagestats";
+
+// The protocol for connecting to the out-of-process Breakpad crash
+// reporter is different for x86-32 and x86-64: the message sizes
+// are different because the message struct contains a pointer.  As
+// a result, there are two different named pipes to connect to.  The
+// 64-bit one is distinguished with an "-x64" suffix.
+#if defined(_WIN64)
+const wchar_t kGoogleUpdatePipeName[] =
+    L"\\\\.\\pipe\\GoogleCrashServices\\S-1-5-18-x64";
+#else
+const wchar_t kGoogleUpdatePipeName[] =
+    L"\\\\.\\pipe\\GoogleCrashServices\\S-1-5-18";
+#endif
+
+using base::subtle::AtomicWord;
+using base::subtle::NoBarrier_CompareAndSwap;
+
+class BreakpadWin {
+ public:
+  BreakpadWin();
+  ~BreakpadWin();
+
+  static BreakpadWin& GetInstance();
+
+ private:
+  // Returns the Custom information to be used for crash reporting.
+  google_breakpad::CustomClientInfo* GetCustomInfo();
+
+  // Checks whether crash dump collection is allowed by the user.
+  bool IsCrashReportingEnabled();
+
+  // This callback is executed when the process has crashed and *before*
+  // the crash dump is created. To prevent duplicate crash reports we
+  // make every thread calling this method, except the very first one,
+  // go to sleep.
+  static bool OnExceptionCallback(void*, EXCEPTION_POINTERS*,
+                                  MDRawAssertionInfo*);
+
+  // Crashes the process after generating a dump for the provided exception.
+  // Note that the crash reporter should be initialized before calling this
+  // function for it to do anything.
+  static int OnWindowProcedureException(EXCEPTION_POINTERS* info);
+
+  // Breakpad's exception handler.
+  scoped_ptr<google_breakpad::ExceptionHandler> breakpad_;
+
+  // This flag is used to indicate that an exception is already being handled.
+  volatile AtomicWord handling_exception_;
+
+  // The testing hooks below allow to override the crash server pipe name and
+  // user's consent.
+  static const wchar_t* pipe_name_;
+  static bool enable_testing_;
+
+  friend void ::remoting::InitializeCrashReportingForTest(const wchar_t*);
+
+  DISALLOW_COPY_AND_ASSIGN(BreakpadWin);
+};
+
+// |LazyInstance| is used to guarantee that the exception handler will be
+// initialized exactly once.
+// N.B. LazyInstance does not allow this to be a static member of the class.
+static base::LazyInstance<BreakpadWin>::Leaky g_instance =
+    LAZY_INSTANCE_INITIALIZER;
+
+const wchar_t* BreakpadWin::pipe_name_ = kGoogleUpdatePipeName;
+bool BreakpadWin::enable_testing_ = false;
+
+BreakpadWin::BreakpadWin() : handling_exception_(0) {
+  // Only report crashes if the user allows it.
+  if (!IsCrashReportingEnabled())
+    return;
+
+  // Disable the message box for assertions.
+  _CrtSetReportMode(_CRT_ASSERT, 0);
+
+  // Get the alternate dump directory. We use the temp path.
+  wchar_t temp_directory[MAX_PATH + 1] = { 0 };
+  DWORD length = ::GetTempPath(MAX_PATH, temp_directory);
+  if (length == 0)
+    return;
+
+  // Minidump with stacks, PEB, TEB, unloaded module list and memory referenced
+  // from stack.
+  MINIDUMP_TYPE dump_type = static_cast<MINIDUMP_TYPE>(
+      MiniDumpWithProcessThreadData |
+      MiniDumpWithUnloadedModules |
+      MiniDumpWithIndirectlyReferencedMemory);
+  breakpad_.reset(
+      new google_breakpad::ExceptionHandler(
+          temp_directory, &OnExceptionCallback, NULL, NULL,
+          google_breakpad::ExceptionHandler::HANDLER_ALL, dump_type,
+          pipe_name_, GetCustomInfo()));
+
+  if (breakpad_->IsOutOfProcess()) {
+    // Tells breakpad to handle breakpoint and single step exceptions.
+    breakpad_->set_handle_debug_exceptions(true);
+  }
+
+  // Catch exceptions thrown from a window procedure.
+  base::win::WinProcExceptionFilter exception_filter =
+      base::win::SetWinProcExceptionFilter(&OnWindowProcedureException);
+  CHECK(!exception_filter);
+}
+
+BreakpadWin::~BreakpadWin() {
+  // This object should be leaked so that crashes during the process shutdown
+  // will be caught.
+  NOTREACHED();
+}
+
+// static
+BreakpadWin& BreakpadWin::GetInstance() {
+  return g_instance.Get();
+}
+
+// Returns the Custom information to be used for crash reporting.
+google_breakpad::CustomClientInfo* BreakpadWin::GetCustomInfo() {
+  HMODULE binary = base::GetModuleFromAddress(
+      reinterpret_cast<void*>(&remoting::InitializeCrashReporting));
+  scoped_ptr<FileVersionInfo> version_info(
+      FileVersionInfo::CreateFileVersionInfoForModule(binary));
+
+  string16 version;
+  if (version_info.get())
+    version = version_info->product_version();
+  if (version.empty())
+    version = kBreakpadVersionDefault;
+
+  static google_breakpad::CustomInfoEntry ver_entry(
+      kBreakpadVersionEntry, version.c_str());
+  static google_breakpad::CustomInfoEntry prod_entry(
+      kBreakpadProdEntry, kBreakpadProductName);
+  static google_breakpad::CustomInfoEntry plat_entry(
+      kBreakpadPlatformEntry, kBreakpadPlatformWin32);
+  static google_breakpad::CustomInfoEntry entries[] = {
+      ver_entry, prod_entry, plat_entry  };
+  static google_breakpad::CustomClientInfo custom_info = {
+      entries, arraysize(entries) };
+  return &custom_info;
+}
+
+bool BreakpadWin::IsCrashReportingEnabled() {
+  // The user's consent to collect crash dumps is recored as the "usagestats"
+  // value in the ClientState or ClientStateMedium key. Probe
+  // the ClientStateMedium key first.
+  string16 client_state = StringPrintf(kOmahaClientStateKeyFormat,
+                                       kOmahaClientStateMedium,
+                                       remoting::kOmahaAppid);
+  base::win::RegKey key;
+  LONG result = key.Open(HKEY_LOCAL_MACHINE, client_state.c_str(), KEY_READ);
+  if (result == ERROR_SUCCESS) {
+    DWORD value = 0;
+    result = key.ReadValueDW(kOmahaUsagestatsValue, &value);
+    if (result == ERROR_SUCCESS) {
+      return value != 0;
+    }
+  }
+
+  client_state = StringPrintf(kOmahaClientStateKeyFormat,
+                              kOmahaClientState,
+                              remoting::kOmahaAppid);
+  result = key.Open(HKEY_LOCAL_MACHINE, client_state.c_str(), KEY_READ);
+  if (result == ERROR_SUCCESS) {
+    DWORD value = 0;
+    result = key.ReadValueDW(kOmahaUsagestatsValue, &value);
+    if (result == ERROR_SUCCESS) {
+      return value != 0;
+    }
+  }
+
+  // Do not collect anything if the user hasn't explicitly allowed it. Make sure
+  // though that crash dump collection is enabled when running the tests.
+  return enable_testing_;
+}
+
+// static
+bool BreakpadWin::OnExceptionCallback(void*, EXCEPTION_POINTERS*,
+                                            MDRawAssertionInfo*) {
+  BreakpadWin& self = BreakpadWin::GetInstance();
+  if (NoBarrier_CompareAndSwap(&self.handling_exception_, 0, 1) != 0) {
+    // Capture every thread except the first one in the sleep. We don't
+    // want multiple threads to concurrently report exceptions.
+    ::Sleep(INFINITE);
+  }
+  return true;
+}
+
+// static
+int BreakpadWin::OnWindowProcedureException(EXCEPTION_POINTERS* info) {
+  BreakpadWin& self = BreakpadWin::GetInstance();
+  if (self.breakpad_.get() != NULL) {
+    self.breakpad_->WriteMinidumpForException(info);
+    ::TerminateProcess(::GetCurrentProcess(),
+                       info->ExceptionRecord->ExceptionCode);
+  }
+  return EXCEPTION_CONTINUE_SEARCH;
+}
+
+}  // namespace
+
+namespace remoting {
+
+void InitializeCrashReporting() {
+  // Touch the object to make sure it is initialized.
+  BreakpadWin::GetInstance();
+}
+
+void InitializeCrashReportingForTest(const wchar_t* pipe_name) {
+  BreakpadWin::pipe_name_ = pipe_name;
+  BreakpadWin::enable_testing_ = true;
+
+  // Touch the object to make sure it is initialized.
+  BreakpadWin::GetInstance();
+}
+
+}  // namespace remoting