Move dependency on env_vars.h to breakpad client

chrome/app/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.
 
 #include "chrome/app/breakpad_win.h"
 
 #include <shellapi.h>
 #include <tchar.h>
 #include <userenv.h>
 #include <windows.h>
@@ skipping 14 matching lines @@
 #include "base/strings/utf_string_conversions.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 "chrome/app/breakpad_field_trial_win.h"
 #include "chrome/app/hard_error_handler_win.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_result_codes.h"
-#include "chrome/common/env_vars.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"
 #include "components/breakpad/breakpad_client.h"
 #include "content/public/common/content_switches.h"
 #include "policy/policy_constants.h"
 #include "sandbox/win/src/nt_internals.h"
 #include "sandbox/win/src/sidestep/preamble_patcher.h"
 
 // userenv.dll is required for GetProfileType().
@@ skipping 436 matching lines @@
   } else {
     g_custom_entries->push_back(
         google_breakpad::CustomInfoEntry(L"num-views", L"N/A"));
   }
 
   // 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 = !controlled_by_policy &&
-      ((command.HasSwitch(switches::kNoErrorDialogs) ||
-      GetEnvironmentVariable(
-          ASCIIToWide(env_vars::kHeadless).c_str(), NULL, 0)));
+  bool use_crash_service =
+      !controlled_by_policy &&
+      (command.HasSwitch(switches::kNoErrorDialogs) ||
+       breakpad::GetBreakpadClient()->IsRunningUnattended());
   if (use_crash_service)
     SetBreakpadDumpPath();
 
   g_num_of_experiments_offset = g_custom_entries->size();
   g_custom_entries->push_back(
       google_breakpad::CustomInfoEntry(L"num-experiments", L"N/A"));
 
   g_experiment_chunks_offset = g_custom_entries->size();
   // We depend on this in UpdateExperiments...
   DCHECK_NE(0UL, g_experiment_chunks_offset);
@@ skipping 42 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;
 
-  // We set CHROME_CRASHED env var. If the CHROME_RESTART is present.
-  // This signals the child process to show the 'chrome has crashed' dialog.
-  scoped_ptr<base::Environment> env(base::Environment::Create());
-  if (!env->HasVar(env_vars::kRestartInfo)) {
+  if (!breakpad::GetBreakpadClient()->AboutToRestart())
     return true;
-  }
-  env->SetVar(env_vars::kShowRestart, "1");
+
   // 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.
@@ skipping 219 matching lines @@
                        chrome::RESULT_CODE_RESPAWN_FAILED);
   }
 
   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 (!::GetEnvironmentVariableW(ASCIIToWide(env_vars::kShowRestart).c_str(),
-                                 NULL, 0)) {
-    return false;
-  }
-
   // If we are being launched in metro mode don't try to show the dialog.
   if (base::win::IsMetroProcess())
     return false;
 
   // Only show this for the browser process. See crbug.com/132119.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   std::string process_type =
       command_line.GetSwitchValueASCII(switches::kProcessType);
-  if (!process_type.empty()) {
+  if (!process_type.empty())
+    return false;
+
+  base::string16 message;
+  base::string16 title;
+  bool is_rtl_locale;
+  if (!breakpad::GetBreakpadClient()->ShouldShowRestartDialog(
+          &title, &message, &is_rtl_locale)) {
     return false;
   }
 
-  DWORD len = ::GetEnvironmentVariableW(
-      ASCIIToWide(env_vars::kRestartInfo).c_str(), NULL, 0);
-  if (!len)
-    return true;
-
-  wchar_t* restart_data = new wchar_t[len + 1];
-  ::GetEnvironmentVariableW(ASCIIToWide(env_vars::kRestartInfo).c_str(),
-                            restart_data, len);
-  restart_data[len] = 0;
-  // The CHROME_RESTART var contains the dialog strings separated by '|'.
-  // See ChromeBrowserMainPartsWin::PrepareRestartOnCrashEnviroment()
-  // for details.
-  std::vector<std::wstring> dlg_strings;
-  base::SplitString(restart_data, L'|', &dlg_strings);
-  delete[] restart_data;
-  if (dlg_strings.size() < 3)
-    return true;
-
   // 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))
+  if (is_rtl_locale)
     flags |= MB_RIGHT | MB_RTLREADING;
 
-  return WrapMessageBoxWithSEH(dlg_strings[1].c_str(), dlg_strings[0].c_str(),
-                               flags, exit_now);
+  return WrapMessageBoxWithSEH(base::UTF16ToWide(message).c_str(),
+                               base::UTF16ToWide(title).c_str(),
+                               flags,
+                               exit_now);
 }
 
 // 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.
 extern "C" int __declspec(dllexport) CrashForException(
     EXCEPTION_POINTERS* info) {
   if (g_breakpad) {
     g_breakpad->WriteMinidumpForException(info);
     // Patched stub exists based on conditions (See InitCrashReporter).
@@ skipping 95 matching lines @@
     // 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 =
       MetricsReportingControlledByPolicy(&crash_reporting_enabled);
 
   const CommandLine& command = *CommandLine::ForCurrentProcess();
-  bool use_crash_service = !controlled_by_policy &&
-      ((command.HasSwitch(switches::kNoErrorDialogs) ||
-      GetEnvironmentVariable(
-          ASCIIToWide(env_vars::kHeadless).c_str(), NULL, 0)));
+  bool use_crash_service =
+      !controlled_by_policy &&
+      (command.HasSwitch(switches::kNoErrorDialogs) ||
+       breakpad::GetBreakpadClient()->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)
@@ skipping 127 matching lines @@
       dump_type, pipe_name.c_str(), custom_info);
 
   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
     std::string headless;
-    if (process_type != L"browser" && !GetEnvironmentVariable(
-            ASCIIToWide(env_vars::kHeadless).c_str(), NULL, 0)) {
+    if (process_type != L"browser" &&
+        !breakpad::GetBreakpadClient()->IsRunningUnattended()) {
       // Initialize the hook TerminateProcess to catch unexpected exits.
       InitTerminateProcessHooks();
     }
 #endif
   }
 }
 
 void InitDefaultCrashCallback(LPTOP_LEVEL_EXCEPTION_FILTER filter) {
   previous_filter = SetUnhandledExceptionFilter(filter);
 }
 
 void StringVectorToCStringVector(const std::vector<std::wstring>& wstrings,
                                  std::vector<const wchar_t*>* cstrings) {
   cstrings->clear();
   cstrings->reserve(wstrings.size());
   for (size_t i = 0; i < wstrings.size(); ++i)
     cstrings->push_back(wstrings[i].c_str());
 }