Leave apps running on Windows and Linux when quitting Chrome from the wrench menu.

chrome/browser/background/background_mode_manager.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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/status_icons/status_icon.h"
 #include "chrome/browser/status_icons/status_tray.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 98 matching lines @@
 BackgroundModeManager::BackgroundModeManager(
     CommandLine* command_line,
     ProfileInfoCache* profile_cache)
     : profile_cache_(profile_cache),
       status_tray_(NULL),
       status_icon_(NULL),
       context_menu_(NULL),
       in_background_mode_(false),
       keep_alive_for_startup_(false),
       keep_alive_for_test_(false),
+      background_mode_suspended_(false),
+      keeping_alive_(false),
       current_command_id_(0) {
   // We should never start up if there is no browser process or if we are
   // currently quitting.
   CHECK(g_browser_process != NULL);
   CHECK(!browser_shutdown::IsTryingToQuit());
 
   // Add self as an observer for the profile info cache so we know when profiles
   // are deleted and their names change.
   profile_cache_->AddObserver(this);
 
   // Listen for the background mode preference changing.
   if (g_browser_process->local_state()) {  // Skip for unit tests
     pref_registrar_.Init(g_browser_process->local_state());
     pref_registrar_.Add(
         prefs::kBackgroundModeEnabled,
         base::Bind(&BackgroundModeManager::OnBackgroundModeEnabledPrefChanged,
                    base::Unretained(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;
     chrome::StartKeepAlive();
+  } else {
+    // Otherwise, start with background mode suspended in case we're launching
+    // in a mode that doesn't open a browser window. It will be resumed when the
+    // first browser window is opened.
+    SuspendBackgroundMode();
   }
 
   // If the -keep-alive-for-test flag is passed, then always keep chrome running
   // in the background until the user explicitly terminates it.
   if (command_line->HasSwitch(switches::kKeepAliveForTest))
     keep_alive_for_test_ = true;
 
   if (ShouldBeInBackgroundMode())
     StartBackgroundMode();
 
   // Listen for the application shutting down so we can decrement our KeepAlive
   // count.
   registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
+  BrowserList::AddObserver(this);
 }
 
 BackgroundModeManager::~BackgroundModeManager() {
   // Remove ourselves from the application observer list (only needed by unit
   // tests since APP_TERMINATING is what does this in a real running system).
   for (BackgroundModeInfoMap::iterator it =
        background_mode_data_.begin();
        it != background_mode_data_.end();
        ++it) {
     it->second->applications_->RemoveObserver(this);
   }
+  BrowserList::RemoveObserver(this);
 
   // We're going away, so exit background mode (does nothing if we aren't in
   // 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();
 }
 
 // static
 void BackgroundModeManager::RegisterPrefs(PrefRegistrySimple* registry) {
@@ skipping 238 matching lines @@
   BackgroundModeData* bmd = background_mode_data_.begin()->second.get();
   switch (command_id) {
     case IDC_ABOUT:
       chrome::ShowAboutChrome(bmd->GetBrowserWindow());
       break;
     case IDC_TASK_MANAGER:
       chrome::OpenTaskManager(bmd->GetBrowserWindow());
       break;
     case IDC_EXIT:
       content::RecordAction(UserMetricsAction("Exit"));
-      chrome::AttemptExit();
+      chrome::CloseAllBrowsers();
       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(chrome::WillKeepAlive());
 
       // Set the background mode pref to "disabled" - the resulting notification
       // will result in a call to DisableBackgroundMode().
       PrefService* service = g_browser_process->local_state();
@@ skipping 24 matching lines @@
 void BackgroundModeManager::StartBackgroundMode() {
   DCHECK(ShouldBeInBackgroundMode());
   // Don't bother putting ourselves in background mode if we're already there
   // or if background mode is disabled.
   if (in_background_mode_)
     return;
 
   // Mark ourselves as running in background mode.
   in_background_mode_ = true;
 
-  // Put ourselves in KeepAlive mode and create a status tray icon.
-  chrome::StartKeepAlive();
-
-  // Display a status icon to exit Chrome.
-  InitStatusTrayIcon();
+  UpdateKeepAliveAndTrayIcon();
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BACKGROUND_MODE_CHANGED,
       content::Source<BackgroundModeManager>(this),
       content::Details<bool>(&in_background_mode_));
 }
 
-void BackgroundModeManager::InitStatusTrayIcon() {
-  // Only initialize status tray icons for those profiles which actually
-  // have a background app running.
-  if (ShouldBeInBackgroundMode())
-    CreateStatusTrayIcon();
-}
-
 void BackgroundModeManager::EndBackgroundMode() {
   if (!in_background_mode_)
     return;
   in_background_mode_ = false;
 
-  // End KeepAlive mode and blow away our status tray icon.
-  chrome::EndKeepAlive();
+  UpdateKeepAliveAndTrayIcon();
 
-  RemoveStatusTrayIcon();
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BACKGROUND_MODE_CHANGED,
       content::Source<BackgroundModeManager>(this),
       content::Details<bool>(&in_background_mode_));
 }
 
 void BackgroundModeManager::EnableBackgroundMode() {
   DCHECK(IsBackgroundModePrefEnabled());
   // If background mode should be enabled, but isn't, turn it on.
   if (!in_background_mode_ && ShouldBeInBackgroundMode()) {
     StartBackgroundMode();
     EnableLaunchOnStartup(true);
   }
 }
 
 void BackgroundModeManager::DisableBackgroundMode() {
   DCHECK(!IsBackgroundModePrefEnabled());
   // If background mode is currently enabled, turn it off.
   if (in_background_mode_) {
     EndBackgroundMode();
     EnableLaunchOnStartup(false);
   }
 }
 
+void BackgroundModeManager::SuspendBackgroundMode() {
+  background_mode_suspended_ = true;
+  UpdateKeepAliveAndTrayIcon();
+}
+
+void BackgroundModeManager::ResumeBackgroundMode() {
+  background_mode_suspended_ = false;
+  UpdateKeepAliveAndTrayIcon();
+}
+
+void BackgroundModeManager::UpdateKeepAliveAndTrayIcon() {
+  if (in_background_mode_ && !background_mode_suspended_) {
+    if (!keeping_alive_) {
+      keeping_alive_ = true;
+      chrome::StartKeepAlive();
+    }
+    CreateStatusTrayIcon();
+    return;
+  }
+
+  RemoveStatusTrayIcon();
+  if (keeping_alive_) {
+    keeping_alive_ = false;
+    chrome::EndKeepAlive();
+  }
+}
+
+void BackgroundModeManager::OnBrowserAdded(Browser* browser) {
+  ResumeBackgroundMode();
+}
+
 int BackgroundModeManager::GetBackgroundAppCount() const {
   int count = 0;
   // Walk the BackgroundModeData for all profiles and count the number of apps.
   for (BackgroundModeInfoMap::const_iterator it =
        background_mode_data_.begin();
        it != background_mode_data_.end();
        ++it) {
     count += it->second->GetBackgroundAppCount();
   }
   DCHECK(count >= 0);
@@ skipping 10 matching lines @@
   return IsBackgroundModePrefEnabled() &&
       (GetBackgroundAppCount() > 0 || keep_alive_for_test_);
 }
 
 void BackgroundModeManager::OnBackgroundAppInstalled(
     const Extension* extension) {
   // Background mode is disabled - don't do anything.
   if (!IsBackgroundModePrefEnabled())
     return;
 
-  // Check if we need a status tray icon and make one if we do (needed so we
-  // can display the app-installed notification below).
-  CreateStatusTrayIcon();
+  // Ensure we have a tray icon (needed so we can display the app-installed
+  // notification below).
+  ResumeBackgroundMode();
+
+  // If we don't have a status icon or one could not be created succesfully,
+  // then we won't notify the user.
+  if (!status_icon_)
+    return;

[Andrew T Wilson (Slow), 2013/10/25 11:32:44]

I'm still not sure about this change. I think we ought to try to display the
notification no matter what - it seems really bad to allow a background app to
get installed and not display it.

What specific use case is this if statement addressing? 

[Sam McNally, 2013/10/28 00:24:55]

I thought it was from before, but it wasn't. Removed it.

 
   // Notify the user that a background app has been installed.
   if (extension) {  // NULL when called by unit tests.
     DisplayAppInstalledNotification(extension);
   }
 }
 
 void BackgroundModeManager::CheckReloadStatus(
     const Extension* extension,
     bool* is_being_reloaded) {
@@ skipping 33 matching lines @@
   status_icon_ = status_tray_->CreateStatusIcon(
       StatusTray::BACKGROUND_MODE_ICON,
       *image_skia,
       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
   if (!status_icon_)
     return;
   UpdateStatusTrayIconContextMenu();
 }
 
 void BackgroundModeManager::UpdateStatusTrayIconContextMenu() {
-  // If no status icon exists, it's either because one wasn't created when
-  // it should have been which can happen when extensions load after the
-  // profile has already been registered with the background mode manager.
-  if (in_background_mode_ && !status_icon_)
-     CreateStatusTrayIcon();
+  // Ensure we have a tray icon if appropriate.
+  UpdateKeepAliveAndTrayIcon();
 
   // If we don't have a status icon or one could not be created succesfully,
   // then no need to continue the update.
   if (!status_icon_)
     return;
 
   // We should only get here if we have a profile loaded, or if we're running
   // in test mode.
   if (background_mode_data_.empty()) {
     DCHECK(keep_alive_for_test_);
@@ skipping 91 matching lines @@
     }
   }
   return profile_it;
 }
 
 bool BackgroundModeManager::IsBackgroundModePrefEnabled() const {
   PrefService* service = g_browser_process->local_state();
   DCHECK(service);
   return service->GetBoolean(prefs::kBackgroundModeEnabled);
 }