browser: Start moving application_lifetime.h functions into chrome namespace.

chrome/browser/lifetime/application_lifetime.cc

 // Copyright (c) 2012 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 "chrome/browser/lifetime/application_lifetime.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/metrics/thread_watcher.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_shutdown.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 68 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();
 #else
   // On most platforms, closing all windows causes the application to exit.
   CloseAllBrowsers();
 #endif
 }
 
-void NotifyAppTerminating() {
-  static bool notified = false;
-  if (notified)
-    return;
-  notified = true;
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_APP_TERMINATING,
-      content::NotificationService::AllSources(),
-      content::NotificationService::NoDetails());
-}
-
-void NotifyAndTerminate(bool fast_path) {
-#if defined(OS_CHROMEOS)
-  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)
-    NotifyAppTerminating();
-
-#if defined(OS_CHROMEOS)
-  if (base::chromeos::IsRunningOnChromeOS()) {
-    // If we're on a ChromeOS device, reboot if an update has been applied,
-    // or else signal the session manager to log out.
-    chromeos::UpdateEngineClient* update_engine_client
-        = chromeos::DBusThreadManager::Get()->GetUpdateEngineClient();
-    if (update_engine_client->GetLastStatus().status ==
-        chromeos::UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT) {
-      update_engine_client->RebootAfterUpdate();
-    } else {
-      chromeos::DBusThreadManager::Get()->GetSessionManagerClient()
-          ->StopSession();
-    }
-  } else {
-    // If running the Chrome OS build, but we're not on the device, act
-    // as if we received signal from SessionManager.
-    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                     base::Bind(&browser::ExitCleanly));
-  }
-#endif
-}
-
-void OnAppExiting() {
-  static bool notified = false;
-  if (notified)
-    return;
-  notified = true;
-  HandleAppExitingForPlatform();
-}
-
 void CloseAllBrowsers() {
   bool session_ending =
       browser_shutdown::GetShutdownType() == browser_shutdown::END_SESSION;
   // Tell everyone that we are shutting down.
   browser_shutdown::SetTryingToQuit(true);
 
 #if defined(ENABLE_SESSION_SERVICE)
   // Before we close the browsers shutdown all session services. That way an
   // exit can restore all browsers open before exiting.
   ProfileManager::ShutdownSessionServices();
 #endif
 
   // 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 (browser_shutdown::ShuttingDownWithoutClosingBrowsers() ||
       BrowserList::empty()) {
-    NotifyAndTerminate(true);
-    OnAppExiting();
+    chrome::NotifyAndTerminate(true);
+    chrome::OnAppExiting();
     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;
@@ skipping 36 matching lines @@
     if (!owner_locale.empty() &&
         state->GetString(prefs::kApplicationLocale) != owner_locale &&
         !state->IsManagedPreference(prefs::kApplicationLocale)) {
       state->SetString(prefs::kApplicationLocale, owner_locale);
       state->CommitPendingWrite();
     }
   }
   g_session_manager_requested_shutdown = false;
   // On ChromeOS, always terminate the browser, regardless of the result of
   // AreAllBrowsersCloseable(). See crbug.com/123107.
-  NotifyAndTerminate(true);
+  chrome::NotifyAndTerminate(true);
 #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);
   AttemptExitInternal();
 #endif
 }
 
 // The Android implementation is in application_lifetime_android.cc
@@ skipping 94 matching lines @@
   // can properly shutdown before we exit.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SESSION_END,
       content::NotificationService::AllSources(),
       content::NotificationService::NoDetails());
 
   // This will end by terminating the process.
   content::ImmediateShutdownAndExitProcess();
 }
 
+}  // namespace browser
+
+namespace chrome {
+
 void StartKeepAlive() {
   // Increment the browser process refcount as long as we're keeping the
   // application alive.
   if (!WillKeepAlive())
     g_browser_process->AddRefModule();
-  ++g_keep_alive_count;
+  ++browser::g_keep_alive_count;
 }
 
 void EndKeepAlive() {
-  DCHECK_GT(g_keep_alive_count, 0);
-  --g_keep_alive_count;
+  DCHECK_GT(browser::g_keep_alive_count, 0);
+  --browser::g_keep_alive_count;
 
   DCHECK(g_browser_process);
   // Although we should have a browser process, if there is none,
   // there is nothing to do.
   if (!g_browser_process) return;
 
   // Allow the app to shutdown again.
   if (!WillKeepAlive()) {
     g_browser_process->ReleaseModule();
     // If there are no browsers open and we aren't already shutting down,
     // initiate a shutdown. Also skips shutdown if this is a unit test
     // (MessageLoop::current() == null).
     if (BrowserList::empty() && !browser_shutdown::IsTryingToQuit() &&
         MessageLoop::current())
-      CloseAllBrowsers();
+      browser::CloseAllBrowsers();
   }
 }
 
 bool WillKeepAlive() {
-  return g_keep_alive_count > 0;
+  return browser::g_keep_alive_count > 0;
 }
 
-}  // namespace browser
+void NotifyAppTerminating() {
+  static bool notified = false;
+  if (notified)
+    return;
+  notified = true;
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_APP_TERMINATING,
+      content::NotificationService::AllSources(),
+      content::NotificationService::NoDetails());
+}
+
+void NotifyAndTerminate(bool fast_path) {
+#if defined(OS_CHROMEOS)
+  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 || browser::g_session_manager_requested_shutdown)
+    return;
+  notified = true;
+#endif
+
+  if (fast_path)
+    NotifyAppTerminating();
+
+#if defined(OS_CHROMEOS)
+  if (base::chromeos::IsRunningOnChromeOS()) {
+    // If we're on a ChromeOS device, reboot if an update has been applied,
+    // or else signal the session manager to log out.
+    chromeos::UpdateEngineClient* update_engine_client
+        = chromeos::DBusThreadManager::Get()->GetUpdateEngineClient();
+    if (update_engine_client->GetLastStatus().status ==
+        chromeos::UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT) {
+      update_engine_client->RebootAfterUpdate();
+    } else {
+      chromeos::DBusThreadManager::Get()->GetSessionManagerClient()
+          ->StopSession();
+    }
+  } else {
+    // If running the Chrome OS build, but we're not on the device, act
+    // as if we received signal from SessionManager.
+    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+                                     base::Bind(&browser::ExitCleanly));
+  }
+#endif
+}
+
+void OnAppExiting() {
+  static bool notified = false;
+  if (notified)
+    return;
+  notified = true;
+  HandleAppExitingForPlatform();
+}
+
+}  // namespace chrome