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 "content/browser/browser_main_loop.h" 6 7 #include "base/bind.h" 8 #include "base/command_line.h" 9 #include "base/debug/trace_event.h" 10 #include "base/file_util.h" 11 #include "base/logging.h" 12 #include "base/message_loop/message_loop.h" 13 #include "base/metrics/field_trial.h" 14 #include "base/metrics/histogram.h" 15 #include "base/path_service.h" 16 #include "base/pending_task.h" 17 #include "base/power_monitor/power_monitor.h" 18 #include "base/power_monitor/power_monitor_device_source.h" 19 #include "base/process/process_metrics.h" 20 #include "base/run_loop.h" 21 #include "base/strings/string_number_conversions.h" 22 #include "base/system_monitor/system_monitor.h" 23 #include "base/threading/thread_restrictions.h" 24 #include "base/timer/hi_res_timer_manager.h" 25 #include "content/browser/browser_thread_impl.h" 26 #include "content/browser/device_orientation/device_motion_service.h" 27 #include "content/browser/download/save_file_manager.h" 28 #include "content/browser/gamepad/gamepad_service.h" 29 #include "content/browser/gpu/browser_gpu_channel_host_factory.h" 30 #include "content/browser/gpu/gpu_data_manager_impl.h" 31 #include "content/browser/gpu/gpu_process_host.h" 32 #include "content/browser/gpu/gpu_process_host_ui_shim.h" 33 #include "content/browser/histogram_synchronizer.h" 34 #include "content/browser/loader/resource_dispatcher_host_impl.h" 35 #include "content/browser/net/browser_online_state_observer.h" 36 #include "content/browser/plugin_service_impl.h" 37 #include "content/browser/renderer_host/media/audio_mirroring_manager.h" 38 #include "content/browser/renderer_host/media/media_stream_manager.h" 39 #include "content/browser/speech/speech_recognition_manager_impl.h" 40 #include "content/browser/startup_task_runner.h" 41 #include "content/browser/tracing/trace_controller_impl.h" 42 #include "content/browser/webui/content_web_ui_controller_factory.h" 43 #include "content/browser/webui/url_data_manager.h" 44 #include "content/public/browser/browser_main_parts.h" 45 #include "content/public/browser/browser_shutdown.h" 46 #include "content/public/browser/compositor_util.h" 47 #include "content/public/browser/content_browser_client.h" 48 #include "content/public/browser/render_process_host.h" 49 #include "content/public/common/content_switches.h" 50 #include "content/public/common/main_function_params.h" 51 #include "content/public/common/result_codes.h" 52 #include "crypto/nss_util.h" 53 #include "media/audio/audio_manager.h" 54 #include "media/base/media.h" 55 #include "media/midi/midi_manager.h" 56 #include "net/base/network_change_notifier.h" 57 #include "net/socket/client_socket_factory.h" 58 #include "net/ssl/ssl_config_service.h" 59 #include "ui/base/clipboard/clipboard.h" 60 61 #if defined(USE_AURA) 62 #include "content/browser/aura/image_transport_factory.h" 63 #endif 64 65 #if defined(OS_ANDROID) 66 #include "base/android/jni_android.h" 67 #include "content/browser/android/browser_startup_config.h" 68 #include "content/browser/android/surface_texture_peer_browser_impl.h" 69 #endif 70 71 #if defined(OS_WIN) 72 #include <windows.h> 73 #include <commctrl.h> 74 #include <shellapi.h> 75 76 #include "base/win/text_services_message_filter.h" 77 #include "content/browser/system_message_window_win.h" 78 #include "content/common/sandbox_win.h" 79 #include "net/base/winsock_init.h" 80 #include "ui/base/l10n/l10n_util_win.h" 81 #endif 82 83 #if defined(OS_LINUX) || defined(OS_OPENBSD) 84 #include <glib-object.h> 85 #endif 86 87 #if defined(OS_LINUX) 88 #include "content/browser/device_monitor_linux.h" 89 #elif defined(OS_MACOSX) && !defined(OS_IOS) 90 #include "content/browser/device_monitor_mac.h" 91 #endif 92 93 #if defined(TOOLKIT_GTK) 94 #include "ui/gfx/gtk_util.h" 95 #endif 96 97 #if defined(OS_POSIX) && !defined(OS_MACOSX) 98 #include <sys/stat.h> 99 100 #include "content/browser/renderer_host/render_sandbox_host_linux.h" 101 #include "content/browser/zygote_host/zygote_host_impl_linux.h" 102 #endif 103 104 #if defined(TCMALLOC_TRACE_MEMORY_SUPPORTED) 105 #include "third_party/tcmalloc/chromium/src/gperftools/heap-profiler.h" 106 #endif 107 108 #if defined(USE_X11) 109 #include <X11/Xlib.h> 110 #endif 111 112 // One of the linux specific headers defines this as a macro. 113 #ifdef DestroyAll 114 #undef DestroyAll 115 #endif 116 117 namespace content { 118 namespace { 119 120 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID) 121 void SetupSandbox(const CommandLine& parsed_command_line) { 122 TRACE_EVENT0("startup", "SetupSandbox"); 123 // TODO(evanm): move this into SandboxWrapper; I'm just trying to move this 124 // code en masse out of chrome_main for now. 125 base::FilePath sandbox_binary; 126 bool env_chrome_devel_sandbox_set = false; 127 struct stat st; 128 129 const bool want_setuid_sandbox = 130 !parsed_command_line.HasSwitch(switches::kNoSandbox) && 131 !parsed_command_line.HasSwitch(switches::kDisableSetuidSandbox); 132 133 if (want_setuid_sandbox) { 134 base::FilePath exe_dir; 135 if (PathService::Get(base::DIR_EXE, &exe_dir)) { 136 base::FilePath sandbox_candidate = exe_dir.AppendASCII("chrome-sandbox"); 137 if (base::PathExists(sandbox_candidate)) 138 sandbox_binary = sandbox_candidate; 139 } 140 141 // In user-managed builds, including development builds, an environment 142 // variable is required to enable the sandbox. See 143 // http://code.google.com/p/chromium/wiki/LinuxSUIDSandboxDevelopment 144 if (sandbox_binary.empty() && 145 stat(base::kProcSelfExe, &st) == 0 && st.st_uid == getuid()) { 146 const char* devel_sandbox_path = getenv("CHROME_DEVEL_SANDBOX"); 147 if (devel_sandbox_path) { 148 env_chrome_devel_sandbox_set = true; 149 sandbox_binary = base::FilePath(devel_sandbox_path); 150 } 151 } 152 153 static const char no_suid_error[] = "Running without the SUID sandbox! See " 154 "https://code.google.com/p/chromium/wiki/LinuxSUIDSandboxDevelopment " 155 "for more information on developing with the sandbox on."; 156 if (sandbox_binary.empty()) { 157 if (!env_chrome_devel_sandbox_set) { 158 // This needs to be fatal. Talk to security (at) chromium.org if you feel 159 // otherwise. 160 LOG(FATAL) << no_suid_error; 161 } 162 163 // TODO(jln): an empty CHROME_DEVEL_SANDBOX environment variable (as 164 // opposed to a non existing one) is not fatal yet. This is needed 165 // because of existing bots and scripts. Fix it (crbug.com/245376). 166 LOG(ERROR) << no_suid_error; 167 } 168 } 169 170 // Tickle the sandbox host and zygote host so they fork now. 171 RenderSandboxHostLinux::GetInstance()->Init(sandbox_binary.value()); 172 ZygoteHostImpl::GetInstance()->Init(sandbox_binary.value()); 173 } 174 #endif 175 176 #if defined(OS_LINUX) || defined(OS_OPENBSD) 177 static void GLibLogHandler(const gchar* log_domain, 178 GLogLevelFlags log_level, 179 const gchar* message, 180 gpointer userdata) { 181 if (!log_domain) 182 log_domain = "<unknown>"; 183 if (!message) 184 message = "<no message>"; 185 186 if (strstr(message, "Loading IM context type") || 187 strstr(message, "wrong ELF class: ELFCLASS64")) { 188 // http://crbug.com/9643 189 // Until we have a real 64-bit build or all of these 32-bit package issues 190 // are sorted out, don't fatal on ELF 32/64-bit mismatch warnings and don't 191 // spam the user with more than one of them. 192 static bool alerted = false; 193 if (!alerted) { 194 LOG(ERROR) << "Bug 9643: " << log_domain << ": " << message; 195 alerted = true; 196 } 197 } else if (strstr(message, "Unable to retrieve the file info for")) { 198 LOG(ERROR) << "GTK File code error: " << message; 199 } else if (strstr(message, "Could not find the icon") && 200 strstr(log_domain, "Gtk")) { 201 LOG(ERROR) << "GTK icon error: " << message; 202 } else if (strstr(message, "Theme file for default has no") || 203 strstr(message, "Theme directory") || 204 strstr(message, "theme pixmap") || 205 strstr(message, "locate theme engine")) { 206 LOG(ERROR) << "GTK theme error: " << message; 207 } else if (strstr(message, "Unable to create Ubuntu Menu Proxy") && 208 strstr(log_domain, "<unknown>")) { 209 LOG(ERROR) << "GTK menu proxy create failed"; 210 } else if (strstr(message, "gtk_drag_dest_leave: assertion")) { 211 LOG(ERROR) << "Drag destination deleted: http://crbug.com/18557"; 212 } else if (strstr(message, "Out of memory") && 213 strstr(log_domain, "<unknown>")) { 214 LOG(ERROR) << "DBus call timeout or out of memory: " 215 << "http://crosbug.com/15496"; 216 } else if (strstr(message, "Could not connect: Connection refused") && 217 strstr(log_domain, "<unknown>")) { 218 LOG(ERROR) << "DConf settings backend could not connect to session bus: " 219 << "http://crbug.com/179797"; 220 } else if (strstr(message, "XDG_RUNTIME_DIR variable not set")) { 221 LOG(ERROR) << message << " (http://bugs.chromium.org/97293)"; 222 } else if (strstr(message, "Attempting to store changes into") || 223 strstr(message, "Attempting to set the permissions of")) { 224 LOG(ERROR) << message << " (http://bugs.chromium.org/161366)"; 225 } else { 226 LOG(DFATAL) << log_domain << ": " << message; 227 } 228 } 229 230 static void SetUpGLibLogHandler() { 231 // Register GLib-handled assertions to go through our logging system. 232 const char* kLogDomains[] = { NULL, "Gtk", "Gdk", "GLib", "GLib-GObject" }; 233 for (size_t i = 0; i < arraysize(kLogDomains); i++) { 234 g_log_set_handler(kLogDomains[i], 235 static_cast<GLogLevelFlags>(G_LOG_FLAG_RECURSION | 236 G_LOG_FLAG_FATAL | 237 G_LOG_LEVEL_ERROR | 238 G_LOG_LEVEL_CRITICAL | 239 G_LOG_LEVEL_WARNING), 240 GLibLogHandler, 241 NULL); 242 } 243 } 244 #endif 245 246 } // namespace 247 248 // The currently-running BrowserMainLoop. There can be one or zero. 249 BrowserMainLoop* g_current_browser_main_loop = NULL; 250 251 // This is just to be able to keep ShutdownThreadsAndCleanUp out of 252 // the public interface of BrowserMainLoop. 253 class BrowserShutdownImpl { 254 public: 255 static void ImmediateShutdownAndExitProcess() { 256 DCHECK(g_current_browser_main_loop); 257 g_current_browser_main_loop->ShutdownThreadsAndCleanUp(); 258 259 #if defined(OS_WIN) 260 // At this point the message loop is still running yet we've shut everything 261 // down. If any messages are processed we'll likely crash. Exit now. 262 ExitProcess(RESULT_CODE_NORMAL_EXIT); 263 #elif defined(OS_POSIX) && !defined(OS_MACOSX) 264 _exit(RESULT_CODE_NORMAL_EXIT); 265 #else 266 NOTIMPLEMENTED(); 267 #endif 268 } 269 }; 270 271 void ImmediateShutdownAndExitProcess() { 272 BrowserShutdownImpl::ImmediateShutdownAndExitProcess(); 273 } 274 275 // For measuring memory usage after each task. Behind a command line flag. 276 class BrowserMainLoop::MemoryObserver : public base::MessageLoop::TaskObserver { 277 public: 278 MemoryObserver() {} 279 virtual ~MemoryObserver() {} 280 281 virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE { 282 } 283 284 virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE { 285 #if !defined(OS_IOS) // No ProcessMetrics on IOS. 286 scoped_ptr<base::ProcessMetrics> process_metrics( 287 base::ProcessMetrics::CreateProcessMetrics( 288 #if defined(OS_MACOSX) 289 base::GetCurrentProcessHandle(), NULL)); 290 #else 291 base::GetCurrentProcessHandle())); 292 #endif 293 size_t private_bytes; 294 process_metrics->GetMemoryBytes(&private_bytes, NULL); 295 HISTOGRAM_MEMORY_KB("Memory.BrowserUsed", private_bytes >> 10); 296 #endif 297 } 298 private: 299 DISALLOW_COPY_AND_ASSIGN(MemoryObserver); 300 }; 301 302 303 // BrowserMainLoop construction / destruction ============================= 304 305 BrowserMainLoop* BrowserMainLoop::GetInstance() { 306 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 307 return g_current_browser_main_loop; 308 } 309 310 BrowserMainLoop::BrowserMainLoop(const MainFunctionParams& parameters) 311 : parameters_(parameters), 312 parsed_command_line_(parameters.command_line), 313 result_code_(RESULT_CODE_NORMAL_EXIT), 314 created_threads_(false) { 315 DCHECK(!g_current_browser_main_loop); 316 g_current_browser_main_loop = this; 317 } 318 319 BrowserMainLoop::~BrowserMainLoop() { 320 DCHECK_EQ(this, g_current_browser_main_loop); 321 #if !defined(OS_IOS) 322 ui::Clipboard::DestroyClipboardForCurrentThread(); 323 #endif // !defined(OS_IOS) 324 g_current_browser_main_loop = NULL; 325 } 326 327 void BrowserMainLoop::Init() { 328 TRACE_EVENT0("startup", "BrowserMainLoop::Init") 329 parts_.reset( 330 GetContentClient()->browser()->CreateBrowserMainParts(parameters_)); 331 } 332 333 // BrowserMainLoop stages ================================================== 334 335 void BrowserMainLoop::EarlyInitialization() { 336 TRACE_EVENT0("startup", "BrowserMainLoop::EarlyInitialization"); 337 #if defined(USE_X11) 338 if (parsed_command_line_.HasSwitch(switches::kSingleProcess) || 339 parsed_command_line_.HasSwitch(switches::kInProcessGPU)) { 340 if (!XInitThreads()) { 341 LOG(ERROR) << "Failed to put Xlib into threaded mode."; 342 } 343 } 344 #endif 345 346 if (parts_) 347 parts_->PreEarlyInitialization(); 348 349 #if defined(OS_WIN) 350 net::EnsureWinsockInit(); 351 #endif 352 353 #if !defined(USE_OPENSSL) 354 // We want to be sure to init NSPR on the main thread. 355 crypto::EnsureNSPRInit(); 356 #endif // !defined(USE_OPENSSL) 357 358 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID) 359 SetupSandbox(parsed_command_line_); 360 #endif 361 362 if (parsed_command_line_.HasSwitch(switches::kEnableSSLCachedInfo)) 363 net::SSLConfigService::EnableCachedInfo(); 364 365 #if !defined(OS_IOS) 366 if (parsed_command_line_.HasSwitch(switches::kRendererProcessLimit)) { 367 std::string limit_string = parsed_command_line_.GetSwitchValueASCII( 368 switches::kRendererProcessLimit); 369 size_t process_limit; 370 if (base::StringToSizeT(limit_string, &process_limit)) { 371 RenderProcessHost::SetMaxRendererProcessCount(process_limit); 372 } 373 } 374 #endif // !defined(OS_IOS) 375 376 if (parts_) 377 parts_->PostEarlyInitialization(); 378 } 379 380 void BrowserMainLoop::MainMessageLoopStart() { 381 TRACE_EVENT0("startup", "BrowserMainLoop::MainMessageLoopStart") 382 if (parts_) { 383 TRACE_EVENT0("startup", 384 "BrowserMainLoop::MainMessageLoopStart:PreMainMessageLoopStart"); 385 parts_->PreMainMessageLoopStart(); 386 } 387 388 #if defined(OS_WIN) 389 // If we're running tests (ui_task is non-null), then the ResourceBundle 390 // has already been initialized. 391 if (!parameters_.ui_task) { 392 // Override the configured locale with the user's preferred UI language. 393 l10n_util::OverrideLocaleWithUILanguageList(); 394 } 395 #endif 396 397 // Create a MessageLoop if one does not already exist for the current thread. 398 if (!base::MessageLoop::current()) 399 main_message_loop_.reset(new base::MessageLoop(base::MessageLoop::TYPE_UI)); 400 401 InitializeMainThread(); 402 403 { 404 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:SystemMonitor") 405 system_monitor_.reset(new base::SystemMonitor); 406 } 407 { 408 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:PowerMonitor") 409 scoped_ptr<base::PowerMonitorSource> power_monitor_source( 410 new base::PowerMonitorDeviceSource()); 411 power_monitor_.reset(new base::PowerMonitor(power_monitor_source.Pass())); 412 } 413 { 414 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:HighResTimerManager") 415 hi_res_timer_manager_.reset(new base::HighResolutionTimerManager); 416 } 417 { 418 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:NetworkChangeNotifier") 419 network_change_notifier_.reset(net::NetworkChangeNotifier::Create()); 420 } 421 422 { 423 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:MediaFeatures") 424 media::InitializeCPUSpecificMediaFeatures(); 425 } 426 { 427 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:AudioMan") 428 audio_manager_.reset(media::AudioManager::Create()); 429 } 430 { 431 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:MIDIManager") 432 midi_manager_.reset(media::MIDIManager::Create()); 433 } 434 435 #if !defined(OS_IOS) 436 { 437 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:ContentWebUIController") 438 WebUIControllerFactory::RegisterFactory( 439 ContentWebUIControllerFactory::GetInstance()); 440 } 441 442 { 443 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:AudioMirroringManager") 444 audio_mirroring_manager_.reset(new AudioMirroringManager()); 445 } 446 447 // Start tracing to a file if needed. 448 if (base::debug::TraceLog::GetInstance()->IsEnabled()) { 449 TRACE_EVENT0("startup", "BrowserMainLoop::InitStartupTracing") 450 TraceControllerImpl::GetInstance()->InitStartupTracing( 451 parsed_command_line_); 452 } 453 454 { 455 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:OnlineStateObserver") 456 online_state_observer_.reset(new BrowserOnlineStateObserver); 457 } 458 #endif // !defined(OS_IOS) 459 460 #if defined(OS_WIN) 461 system_message_window_.reset(new SystemMessageWindowWin); 462 463 if (base::win::IsTSFAwareRequired()) { 464 // Create a TSF message filter for the message loop. MessageLoop takes 465 // ownership of the filter. 466 scoped_ptr<base::win::TextServicesMessageFilter> tsf_message_filter( 467 new base::win::TextServicesMessageFilter); 468 if (tsf_message_filter->Init()) { 469 base::MessageLoopForUI::current()->SetMessageFilter( 470 tsf_message_filter.PassAs<base::MessageLoopForUI::MessageFilter>()); 471 } 472 } 473 #endif 474 475 if (parts_) 476 parts_->PostMainMessageLoopStart(); 477 478 #if defined(OS_ANDROID) 479 { 480 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:SurfaceTexturePeer") 481 SurfaceTexturePeer::InitInstance(new SurfaceTexturePeerBrowserImpl()); 482 } 483 #endif 484 485 if (parsed_command_line_.HasSwitch(switches::kMemoryMetrics)) { 486 TRACE_EVENT0("startup", "BrowserMainLoop::Subsystem:MemoryObserver") 487 memory_observer_.reset(new MemoryObserver()); 488 base::MessageLoop::current()->AddTaskObserver(memory_observer_.get()); 489 } 490 491 #if defined(TCMALLOC_TRACE_MEMORY_SUPPORTED) 492 trace_memory_controller_.reset(new base::debug::TraceMemoryController( 493 base::MessageLoop::current()->message_loop_proxy(), 494 ::HeapProfilerWithPseudoStackStart, 495 ::HeapProfilerStop, 496 ::GetHeapProfile)); 497 #endif 498 } 499 500 int BrowserMainLoop::PreCreateThreads() { 501 502 if (parts_) { 503 TRACE_EVENT0("startup", 504 "BrowserMainLoop::CreateThreads:PreCreateThreads"); 505 result_code_ = parts_->PreCreateThreads(); 506 } 507 508 #if defined(ENABLE_PLUGINS) 509 // Prior to any processing happening on the io thread, we create the 510 // plugin service as it is predominantly used from the io thread, 511 // but must be created on the main thread. The service ctor is 512 // inexpensive and does not invoke the io_thread() accessor. 513 { 514 TRACE_EVENT0("startup", "BrowserMainLoop::CreateThreads:PluginService") 515 PluginService::GetInstance()->Init(); 516 } 517 #endif 518 519 #if !defined(OS_IOS) && (!defined(GOOGLE_CHROME_BUILD) || defined(OS_ANDROID)) 520 // Single-process is an unsupported and not fully tested mode, so 521 // don't enable it for official Chrome builds (except on Android). 522 if (parsed_command_line_.HasSwitch(switches::kSingleProcess)) 523 RenderProcessHost::SetRunRendererInProcess(true); 524 #endif 525 return result_code_; 526 } 527 528 void BrowserMainLoop::CreateStartupTasks() { 529 TRACE_EVENT0("startup", "BrowserMainLoop::CreateStartupTasks") 530 531 #if defined(OS_ANDROID) 532 scoped_refptr<StartupTaskRunner> task_runner = 533 new StartupTaskRunner(BrowserMayStartAsynchronously(), 534 base::Bind(&BrowserStartupComplete), 535 base::MessageLoop::current()->message_loop_proxy()); 536 #else 537 scoped_refptr<StartupTaskRunner> task_runner = 538 new StartupTaskRunner(false, 539 base::Callback<void(int)>(), 540 base::MessageLoop::current()->message_loop_proxy()); 541 #endif 542 StartupTask pre_create_threads = 543 base::Bind(&BrowserMainLoop::PreCreateThreads, base::Unretained(this)); 544 task_runner->AddTask(pre_create_threads); 545 546 StartupTask create_threads = 547 base::Bind(&BrowserMainLoop::CreateThreads, base::Unretained(this)); 548 task_runner->AddTask(create_threads); 549 550 StartupTask browser_thread_started = base::Bind( 551 &BrowserMainLoop::BrowserThreadsStarted, base::Unretained(this)); 552 task_runner->AddTask(browser_thread_started); 553 554 StartupTask pre_main_message_loop_run = base::Bind( 555 &BrowserMainLoop::PreMainMessageLoopRun, base::Unretained(this)); 556 task_runner->AddTask(pre_main_message_loop_run); 557 558 task_runner->StartRunningTasks(); 559 } 560 561 int BrowserMainLoop::CreateThreads() { 562 TRACE_EVENT0("startup", "BrowserMainLoop::CreateThreads"); 563 564 base::Thread::Options default_options; 565 base::Thread::Options io_message_loop_options; 566 io_message_loop_options.message_loop_type = base::MessageLoop::TYPE_IO; 567 base::Thread::Options ui_message_loop_options; 568 ui_message_loop_options.message_loop_type = base::MessageLoop::TYPE_UI; 569 570 // Start threads in the order they occur in the BrowserThread::ID 571 // enumeration, except for BrowserThread::UI which is the main 572 // thread. 573 // 574 // Must be size_t so we can increment it. 575 for (size_t thread_id = BrowserThread::UI + 1; 576 thread_id < BrowserThread::ID_COUNT; 577 ++thread_id) { 578 scoped_ptr<BrowserProcessSubThread>* thread_to_start = NULL; 579 base::Thread::Options* options = &default_options; 580 581 switch (thread_id) { 582 case BrowserThread::DB: 583 TRACE_EVENT_BEGIN1("startup", 584 "BrowserMainLoop::CreateThreads:start", 585 "Thread", "BrowserThread::DB"); 586 thread_to_start = &db_thread_; 587 break; 588 case BrowserThread::FILE_USER_BLOCKING: 589 TRACE_EVENT_BEGIN1("startup", 590 "BrowserMainLoop::CreateThreads:start", 591 "Thread", "BrowserThread::FILE_USER_BLOCKING"); 592 thread_to_start = &file_user_blocking_thread_; 593 break; 594 case BrowserThread::FILE: 595 TRACE_EVENT_BEGIN1("startup", 596 "BrowserMainLoop::CreateThreads:start", 597 "Thread", "BrowserThread::FILE"); 598 thread_to_start = &file_thread_; 599 #if defined(OS_WIN) 600 // On Windows, the FILE thread needs to be have a UI message loop 601 // which pumps messages in such a way that Google Update can 602 // communicate back to us. 603 options = &ui_message_loop_options; 604 #else 605 options = &io_message_loop_options; 606 #endif 607 break; 608 case BrowserThread::PROCESS_LAUNCHER: 609 TRACE_EVENT_BEGIN1("startup", 610 "BrowserMainLoop::CreateThreads:start", 611 "Thread", "BrowserThread::PROCESS_LAUNCHER"); 612 thread_to_start = &process_launcher_thread_; 613 break; 614 case BrowserThread::CACHE: 615 TRACE_EVENT_BEGIN1("startup", 616 "BrowserMainLoop::CreateThreads:start", 617 "Thread", "BrowserThread::CACHE"); 618 thread_to_start = &cache_thread_; 619 options = &io_message_loop_options; 620 break; 621 case BrowserThread::IO: 622 TRACE_EVENT_BEGIN1("startup", 623 "BrowserMainLoop::CreateThreads:start", 624 "Thread", "BrowserThread::IO"); 625 thread_to_start = &io_thread_; 626 options = &io_message_loop_options; 627 break; 628 case BrowserThread::UI: 629 case BrowserThread::ID_COUNT: 630 default: 631 NOTREACHED(); 632 break; 633 } 634 635 BrowserThread::ID id = static_cast<BrowserThread::ID>(thread_id); 636 637 if (thread_to_start) { 638 (*thread_to_start).reset(new BrowserProcessSubThread(id)); 639 (*thread_to_start)->StartWithOptions(*options); 640 } else { 641 NOTREACHED(); 642 } 643 644 TRACE_EVENT_END0("startup", "BrowserMainLoop::CreateThreads:start"); 645 646 } 647 created_threads_ = true; 648 return result_code_; 649 } 650 651 int BrowserMainLoop::PreMainMessageLoopRun() { 652 if (parts_) { 653 TRACE_EVENT0("startup", 654 "BrowserMainLoop::CreateThreads:PreMainMessageLoopRun"); 655 parts_->PreMainMessageLoopRun(); 656 } 657 658 // If the UI thread blocks, the whole UI is unresponsive. 659 // Do not allow disk IO from the UI thread. 660 base::ThreadRestrictions::SetIOAllowed(false); 661 base::ThreadRestrictions::DisallowWaiting(); 662 return result_code_; 663 } 664 665 void BrowserMainLoop::RunMainMessageLoopParts() { 666 TRACE_EVENT_BEGIN_ETW("BrowserMain:MESSAGE_LOOP", 0, ""); 667 668 bool ran_main_loop = false; 669 if (parts_) 670 ran_main_loop = parts_->MainMessageLoopRun(&result_code_); 671 672 if (!ran_main_loop) 673 MainMessageLoopRun(); 674 675 TRACE_EVENT_END_ETW("BrowserMain:MESSAGE_LOOP", 0, ""); 676 } 677 678 void BrowserMainLoop::ShutdownThreadsAndCleanUp() { 679 680 if (!created_threads_) { 681 // Called early, nothing to do 682 return; 683 } 684 // Teardown may start in PostMainMessageLoopRun, and during teardown we 685 // need to be able to perform IO. 686 base::ThreadRestrictions::SetIOAllowed(true); 687 BrowserThread::PostTask( 688 BrowserThread::IO, FROM_HERE, 689 base::Bind(base::IgnoreResult(&base::ThreadRestrictions::SetIOAllowed), 690 true)); 691 692 if (parts_) 693 parts_->PostMainMessageLoopRun(); 694 695 trace_memory_controller_.reset(); 696 697 #if !defined(OS_IOS) 698 // Destroying the GpuProcessHostUIShims on the UI thread posts a task to 699 // delete related objects on the GPU thread. This must be done before 700 // stopping the GPU thread. The GPU thread will close IPC channels to renderer 701 // processes so this has to happen before stopping the IO thread. 702 GpuProcessHostUIShim::DestroyAll(); 703 704 // Cancel pending requests and prevent new requests. 705 if (resource_dispatcher_host_) 706 resource_dispatcher_host_.get()->Shutdown(); 707 708 #if defined(USE_AURA) 709 ImageTransportFactory::Terminate(); 710 #endif 711 712 // The device monitors are using |system_monitor_| as dependency, so delete 713 // them before |system_monitor_| goes away. 714 // On Mac and windows, the monitor needs to be destroyed on the same thread 715 // as they were created. On Linux, the monitor will be deleted when IO thread 716 // goes away. 717 #if defined(OS_WIN) 718 system_message_window_.reset(); 719 #elif defined(OS_MACOSX) 720 device_monitor_mac_.reset(); 721 #endif 722 #endif // !defined(OS_IOS) 723 724 // Must be size_t so we can subtract from it. 725 for (size_t thread_id = BrowserThread::ID_COUNT - 1; 726 thread_id >= (BrowserThread::UI + 1); 727 --thread_id) { 728 // Find the thread object we want to stop. Looping over all valid 729 // BrowserThread IDs and DCHECKing on a missing case in the switch 730 // statement helps avoid a mismatch between this code and the 731 // BrowserThread::ID enumeration. 732 // 733 // The destruction order is the reverse order of occurrence in the 734 // BrowserThread::ID list. The rationale for the order is as 735 // follows (need to be filled in a bit): 736 // 737 // 738 // - The IO thread is the only user of the CACHE thread. 739 // 740 // - The PROCESS_LAUNCHER thread must be stopped after IO in case 741 // the IO thread posted a task to terminate a process on the 742 // process launcher thread. 743 // 744 // - (Not sure why DB stops last.) 745 switch (thread_id) { 746 case BrowserThread::DB: 747 db_thread_.reset(); 748 break; 749 case BrowserThread::FILE_USER_BLOCKING: 750 file_user_blocking_thread_.reset(); 751 break; 752 case BrowserThread::FILE: 753 #if !defined(OS_IOS) 754 // Clean up state that lives on or uses the file_thread_ before 755 // it goes away. 756 if (resource_dispatcher_host_) 757 resource_dispatcher_host_.get()->save_file_manager()->Shutdown(); 758 #endif // !defined(OS_IOS) 759 file_thread_.reset(); 760 break; 761 case BrowserThread::PROCESS_LAUNCHER: 762 process_launcher_thread_.reset(); 763 break; 764 case BrowserThread::CACHE: 765 cache_thread_.reset(); 766 break; 767 case BrowserThread::IO: 768 io_thread_.reset(); 769 break; 770 case BrowserThread::UI: 771 case BrowserThread::ID_COUNT: 772 default: 773 NOTREACHED(); 774 break; 775 } 776 } 777 778 #if !defined(OS_IOS) 779 indexed_db_thread_.reset(); 780 #endif 781 782 // Close the blocking I/O pool after the other threads. Other threads such 783 // as the I/O thread may need to schedule work like closing files or flushing 784 // data during shutdown, so the blocking pool needs to be available. There 785 // may also be slow operations pending that will blcok shutdown, so closing 786 // it here (which will block until required operations are complete) gives 787 // more head start for those operations to finish. 788 BrowserThreadImpl::ShutdownThreadPool(); 789 790 #if !defined(OS_IOS) 791 // Must happen after the IO thread is shutdown since this may be accessed from 792 // it. 793 BrowserGpuChannelHostFactory::Terminate(); 794 795 // Must happen after the I/O thread is shutdown since this class lives on the 796 // I/O thread and isn't threadsafe. 797 GamepadService::GetInstance()->Terminate(); 798 DeviceMotionService::GetInstance()->Shutdown(); 799 800 URLDataManager::DeleteDataSources(); 801 #endif // !defined(OS_IOS) 802 803 if (parts_) 804 parts_->PostDestroyThreads(); 805 } 806 807 void BrowserMainLoop::InitializeMainThread() { 808 TRACE_EVENT0("startup", "BrowserMainLoop::InitializeMainThread") 809 const char* kThreadName = "CrBrowserMain"; 810 base::PlatformThread::SetName(kThreadName); 811 if (main_message_loop_) 812 main_message_loop_->set_thread_name(kThreadName); 813 814 // Register the main thread by instantiating it, but don't call any methods. 815 main_thread_.reset( 816 new BrowserThreadImpl(BrowserThread::UI, base::MessageLoop::current())); 817 } 818 819 int BrowserMainLoop::BrowserThreadsStarted() { 820 TRACE_EVENT0("startup", "BrowserMainLoop::BrowserThreadsStarted") 821 822 #if !defined(OS_IOS) 823 indexed_db_thread_.reset(new base::Thread("IndexedDB")); 824 indexed_db_thread_->Start(); 825 #endif 826 827 #if defined(OS_ANDROID) 828 // Up the priority of anything that touches with display tasks 829 // (this thread is UI thread, and io_thread_ is for IPCs). 830 io_thread_->SetPriority(base::kThreadPriority_Display); 831 base::PlatformThread::SetThreadPriority( 832 base::PlatformThread::CurrentHandle(), 833 base::kThreadPriority_Display); 834 #endif 835 836 #if !defined(OS_IOS) 837 HistogramSynchronizer::GetInstance(); 838 839 BrowserGpuChannelHostFactory::Initialize(); 840 #if defined(USE_AURA) 841 ImageTransportFactory::Initialize(); 842 #endif 843 844 #if defined(OS_LINUX) 845 device_monitor_linux_.reset(new DeviceMonitorLinux()); 846 #elif defined(OS_MACOSX) 847 device_monitor_mac_.reset(new DeviceMonitorMac()); 848 #endif 849 850 // RDH needs the IO thread to be created 851 { 852 TRACE_EVENT0("startup", 853 "BrowserMainLoop::BrowserThreadsStarted:InitResourceDispatcherHost"); 854 resource_dispatcher_host_.reset(new ResourceDispatcherHostImpl()); 855 } 856 857 // MediaStreamManager needs the IO thread to be created. 858 { 859 TRACE_EVENT0("startup", 860 "BrowserMainLoop::BrowserThreadsStarted:InitMediaStreamManager"); 861 media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get())); 862 } 863 864 // Initialize the GpuDataManager before we set up the MessageLoops because 865 // otherwise we'll trigger the assertion about doing IO on the UI thread. 866 GpuDataManagerImpl::GetInstance()->Initialize(); 867 868 { 869 TRACE_EVENT0("startup", 870 "BrowserMainLoop::BrowserThreadsStarted:InitSpeechRecognition"); 871 speech_recognition_manager_.reset(new SpeechRecognitionManagerImpl( 872 audio_manager_.get(), media_stream_manager_.get())); 873 } 874 875 // Alert the clipboard class to which threads are allowed to access the 876 // clipboard: 877 std::vector<base::PlatformThreadId> allowed_clipboard_threads; 878 // The current thread is the UI thread. 879 allowed_clipboard_threads.push_back(base::PlatformThread::CurrentId()); 880 #if defined(OS_WIN) 881 // On Windows, clipboards are also used on the File or IO threads. 882 allowed_clipboard_threads.push_back(file_thread_->thread_id()); 883 allowed_clipboard_threads.push_back(io_thread_->thread_id()); 884 #endif 885 ui::Clipboard::SetAllowedThreads(allowed_clipboard_threads); 886 887 // When running the GPU thread in-process, avoid optimistically starting it 888 // since creating the GPU thread races against creation of the one-and-only 889 // ChildProcess instance which is created by the renderer thread. 890 if (GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(NULL) && 891 IsForceCompositingModeEnabled() && 892 !parsed_command_line_.HasSwitch(switches::kDisableGpuProcessPrelaunch) && 893 !parsed_command_line_.HasSwitch(switches::kSingleProcess) && 894 !parsed_command_line_.HasSwitch(switches::kInProcessGPU)) { 895 TRACE_EVENT_INSTANT0("gpu", "Post task to launch GPU process", 896 TRACE_EVENT_SCOPE_THREAD); 897 BrowserThread::PostTask( 898 BrowserThread::IO, FROM_HERE, base::Bind( 899 base::IgnoreResult(&GpuProcessHost::Get), 900 GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED, 901 CAUSE_FOR_GPU_LAUNCH_BROWSER_STARTUP)); 902 } 903 #endif // !defined(OS_IOS) 904 return result_code_; 905 } 906 907 void BrowserMainLoop::InitializeToolkit() { 908 TRACE_EVENT0("startup", "BrowserMainLoop::InitializeToolkit") 909 // TODO(evan): this function is rather subtle, due to the variety 910 // of intersecting ifdefs we have. To keep it easy to follow, there 911 // are no #else branches on any #ifs. 912 // TODO(stevenjb): Move platform specific code into platform specific Parts 913 // (Need to add InitializeToolkit stage to BrowserParts). 914 #if defined(OS_LINUX) || defined(OS_OPENBSD) 915 // g_type_init will be deprecated in 2.36. 2.35 is the development 916 // version for 2.36, hence do not call g_type_init starting 2.35. 917 // http://developer.gnome.org/gobject/unstable/gobject-Type-Information.html#g-type-init 918 #if !GLIB_CHECK_VERSION(2, 35, 0) 919 // Glib type system initialization. Needed at least for gconf, 920 // used in net/proxy/proxy_config_service_linux.cc. Most likely 921 // this is superfluous as gtk_init() ought to do this. It's 922 // definitely harmless, so retained as a reminder of this 923 // requirement for gconf. 924 g_type_init(); 925 #endif 926 927 #if !defined(USE_AURA) 928 gfx::GtkInitFromCommandLine(parsed_command_line_); 929 #endif 930 931 SetUpGLibLogHandler(); 932 #endif 933 934 #if defined(TOOLKIT_GTK) 935 // It is important for this to happen before the first run dialog, as it 936 // styles the dialog as well. 937 gfx::InitRCStyles(); 938 #endif 939 940 #if defined(OS_WIN) 941 // Init common control sex. 942 INITCOMMONCONTROLSEX config; 943 config.dwSize = sizeof(config); 944 config.dwICC = ICC_WIN95_CLASSES; 945 if (!InitCommonControlsEx(&config)) 946 LOG_GETLASTERROR(FATAL); 947 #endif 948 949 if (parts_) 950 parts_->ToolkitInitialized(); 951 } 952 953 void BrowserMainLoop::MainMessageLoopRun() { 954 #if defined(OS_ANDROID) 955 // Android's main message loop is the Java message loop. 956 NOTREACHED(); 957 #else 958 DCHECK_EQ(base::MessageLoop::TYPE_UI, base::MessageLoop::current()->type()); 959 if (parameters_.ui_task) 960 base::MessageLoopForUI::current()->PostTask(FROM_HERE, 961 *parameters_.ui_task); 962 963 base::RunLoop run_loop; 964 run_loop.Run(); 965 #endif 966 } 967 968 } // namespace content 969
