Revert 184352

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 <windows.h>
 #include <shellapi.h>
 #include <tchar.h>
 #include <userenv.h>
@@ skipping 683 matching lines @@
   google_breakpad::CustomInfoEntry* entry = NULL;
   if (it == g_dynamic_entries->end()) {
     if (g_dynamic_keys_offset >= g_dynamic_entries_count)
       return;
     entry = &(*g_custom_entries)[g_dynamic_keys_offset++];
     g_dynamic_entries->insert(std::make_pair(key_string, entry));
   } else {
     entry = it->second;
   }
 
-  entry->set(base::UTF8ToWide(key).data(), base::UTF8ToWide(value).data());
+  entry->set(UTF8ToWide(key).data(), UTF8ToWide(value).data());
 }
 
 void ClearCrashKeyValue(const base::StringPiece& key) {
   DynamicEntriesMap::iterator it = g_dynamic_entries->find(key.as_string());
   if (it == g_dynamic_entries->end())
     return;
 
   it->second->set_value(NULL);
 }
 
@@ skipping 21 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(
-          base::ASCIIToWide(env_vars::kShowRestart).c_str(), NULL, 0)) {
+  if (!::GetEnvironmentVariableW(ASCIIToWide(env_vars::kShowRestart).c_str(),
+                                 NULL, 0)) {
     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()) {
     return false;
   }
 
   DWORD len = ::GetEnvironmentVariableW(
-      base::ASCIIToWide(env_vars::kRestartInfo).c_str(), NULL, 0);
+      ASCIIToWide(env_vars::kRestartInfo).c_str(), NULL, 0);
   if (!len)
     return true;
 
   wchar_t* restart_data = new wchar_t[len + 1];
-  ::GetEnvironmentVariableW(base::ASCIIToWide(env_vars::kRestartInfo).c_str(),
+  ::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] == base::ASCIIToWide(env_vars::kRtlLocale))
+  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);
 }
 
 // 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);
     if (g_crash_analysis)
       g_crash_analysis->Analyze(info);
     ::TerminateProcess(::GetCurrentProcess(), content::RESULT_CODE_KILLED);
   }
   return EXCEPTION_CONTINUE_SEARCH;
 }
 
 // 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 =
-      base::UTF8ToWide(policy::key::kMetricsReportingEnabled);
+  std::wstring key_name = UTF8ToWide(policy::key::kMetricsReportingEnabled);
   DWORD value = 0;
   base::win::RegKey hklm_policy_key(HKEY_LOCAL_MACHINE,
                                     policy::kRegistryMandatorySubKey, KEY_READ);
   if (hklm_policy_key.ReadValueDW(key_name.c_str(), &value) == ERROR_SUCCESS) {
     *result = value != 0;
     return true;
   }
 
   base::win::RegKey hkcu_policy_key(HKEY_CURRENT_USER,
                                     policy::kRegistryMandatorySubKey, KEY_READ);
@@ skipping 26 matching lines @@
 
   // 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(
-          base::ASCIIToWide(env_vars::kHeadless).c_str(), NULL, 0)));
+          ASCIIToWide(env_vars::kHeadless).c_str(), NULL, 0)));
 
   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 15 matching lines @@
       if (!base::win::GetUserSidString(&user_sid)) {
         return;
       }
     } else {
       user_sid = kSystemPrincipalSid;
     }
 
     pipe_name = kGoogleUpdatePipeName;
     pipe_name += user_sid;
   }
-  env->SetVar(kPipeNameVar, base::WideToASCII(pipe_name));
+  env->SetVar(kPipeNameVar, WideToASCII(pipe_name));
 }
 
 void InitCrashReporter() {
   const CommandLine& command = *CommandLine::ForCurrentProcess();
   if (command.HasSwitch(switches::kDisableBreakpad))
     return;
 
   // Disable the message box for assertions.
   _CrtSetReportMode(_CRT_ASSERT, 0);
 
@@ skipping 38 matching lines @@
   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)
       InitDefaultCrashCallback(default_filter);
     return;
   }
-  std::wstring pipe_name = base::ASCIIToWide(pipe_name_ascii);
+  std::wstring pipe_name = ASCIIToWide(pipe_name_ascii);
 
 #ifdef _WIN64
   // 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.
   pipe_name += L"-x64";
 #endif
 
@@ skipping 46 matching lines @@
   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());
 }