1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_BACKGROUND_MODE_MANAGER_H_ 6 #define CHROME_BROWSER_BACKGROUND_MODE_MANAGER_H_ 7 #pragma once 8 9 #include "base/gtest_prod_util.h" 10 #include "chrome/browser/background_application_list_model.h" 11 #include "chrome/browser/prefs/pref_change_registrar.h" 12 #include "chrome/browser/profiles/profile_keyed_service.h" 13 #include "chrome/browser/status_icons/status_icon.h" 14 #include "content/common/notification_observer.h" 15 #include "content/common/notification_registrar.h" 16 #include "ui/base/models/simple_menu_model.h" 17 18 class Browser; 19 class CommandLine; 20 class Extension; 21 class PrefService; 22 class Profile; 23 class StatusIcon; 24 class StatusTray; 25 26 // BackgroundModeManager is responsible for switching Chrome into and out of 27 // "background mode" and for providing UI for the user to exit Chrome when there 28 // are no open browser windows. 29 // 30 // Chrome enters background mode whenever there is an application with the 31 // "background" permission installed. This class monitors the set of 32 // installed/loaded extensions to ensure that Chrome enters/exits background 33 // mode at the appropriate time. 34 // 35 // When Chrome is in background mode, it will continue running even after the 36 // last browser window is closed, until the user explicitly exits the app. 37 // Additionally, when in background mode, Chrome will launch on OS login with 38 // no open windows to allow apps with the "background" permission to run in the 39 // background. 40 class BackgroundModeManager 41 : public NotificationObserver, 42 public ui::SimpleMenuModel::Delegate, 43 public BackgroundApplicationListModel::Observer, 44 public ProfileKeyedService { 45 public: 46 BackgroundModeManager(Profile* profile, CommandLine* command_line); 47 virtual ~BackgroundModeManager(); 48 49 static bool IsBackgroundModeEnabled(const CommandLine* command_line); 50 static void RegisterPrefs(PrefService* prefs); 51 52 private: 53 friend class TestBackgroundModeManager; 54 friend class BackgroundModeManagerTest; 55 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 56 BackgroundAppLoadUnload); 57 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 58 BackgroundAppInstallUninstall); 59 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 60 BackgroundPrefDisabled); 61 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 62 BackgroundPrefDynamicDisable); 63 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 64 BackgroundPrefDynamicEnable); 65 66 // NotificationObserver implementation. 67 virtual void Observe(NotificationType type, 68 const NotificationSource& source, 69 const NotificationDetails& details); 70 71 // SimpleMenuModel::Delegate implementation. 72 virtual bool IsCommandIdChecked(int command_id) const; 73 virtual bool IsCommandIdEnabled(int command_id) const; 74 virtual bool GetAcceleratorForCommandId(int command_id, 75 ui::Accelerator* accelerator); 76 virtual void ExecuteCommand(int command_id); 77 78 // Open an application in a new tab, opening a new window if needed. 79 virtual void ExecuteApplication(int application_id); 80 81 // BackgroundApplicationListModel::Observer implementation. 82 virtual void OnApplicationDataChanged(const Extension* extension); 83 virtual void OnApplicationListChanged(); 84 85 // Called when an extension is loaded to manage count of background apps. 86 void OnBackgroundAppLoaded(); 87 88 // Called when an extension is unloaded to manage count of background apps. 89 void OnBackgroundAppUnloaded(); 90 91 // Invoked when an extension is installed so we can ensure that 92 // launch-on-startup is enabled if appropriate. |extension| can be NULL when 93 // called from unit tests. 94 void OnBackgroundAppInstalled(const Extension* extension); 95 96 // Invoked when an extension is uninstalled so we can ensure that 97 // launch-on-startup is disabled if appropriate. 98 void OnBackgroundAppUninstalled(); 99 100 // Called to make sure that our launch-on-startup mode is properly set. 101 // (virtual so we can override for tests). 102 virtual void EnableLaunchOnStartup(bool should_launch); 103 104 // Invoked when a background app is installed so we can display a 105 // platform-specific notification to the user. 106 void DisplayAppInstalledNotification(const Extension* extension); 107 108 // Invoked to put Chrome in KeepAlive mode - chrome runs in the background 109 // and has a status bar icon. 110 void StartBackgroundMode(); 111 112 // Invoked to take Chrome out of KeepAlive mode - chrome stops running in 113 // the background and removes its status bar icon. 114 void EndBackgroundMode(); 115 116 // If --no-startup-window is passed, BackgroundModeManager will manually keep 117 // chrome running while waiting for apps to load. This is called when we no 118 // longer need to do this (either because the user has chosen to exit chrome 119 // manually, or all apps have been loaded). 120 void EndKeepAliveForStartup(); 121 122 // Return an appropriate name for a Preferences menu entry. Preferences is 123 // sometimes called Options or Settings. 124 string16 GetPreferencesMenuLabel(); 125 126 // Create a status tray icon to allow the user to shutdown Chrome when running 127 // in background mode. Virtual to enable testing. 128 virtual void CreateStatusTrayIcon(); 129 130 // Removes the status tray icon because we are exiting background mode. 131 // Virtual to enable testing. 132 virtual void RemoveStatusTrayIcon(); 133 134 // Updates the status icon's context menu entry corresponding to |extension| 135 // to use the icon associated with |extension| in the 136 // BackgroundApplicationListModel. 137 void UpdateContextMenuEntryIcon(const Extension* extension); 138 139 // Create a context menu, or replace/update an existing context menu, for the 140 // status tray icon which, among other things, allows the user to shutdown 141 // Chrome when running in background mode. 142 virtual void UpdateStatusTrayIconContextMenu(); 143 144 // Returns a browser window, or creates one if none are open. Used by 145 // operations (like displaying the preferences dialog) that require a Browser 146 // window. 147 Browser* GetBrowserWindow(); 148 149 NotificationRegistrar registrar_; 150 151 // The parent profile for this object. 152 Profile* profile_; 153 154 // The cached list of BackgroundApplications. 155 BackgroundApplicationListModel applications_; 156 157 // The number of background apps currently loaded. 158 int background_app_count_; 159 160 // Reference to our status icon's context menu (if any) - owned by the 161 // status_icon_ 162 ui::SimpleMenuModel* context_menu_; 163 164 // Set to the position of the first application entry in the status icon's 165 // context menu. 166 int context_menu_application_offset_; 167 168 // Set to true when we are running in background mode. Allows us to track our 169 // current background state so we can take the appropriate action when the 170 // user disables/enables background mode via preferences. 171 bool in_background_mode_; 172 173 // Set when we are keeping chrome running during the startup process - this 174 // is required when running with the --no-startup-window flag, as otherwise 175 // chrome would immediately exit due to having no open windows. 176 bool keep_alive_for_startup_; 177 178 // Reference to our status tray (owned by our parent profile). If null, the 179 // platform doesn't support status icons. 180 StatusTray* status_tray_; 181 182 // Reference to our status icon (if any) - owned by the StatusTray. 183 StatusIcon* status_icon_; 184 185 DISALLOW_COPY_AND_ASSIGN(BackgroundModeManager); 186 }; 187 188 #endif // CHROME_BROWSER_BACKGROUND_MODE_MANAGER_H_ 189