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