Rename BreakpadClient to CrashReporterClient.

components/crash/app/breakpad_win.cc

 // Copyright 2013 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 "components/crash/app/breakpad_win.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <tchar.h>
 #include <userenv.h>
@@ skipping 14 matching lines @@
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/win/metro.h"
 #include "base/win/pe_image.h"
 #include "base/win/registry.h"
 #include "base/win/win_util.h"
 #include "breakpad/src/client/windows/handler/exception_handler.h"
-#include "components/crash/app/breakpad_client.h"
 #include "components/crash/app/crash_keys_win.h"
+#include "components/crash/app/crash_reporter_client.h"
 #include "components/crash/app/hard_error_handler_win.h"
 #include "content/public/common/result_codes.h"
 #include "sandbox/win/src/nt_internals.h"
 #include "sandbox/win/src/sidestep/preamble_patcher.h"
 
 // userenv.dll is required for GetProfileType().
 #pragma comment(lib, "userenv.lib")
 
 #pragma intrinsic(_AddressOfReturnAddress)
 #pragma intrinsic(_ReturnAddress)
 
 namespace breakpad {
 
+using crash_reporter::GetCrashReporterClient;
+
 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.
 
 // Minidump with all of the above, plus memory referenced from stack.
 const MINIDUMP_TYPE kLargerDumpType = static_cast<MINIDUMP_TYPE>(
     MiniDumpWithProcessThreadData |  // Get PEB and TEB.
@@ skipping 133 matching lines @@
 bool DumpDoneCallback(const wchar_t*, const wchar_t*, void*,
                       EXCEPTION_POINTERS* ex_info,
                       MDRawAssertionInfo*, bool) {
   // Check if the exception is one of the kind which would not be solved
   // by simply restarting chrome. In this case we show a message box with
   // and exit silently. Remember that chrome is in a crashed state so we
   // can't show our own UI from this process.
   if (HardErrorHandler(ex_info))
     return true;
 
-  if (!GetBreakpadClient()->AboutToRestart())
+  if (!GetCrashReporterClient()->AboutToRestart())
     return true;
 
   // Now we just start chrome browser with the same command line.
   STARTUPINFOW si = {sizeof(si)};
   PROCESS_INFORMATION pi;
   if (::CreateProcessW(NULL, ::GetCommandLineW(), NULL, NULL, FALSE,
                        CREATE_UNICODE_ENVIRONMENT, NULL, NULL, &si, &pi)) {
     ::CloseHandle(pi.hProcess);
     ::CloseHandle(pi.hThread);
   }
   // After this return we will be terminated. The actual return value is
   // not used at all.
   return true;
 }
 
 // flag to indicate that we are already handling an exception.
 volatile LONG handling_exception = 0;
 
 // This callback is used when there is no crash. Note: Unlike the
 // |FilterCallback| below this does not do dupe detection. It is upto the caller
 // to implement it.
 bool FilterCallbackWhenNoCrash(
     void*, EXCEPTION_POINTERS*, MDRawAssertionInfo*) {
-  GetBreakpadClient()->RecordCrashDumpAttempt(false);
+  GetCrashReporterClient()->RecordCrashDumpAttempt(false);
   return true;
 }
 
 // This callback is executed when the Chrome 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.
 bool FilterCallback(void*, EXCEPTION_POINTERS*, MDRawAssertionInfo*) {
   // Capture every thread except the first one in the sleep. We don't
   // want multiple threads to concurrently report exceptions.
   if (::InterlockedCompareExchange(&handling_exception, 1, 0) == 1) {
     ::Sleep(INFINITE);
   }
-  GetBreakpadClient()->RecordCrashDumpAttempt(true);
+  GetCrashReporterClient()->RecordCrashDumpAttempt(true);
   return true;
 }
 
 // Previous unhandled filter. Will be called if not null when we
 // intercept a crash.
 LPTOP_LEVEL_EXCEPTION_FILTER previous_filter = NULL;
 
 // Exception filter used when breakpad is not enabled. We just display
 // the "Do you want to restart" message and then we call the previous filter.
 long WINAPI ChromeExceptionFilter(EXCEPTION_POINTERS* info) {
@@ skipping 44 matching lines @@
 static bool WrapMessageBoxWithSEH(const wchar_t* text, const wchar_t* caption,
                                   UINT flags, bool* exit_now) {
   // We wrap the call to MessageBoxW with a SEH handler because it some
   // machines with CursorXP, PeaDict or with FontExplorer installed it crashes
   // uncontrollably here. Being this a best effort deal we better go away.
   __try {
     *exit_now = (IDOK != ::MessageBoxW(NULL, text, caption, flags));
   } __except(EXCEPTION_EXECUTE_HANDLER) {
     // Its not safe to continue executing, exit silently here.
     ::TerminateProcess(::GetCurrentProcess(),
-                       GetBreakpadClient()->GetResultCodeRespawnFailed());
+                       GetCrashReporterClient()->GetResultCodeRespawnFailed());
   }
 
   return true;
 }
 
 // This function is executed by the child process that DumpDoneCallback()
 // spawned and basically just shows the 'chrome has crashed' dialog if
 // the CHROME_CRASHED environment variable is present.
 bool ShowRestartDialogIfCrashed(bool* exit_now) {
   // If we are being launched in metro mode don't try to show the dialog.
   if (base::win::IsMetroProcess())
     return false;
 
   base::string16 message;
   base::string16 title;
   bool is_rtl_locale;
-  if (!GetBreakpadClient()->ShouldShowRestartDialog(
-           &title, &message, &is_rtl_locale)) {
+  if (!GetCrashReporterClient()->ShouldShowRestartDialog(
+          &title, &message, &is_rtl_locale)) {
     return false;
   }
 
   // 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 (is_rtl_locale)
     flags |= MB_RIGHT | MB_RTLREADING;
 
   return WrapMessageBoxWithSEH(message.c_str(), title.c_str(), flags, exit_now);
@@ skipping 92 matching lines @@
 
 static void InitPipeNameEnvVar(bool is_per_user_install) {
   scoped_ptr<base::Environment> env(base::Environment::Create());
   if (env->HasVar(kPipeNameVar)) {
     // The Breakpad pipe name is already configured: nothing to do.
     return;
   }
 
   // Check whether configuration management controls crash reporting.
   bool crash_reporting_enabled = true;
-  bool controlled_by_policy = GetBreakpadClient()->ReportingIsEnforcedByPolicy(
-      &crash_reporting_enabled);
+  bool controlled_by_policy =
+      GetCrashReporterClient()->ReportingIsEnforcedByPolicy(
+          &crash_reporting_enabled);
 
   const CommandLine& command = *CommandLine::ForCurrentProcess();
-  bool use_crash_service =
-      !controlled_by_policy && (command.HasSwitch(switches::kNoErrorDialogs) ||
-                                GetBreakpadClient()->IsRunningUnattended());
+  bool use_crash_service = !controlled_by_policy &&
+                           (command.HasSwitch(switches::kNoErrorDialogs) ||
+                            GetCrashReporterClient()->IsRunningUnattended());
 
   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 (in case the administrator didn't already decide
     // via policy).
     if (!controlled_by_policy)
-      crash_reporting_enabled = GetBreakpadClient()->GetCollectStatsConsent();
+      crash_reporting_enabled =
+          GetCrashReporterClient()->GetCollectStatsConsent();
 
     if (!crash_reporting_enabled) {
       // Crash reporting is disabled, don't set the environment variable.
       return;
     }
 
     // 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;
@@ skipping 25 matching lines @@
 
   std::wstring process_type = base::ASCIIToWide(process_type_switch);
   if (process_type.empty())
     process_type = L"browser";
 
   wchar_t exe_path[MAX_PATH];
   exe_path[0] = 0;
   GetModuleFileNameW(NULL, exe_path, MAX_PATH);
 
   bool is_per_user_install =
-      GetBreakpadClient()->GetIsPerUserInstall(base::FilePath(exe_path));
+      GetCrashReporterClient()->GetIsPerUserInstall(base::FilePath(exe_path));
 
   // This is intentionally leaked.
   CrashKeysWin* keeper = new CrashKeysWin();
 
   google_breakpad::CustomClientInfo* custom_info =
       keeper->GetCustomInfo(exe_path, process_type,
                             GetProfileType(), CommandLine::ForCurrentProcess(),
-                            GetBreakpadClient());
+                            GetCrashReporterClient());
 
   google_breakpad::ExceptionHandler::MinidumpCallback callback = NULL;
   LPTOP_LEVEL_EXCEPTION_FILTER default_filter = NULL;
   // We install the post-dump callback only for the browser and service
   // processes. It spawns a new browser/service process.
   if (process_type == L"browser") {
     callback = &DumpDoneCallback;
     default_filter = &ChromeExceptionFilter;
   } else if (process_type == L"service") {
     callback = &DumpDoneCallback;
     default_filter = &ServiceExceptionFilter;
   }
 
   if (process_type == L"browser") {
     InitPipeNameEnvVar(is_per_user_install);
-    GetBreakpadClient()->InitBrowserCrashDumpsRegKey();
+    GetCrashReporterClient()->InitBrowserCrashDumpsRegKey();
   }
 
   scoped_ptr<base::Environment> env(base::Environment::Create());
   std::string pipe_name_ascii;
   if (!env->GetVar(kPipeNameVar, &pipe_name_ascii)) {
     // Breakpad is not enabled.  Configuration is 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/service processes.
     if (default_filter)
@@ skipping 12 matching lines @@
 #endif
 
   // Get the alternate dump directory. We use the temp path.
   wchar_t temp_dir[MAX_PATH] = {0};
   ::GetTempPathW(MAX_PATH, temp_dir);
 
   MINIDUMP_TYPE dump_type = kSmallDumpType;
   // Capture full memory if explicitly instructed to.
   if (command.HasSwitch(switches::kFullMemoryCrashReport))
     dump_type = kFullDumpType;
-  else if (GetBreakpadClient()->GetShouldDumpLargerDumps(is_per_user_install))
+  else if (GetCrashReporterClient()->GetShouldDumpLargerDumps(
+               is_per_user_install))
     dump_type = kLargerDumpType;
 
   g_breakpad = new google_breakpad::ExceptionHandler(temp_dir, &FilterCallback,
                    callback, NULL,
                    google_breakpad::ExceptionHandler::HANDLER_ALL,
                    dump_type, pipe_name.c_str(), custom_info);
 
   // Now initialize the non crash dump handler.
   g_dumphandler_no_crash = new google_breakpad::ExceptionHandler(temp_dir,
       &FilterCallbackWhenNoCrash,
@@ skipping 12 matching lines @@
   base::debug::SetDumpWithoutCrashingFunction(&DumpProcessWithoutCrash);
 
   if (g_breakpad->IsOutOfProcess()) {
     // Tells breakpad to handle breakpoint and single step exceptions.
     // This might break JIT debuggers, but at least it will always
     // generate a crashdump for these exceptions.
     g_breakpad->set_handle_debug_exceptions(true);
 
 #ifndef _WIN64
     if (process_type != L"browser" &&
-        !GetBreakpadClient()->IsRunningUnattended()) {
+        !GetCrashReporterClient()->IsRunningUnattended()) {
       // Initialize the hook TerminateProcess to catch unexpected exits.
       InitTerminateProcessHooks();
     }
 #endif
   }
 }
 
 // If the user has disabled crash reporting uploads and restarted Chrome, the
 // restarted instance will still contain the pipe environment variable, which
 // will allow the restarted process to still upload crash reports. This function
 // clears the environment variable, so that the restarted Chrome, which inherits
 // its environment from the current Chrome, will no longer contain the variable.
 extern "C" void __declspec(dllexport) __cdecl
       ClearBreakpadPipeEnvironmentVariable() {
   scoped_ptr<base::Environment> env(base::Environment::Create());
   env->UnSetVar(kPipeNameVar);
 }
 
 }  // namespace breakpad