Make --keep-alive-for-test respect the kBackgroundModeEnabled flag.

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 165 matching lines @@
   // 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;
     browser::StartKeepAlive();
   }
 
   // If the -keep-alive-for-test flag is passed, then always keep chrome running
-  // in the background until the user explicitly terminates it, by acting as if
-  // we loaded a background app.
-  if (command_line->HasSwitch(switches::kKeepAliveForTest)) {
+  // 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, content::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
 }
 
 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).
@@ skipping 79 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 //  BackgroundModeManager, content::NotificationObserver overrides
 void BackgroundModeManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PREF_CHANGED:
       DCHECK(*content::Details<std::string>(details).ptr() ==
              prefs::kBackgroundModeEnabled);
-      if (IsBackgroundModePrefEnabled())
-        EnableBackgroundMode();
-      else
-        DisableBackgroundMode();
+      OnBackgroundModeEnabledPrefChanged();
       break;
     case chrome::NOTIFICATION_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();
       break;
 
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
         Extension* extension = content::Details<Extension>(details).ptr();
         Profile* profile = content::Source<Profile>(source).ptr();
@@ skipping 33 matching lines @@
            ++it) {
         it->second->applications_->RemoveObserver(this);
       }
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
+void BackgroundModeManager::OnBackgroundModeEnabledPrefChanged() {
+  if (IsBackgroundModePrefEnabled())
+    EnableBackgroundMode();
+  else
+    DisableBackgroundMode();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 //  BackgroundModeManager, BackgroundApplicationListModel::Observer overrides
 void BackgroundModeManager::OnApplicationDataChanged(
     const Extension* extension, Profile* profile) {
   UpdateStatusTrayIconContextMenu();
 }
 
 void BackgroundModeManager::OnApplicationListChanged(Profile* profile) {
   if (!IsBackgroundModePrefEnabled())
     return;
 
-  // Figure out what just happened based on the count of background apps.
-  int count = GetBackgroundAppCount();
-
   // Update the profile cache with the fact whether background apps are running
   // for this profile.
   size_t profile_index = profile_cache_->GetIndexOfProfileWithPath(
       profile->GetPath());
   if (profile_index != std::string::npos) {
     profile_cache_->SetBackgroundStatusOfProfileAtIndex(
         profile_index, GetBackgroundAppCountForProfile(profile) != 0);
   }
 
-  if (count == 0) {
+  if (!ShouldBeInBackgroundMode()) {
     // We've uninstalled our last background app, make sure we exit background
     // mode and no longer launch on startup.
     EnableLaunchOnStartup(false);
     EndBackgroundMode();
   } else {
     // We have at least one background app running - make sure we're in
     // background mode.
     if (!in_background_mode_) {
       // We're entering background mode - make sure we have launch-on-startup
       // enabled.
@@ skipping 146 matching lines @@
     keep_alive_for_startup_ = false;
     // We call this via the message queue to make sure we don't try to end
     // keep-alive (which can shutdown Chrome) before the message loop has
     // started.
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&browser::EndKeepAlive));
   }
 }
 
 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_ ||
-      (!IsBackgroundModePrefEnabled() && !keep_alive_for_test_))
+  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.
   browser::StartKeepAlive();
 
   // Display a status icon to exit Chrome.
   InitStatusTrayIcon();
 
   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 (keep_alive_for_test_ || GetBackgroundAppCount() > 0) {
+  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.
   browser::EndKeepAlive();
 
   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_ &&
-      (GetBackgroundAppCount() > 0 || keep_alive_for_test_)) {
+  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();
@@ skipping 13 matching lines @@
   DCHECK(count >= 0);
   return count;
 }
 
 int BackgroundModeManager::GetBackgroundAppCountForProfile(
     Profile* const profile) const {
   BackgroundModeData* bmd = GetBackgroundModeData(profile);
   return bmd->GetBackgroundAppCount();
 }
 
+bool BackgroundModeManager::ShouldBeInBackgroundMode() const {
+  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;
 
   // Special behavior for the Mac: We enable "launch-on-startup" only on new app
   // installation rather than every time we go into background mode. This is
   // because the Mac exposes "Open at Login" UI to the user and we don't want to
   // clobber the user's selection on every browser launch.
@@ skipping 138 matching lines @@
     }
   }
   return profile_it;
 }
 
 bool BackgroundModeManager::IsBackgroundModePrefEnabled() const {
   PrefService* service = g_browser_process->local_state();
   DCHECK(service);
   return service->GetBoolean(prefs::kBackgroundModeEnabled);
 }