Shutdown

chrome/browser/ui/browser_list.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/browser_list.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "build/build_config.h"
@@ skipping 22 matching lines @@
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/login_library.h"
 #include "chrome/browser/chromeos/cros/update_library.h"
 #if defined(TOOLKIT_USES_GTK)
 #include "chrome/browser/chromeos/wm_ipc.h"
 #endif
 #endif
 
 namespace {
 
+// ********************* IMPORTANT ****************
+// Please read and update if you need to change the quit/shutdown
+// process.
+//
+// This is an attempt to descritbe different kinds of quit/shutdown
+// process that chrome may process. This overs only Windows and Linux
+// because I (oshima) don't know about mac. Mac contribution to this
+// comment would be greatly appreciated.
+//
+// Common behavior.
+//   APP_EXITING notification is always sent when chrome starts shutdown
+//   process (with one exception. see ChromeOS guest mode below).
+//   Note that shutdown process can be canceled, so APP_EXITING may
+//   be sent MORE THAN ONCE.
+// 
+// Normal shutdown on Linux & Windows
+//     A user requested to quit the browser (win: by wrench menu or
+//     ctrl-alt-q, or linux:wrench menu, ctrl-alt-q or SIGTERM). 
+//     It notifies APP_EXITING, then tries to close all browsers.
+//     When the last browser gets deleted, it sends out APP_TERMINATING
+//     notification as a signal that browser is really quitting.
+//     Shutdown may be blocked and canceled by beforeunload handler or
+//     downloads in progress. (in which case, APP_TERMINATING won't be sent)
+//
+// Restart on Linux & Windows
+//     A user requested to restart the browser. This can happen when
+//     certain preference has changed (flags page, language option), or
+//     update is availabe. Chrome sets kRestartLastSessionOnShutdown
+//     preference to true, follows normal shutdown process and re-launches
+//     itself at the end of the process (see browser_shutdown::Shutdown()).
+//
+// Logoff/power off on Windows
+//     This happens when chrome recieves WM_ENDSESSION message. It
+//     notifies APP_EXITING, then close all tabs forcibly. This
+//     process does send APP_TERMINATING notification. This shutdown
+//     process cannot be blocked nor canceled.
+//
+// X IO Error on Linux and ChromeOS:
+//     When X server reports IO error, it's most likely X has gone away and
+//     chrome needs has to shutdown without make another call to X.
+//     This is similar to Window's logoff/power off process, except that
+//     chrome doesn't try to close browsers nor tabs. APP_TERMINATING is sent
+//     after APP_EXITING.
+//
+// ChromeOS specific:
+//   Fast shutdown
+//     When a user requested to quit browser either by wrench menu or
+//     ctrl-alt-q, and we know that shutdown will not be canceled (that is,
+//     all contents have no beforeunload handlers and there is no
+//     downloads in progress), chrome quits using fast shutdown process.
+//     It notifies APP_EXITING, followed by APP_TERMINATING, then
+//     tells SessionManager to start shutdown process. SessionManager sends
+//     SIGTERM back to chrome, which closes all browsers.
+//
+//   Slow shutdown
+//     If there is a tab with beforeunload handlers, or a download is
+//     in progress, it will follow normal shutdown process. That is,
+//     it notifies APP_EXITING, tries to closes all browsers. APP_TERMINATING
+//     will be sent when the last browser is closd. Shutdown may be cancelled
+//     either by beforeunload handler or download dialog.
+//
+//   Restart
+//     ChromeOS does not support restarting. It follows regular shutdown process,
+//      
+//   Power off
+//     A user pressed power button, or closed a lid on login screen. This is
+//     similar to Windows log-off/power-off scenario. Chrome receives SIGTERM
+//     and start shutdown process. It will close all tabs forcibly and shutdown
+//     cannot be canceled.
+//
+//   Signout from Screen locker.
+//     A user clicked signout button on screen locker. This is basically same
+//     as Power off. Chrome asks session manager to stop session and session
+//     manager sends SIGTERM to chrome.
+//
+//   Switching to Guest mode
+//     When a user selected guest mode, Chrome first writes exit_cleanly bit
+//     off to the disk (see g_browser_process->EndSession() in
+//     chromeos/login_utils.cc), then tells SessionManager to switch to guest
+//     mode. Session manager kills and restarts Chrome with guest mode flag.
+//     This process never use method in BrowserList, nor sends APP_EXITING
+//     or APP_TERMINATING (to restart fast).
+//
+// Note that different shutdown path
+//
+// Mac:
+//    T.B.D.
+//
+
 // This object is instantiated when the first Browser object is added to the
 // list and delete when the last one is removed. It watches for loads and
 // creates histograms of some global object counts.
 class BrowserActivityObserver : public NotificationObserver {
  public:
   BrowserActivityObserver() {
     registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                    NotificationService::AllSources());
   }
   ~BrowserActivityObserver() {}
@@ skipping 141 matching lines @@
     (*i)->CheckDownloadsInProgress(&normal_downloads_are_present,
                                    &incognito_downloads_are_present);
     if (normal_downloads_are_present ||
         incognito_downloads_are_present ||
         (*i)->TabsNeedBeforeUnloadFired())
       return false;
   }
   return true;
 }
 
