Chrome OS: Shutdown without blocking when SIGTERM is received.

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 184 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;
 }
 
+// Emits APP_TERMINATING notification. It is guaranteed that the
+// notification is sent only once.
+void NotifyAppTerminating() {
+  static bool notified = false;
+  if (notified)
+    return;
+  notified = true;
+  content::NotificationService::current()->Notify(
+      content::NOTIFICATION_APP_TERMINATING,
+      content::NotificationService::AllSources(),
+      content::NotificationService::NoDetails());
+}
+
 #if defined(OS_CHROMEOS)
 
-bool signout = false;
+// Whether a session manager requested to shutdown.
+bool g_session_manager_requested_shutdown = true;
 
 // 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)
+  static bool notified = false;
+  // Don't ask SessionManager to shutdown if
+  // a) a shutdown request has already been sent.
+  // b) shutdown request comes from session manager.
+  if (notified || g_session_manager_requested_shutdown)
     return;
+  notified = true;
 #endif
 
-  if (fast_path) {
-    content::NotificationService::current()->Notify(
-        content::NOTIFICATION_APP_TERMINATING,
-        content::NotificationService::AllSources(),
-        content::NotificationService::NoDetails());
-  }
+  if (fast_path)
+    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();
     } else {
@@ skipping 42 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.
-    content::NotificationService::current()->Notify(
-        content::NOTIFICATION_APP_TERMINATING,
-        content::NotificationService::AllSources(),
-        content::NotificationService::NoDetails());
+    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() {
   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 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()) {
+  if (browser_shutdown::ShuttingDownWithoutClosingBrowsers() ||
+      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;
     browser->window()->Close();
     if (!session_ending) {
       ++i;
@@ skipping 47 matching lines @@
   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();
     }
   }
+  g_session_manager_requested_shutdown = false;
   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();
 }
@@ skipping 18 matching lines @@
   // 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)
+// A function called when SIGTERM is received.
 // static
 void BrowserList::ExitCleanly() {
-  // We always mark exit cleanly.
+  // We always mark exit cleanly because SessionManager may kill
+  // chrome in 3 seconds after SIGTERM.
   g_browser_process->EndSession();
+
+  // Don't block when SIGTERM is received. AreaAllBrowsersCloseable()
+  // can be false in following cases. a) power-off b) signout from
+  // screen locker.
+  if (!AreAllBrowsersCloseable())
+    browser_shutdown::OnShutdownStarting(browser_shutdown::END_SESSION);
   AttemptExitInternal();
 }
 #endif
 
 static void TimeLimitedSessionEnding() {
   // 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));
@@ skipping 268 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;
 }