Add "Keep chrome running in background" preference.

chrome/browser/background_mode_manager.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 <string>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/background_application_list_model.h"
 #include "chrome/browser/background_mode_manager.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/status_icons/status_icon.h"
 #include "chrome/browser/status_icons/status_tray.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_type.h"
@@ skipping 16 matching lines @@
                                              CommandLine* command_line)
     : profile_(profile),
       applications_(profile),
       background_app_count_(0),
       context_menu_(NULL),
       context_menu_application_offset_(0),
       in_background_mode_(false),
       keep_alive_for_startup_(false),
       status_tray_(NULL),
       status_icon_(NULL) {
-  // If background mode is disabled, just exit - don't listen for any
+  // If background mode is currently disabled, just exit - don't listen for any
   // notifications.
-  if (!IsBackgroundModeEnabled(command_line))
+  if (IsBackgroundModePermanentlyDisabled(command_line))
     return;
 
+  // Listen for the background mode preference changing.
+  pref_registrar_.Init(g_browser_process->local_state());
+  pref_registrar_.Add(prefs::kBackgroundModeEnabled, this);
+
   // Keep the browser alive until extensions are done loading - this is needed
   // by the --no-startup-window flag. We want to stay alive until we load
   // extensions, at which point we should either run in background mode (if
   // there are background apps) or exit if there are none.
   if (command_line->HasSwitch(switches::kNoStartupWindow)) {
     keep_alive_for_startup_ = true;
     BrowserList::StartKeepAlive();
   }
 
   // If the -keep-alive-for-test flag is passed, then always keep chrome running
@@ skipping 31 matching lines @@
   // background mode currently). This is primarily needed for unit tests,
   // because in an actual running system we'd get an APP_TERMINATING
   // notification before being destroyed.
   EndBackgroundMode();
 }
 
 void BackgroundModeManager::Observe(NotificationType type,
                                     const NotificationSource& source,
                                     const NotificationDetails& details) {
   switch (type.value) {
+    case NotificationType::PREF_CHANGED:
+      DCHECK(*Details<std::string>(details).ptr() ==
+             prefs::kBackgroundModeEnabled);
+      if (IsBackgroundModePrefEnabled())
+        EnableBackgroundMode();
+      else
+        DisableBackgroundMode();
+      break;
     case NotificationType::EXTENSIONS_READY:
       // Extensions are loaded, so we don't need to manually keep the browser
       // process alive any more when running in no-startup-window mode.
       EndKeepAliveForStartup();
 
       // On a Mac, we use 'login items' mechanism which has user-facing UI so we
       // don't want to stomp on user choice every time we start and load
       // registered extensions. This means that if a background app is removed
       // or added while Chrome is not running, we could leave Chrome in the
       // wrong state, but this is better than constantly forcing Chrome to
@@ skipping 58 matching lines @@
 
 void BackgroundModeManager::OnBackgroundAppLoaded() {
   // When a background app loads, increment our count and also enable
   // KeepAlive mode if the preference is set.
   background_app_count_++;
   if (background_app_count_ == 1)
     StartBackgroundMode();
 }
 
 void BackgroundModeManager::StartBackgroundMode() {
-  // Don't bother putting ourselves in background mode if we're already there.
-  if (in_background_mode_)
+  // Don't bother putting ourselves in background mode if we're already there
+  // or if background mode is disabled.
+  if (in_background_mode_ || !IsBackgroundModePrefEnabled())
     return;
 
   // Mark ourselves as running in background mode.
   in_background_mode_ = true;
 
   // Put ourselves in KeepAlive mode and create a status tray icon.
   BrowserList::StartKeepAlive();
 
   // Display a status icon to exit Chrome.
   CreateStatusTrayIcon();
@@ skipping 11 matching lines @@
 void BackgroundModeManager::EndBackgroundMode() {
   if (!in_background_mode_)
     return;
   in_background_mode_ = false;
 
   // End KeepAlive mode and blow away our status tray icon.
   BrowserList::EndKeepAlive();
   RemoveStatusTrayIcon();
 }
 
+void BackgroundModeManager::EnableBackgroundMode() {
+  // If background mode should be enabled, but isn't, turn it on.
+  if (background_app_count_ > 0 && !in_background_mode_) {
+    StartBackgroundMode();
+    EnableLaunchOnStartup(true);
+  }
+}
+
+void BackgroundModeManager::DisableBackgroundMode() {
+  // If background mode is currently enabled, turn it off.
+  if (in_background_mode_) {
+    EndBackgroundMode();
+    EnableLaunchOnStartup(false);
+  }
+}
+
 void BackgroundModeManager::OnBackgroundAppInstalled(
     const Extension* extension) {
+  // Background mode is disabled - don't do anything.
+  if (!IsBackgroundModePrefEnabled())
+    return;
+
   // We're installing a background app. If this is the first background app
   // being installed, make sure we are set to launch on startup.
   if (background_app_count_ == 0)
     EnableLaunchOnStartup(true);
 
   // Notify the user that a background app has been installed.
   if (extension)  // NULL when called by unit tests.
     DisplayAppInstalledNotification(extension);
 }
 
@@ skipping 57 matching lines @@
        ++cursor, ++position) {
     const SkBitmap* icon = applications_.GetIcon(*cursor);
     DCHECK(position == applications_.GetPosition(*cursor));
     const std::string& name = (*cursor)->name();
     menu->AddItem(position, UTF8ToUTF16(name));
     if (icon)
       menu->SetIcon(menu->GetItemCount() - 1, *icon);
   }
   if (applications_.size() > 0)
     menu->AddSeparator();
+  menu->AddCheckItem(IDC_STATUS_TRAY_KEEP_CHROME_RUNNING_IN_BACKGROUND,
+                     l10n_util::GetStringFUTF16(
+                         IDS_KEEP_CHROME_RUNNING_IN_BACKGROUND,
+                         l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
   menu->AddItemWithStringId(IDC_EXIT, IDS_EXIT);
   context_menu_ = menu;
   status_icon_->SetContextMenu(menu);
 }
 
 bool BackgroundModeManager::IsCommandIdChecked(int command_id) const {
-  return false;
+  DCHECK(command_id == IDC_STATUS_TRAY_KEEP_CHROME_RUNNING_IN_BACKGROUND);
+  return true;
 }
 
 bool BackgroundModeManager::IsCommandIdEnabled(int command_id) const {
   // For now, we do not support disabled items.
   return true;
 }
 
 bool BackgroundModeManager::GetAcceleratorForCommandId(
     int command_id,
     ui::Accelerator* accelerator) {
@@ skipping 27 matching lines @@
     case IDC_EXIT:
       UserMetrics::RecordAction(UserMetricsAction("Exit"));
       BrowserList::CloseAllBrowsersAndExit();
       break;
     case IDC_OPTIONS:
       GetBrowserWindow()->OpenOptionsDialog();
       break;
     case IDC_TASK_MANAGER:
       GetBrowserWindow()->OpenTaskManager(true);
       break;
+    case IDC_STATUS_TRAY_KEEP_CHROME_RUNNING_IN_BACKGROUND: {
+      // Background mode must already be enabled (as otherwise this menu would
+      // not be visible).
+      DCHECK(IsBackgroundModePrefEnabled());
+      DCHECK(BrowserList::WillKeepAlive());
+      if (BrowserList::size() == 0) {
+        // There are no windows open - unchecking this will exit Chrome. Warn
+        // the user.
+        if (!platform_util::SimpleYesNoBox(
+                NULL,
+                l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
+                l10n_util::GetStringFUTF16(
+                    IDS_CONFIRM_EXIT_BACKGROUND_MODE_BODY,
+                    GetPreferencesMenuLabel()))) {
+          return;
+        }
+      }
+
+      // Set the background mode pref to "disabled" - the resulting notification
+      // will result in a call to DisableBackgroundMode().
+      PrefService* service = g_browser_process->local_state();
+      DCHECK(service);
+      service->SetBoolean(prefs::kBackgroundModeEnabled, false);
+      break;
+    }
     default:
       ExecuteApplication(item);
       break;
   }
 }
 
 Browser* BackgroundModeManager::GetBrowserWindow() {
   Browser* browser = BrowserList::GetLastActive();
   if (!browser) {
     Browser::OpenEmptyWindow(profile_);
     browser = BrowserList::GetLastActive();
   }
   return browser;
 }
 
 // static
-bool BackgroundModeManager::IsBackgroundModeEnabled(
+bool BackgroundModeManager::IsBackgroundModePermanentlyDisabled(
     const CommandLine* command_line) {
 
   // Background mode is disabled if the appropriate flag is passed, or if
-  // extensions are disabled. It's always disabled on chromeos since chrome
-  // is always running on that platform, making it superfluous.
+  // extensions are disabled, or if the associated preference is unset. It's
+  // always disabled on chromeos since chrome is always running on that
+  // platform, making it superfluous.
 #if defined(OS_CHROMEOS)
-  return false;
+  return true;
 #else
-  bool background_mode_enabled =
-      !command_line->HasSwitch(switches::kDisableBackgroundMode) &&
-      !command_line->HasSwitch(switches::kDisableExtensions);
-  return background_mode_enabled;
+  bool background_mode_disabled =
+      command_line->HasSwitch(switches::kDisableBackgroundMode) ||
+      command_line->HasSwitch(switches::kDisableExtensions);
+  return background_mode_disabled;
 #endif
 }
 
+bool BackgroundModeManager::IsBackgroundModePrefEnabled() {
+  PrefService* service = g_browser_process->local_state();
+  DCHECK(service);
+  return service->GetBoolean(prefs::kBackgroundModeEnabled);
+}
+
 // static
 void BackgroundModeManager::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kUserCreatedLoginItem, false);
+  prefs->RegisterBooleanPref(prefs::kBackgroundModeEnabled, true);
 }