+// Sends out NOTIFICATION_APP_TERMINATING notification.
+// Returns true if the notification is set, or false if the notification
+// has already sent out before.
+bool NotifyAppTerminating() {
+  static bool notified = false;
+  if (notified)
+    return false;
+  notified = true;
+  NotificationService::current()->Notify(
+      content::NOTIFICATION_APP_TERMINATING,
+      NotificationService::AllSources(),
+      NotificationService::NoDetails());
+  return true;
+}
+
 #if defined(OS_CHROMEOS)
 
-bool signout = false;
+bool explicit_signout = false;
 
 // Fast shutdown for ChromeOS. It tells session manager to start
 // shutdown process when closing browser windows won't be canceled.
 // Returns true if fast shutdown is successfully started.
 bool FastShutdown() {
-  signout = true;
   if (chromeos::CrosLibrary::Get()->EnsureLoaded()
       && AreAllBrowsersCloseable()) {
     BrowserList::NotifyAndTerminate(true);
     return true;
   }
   return false;
 }
 
 void NotifyWindowManagerAboutSignout() {
 #if defined(TOOLKIT_USES_GTK)
@@ skipping 57 matching lines @@
   // On the Mac, the application continues to run once all windows are closed.
   // Terminate will result in a CloseAllBrowsers() call, and once (and if)
   // that is done, will cause the application to exit cleanly.
   chrome_browser_application_mac::Terminate();
 #endif
 }
 
 // static
 void BrowserList::NotifyAndTerminate(bool fast_path) {
 #if defined(OS_CHROMEOS)
-  if (!signout)
+  if (browser_shutdown::ShutdownType() != browser_shutdown::BROWSER_EXIT);
     return;
 #endif
 
   if (fast_path) {
-    NotificationService::current()->Notify(
-        content::NOTIFICATION_APP_TERMINATING,
-        NotificationService::AllSources(),
-        NotificationService::NoDetails());
+    NotifyAppTerminating();
   }
 
 #if defined(OS_CHROMEOS)
   NotifyWindowManagerAboutSignout();
   chromeos::CrosLibrary* cros_library = chromeos::CrosLibrary::Get();
   if (cros_library->EnsureLoaded()) {
     // If update has been installed, reboot, otherwise, sign out.
     if (cros_library->GetUpdateLibrary()->status().status ==
           chromeos::UPDATE_STATUS_UPDATED_NEED_REBOOT) {
       cros_library->GetUpdateLibrary()->RebootAfterUpdate();
@@ skipping 41 matching lines @@
   // If we're exiting, send out the APP_TERMINATING notification to allow other
   // modules to shut themselves down.
   if (browsers_.empty() &&
       (browser_shutdown::IsTryingToQuit() ||
        g_browser_process->IsShuttingDown())) {
     // Last browser has just closed, and this is a user-initiated quit or there
     // is no module keeping the app alive, so send out our notification. No need
     // to call ProfileManager::ShutdownSessionServices() as part of the
     // shutdown, because Browser::WindowClosing() already makes sure that the
     // SessionService is created and notified.
-    NotificationService::current()->Notify(
-        content::NOTIFICATION_APP_TERMINATING,
-        NotificationService::AllSources(),
-        NotificationService::NoDetails());
+    // On ChromeOS, APP_TERMINATING might have already been sent when
+    // shutdown is first requested. The call will be ignored in that case.
+    NotifyAppTerminating();
     AllBrowsersClosedAndAppExiting();
   }
 }
 
 // static
 void BrowserList::AddObserver(BrowserList::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 // static
 void BrowserList::RemoveObserver(BrowserList::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 // static
 void BrowserList::CloseAllBrowsers() {
+  browser_shutdown::ShutdownType shutdown_type =
+    browser_shutdown::GetShutdownType()
+  /*
   bool session_ending =
       browser_shutdown::GetShutdownType() == browser_shutdown::END_SESSION;
   bool force_exit = false;
 #if defined(USE_X11)
   if (session_ending)
     force_exit = true;
 #endif
+  */
   // Tell everyone that we are shutting down.
   browser_shutdown::SetTryingToQuit(true);
 
   // Before we close the browsers shutdown all session services. That way an
   // exit can restore all browsers open before exiting.
   ProfileManager::ShutdownSessionServices();
 
+  // If we're not closing browser, send APP_TERMINATING
+  if (shutdown_type == browser_shutdown::SHUTDOWN_WITHOUT_CLOSE) {
+    NotifyAppTerminating();
+    return;
+  }
+
   // If there are no browsers, send the APP_TERMINATING action here. Otherwise,
   // it will be sent by RemoveBrowser() when the last browser has closed.
   if (force_exit || browsers_.empty()) {
     NotifyAndTerminate(true);
     return;
   }
+
 #if defined(OS_CHROMEOS)
   chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker(
       "StartedClosingWindows", false);
 #endif
+
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end();) {
     Browser* browser = *i;

[achuithb, 2011/10/28 22:22:26]

Do you think you could also clean this loop up if possible? It's quite difficult
to read.

     browser->window()->Close();
-    if (!session_ending) {
+    if (shutdown_type != browser_shutdown::POWER_OFF) {
       ++i;
     } else {
       // This path is hit during logoff/power-down. In this case we won't get
       // a final message and so we force the browser to be deleted.
       // Close doesn't immediately destroy the browser
       // (Browser::TabStripEmpty() uses invoke later) but when we're ending the
       // session we need to make sure the browser is destroyed now. So, invoke
       // DestroyBrowser to make sure the browser is deleted and cleanup can
       // happen.
       while (browser->tab_count())
@@ skipping 21 matching lines @@
   }
 
   for (BrowserVector::const_iterator i = browsers_to_close.begin();
        i != browsers_to_close.end(); ++i) {
     (*i)->window()->Close();
   }
 }
 
 // static
 void BrowserList::AttemptUserExit() {
+  browser_shutdown::OnShutdownStarting(browser_shutdown::BROWSER_EXIT);
 #if defined(OS_CHROMEOS)
   chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker("LogoutStarted", false);
   // Write /tmp/uptime-logout-started as well.
   const char kLogoutStarted[] = "logout-started";
   chromeos::BootTimesLoader::Get()->RecordCurrentStats(kLogoutStarted);
 
   // Login screen should show up in owner's locale.
   PrefService* state = g_browser_process->local_state();
   if (state) {
     std::string owner_locale = state->GetString(prefs::kOwnerLocale);
     if (!owner_locale.empty() &&
         state->GetString(prefs::kApplicationLocale) != owner_locale &&
         !state->IsManagedPreference(prefs::kApplicationLocale)) {
       state->SetString(prefs::kApplicationLocale, owner_locale);
       state->SavePersistentPrefs();
     }
   }
+  
   if (FastShutdown())
     return;
 #else
   // Reset the restart bit that might have been set in cancelled restart
   // request.
   PrefService* pref_service = g_browser_process->local_state();
   pref_service->SetBoolean(prefs::kRestartLastSessionOnShutdown, false);
 #endif
   AttemptExitInternal();
 }
 
 // static
 void BrowserList::AttemptRestart() {
 #if defined(OS_CHROMEOS)
   // For CrOS instead of browser restart (which is not supported) perform a full
   // sign out. Session will be only restored if user has that setting set.
   // Same session restore behavior happens in case of full restart after update.
+  // TODO(oshima): Should we use LoginLibrary::RestartJob()?
   AttemptUserExit();
 #else
   // Set the flag to restore state after the restart.
   PrefService* pref_service = g_browser_process->local_state();
   pref_service->SetBoolean(prefs::kRestartLastSessionOnShutdown, true);
   AttemptExit();
 #endif
 }
 
 // static
 void BrowserList::AttemptExit() {
   // If we know that all browsers can be closed without blocking,
   // don't notify users of crashes beyond this point.
   // Note that MarkAsCleanShutdown does not set UMA's exit cleanly bit
   // so crashes during shutdown are still reported in UMA.
   if (AreAllBrowsersCloseable())
     MarkAsCleanShutdown();
   AttemptExitInternal();
 }
 
 #if defined(OS_CHROMEOS)
 // static
 void BrowserList::ExitCleanly() {
   // We always mark exit cleanly.
   g_browser_process->EndSession();
+  if (AreAllBrowsersCloseable())
+    
   AttemptExitInternal();
 }
 #endif
 
-static void TimeLimitedSessionEnding() {
+static void TimeLimitedForceShutdown(browser_shutdown::ShutdownType type) {
   // Start watching for hang during shutdown, and crash it if takes too long.
   // We disarm when |shutdown_watcher| object is destroyed, which is when we
   // exit this function.
   ShutdownWatcherHelper shutdown_watcher;
   shutdown_watcher.Arm(base::TimeDelta::FromSeconds(90));
 
   // EndSession is invoked once per frame. Only do something the first time.
   static bool already_ended = false;
   // We may get called in the middle of shutdown, e.g. http://crbug.com/70852
   // In this case, do nothing.
   if (already_ended || !NotificationService::current())
     return;
   already_ended = true;
-
-  browser_shutdown::OnShutdownStarting(browser_shutdown::END_SESSION);
+  
+  browser_shutdown::OnShutdownStarting(type);
 
   NotificationService::current()->Notify(
       content::NOTIFICATION_APP_EXITING,
       NotificationService::AllSources(),
       NotificationService::NoDetails());
 
   // Write important data first.
   g_browser_process->EndSession();
 
   BrowserList::CloseAllBrowsers();
 
   // Send out notification. This is used during testing so that the test harness
   // can properly shutdown before we exit.
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_SESSION_END,
       NotificationService::AllSources(),
       NotificationService::NoDetails());
 
   // And shutdown.
   browser_shutdown::Shutdown();
 }
 
 // static
-void BrowserList::SessionEnding() {
-  TimeLimitedSessionEnding();
+void BrowserList::ForceShutdown(SessionEndingReason raeson) {
+  TimeLimitedForceShutdown(reason);
 
 #if defined(OS_WIN)
   // At this point the message loop is still running yet we've shut everything
   // down. If any messages are processed we'll likely crash. Exit now.
   ExitProcess(content::RESULT_CODE_NORMAL_EXIT);
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
   _exit(content::RESULT_CODE_NORMAL_EXIT);
 #else
   NOTIMPLEMENTED();
 #endif
@@ skipping 223 matching lines @@
   // If no more TabContents from Browsers, check the BackgroundPrintingManager.
   while (bg_printing_iterator_ != GetBackgroundPrintingManager()->end()) {
     cur_ = *bg_printing_iterator_;
     CHECK(cur_);
     ++bg_printing_iterator_;
     return;
   }
   // Reached the end - no more TabContents.
   cur_ = NULL;
 }