| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/app/chrome_breakpad_client.h" | |
| 6 | |
| 7 #include "base/atomicops.h" | |
| 8 #include "base/command_line.h" | |
| 9 #include "base/environment.h" | |
| 10 #include "base/files/file_path.h" | |
| 11 #include "base/logging.h" | |
| 12 #include "base/memory/scoped_ptr.h" | |
| 13 #include "base/path_service.h" | |
| 14 #include "base/strings/safe_sprintf.h" | |
| 15 #include "base/strings/string_split.h" | |
| 16 #include "base/strings/utf_string_conversions.h" | |
| 17 #include "chrome/common/chrome_constants.h" | |
| 18 #include "chrome/common/chrome_paths.h" | |
| 19 #include "chrome/common/chrome_result_codes.h" | |
| 20 #include "chrome/common/chrome_switches.h" | |
| 21 #include "chrome/common/crash_keys.h" | |
| 22 #include "chrome/common/env_vars.h" | |
| 23 #include "chrome/installer/util/google_update_settings.h" | |
| 24 | |
| 25 #if defined(OS_WIN) | |
| 26 #include <windows.h> | |
| 27 | |
| 28 #include "base/file_version_info.h" | |
| 29 #include "base/win/registry.h" | |
| 30 #include "chrome/installer/util/google_chrome_sxs_distribution.h" | |
| 31 #include "chrome/installer/util/install_util.h" | |
| 32 #include "chrome/installer/util/util_constants.h" | |
| 33 #include "policy/policy_constants.h" | |
| 34 #endif | |
| 35 | |
| 36 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_IOS) | |
| 37 #include "chrome/browser/crash_upload_list.h" | |
| 38 #include "chrome/common/chrome_version_info_posix.h" | |
| 39 #endif | |
| 40 | |
| 41 #if defined(OS_POSIX) | |
| 42 #include "base/debug/dump_without_crashing.h" | |
| 43 #endif | |
| 44 | |
| 45 #if defined(OS_ANDROID) | |
| 46 #include "chrome/common/descriptors_android.h" | |
| 47 #endif | |
| 48 | |
| 49 #if defined(OS_CHROMEOS) | |
| 50 #include "chrome/common/chrome_version_info.h" | |
| 51 #include "chromeos/chromeos_switches.h" | |
| 52 #endif | |
| 53 | |
| 54 namespace chrome { | |
| 55 | |
| 56 namespace { | |
| 57 | |
| 58 #if defined(OS_WIN) | |
| 59 // This is the minimum version of google update that is required for deferred | |
| 60 // crash uploads to work. | |
| 61 const char kMinUpdateVersion[] = "1.3.21.115"; | |
| 62 | |
| 63 // The value name prefix will be of the form {chrome-version}-{pid}-{timestamp} | |
| 64 // (i.e., "#####.#####.#####.#####-########-########") which easily fits into a | |
| 65 // 63 character buffer. | |
| 66 const char kBrowserCrashDumpPrefixTemplate[] = "%s-%08x-%08x"; | |
| 67 const size_t kBrowserCrashDumpPrefixLength = 63; | |
| 68 char g_browser_crash_dump_prefix[kBrowserCrashDumpPrefixLength + 1] = {}; | |
| 69 | |
| 70 // These registry key to which we'll write a value for each crash dump attempt. | |
| 71 HKEY g_browser_crash_dump_regkey = NULL; | |
| 72 | |
| 73 // A atomic counter to make each crash dump value name unique. | |
| 74 base::subtle::Atomic32 g_browser_crash_dump_count = 0; | |
| 75 #endif | |
| 76 | |
| 77 } // namespace | |
| 78 | |
| 79 ChromeBreakpadClient::ChromeBreakpadClient() {} | |
| 80 | |
| 81 ChromeBreakpadClient::~ChromeBreakpadClient() {} | |
| 82 | |
| 83 void ChromeBreakpadClient::SetBreakpadClientIdFromGUID( | |
| 84 const std::string& client_guid) { | |
| 85 crash_keys::SetCrashClientIdFromGUID(client_guid); | |
| 86 } | |
| 87 | |
| 88 #if defined(OS_WIN) | |
| 89 bool ChromeBreakpadClient::GetAlternativeCrashDumpLocation( | |
| 90 base::FilePath* crash_dir) { | |
| 91 // By setting the BREAKPAD_DUMP_LOCATION environment variable, an alternate | |
| 92 // location to write breakpad crash dumps can be set. | |
| 93 scoped_ptr<base::Environment> env(base::Environment::Create()); | |
| 94 std::string alternate_crash_dump_location; | |
| 95 if (env->GetVar("BREAKPAD_DUMP_LOCATION", &alternate_crash_dump_location)) { | |
| 96 *crash_dir = base::FilePath::FromUTF8Unsafe(alternate_crash_dump_location); | |
| 97 return true; | |
| 98 } | |
| 99 | |
| 100 return false; | |
| 101 } | |
| 102 | |
| 103 void ChromeBreakpadClient::GetProductNameAndVersion( | |
| 104 const base::FilePath& exe_path, | |
| 105 base::string16* product_name, | |
| 106 base::string16* version, | |
| 107 base::string16* special_build, | |
| 108 base::string16* channel_name) { | |
| 109 DCHECK(product_name); | |
| 110 DCHECK(version); | |
| 111 DCHECK(special_build); | |
| 112 DCHECK(channel_name); | |
| 113 | |
| 114 scoped_ptr<FileVersionInfo> version_info( | |
| 115 FileVersionInfo::CreateFileVersionInfo(exe_path)); | |
| 116 | |
| 117 if (version_info.get()) { | |
| 118 // Get the information from the file. | |
| 119 *version = version_info->product_version(); | |
| 120 if (!version_info->is_official_build()) | |
| 121 version->append(base::ASCIIToUTF16("-devel")); | |
| 122 | |
| 123 *product_name = version_info->product_short_name(); | |
| 124 *special_build = version_info->special_build(); | |
| 125 } else { | |
| 126 // No version info found. Make up the values. | |
| 127 *product_name = base::ASCIIToUTF16("Chrome"); | |
| 128 *version = base::ASCIIToUTF16("0.0.0.0-devel"); | |
| 129 } | |
| 130 | |
| 131 GoogleUpdateSettings::GetChromeChannelAndModifiers( | |
| 132 !GetIsPerUserInstall(exe_path), channel_name); | |
| 133 } | |
| 134 | |
| 135 bool ChromeBreakpadClient::ShouldShowRestartDialog(base::string16* title, | |
| 136 base::string16* message, | |
| 137 bool* is_rtl_locale) { | |
| 138 scoped_ptr<base::Environment> env(base::Environment::Create()); | |
| 139 if (!env->HasVar(env_vars::kShowRestart) || | |
| 140 !env->HasVar(env_vars::kRestartInfo) || | |
| 141 env->HasVar(env_vars::kMetroConnected)) { | |
| 142 return false; | |
| 143 } | |
| 144 | |
| 145 std::string restart_info; | |
| 146 env->GetVar(env_vars::kRestartInfo, &restart_info); | |
| 147 | |
| 148 // The CHROME_RESTART var contains the dialog strings separated by '|'. | |
| 149 // See ChromeBrowserMainPartsWin::PrepareRestartOnCrashEnviroment() | |
| 150 // for details. | |
| 151 std::vector<std::string> dlg_strings; | |
| 152 base::SplitString(restart_info, '|', &dlg_strings); | |
| 153 | |
| 154 if (dlg_strings.size() < 3) | |
| 155 return false; | |
| 156 | |
| 157 *title = base::UTF8ToUTF16(dlg_strings[0]); | |
| 158 *message = base::UTF8ToUTF16(dlg_strings[1]); | |
| 159 *is_rtl_locale = dlg_strings[2] == env_vars::kRtlLocale; | |
| 160 return true; | |
| 161 } | |
| 162 | |
| 163 bool ChromeBreakpadClient::AboutToRestart() { | |
| 164 scoped_ptr<base::Environment> env(base::Environment::Create()); | |
| 165 if (!env->HasVar(env_vars::kRestartInfo)) | |
| 166 return false; | |
| 167 | |
| 168 env->SetVar(env_vars::kShowRestart, "1"); | |
| 169 return true; | |
| 170 } | |
| 171 | |
| 172 bool ChromeBreakpadClient::GetDeferredUploadsSupported( | |
| 173 bool is_per_user_install) { | |
| 174 Version update_version = GoogleUpdateSettings::GetGoogleUpdateVersion( | |
| 175 !is_per_user_install); | |
| 176 if (!update_version.IsValid() || | |
| 177 update_version.IsOlderThan(std::string(kMinUpdateVersion))) | |
| 178 return false; | |
| 179 | |
| 180 return true; | |
| 181 } | |
| 182 | |
| 183 bool ChromeBreakpadClient::GetIsPerUserInstall(const base::FilePath& exe_path) { | |
| 184 return InstallUtil::IsPerUserInstall(exe_path.value().c_str()); | |
| 185 } | |
| 186 | |
| 187 bool ChromeBreakpadClient::GetShouldDumpLargerDumps(bool is_per_user_install) { | |
| 188 base::string16 channel_name = | |
| 189 GoogleUpdateSettings::GetChromeChannel(!is_per_user_install); | |
| 190 | |
| 191 // Capture more detail in crash dumps for beta and dev channel builds. | |
| 192 return (channel_name == installer::kChromeChannelDev || | |
| 193 channel_name == installer::kChromeChannelBeta || | |
| 194 channel_name == GoogleChromeSxSDistribution::ChannelName()); | |
| 195 } | |
| 196 | |
| 197 int ChromeBreakpadClient::GetResultCodeRespawnFailed() { | |
| 198 return chrome::RESULT_CODE_RESPAWN_FAILED; | |
| 199 } | |
| 200 | |
| 201 void ChromeBreakpadClient::InitBrowserCrashDumpsRegKey() { | |
| 202 DCHECK(g_browser_crash_dump_regkey == NULL); | |
| 203 | |
| 204 base::win::RegKey regkey; | |
| 205 if (regkey.Create(HKEY_CURRENT_USER, | |
| 206 chrome::kBrowserCrashDumpAttemptsRegistryPath, | |
| 207 KEY_ALL_ACCESS) != ERROR_SUCCESS) { | |
| 208 return; | |
| 209 } | |
| 210 | |
| 211 // We use the current process id and the current tick count as a (hopefully) | |
| 212 // unique combination for the crash dump value. There's a small chance that | |
| 213 // across a reboot we might have a crash dump signal written, and the next | |
| 214 // browser process might have the same process id and tick count, but crash | |
| 215 // before consuming the signal (overwriting the signal with an identical one). | |
| 216 // For now, we're willing to live with that risk. | |
| 217 int length = base::strings::SafeSPrintf(g_browser_crash_dump_prefix, | |
| 218 kBrowserCrashDumpPrefixTemplate, | |
| 219 chrome::kChromeVersion, | |
| 220 ::GetCurrentProcessId(), | |
| 221 ::GetTickCount()); | |
| 222 if (length <= 0) { | |
| 223 NOTREACHED(); | |
| 224 g_browser_crash_dump_prefix[0] = '\0'; | |
| 225 return; | |
| 226 } | |
| 227 | |
| 228 // Hold the registry key in a global for update on crash dump. | |
| 229 g_browser_crash_dump_regkey = regkey.Take(); | |
| 230 } | |
| 231 | |
| 232 void ChromeBreakpadClient::RecordCrashDumpAttempt(bool is_real_crash) { | |
| 233 // If we're not a browser (or the registry is unavailable to us for some | |
| 234 // reason) then there's nothing to do. | |
| 235 if (g_browser_crash_dump_regkey == NULL) | |
| 236 return; | |
| 237 | |
| 238 // Generate the final value name we'll use (appends the crash number to the | |
| 239 // base value name). | |
| 240 const size_t kMaxValueSize = 2 * kBrowserCrashDumpPrefixLength; | |
| 241 char value_name[kMaxValueSize + 1] = {}; | |
| 242 int length = base::strings::SafeSPrintf( | |
| 243 value_name, | |
| 244 "%s-%x", | |
| 245 g_browser_crash_dump_prefix, | |
| 246 base::subtle::NoBarrier_AtomicIncrement(&g_browser_crash_dump_count, 1)); | |
| 247 | |
| 248 if (length > 0) { | |
| 249 DWORD value_dword = is_real_crash ? 1 : 0; | |
| 250 ::RegSetValueExA(g_browser_crash_dump_regkey, value_name, 0, REG_DWORD, | |
| 251 reinterpret_cast<BYTE*>(&value_dword), | |
| 252 sizeof(value_dword)); | |
| 253 } | |
| 254 } | |
| 255 | |
| 256 bool ChromeBreakpadClient::ReportingIsEnforcedByPolicy(bool* breakpad_enabled) { | |
| 257 // Determine whether configuration management allows loading the crash reporter. | |
| 258 // Since the configuration management infrastructure is not initialized at this | |
| 259 // point, we read the corresponding registry key directly. The return status | |
| 260 // indicates whether policy data was successfully read. If it is true, | |
| 261 // |breakpad_enabled| contains the value set by policy. | |
| 262 base::string16 key_name = | |
| 263 base::UTF8ToUTF16(policy::key::kMetricsReportingEnabled); | |
| 264 DWORD value = 0; | |
| 265 base::win::RegKey hklm_policy_key(HKEY_LOCAL_MACHINE, | |
| 266 policy::kRegistryChromePolicyKey, KEY_READ); | |
| 267 if (hklm_policy_key.ReadValueDW(key_name.c_str(), &value) == ERROR_SUCCESS) { | |
| 268 *breakpad_enabled = value != 0; | |
| 269 return true; | |
| 270 } | |
| 271 | |
| 272 base::win::RegKey hkcu_policy_key(HKEY_CURRENT_USER, | |
| 273 policy::kRegistryChromePolicyKey, KEY_READ); | |
| 274 if (hkcu_policy_key.ReadValueDW(key_name.c_str(), &value) == ERROR_SUCCESS) { | |
| 275 *breakpad_enabled = value != 0; | |
| 276 return true; | |
| 277 } | |
| 278 | |
| 279 return false; | |
| 280 } | |
| 281 #endif // defined(OS_WIN) | |
| 282 | |
| 283 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_IOS) | |
| 284 void ChromeBreakpadClient::GetProductNameAndVersion(std::string* product_name, | |
| 285 std::string* version) { | |
| 286 DCHECK(product_name); | |
| 287 DCHECK(version); | |
| 288 #if defined(OS_ANDROID) | |
| 289 *product_name = "Chrome_Android"; | |
| 290 #elif defined(OS_CHROMEOS) | |
| 291 *product_name = "Chrome_ChromeOS"; | |
| 292 #else // OS_LINUX | |
| 293 #if !defined(ADDRESS_SANITIZER) | |
| 294 *product_name = "Chrome_Linux"; | |
| 295 #else | |
| 296 *product_name = "Chrome_Linux_ASan"; | |
| 297 #endif | |
| 298 #endif | |
| 299 | |
| 300 *version = PRODUCT_VERSION; | |
| 301 } | |
| 302 | |
| 303 base::FilePath ChromeBreakpadClient::GetReporterLogFilename() { | |
| 304 return base::FilePath(CrashUploadList::kReporterLogFilename); | |
| 305 } | |
| 306 #endif | |
| 307 | |
| 308 bool ChromeBreakpadClient::GetCrashDumpLocation(base::FilePath* crash_dir) { | |
| 309 // By setting the BREAKPAD_DUMP_LOCATION environment variable, an alternate | |
| 310 // location to write breakpad crash dumps can be set. | |
| 311 scoped_ptr<base::Environment> env(base::Environment::Create()); | |
| 312 std::string alternate_crash_dump_location; | |
| 313 if (env->GetVar("BREAKPAD_DUMP_LOCATION", &alternate_crash_dump_location)) { | |
| 314 base::FilePath crash_dumps_dir_path = | |
| 315 base::FilePath::FromUTF8Unsafe(alternate_crash_dump_location); | |
| 316 PathService::Override(chrome::DIR_CRASH_DUMPS, crash_dumps_dir_path); | |
| 317 } | |
| 318 | |
| 319 return PathService::Get(chrome::DIR_CRASH_DUMPS, crash_dir); | |
| 320 } | |
| 321 | |
| 322 size_t ChromeBreakpadClient::RegisterCrashKeys() { | |
| 323 // Note: This is not called on Windows because Breakpad is initialized in the | |
| 324 // EXE module, but code that uses crash keys is in the DLL module. | |
| 325 // RegisterChromeCrashKeys() will be called after the DLL is loaded. | |
| 326 return crash_keys::RegisterChromeCrashKeys(); | |
| 327 } | |
| 328 | |
| 329 bool ChromeBreakpadClient::IsRunningUnattended() { | |
| 330 scoped_ptr<base::Environment> env(base::Environment::Create()); | |
| 331 return env->HasVar(env_vars::kHeadless); | |
| 332 } | |
| 333 | |
| 334 bool ChromeBreakpadClient::GetCollectStatsConsent() { | |
| 335 #if defined(GOOGLE_CHROME_BUILD) | |
| 336 bool is_official_chrome_build = true; | |
| 337 #else | |
| 338 bool is_official_chrome_build = false; | |
| 339 #endif | |
| 340 | |
| 341 #if defined(OS_CHROMEOS) | |
| 342 bool is_guest_session = CommandLine::ForCurrentProcess()->HasSwitch( | |
| 343 chromeos::switches::kGuestSession); | |
| 344 bool is_stable_channel = | |
| 345 chrome::VersionInfo::GetChannel() == chrome::VersionInfo::CHANNEL_STABLE; | |
| 346 | |
| 347 if (is_guest_session && is_stable_channel) | |
| 348 return false; | |
| 349 #endif // defined(OS_CHROMEOS) | |
| 350 | |
| 351 #if defined(OS_ANDROID) | |
| 352 // TODO(jcivelli): we should not initialize the crash-reporter when it was not | |
| 353 // enabled. Right now if it is disabled we still generate the minidumps but we | |
| 354 // do not upload them. | |
| 355 return is_official_chrome_build; | |
| 356 #else // !defined(OS_ANDROID) | |
| 357 return is_official_chrome_build && | |
| 358 GoogleUpdateSettings::GetCollectStatsConsent(); | |
| 359 #endif // defined(OS_ANDROID) | |
| 360 } | |
| 361 | |
| 362 #if defined(OS_ANDROID) | |
| 363 int ChromeBreakpadClient::GetAndroidMinidumpDescriptor() { | |
| 364 return kAndroidMinidumpDescriptor; | |
| 365 } | |
| 366 #endif | |
| 367 | |
| 368 bool ChromeBreakpadClient::EnableBreakpadForProcess( | |
| 369 const std::string& process_type) { | |
| 370 return process_type == switches::kRendererProcess || | |
| 371 process_type == switches::kPluginProcess || | |
| 372 process_type == switches::kPpapiPluginProcess || | |
| 373 process_type == switches::kZygoteProcess || | |
| 374 process_type == switches::kGpuProcess; | |
| 375 } | |
| 376 | |
| 377 } // namespace chrome | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 585633002:
Rename BreakpadClient to CrashReporterClient. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master