1 // Copyright (c) 2012 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_main_delegate.h" 6 7 #include "base/base_paths.h" 8 #include "base/command_line.h" 9 #include "base/cpu.h" 10 #include "base/files/file_path.h" 11 #include "base/i18n/rtl.h" 12 #include "base/lazy_instance.h" 13 #include "base/message_loop/message_loop.h" 14 #include "base/metrics/statistics_recorder.h" 15 #include "base/metrics/stats_counters.h" 16 #include "base/path_service.h" 17 #include "base/process/memory.h" 18 #include "base/process/process_handle.h" 19 #include "base/strings/string_util.h" 20 #include "build/build_config.h" 21 #include "chrome/browser/chrome_content_browser_client.h" 22 #include "chrome/browser/defaults.h" 23 #include "chrome/common/chrome_constants.h" 24 #include "chrome/common/chrome_content_client.h" 25 #include "chrome/common/chrome_paths.h" 26 #include "chrome/common/chrome_paths_internal.h" 27 #include "chrome/common/chrome_switches.h" 28 #include "chrome/common/chrome_version_info.h" 29 #include "chrome/common/crash_keys.h" 30 #include "chrome/common/logging_chrome.h" 31 #include "chrome/common/profiling.h" 32 #include "chrome/common/switch_utils.h" 33 #include "chrome/common/url_constants.h" 34 #include "chrome/plugin/chrome_content_plugin_client.h" 35 #include "chrome/renderer/chrome_content_renderer_client.h" 36 #include "chrome/utility/chrome_content_utility_client.h" 37 #include "components/component_updater/component_updater_paths.h" 38 #include "components/content_settings/core/common/content_settings_pattern.h" 39 #include "components/startup_metric_utils/startup_metric_utils.h" 40 #include "content/public/common/content_client.h" 41 #include "content/public/common/content_paths.h" 42 #include "extensions/common/constants.h" 43 #include "ui/base/ui_base_switches.h" 44 45 #if defined(OS_WIN) 46 #include <atlbase.h> 47 #include <malloc.h> 48 #include <algorithm> 49 #include "chrome/app/close_handle_hook_win.h" 50 #include "chrome/common/child_process_logging.h" 51 #include "chrome/common/terminate_on_heap_corruption_experiment_win.h" 52 #include "sandbox/win/src/sandbox.h" 53 #include "ui/base/resource/resource_bundle_win.h" 54 #endif 55 56 #if defined(OS_MACOSX) 57 #include "base/mac/mac_util.h" 58 #include "base/mac/os_crash_dumps.h" 59 #include "chrome/app/chrome_main_mac.h" 60 #include "chrome/browser/mac/relauncher.h" 61 #include "chrome/common/mac/cfbundle_blocker.h" 62 #include "chrome/common/mac/objc_zombie.h" 63 #include "components/crash/app/breakpad_mac.h" 64 #include "ui/base/l10n/l10n_util_mac.h" 65 #endif 66 67 #if defined(OS_POSIX) 68 #include <locale.h> 69 #include <signal.h> 70 #include "chrome/app/chrome_crash_reporter_client.h" 71 #include "components/crash/app/crash_reporter_client.h" 72 #endif 73 74 #if !defined(DISABLE_NACL) && defined(OS_LINUX) 75 #include "components/nacl/common/nacl_paths.h" 76 #include "components/nacl/zygote/nacl_fork_delegate_linux.h" 77 #endif 78 79 #if defined(OS_CHROMEOS) 80 #include "base/sys_info.h" 81 #include "chrome/browser/chromeos/boot_times_loader.h" 82 #include "chromeos/chromeos_paths.h" 83 #include "chromeos/chromeos_switches.h" 84 #endif 85 86 #if defined(OS_ANDROID) 87 #include "chrome/common/descriptors_android.h" 88 #else 89 // Diagnostics is only available on non-android platforms. 90 #include "chrome/browser/diagnostics/diagnostics_controller.h" 91 #include "chrome/browser/diagnostics/diagnostics_writer.h" 92 #endif 93 94 #if defined(USE_X11) 95 #include <stdlib.h> 96 #include <string.h> 97 #include "ui/base/x/x11_util.h" 98 #endif 99 100 #if defined(OS_POSIX) && !defined(OS_MACOSX) 101 #include "components/crash/app/breakpad_linux.h" 102 #endif 103 104 #if defined(OS_LINUX) 105 #include "base/environment.h" 106 #endif 107 108 #if defined(OS_MACOSX) || defined(OS_WIN) 109 #include "chrome/browser/policy/policy_path_parser.h" 110 #endif 111 112 #if !defined(DISABLE_NACL) 113 #include "components/nacl/common/nacl_switches.h" 114 #endif 115 116 #if !defined(CHROME_MULTIPLE_DLL_CHILD) 117 base::LazyInstance<chrome::ChromeContentBrowserClient> 118 g_chrome_content_browser_client = LAZY_INSTANCE_INITIALIZER; 119 #endif 120 121 #if !defined(CHROME_MULTIPLE_DLL_BROWSER) 122 base::LazyInstance<ChromeContentRendererClient> 123 g_chrome_content_renderer_client = LAZY_INSTANCE_INITIALIZER; 124 base::LazyInstance<ChromeContentUtilityClient> 125 g_chrome_content_utility_client = LAZY_INSTANCE_INITIALIZER; 126 base::LazyInstance<chrome::ChromeContentPluginClient> 127 g_chrome_content_plugin_client = LAZY_INSTANCE_INITIALIZER; 128 #endif 129 130 #if defined(OS_POSIX) 131 base::LazyInstance<chrome::ChromeCrashReporterClient>::Leaky 132 g_chrome_crash_client = LAZY_INSTANCE_INITIALIZER; 133 #endif 134 135 extern int NaClMain(const content::MainFunctionParams&); 136 extern int ServiceProcessMain(const content::MainFunctionParams&); 137 138 namespace { 139 140 #if defined(OS_WIN) 141 // Early versions of Chrome incorrectly registered a chromehtml: URL handler, 142 // which gives us nothing but trouble. Avoid launching chrome this way since 143 // some apps fail to properly escape arguments. 144 bool HasDeprecatedArguments(const std::wstring& command_line) { 145 const wchar_t kChromeHtml[] = L"chromehtml:"; 146 std::wstring command_line_lower = command_line; 147 // We are only searching for ASCII characters so this is OK. 148 base::StringToLowerASCII(&command_line_lower); 149 std::wstring::size_type pos = command_line_lower.find(kChromeHtml); 150 return (pos != std::wstring::npos); 151 } 152 153 // If we try to access a path that is not currently available, we want the call 154 // to fail rather than show an error dialog. 155 void SuppressWindowsErrorDialogs() { 156 UINT new_flags = SEM_FAILCRITICALERRORS | 157 SEM_NOOPENFILEERRORBOX; 158 159 // Preserve existing error mode. 160 UINT existing_flags = SetErrorMode(new_flags); 161 SetErrorMode(existing_flags | new_flags); 162 } 163 164 #endif // defined(OS_WIN) 165 166 #if defined(OS_LINUX) 167 static void AdjustLinuxOOMScore(const std::string& process_type) { 168 // Browsers and zygotes should still be killable, but killed last. 169 const int kZygoteScore = 0; 170 // The minimum amount to bump a score by. This is large enough that 171 // even if it's translated into the old values, it will still go up 172 // by at least one. 173 const int kScoreBump = 100; 174 // This is the lowest score that renderers and extensions start with 175 // in the OomPriorityManager. 176 const int kRendererScore = chrome::kLowestRendererOomScore; 177 // For "miscellaneous" things, we want them after renderers, 178 // but before plugins. 179 const int kMiscScore = kRendererScore - kScoreBump; 180 // We want plugins to die after the renderers. 181 const int kPluginScore = kMiscScore - kScoreBump; 182 int score = -1; 183 184 DCHECK(kMiscScore > 0); 185 DCHECK(kPluginScore > 0); 186 187 if (process_type == switches::kPluginProcess || 188 process_type == switches::kPpapiPluginProcess) { 189 score = kPluginScore; 190 } else if (process_type == switches::kPpapiBrokerProcess) { 191 // The broker should be killed before the PPAPI plugin. 192 score = kPluginScore + kScoreBump; 193 } else if (process_type == switches::kUtilityProcess || 194 process_type == switches::kGpuProcess || 195 process_type == switches::kServiceProcess) { 196 score = kMiscScore; 197 #ifndef DISABLE_NACL 198 } else if (process_type == switches::kNaClLoaderProcess || 199 process_type == switches::kNaClLoaderNonSfiProcess) { 200 score = kPluginScore; 201 #endif 202 } else if (process_type == switches::kZygoteProcess || 203 process_type.empty()) { 204 // For zygotes and unlabeled process types, we want to still make 205 // them killable by the OOM killer. 206 score = kZygoteScore; 207 } else if (process_type == switches::kRendererProcess) { 208 LOG(WARNING) << "process type 'renderer' " 209 << "should be created through the zygote."; 210 // When debugging, this process type can end up being run directly, but 211 // this isn't the typical path for assigning the OOM score for it. Still, 212 // we want to assign a score that is somewhat representative for debugging. 213 score = kRendererScore; 214 } else { 215 NOTREACHED() << "Unknown process type"; 216 } 217 if (score > -1) 218 base::AdjustOOMScore(base::GetCurrentProcId(), score); 219 } 220 #endif // defined(OS_LINUX) 221 222 // Returns true if this subprocess type needs the ResourceBundle initialized 223 // and resources loaded. 224 bool SubprocessNeedsResourceBundle(const std::string& process_type) { 225 return 226 #if defined(OS_WIN) || defined(OS_MACOSX) 227 // Windows needs resources for the default/null plugin. 228 // Mac needs them for the plugin process name. 229 process_type == switches::kPluginProcess || 230 #endif 231 #if defined(OS_POSIX) && !defined(OS_MACOSX) 232 // The zygote process opens the resources for the renderers. 233 process_type == switches::kZygoteProcess || 234 #endif 235 #if defined(OS_MACOSX) 236 // Mac needs them too for scrollbar related images and for sandbox 237 // profiles. 238 #if !defined(DISABLE_NACL) 239 process_type == switches::kNaClLoaderProcess || 240 #endif 241 process_type == switches::kPpapiPluginProcess || 242 process_type == switches::kPpapiBrokerProcess || 243 process_type == switches::kGpuProcess || 244 #endif 245 process_type == switches::kRendererProcess || 246 process_type == switches::kUtilityProcess; 247 } 248 249 #if defined(OS_POSIX) 250 // Check for --version and --product-version; return true if we encountered 251 // one of these switches and should exit now. 252 bool HandleVersionSwitches(const CommandLine& command_line) { 253 const chrome::VersionInfo version_info; 254 255 #if !defined(OS_MACOSX) 256 if (command_line.HasSwitch(switches::kProductVersion)) { 257 printf("%s\n", version_info.Version().c_str()); 258 return true; 259 } 260 #endif 261 262 if (command_line.HasSwitch(switches::kVersion)) { 263 printf("%s %s %s\n", 264 version_info.Name().c_str(), 265 version_info.Version().c_str(), 266 chrome::VersionInfo::GetVersionStringModifier().c_str()); 267 return true; 268 } 269 270 return false; 271 } 272 273 #if !defined(OS_MACOSX) && !defined(OS_CHROMEOS) 274 // Show the man page if --help or -h is on the command line. 275 void HandleHelpSwitches(const CommandLine& command_line) { 276 if (command_line.HasSwitch(switches::kHelp) || 277 command_line.HasSwitch(switches::kHelpShort)) { 278 base::FilePath binary(command_line.argv()[0]); 279 execlp("man", "man", binary.BaseName().value().c_str(), NULL); 280 PLOG(FATAL) << "execlp failed"; 281 } 282 } 283 #endif 284 285 #if !defined(OS_MACOSX) && !defined(OS_ANDROID) 286 void SIGTERMProfilingShutdown(int signal) { 287 Profiling::Stop(); 288 struct sigaction sigact; 289 memset(&sigact, 0, sizeof(sigact)); 290 sigact.sa_handler = SIG_DFL; 291 CHECK(sigaction(SIGTERM, &sigact, NULL) == 0); 292 raise(signal); 293 } 294 295 void SetUpProfilingShutdownHandler() { 296 struct sigaction sigact; 297 sigact.sa_handler = SIGTERMProfilingShutdown; 298 sigact.sa_flags = SA_RESETHAND; 299 sigemptyset(&sigact.sa_mask); 300 CHECK(sigaction(SIGTERM, &sigact, NULL) == 0); 301 } 302 #endif // !defined(OS_MACOSX) && !defined(OS_ANDROID) 303 304 #endif // OS_POSIX 305 306 struct MainFunction { 307 const char* name; 308 int (*function)(const content::MainFunctionParams&); 309 }; 310 311 // Initializes the user data dir. Must be called before InitializeLocalState(). 312 void InitializeUserDataDir() { 313 CommandLine* command_line = CommandLine::ForCurrentProcess(); 314 base::FilePath user_data_dir = 315 command_line->GetSwitchValuePath(switches::kUserDataDir); 316 std::string process_type = 317 command_line->GetSwitchValueASCII(switches::kProcessType); 318 319 #if defined(OS_LINUX) 320 // On Linux, Chrome does not support running multiple copies under different 321 // DISPLAYs, so the profile directory can be specified in the environment to 322 // support the virtual desktop use-case. 323 if (user_data_dir.empty()) { 324 std::string user_data_dir_string; 325 scoped_ptr<base::Environment> environment(base::Environment::Create()); 326 if (environment->GetVar("CHROME_USER_DATA_DIR", &user_data_dir_string) && 327 base::IsStringUTF8(user_data_dir_string)) { 328 user_data_dir = base::FilePath::FromUTF8Unsafe(user_data_dir_string); 329 } 330 } 331 #endif 332 #if defined(OS_MACOSX) || defined(OS_WIN) 333 policy::path_parser::CheckUserDataDirPolicy(&user_data_dir); 334 #endif 335 336 const bool specified_directory_was_invalid = !user_data_dir.empty() && 337 !PathService::OverrideAndCreateIfNeeded(chrome::DIR_USER_DATA, 338 user_data_dir, false, true); 339 // Save inaccessible or invalid paths so the user may be prompted later. 340 if (specified_directory_was_invalid) 341 chrome::SetInvalidSpecifiedUserDataDir(user_data_dir); 342 343 // Warn and fail early if the process fails to get a user data directory. 344 if (!PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) { 345 // If an invalid command-line or policy override was specified, the user 346 // will be given an error with that value. Otherwise, use the directory 347 // returned by PathService (or the fallback default directory) in the error. 348 if (!specified_directory_was_invalid) { 349 // PathService::Get() returns false and yields an empty path if it fails 350 // to create DIR_USER_DATA. Retrieve the default value manually to display 351 // a more meaningful error to the user in that case. 352 if (user_data_dir.empty()) 353 chrome::GetDefaultUserDataDirectory(&user_data_dir); 354 chrome::SetInvalidSpecifiedUserDataDir(user_data_dir); 355 } 356 357 // The browser process (which is identified by an empty |process_type|) will 358 // handle the error later; other processes that need the dir crash here. 359 CHECK(process_type.empty()) << "Unable to get the user data directory " 360 << "for process type: " << process_type; 361 } 362 363 // Append the fallback user data directory to the commandline. Otherwise, 364 // child or service processes will attempt to use the invalid directory. 365 if (specified_directory_was_invalid) 366 command_line->AppendSwitchPath(switches::kUserDataDir, user_data_dir); 367 } 368 369 } // namespace 370 371 ChromeMainDelegate::ChromeMainDelegate() { 372 #if defined(OS_ANDROID) 373 // On Android the main entry point time is the time when the Java code starts. 374 // This happens before the shared library containing this code is even loaded. 375 // The Java startup code has recorded that time, but the C++ code can't fetch it 376 // from the Java side until it has initialized the JNI. See 377 // ChromeMainDelegateAndroid. 378 #else 379 startup_metric_utils::RecordMainEntryPointTime(); 380 #endif 381 } 382 383 ChromeMainDelegate::~ChromeMainDelegate() { 384 } 385 386 bool ChromeMainDelegate::BasicStartupComplete(int* exit_code) { 387 #if defined(OS_CHROMEOS) 388 chromeos::BootTimesLoader::Get()->SaveChromeMainStats(); 389 #endif 390 391 const CommandLine& command_line = *CommandLine::ForCurrentProcess(); 392 393 #if defined(OS_MACOSX) 394 // Give the browser process a longer treadmill, since crashes 395 // there have more impact. 396 const bool is_browser = !command_line.HasSwitch(switches::kProcessType); 397 ObjcEvilDoers::ZombieEnable(true, is_browser ? 10000 : 1000); 398 399 SetUpBundleOverrides(); 400 chrome::common::mac::EnableCFBundleBlocker(); 401 #endif 402 403 Profiling::ProcessStarted(); 404 405 #if defined(OS_POSIX) 406 if (HandleVersionSwitches(command_line)) { 407 *exit_code = 0; 408 return true; // Got a --version switch; exit with a success error code. 409 } 410 #if !defined(OS_MACOSX) && !defined(OS_CHROMEOS) 411 // This will directly exit if the user asked for help. 412 HandleHelpSwitches(command_line); 413 #endif 414 #endif // OS_POSIX 415 416 #if defined(OS_WIN) 417 // Must do this before any other usage of command line! 418 if (HasDeprecatedArguments(command_line.GetCommandLineString())) { 419 *exit_code = 1; 420 return true; 421 } 422 423 InstallCloseHandleHooks(); 424 #endif 425 426 chrome::RegisterPathProvider(); 427 #if defined(OS_CHROMEOS) 428 chromeos::RegisterPathProvider(); 429 #endif 430 #if !defined(DISABLE_NACL) && defined(OS_LINUX) 431 nacl::RegisterPathProvider(); 432 #endif 433 434 ContentSettingsPattern::SetNonWildcardDomainNonPortScheme( 435 extensions::kExtensionScheme); 436 437 // No support for ANDROID yet as DiagnosticsController needs wchar support. 438 // TODO(gspencer): That's not true anymore, or at least there are no w-string 439 // references anymore. Not sure if that means this can be enabled on Android or 440 // not though. As there is no easily accessible command line on Android, I'm 441 // not sure this is a big deal. 442 #if !defined(OS_ANDROID) && !defined(CHROME_MULTIPLE_DLL_CHILD) 443 // If we are in diagnostics mode this is the end of the line: after the 444 // diagnostics are run the process will invariably exit. 445 if (command_line.HasSwitch(switches::kDiagnostics)) { 446 diagnostics::DiagnosticsWriter::FormatType format = 447 diagnostics::DiagnosticsWriter::HUMAN; 448 if (command_line.HasSwitch(switches::kDiagnosticsFormat)) { 449 std::string format_str = 450 command_line.GetSwitchValueASCII(switches::kDiagnosticsFormat); 451 if (format_str == "machine") { 452 format = diagnostics::DiagnosticsWriter::MACHINE; 453 } else if (format_str == "log") { 454 format = diagnostics::DiagnosticsWriter::LOG; 455 } else { 456 DCHECK_EQ("human", format_str); 457 } 458 } 459 460 diagnostics::DiagnosticsWriter writer(format); 461 *exit_code = diagnostics::DiagnosticsController::GetInstance()->Run( 462 command_line, &writer); 463 diagnostics::DiagnosticsController::GetInstance()->ClearResults(); 464 return true; 465 } 466 #endif 467 468 #if defined(OS_CHROMEOS) 469 // Initialize primary user homedir (in multi-profile session) as it may be 470 // passed as a command line switch. 471 base::FilePath homedir; 472 if (command_line.HasSwitch(chromeos::switches::kHomedir)) { 473 homedir = base::FilePath( 474 command_line.GetSwitchValueASCII(chromeos::switches::kHomedir)); 475 PathService::OverrideAndCreateIfNeeded( 476 base::DIR_HOME, homedir, true, false); 477 } 478 479 // If we are recovering from a crash on ChromeOS, then we will do some 480 // recovery using the diagnostics module, and then continue on. We fake up a 481 // command line to tell it that we want it to recover, and to preserve the 482 // original command line. 483 if (command_line.HasSwitch(chromeos::switches::kLoginUser) || 484 command_line.HasSwitch(switches::kDiagnosticsRecovery)) { 485 486 // The statistics subsystem needs get initialized soon enough for the 487 // statistics to be collected. It's safe to call this more than once. 488 base::StatisticsRecorder::Initialize(); 489 490 CommandLine interim_command_line(command_line.GetProgram()); 491 const char* kSwitchNames[] = {switches::kUserDataDir, }; 492 interim_command_line.CopySwitchesFrom( 493 command_line, kSwitchNames, arraysize(kSwitchNames)); 494 interim_command_line.AppendSwitch(switches::kDiagnostics); 495 interim_command_line.AppendSwitch(switches::kDiagnosticsRecovery); 496 497 diagnostics::DiagnosticsWriter::FormatType format = 498 diagnostics::DiagnosticsWriter::LOG; 499 if (command_line.HasSwitch(switches::kDiagnosticsFormat)) { 500 std::string format_str = 501 command_line.GetSwitchValueASCII(switches::kDiagnosticsFormat); 502 if (format_str == "machine") { 503 format = diagnostics::DiagnosticsWriter::MACHINE; 504 } else if (format_str == "human") { 505 format = diagnostics::DiagnosticsWriter::HUMAN; 506 } else { 507 DCHECK_EQ("log", format_str); 508 } 509 } 510 511 diagnostics::DiagnosticsWriter writer(format); 512 int diagnostics_exit_code = 513 diagnostics::DiagnosticsController::GetInstance()->Run(command_line, 514 &writer); 515 if (diagnostics_exit_code) { 516 // Diagnostics has failed somehow, so we exit. 517 *exit_code = diagnostics_exit_code; 518 return true; 519 } 520 521 // Now we run the actual recovery tasks. 522 int recovery_exit_code = 523 diagnostics::DiagnosticsController::GetInstance()->RunRecovery( 524 command_line, &writer); 525 526 if (recovery_exit_code) { 527 // Recovery has failed somehow, so we exit. 528 *exit_code = recovery_exit_code; 529 return true; 530 } 531 } else { // Not running diagnostics or recovery. 532 diagnostics::DiagnosticsController::GetInstance()->RecordRegularStartup(); 533 } 534 #endif 535 536 content::SetContentClient(&chrome_content_client_); 537 538 return false; 539 } 540 541 #if defined(OS_MACOSX) 542 void ChromeMainDelegate::InitMacCrashReporter( 543 const base::CommandLine& command_line, 544 const std::string& process_type) { 545 // TODO(mark): Right now, InitCrashReporter() needs to be called after 546 // CommandLine::Init() and chrome::RegisterPathProvider(). Ideally, 547 // Breakpad initialization could occur sooner, preferably even before the 548 // framework dylib is even loaded, to catch potential early crashes. 549 breakpad::InitCrashReporter(process_type); 550 551 #if defined(NDEBUG) 552 bool is_debug_build = false; 553 #else 554 bool is_debug_build = true; 555 #endif 556 557 // Details on when we enable Apple's Crash reporter. 558 // 559 // Motivation: 560 // In debug mode it takes Apple's crash reporter eons to generate a crash 561 // dump. 562 // 563 // What we do: 564 // * We only pass crashes for foreground processes to Apple's Crash 565 // reporter. At the time of this writing, that means just the Browser 566 // process. 567 // * If Breakpad is enabled, it will pass browser crashes to Crash Reporter 568 // itself. 569 // * If Breakpad is disabled, we only turn on Crash Reporter for the 570 // Browser process in release mode. 571 if (!command_line.HasSwitch(switches::kDisableBreakpad)) { 572 bool disable_apple_crash_reporter = is_debug_build || 573 base::mac::IsBackgroundOnlyProcess(); 574 if (!breakpad::IsCrashReporterEnabled() && disable_apple_crash_reporter) { 575 base::mac::DisableOSCrashDumps(); 576 } 577 } 578 579 // Mac Chrome is packaged with a main app bundle and a helper app bundle. 580 // The main app bundle should only be used for the browser process, so it 581 // should never see a --type switch (switches::kProcessType). Likewise, 582 // the helper should always have a --type switch. 583 // 584 // This check is done this late so there is already a call to 585 // base::mac::IsBackgroundOnlyProcess(), so there is no change in 586 // startup/initialization order. 587 588 // The helper's Info.plist marks it as a background only app. 589 if (base::mac::IsBackgroundOnlyProcess()) { 590 CHECK(command_line.HasSwitch(switches::kProcessType) && 591 !process_type.empty()) 592 << "Helper application requires --type."; 593 594 // In addition, some helper flavors only work with certain process types. 595 base::FilePath executable; 596 if (PathService::Get(base::FILE_EXE, &executable) && 597 executable.value().size() >= 3) { 598 std::string last_three = 599 executable.value().substr(executable.value().size() - 3); 600 601 if (last_three == " EH") { 602 CHECK(process_type == switches::kPluginProcess || 603 process_type == switches::kUtilityProcess) 604 << "Executable-heap process requires --type=" 605 << switches::kPluginProcess << " or " 606 << switches::kUtilityProcess << ", saw " << process_type; 607 } else if (last_three == " NP") { 608 #if !defined(DISABLE_NACL) 609 CHECK_EQ(switches::kNaClLoaderProcess, process_type) 610 << "Non-PIE process requires --type=" 611 << switches::kNaClLoaderProcess << ", saw " << process_type; 612 #endif 613 } else { 614 #if defined(DISABLE_NACL) 615 CHECK(process_type != switches::kPluginProcess) 616 << "Non-executable-heap PIE process is intolerant of --type=" 617 << switches::kPluginProcess; 618 #else 619 CHECK(process_type != switches::kPluginProcess && 620 process_type != switches::kNaClLoaderProcess) 621 << "Non-executable-heap PIE process is intolerant of --type=" 622 << switches::kPluginProcess << " and " 623 << switches::kNaClLoaderProcess << ", saw " << process_type; 624 #endif 625 } 626 } 627 } else { 628 CHECK(!command_line.HasSwitch(switches::kProcessType) && 629 process_type.empty()) 630 << "Main application forbids --type, saw " << process_type; 631 } 632 633 if (breakpad::IsCrashReporterEnabled()) 634 breakpad::InitCrashProcessInfo(process_type); 635 } 636 #endif // defined(OS_MACOSX) 637 638 void ChromeMainDelegate::PreSandboxStartup() { 639 const CommandLine& command_line = *CommandLine::ForCurrentProcess(); 640 std::string process_type = 641 command_line.GetSwitchValueASCII(switches::kProcessType); 642 643 #if defined(OS_POSIX) 644 crash_reporter::SetCrashReporterClient(g_chrome_crash_client.Pointer()); 645 #endif 646 647 #if defined(OS_MACOSX) 648 // On the Mac, the child executable lives at a predefined location within 649 // the app bundle's versioned directory. 650 PathService::Override(content::CHILD_PROCESS_EXE, 651 chrome::GetVersionedDirectory(). 652 Append(chrome::kHelperProcessExecutablePath)); 653 654 InitMacCrashReporter(command_line, process_type); 655 #endif 656 657 #if defined(OS_WIN) 658 child_process_logging::Init(); 659 #endif 660 #if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX)) 661 // Create an instance of the CPU class to parse /proc/cpuinfo and cache 662 // cpu_brand info. 663 base::CPU cpu_info; 664 #endif 665 666 // Initialize the user data dir for any process type that needs it. 667 if (chrome::ProcessNeedsProfileDir(process_type)) 668 InitializeUserDataDir(); 669 670 // Register component_updater PathProvider after DIR_USER_DATA overidden by 671 // command line flags. Maybe move the chrome PathProvider down here also? 672 component_updater::RegisterPathProvider(chrome::DIR_USER_DATA); 673 674 stats_counter_timer_.reset(new base::StatsCounterTimer("Chrome.Init")); 675 startup_timer_.reset(new base::StatsScope<base::StatsCounterTimer> 676 (*stats_counter_timer_)); 677 678 // Enable Message Loop related state asap. 679 if (command_line.HasSwitch(switches::kMessageLoopHistogrammer)) 680 base::MessageLoop::EnableHistogrammer(true); 681 682 #if !defined(OS_ANDROID) 683 // Android does InitLogging when library is loaded. Skip here. 684 logging::OldFileDeletionState file_state = 685 logging::APPEND_TO_OLD_LOG_FILE; 686 if (process_type.empty()) { 687 file_state = logging::DELETE_OLD_LOG_FILE; 688 } 689 logging::InitChromeLogging(command_line, file_state); 690 #endif 691 692 #if defined(OS_WIN) 693 // TODO(zturner): Throbber icons are still stored in chrome.dll, this can be 694 // killed once those are merged into resources.pak. See 695 // GlassBrowserFrameView::InitThrobberIcons() and http://crbug.com/368327. 696 ui::SetResourcesDataDLL(_AtlBaseModule.GetResourceInstance()); 697 #endif 698 699 if (SubprocessNeedsResourceBundle(process_type)) { 700 // Initialize ResourceBundle which handles files loaded from external 701 // sources. The language should have been passed in to us from the 702 // browser process as a command line flag. 703 #if defined(DISABLE_NACL) 704 DCHECK(command_line.HasSwitch(switches::kLang) || 705 process_type == switches::kZygoteProcess || 706 process_type == switches::kGpuProcess || 707 process_type == switches::kPpapiBrokerProcess || 708 process_type == switches::kPpapiPluginProcess); 709 #else 710 DCHECK(command_line.HasSwitch(switches::kLang) || 711 process_type == switches::kZygoteProcess || 712 process_type == switches::kGpuProcess || 713 process_type == switches::kNaClLoaderProcess || 714 process_type == switches::kPpapiBrokerProcess || 715 process_type == switches::kPpapiPluginProcess); 716 #endif 717 718 // TODO(markusheintz): The command line flag --lang is actually processed 719 // by the CommandLinePrefStore, and made available through the PrefService 720 // via the preference prefs::kApplicationLocale. The browser process uses 721 // the --lang flag to pass the value of the PrefService in here. Maybe 722 // this value could be passed in a different way. 723 const std::string locale = 724 command_line.GetSwitchValueASCII(switches::kLang); 725 #if defined(OS_ANDROID) 726 // The renderer sandbox prevents us from accessing our .pak files directly. 727 // Therefore file descriptors to the .pak files that we need are passed in 728 // at process creation time. 729 int locale_pak_fd = base::GlobalDescriptors::GetInstance()->MaybeGet( 730 kAndroidLocalePakDescriptor); 731 CHECK(locale_pak_fd != -1); 732 ResourceBundle::InitSharedInstanceWithPakFileRegion( 733 base::File(locale_pak_fd), base::MemoryMappedFile::Region::kWholeFile); 734 735 int extra_pak_keys[] = { 736 kAndroidChrome100PercentPakDescriptor, 737 kAndroidUIResourcesPakDescriptor, 738 }; 739 for (size_t i = 0; i < arraysize(extra_pak_keys); ++i) { 740 int pak_fd = 741 base::GlobalDescriptors::GetInstance()->MaybeGet(extra_pak_keys[i]); 742 CHECK(pak_fd != -1); 743 ResourceBundle::GetSharedInstance().AddDataPackFromFile( 744 base::File(pak_fd), ui::SCALE_FACTOR_100P); 745 } 746 747 base::i18n::SetICUDefaultLocale(locale); 748 const std::string loaded_locale = locale; 749 #else 750 const std::string loaded_locale = 751 ui::ResourceBundle::InitSharedInstanceWithLocale( 752 locale, NULL, ui::ResourceBundle::LOAD_COMMON_RESOURCES); 753 754 base::FilePath resources_pack_path; 755 PathService::Get(chrome::FILE_RESOURCES_PACK, &resources_pack_path); 756 ResourceBundle::GetSharedInstance().AddDataPackFromPath( 757 resources_pack_path, ui::SCALE_FACTOR_NONE); 758 #endif 759 CHECK(!loaded_locale.empty()) << "Locale could not be found for " << 760 locale; 761 762 #if !defined(CHROME_MULTIPLE_DLL_BROWSER) 763 if (process_type == switches::kUtilityProcess || 764 process_type == switches::kZygoteProcess) { 765 ChromeContentUtilityClient::PreSandboxStartup(); 766 } 767 #endif 768 } 769 770 #if defined(OS_POSIX) && !defined(OS_MACOSX) 771 // Zygote needs to call InitCrashReporter() in RunZygote(). 772 if (process_type != switches::kZygoteProcess) { 773 #if defined(OS_ANDROID) 774 if (process_type.empty()) 775 breakpad::InitCrashReporter(process_type); 776 else 777 breakpad::InitNonBrowserCrashReporterForAndroid(process_type); 778 #else // !defined(OS_ANDROID) 779 breakpad::InitCrashReporter(process_type); 780 #endif // defined(OS_ANDROID) 781 } 782 #endif // defined(OS_POSIX) && !defined(OS_MACOSX) 783 784 // After all the platform Breakpads have been initialized, store the command 785 // line for crash reporting. 786 crash_keys::SetSwitchesFromCommandLine(&command_line); 787 } 788 789 void ChromeMainDelegate::SandboxInitialized(const std::string& process_type) { 790 startup_timer_->Stop(); // End of Startup Time Measurement. 791 792 // Note: If you are adding a new process type below, be sure to adjust the 793 // AdjustLinuxOOMScore function too. 794 #if defined(OS_LINUX) 795 AdjustLinuxOOMScore(process_type); 796 #endif 797 #if defined(OS_WIN) 798 SuppressWindowsErrorDialogs(); 799 #endif 800 } 801 802 int ChromeMainDelegate::RunProcess( 803 const std::string& process_type, 804 const content::MainFunctionParams& main_function_params) { 805 // ANDROID doesn't support "service", so no ServiceProcessMain, and arraysize 806 // doesn't support empty array. So we comment out the block for Android. 807 #if !defined(OS_ANDROID) 808 static const MainFunction kMainFunctions[] = { 809 #if defined(ENABLE_FULL_PRINTING) && !defined(CHROME_MULTIPLE_DLL_CHILD) 810 { switches::kServiceProcess, ServiceProcessMain }, 811 #endif 812 813 #if defined(OS_MACOSX) 814 { switches::kRelauncherProcess, 815 mac_relauncher::internal::RelauncherMain }, 816 #endif 817 818 // This entry is not needed on Linux, where the NaCl loader 819 // process is launched via nacl_helper instead. 820 #if !defined(DISABLE_NACL) && !defined(CHROME_MULTIPLE_DLL_BROWSER) && \ 821 !defined(OS_LINUX) 822 { switches::kNaClLoaderProcess, NaClMain }, 823 #else 824 { "<invalid>", NULL }, // To avoid constant array of size 0 825 // when DISABLE_NACL and CHROME_MULTIPLE_DLL_CHILD 826 #endif // DISABLE_NACL 827 }; 828 829 for (size_t i = 0; i < arraysize(kMainFunctions); ++i) { 830 if (process_type == kMainFunctions[i].name) 831 return kMainFunctions[i].function(main_function_params); 832 } 833 #endif 834 835 return -1; 836 } 837 838 void ChromeMainDelegate::ProcessExiting(const std::string& process_type) { 839 if (SubprocessNeedsResourceBundle(process_type)) 840 ResourceBundle::CleanupSharedInstance(); 841 #if !defined(OS_ANDROID) 842 logging::CleanupChromeLogging(); 843 #else 844 // Android doesn't use InitChromeLogging, so we close the log file manually. 845 logging::CloseLogFile(); 846 #endif // !defined(OS_ANDROID) 847 848 #if defined(OS_WIN) 849 RemoveCloseHandleHooks(); 850 #endif 851 } 852 853 #if defined(OS_MACOSX) 854 bool ChromeMainDelegate::ProcessRegistersWithSystemProcess( 855 const std::string& process_type) { 856 #if defined(DISABLE_NACL) 857 return false; 858 #else 859 return process_type == switches::kNaClLoaderProcess; 860 #endif 861 } 862 863 bool ChromeMainDelegate::ShouldSendMachPort(const std::string& process_type) { 864 return process_type != switches::kRelauncherProcess && 865 process_type != switches::kServiceProcess; 866 } 867 868 bool ChromeMainDelegate::DelaySandboxInitialization( 869 const std::string& process_type) { 870 #if !defined(DISABLE_NACL) 871 // NaClLoader does this in NaClMainPlatformDelegate::EnableSandbox(). 872 // No sandbox needed for relauncher. 873 if (process_type == switches::kNaClLoaderProcess) 874 return true; 875 #endif 876 return process_type == switches::kRelauncherProcess; 877 } 878 #elif defined(OS_POSIX) && !defined(OS_ANDROID) 879 void ChromeMainDelegate::ZygoteStarting( 880 ScopedVector<content::ZygoteForkDelegate>* delegates) { 881 #if !defined(DISABLE_NACL) 882 nacl::AddNaClZygoteForkDelegates(delegates); 883 #endif 884 } 885 886 void ChromeMainDelegate::ZygoteForked() { 887 Profiling::ProcessStarted(); 888 if (Profiling::BeingProfiled()) { 889 base::debug::RestartProfilingAfterFork(); 890 SetUpProfilingShutdownHandler(); 891 } 892 893 // Needs to be called after we have chrome::DIR_USER_DATA. BrowserMain sets 894 // this up for the browser process in a different manner. 895 const CommandLine* command_line = CommandLine::ForCurrentProcess(); 896 std::string process_type = 897 command_line->GetSwitchValueASCII(switches::kProcessType); 898 breakpad::InitCrashReporter(process_type); 899 900 // Reset the command line for the newly spawned process. 901 crash_keys::SetSwitchesFromCommandLine(command_line); 902 } 903 904 #endif // OS_MACOSX 905 906 #if defined(OS_WIN) 907 bool ChromeMainDelegate::ShouldEnableTerminationOnHeapCorruption() { 908 return !ShouldExperimentallyDisableTerminateOnHeapCorruption(); 909 } 910 #endif // OS_WIN 911 912 content::ContentBrowserClient* 913 ChromeMainDelegate::CreateContentBrowserClient() { 914 #if defined(CHROME_MULTIPLE_DLL_CHILD) 915 return NULL; 916 #else 917 return g_chrome_content_browser_client.Pointer(); 918 #endif 919 } 920 921 content::ContentPluginClient* ChromeMainDelegate::CreateContentPluginClient() { 922 #if defined(CHROME_MULTIPLE_DLL_BROWSER) 923 return NULL; 924 #else 925 return g_chrome_content_plugin_client.Pointer(); 926 #endif 927 } 928 929 content::ContentRendererClient* 930 ChromeMainDelegate::CreateContentRendererClient() { 931 #if defined(CHROME_MULTIPLE_DLL_BROWSER) 932 return NULL; 933 #else 934 return g_chrome_content_renderer_client.Pointer(); 935 #endif 936 } 937 938 content::ContentUtilityClient* 939 ChromeMainDelegate::CreateContentUtilityClient() { 940 #if defined(CHROME_MULTIPLE_DLL_BROWSER) 941 return NULL; 942 #else 943 return g_chrome_content_utility_client.Pointer(); 944 #endif 945 } 946
