1 // Copyright (c) 2012 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_BACKGROUND_MODE_MANAGER_H_ 6 #define CHROME_BROWSER_BACKGROUND_BACKGROUND_MODE_MANAGER_H_ 7 8 #include <map> 9 10 #include "base/gtest_prod_util.h" 11 #include "base/memory/scoped_vector.h" 12 #include "base/prefs/pref_change_registrar.h" 13 #include "chrome/browser/background/background_application_list_model.h" 14 #include "chrome/browser/profiles/profile_info_cache_observer.h" 15 #include "chrome/browser/status_icons/status_icon.h" 16 #include "chrome/browser/status_icons/status_icon_menu_model.h" 17 #include "chrome/browser/ui/browser_list_observer.h" 18 #include "components/keyed_service/core/keyed_service.h" 19 #include "content/public/browser/notification_observer.h" 20 #include "content/public/browser/notification_registrar.h" 21 22 class Browser; 23 class PrefRegistrySimple; 24 class Profile; 25 class ProfileInfoCache; 26 class StatusIcon; 27 class StatusTray; 28 29 namespace base { 30 class CommandLine; 31 } 32 33 namespace extensions { 34 class Extension; 35 } 36 37 typedef std::vector<int> CommandIdExtensionVector; 38 39 // BackgroundModeManager is responsible for switching Chrome into and out of 40 // "background mode" and for providing UI for the user to exit Chrome when there 41 // are no open browser windows. 42 // 43 // Chrome enters background mode whenever there is an application with the 44 // "background" permission installed. This class monitors the set of 45 // installed/loaded extensions to ensure that Chrome enters/exits background 46 // mode at the appropriate time. 47 // 48 // When Chrome is in background mode, it will continue running even after the 49 // last browser window is closed, until the user explicitly exits the app. 50 // Additionally, when in background mode, Chrome will launch on OS login with 51 // no open windows to allow apps with the "background" permission to run in the 52 // background. 53 class BackgroundModeManager 54 : public content::NotificationObserver, 55 public chrome::BrowserListObserver, 56 public BackgroundApplicationListModel::Observer, 57 public ProfileInfoCacheObserver, 58 public StatusIconMenuModel::Delegate { 59 public: 60 BackgroundModeManager(base::CommandLine* command_line, 61 ProfileInfoCache* profile_cache); 62 virtual ~BackgroundModeManager(); 63 64 static void RegisterPrefs(PrefRegistrySimple* registry); 65 66 virtual void RegisterProfile(Profile* profile); 67 68 static void LaunchBackgroundApplication(Profile* profile, 69 const extensions::Extension* extension); 70 71 // Returns true if background mode is active. 72 virtual bool IsBackgroundModeActive(); 73 74 // Suspends background mode until either ResumeBackgroundMode is called or 75 // Chrome is restarted. This has the same effect as ending background mode 76 // for the current browser session. 77 virtual void SuspendBackgroundMode(); 78 79 // Resumes background mode. This ends a suspension of background mode, but 80 // will not start it if it is not enabled. 81 virtual void ResumeBackgroundMode(); 82 83 // For testing purposes. 84 int NumberOfBackgroundModeData(); 85 86 private: 87 friend class AppBackgroundPageApiTest; 88 friend class BackgroundModeManagerTest; 89 friend class TestBackgroundModeManager; 90 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 91 BackgroundAppLoadUnload); 92 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 93 BackgroundLaunchOnStartup); 94 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 95 BackgroundAppInstallUninstallWhileDisabled); 96 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 97 BackgroundModeDisabledPreventsKeepAliveOnStartup); 98 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 99 DisableBackgroundModeUnderTestFlag); 100 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 101 EnableAfterBackgroundAppInstall); 102 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 103 MultiProfile); 104 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 105 ProfileInfoCacheStorage); 106 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 107 ProfileInfoCacheObserver); 108 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 109 DeleteBackgroundProfile); 110 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 111 BackgroundMenuGeneration); 112 FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest, 113 BackgroundMenuGenerationMultipleProfile); 114 FRIEND_TEST_ALL_PREFIXES(BackgroundAppBrowserTest, 115 ReloadBackgroundApp); 116 117 class BackgroundModeData : public StatusIconMenuModel::Delegate { 118 public: 119 explicit BackgroundModeData( 120 Profile* profile, 121 CommandIdExtensionVector* command_id_extension_vector); 122 virtual ~BackgroundModeData(); 123 124 // The cached list of BackgroundApplications. 125 scoped_ptr<BackgroundApplicationListModel> applications_; 126 127 // Overrides from StatusIconMenuModel::Delegate implementation. 128 virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE; 129 130 // Returns a browser window, or creates one if none are open. Used by 131 // operations (like displaying the preferences dialog) that require a 132 // Browser window. 133 Browser* GetBrowserWindow(); 134 135 // Returns the number of background apps for this profile. 136 int GetBackgroundAppCount() const; 137 138 // Builds the profile specific parts of the menu. The menu passed in may 139 // be a submenu in the case of multi-profiles or the main menu in the case 140 // of the single profile case. If containing_menu is valid, we will add 141 // menu as a submenu to it. 142 void BuildProfileMenu(StatusIconMenuModel* menu, 143 StatusIconMenuModel* containing_menu); 144 145 // Set the name associated with this background mode data for displaying in 146 // the status tray. 147 void SetName(const base::string16& new_profile_name); 148 149 // The name associated with this background mode data. This should match 150 // the name in the ProfileInfoCache for this profile. 151 base::string16 name(); 152 153 // Used for sorting BackgroundModeData*s. 154 static bool BackgroundModeDataCompare(const BackgroundModeData* bmd1, 155 const BackgroundModeData* bmd2); 156 157 private: 158 // Name associated with this profile which is used to label its submenu. 159 base::string16 name_; 160 161 // The profile associated with this background app data. 162 Profile* profile_; 163 164 // Weak ref vector owned by BackgroundModeManager where the 165 // indices correspond to Command IDs and values correspond to 166 // extension indices. A value of -1 indicates no extension is associated 167 // with the index. 168 CommandIdExtensionVector* command_id_extension_vector_; 169 }; 170 171 // Ideally we would want our BackgroundModeData to be scoped_ptrs, 172 // but since maps copy their entries, we can't used scoped_ptrs. 173 // Similarly, we can't just have a map of BackgroundModeData objects, 174 // since BackgroundModeData contains a scoped_ptr which once again 175 // can't be copied. So rather than using BackgroundModeData* which 176 // we'd have to remember to delete, we use the ref-counted linked_ptr 177 // which is similar to a shared_ptr. 178 typedef linked_ptr<BackgroundModeData> BackgroundModeInfo; 179 180 typedef std::map<Profile*, BackgroundModeInfo> BackgroundModeInfoMap; 181 182 // content::NotificationObserver implementation. 183 virtual void Observe(int type, 184 const content::NotificationSource& source, 185 const content::NotificationDetails& details) OVERRIDE; 186 187 // Called when the kBackgroundModeEnabled preference changes. 188 void OnBackgroundModeEnabledPrefChanged(); 189 190 // BackgroundApplicationListModel::Observer implementation. 191 virtual void OnApplicationDataChanged(const extensions::Extension* extension, 192 Profile* profile) OVERRIDE; 193 virtual void OnApplicationListChanged(Profile* profile) OVERRIDE; 194 195 // Overrides from ProfileInfoCacheObserver 196 virtual void OnProfileAdded(const base::FilePath& profile_path) OVERRIDE; 197 virtual void OnProfileWillBeRemoved( 198 const base::FilePath& profile_path) OVERRIDE; 199 virtual void OnProfileNameChanged( 200 const base::FilePath& profile_path, 201 const base::string16& old_profile_name) OVERRIDE; 202 203 // Overrides from StatusIconMenuModel::Delegate implementation. 204 virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE; 205 206 // chrome::BrowserListObserver implementation. 207 virtual void OnBrowserAdded(Browser* browser) OVERRIDE; 208 209 // Invoked when an extension is installed so we can ensure that 210 // launch-on-startup is enabled if appropriate. |extension| can be NULL when 211 // called from unit tests. 212 void OnBackgroundAppInstalled( 213 const extensions::Extension* extension); 214 215 // Walk the list of profiles and see if an extension or app is being 216 // currently upgraded or reloaded by any profile. If so, update the 217 // output variables appropriately. 218 void CheckReloadStatus( 219 const extensions::Extension* extension, 220 bool* is_being_reloaded); 221 222 // Called to make sure that our launch-on-startup mode is properly set. 223 // (virtual so we can override for tests). 224 virtual void EnableLaunchOnStartup(bool should_launch); 225 226 // Invoked when a background app is installed so we can display a 227 // platform-specific notification to the user. 228 virtual void DisplayAppInstalledNotification( 229 const extensions::Extension* extension); 230 231 // Invoked to put Chrome in KeepAlive mode - chrome runs in the background 232 // and has a status bar icon. 233 void StartBackgroundMode(); 234 235 // Invoked to take Chrome out of KeepAlive mode - chrome stops running in 236 // the background and removes its status bar icon. 237 void EndBackgroundMode(); 238 239 // Enables keep alive and the status tray icon if and only if background mode 240 // is active and not suspended. 241 virtual void UpdateKeepAliveAndTrayIcon(); 242 243 // If --no-startup-window is passed, BackgroundModeManager will manually keep 244 // chrome running while waiting for apps to load. This is called when we no 245 // longer need to do this (either because the user has chosen to exit chrome 246 // manually, or all apps have been loaded). 247 void DecrementKeepAliveCountForStartup(); 248 249 // Return an appropriate name for a Preferences menu entry. Preferences is 250 // sometimes called Options or Settings. 251 base::string16 GetPreferencesMenuLabel(); 252 253 // Create a status tray icon to allow the user to shutdown Chrome when running 254 // in background mode. Virtual to enable testing. 255 virtual void CreateStatusTrayIcon(); 256 257 // Removes the status tray icon because we are exiting background mode. 258 // Virtual to enable testing. 259 virtual void RemoveStatusTrayIcon(); 260 261 // Create a context menu, or replace/update an existing context menu, for the 262 // status tray icon which, among other things, allows the user to shutdown 263 // Chrome when running in background mode. All profiles are listed under 264 // the one context menu. 265 virtual void UpdateStatusTrayIconContextMenu(); 266 267 // Returns the BackgroundModeData associated with this profile. If it does 268 // not exist, returns NULL. 269 BackgroundModeManager::BackgroundModeData* GetBackgroundModeData( 270 Profile* const profile) const; 271 272 // Returns the iterator associated with a particular profile name. 273 // This should not be used to iterate over the background mode data. It is 274 // used to efficiently delete an item from the background mode data map. 275 BackgroundModeInfoMap::iterator GetBackgroundModeIterator( 276 const base::string16& profile_name); 277 278 // Returns true if the "Let chrome run in the background" pref is checked. 279 // (virtual to allow overriding in tests). 280 virtual bool IsBackgroundModePrefEnabled() const; 281 282 // Turns off background mode if it's currently enabled. 283 void DisableBackgroundMode(); 284 285 // Turns on background mode if it's currently disabled. 286 void EnableBackgroundMode(); 287 288 // Returns the number of background apps in the system (virtual to allow 289 // overriding in unit tests). 290 virtual int GetBackgroundAppCount() const; 291 292 // Returns the number of background apps for a profile. 293 virtual int GetBackgroundAppCountForProfile(Profile* const profile) const; 294 295 // Returns true if we should be in background mode. 296 bool ShouldBeInBackgroundMode() const; 297 298 // Reference to the profile info cache. It is used to update the background 299 // app status of profiles when they open/close background apps. 300 ProfileInfoCache* profile_cache_; 301 302 // Registrars for managing our change observers. 303 content::NotificationRegistrar registrar_; 304 PrefChangeRegistrar pref_registrar_; 305 306 // The profile-keyed data for this background mode manager. Keyed on profile. 307 BackgroundModeInfoMap background_mode_data_; 308 309 // Contains the dynamic Command IDs for the entire background menu. 310 CommandIdExtensionVector command_id_extension_vector_; 311 312 // Maintains submenu lifetime for the multiple profile context menu. 313 ScopedVector<StatusIconMenuModel> submenus; 314 315 // Reference to our status tray. If null, the platform doesn't support status 316 // icons. 317 StatusTray* status_tray_; 318 319 // Reference to our status icon (if any) - owned by the StatusTray. 320 StatusIcon* status_icon_; 321 322 // Reference to our status icon's context menu (if any) - owned by the 323 // status_icon_. 324 StatusIconMenuModel* context_menu_; 325 326 // Set to true when we are running in background mode. Allows us to track our 327 // current background state so we can take the appropriate action when the 328 // user disables/enables background mode via preferences. 329 bool in_background_mode_; 330 331 // Set when we are keeping chrome running during the startup process - this 332 // is required when running with the --no-startup-window flag, as otherwise 333 // chrome would immediately exit due to having no open windows. 334 bool keep_alive_for_startup_; 335 336 // Set to true when Chrome is running with the --keep-alive-for-test flag 337 // (used for testing background mode without having to install a background 338 // app). 339 bool keep_alive_for_test_; 340 341 // Set to true when background mode is suspended. 342 bool background_mode_suspended_; 343 344 // Set to true when background mode is keeping Chrome alive. 345 bool keeping_alive_; 346 347 DISALLOW_COPY_AND_ASSIGN(BackgroundModeManager); 348 }; 349 350 #endif // CHROME_BROWSER_BACKGROUND_BACKGROUND_MODE_MANAGER_H_ 351