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);
 
@@ skipping 13 matching lines @@
   if (command_line->HasSwitch(switches::kNoStartupWindow)) {
     keep_alive_for_startup_ = true;
     chrome::StartKeepAlive();
   }
 
   // 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 the --app-id or the --show-app-list flag is passed, then start with
+  // background mode suspended. It will be resumed when the first browser window
+  // is opened.
+  if (command_line->HasSwitch(switches::kAppId) ||
+      command_line->HasSwitch(switches::kShowAppList)) {
+    SuspendBackgroundMode();

[benwells, 2013/10/21 05:57:22]

Relying on these two flags feels fragile. E.g. --load-and-launch-app is another
flag you should probably check (probably as right now it won't matter, but once
all this lifetime stuff is sorted out and we fix it, it will).

Can you just suspend if !kNoStartupWindow and then let the browser window
opening unsuspend?

[Sam McNally, 2013/10/21 06:45:35]

Done.

+  }
+
   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();

[benwells, 2013/10/21 05:57:22]

Nit: early return instead of else.

[Sam McNally, 2013/10/21 06:45:35]

Done.

+  } else {
+    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 if appropriate (needed so we can display the
+  // app-installed notification below).
+  UpdateKeepAliveAndTrayIcon();
+
+  // 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;
 
   // 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 36 matching lines @@
       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();
+  UpdateKeepAliveAndTrayIcon();

[benwells, 2013/10/21 05:57:22]

This only happened before if !status_icon, and the comment talks about this as
well. Either keep the logic the same, or if it is worthy of changing (maybe it
doesn't matter), update the comment.

[Sam McNally, 2013/10/21 06:45:35]

Done.

 
   // 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);
 }