Fixing background mode manager to correctly display the name of the profile in the status icon. P...

chrome/browser/background/background_mode_manager.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_BACKGROUND_BACKGROUND_MODE_MANAGER_H_
 #define CHROME_BROWSER_BACKGROUND_BACKGROUND_MODE_MANAGER_H_
 #pragma once
 
 #include <map>
 
 #include "base/gtest_prod_util.h"
 #include "chrome/browser/background/background_application_list_model.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
+#include "chrome/browser/profiles/profile_info_cache_observer.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/status_icons/status_icon.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/base/models/simple_menu_model.h"
 
 class Browser;
 class CommandLine;
 class Extension;
 class PrefService;
@@ skipping 12 matching lines @@
 // mode at the appropriate time.
 //
 // When Chrome is in background mode, it will continue running even after the
 // last browser window is closed, until the user explicitly exits the app.
 // Additionally, when in background mode, Chrome will launch on OS login with
 // no open windows to allow apps with the "background" permission to run in the
 // background.
 class BackgroundModeManager
     : public content::NotificationObserver,
       public BackgroundApplicationListModel::Observer,
+      public ProfileInfoCacheObserver,
       public ProfileKeyedService,
       public ui::SimpleMenuModel::Delegate {
  public:
   BackgroundModeManager(CommandLine* command_line,
                         ProfileInfoCache* profile_cache);
   virtual ~BackgroundModeManager();
 
   static void RegisterPrefs(PrefService* prefs);
 
   virtual void RegisterProfile(Profile* profile);
 
   // Returns true if background mode is permanently disabled for this Chrome
   // session.
   static bool IsBackgroundModePermanentlyDisabled(
       const CommandLine* command_line);
 
   static void LaunchBackgroundApplication(Profile* profile,
                                           const Extension* extension);
 
+  // For testing purposes.
+  int NumberOfBackgroundModeData();
+
+  // For testing purposes.
+  string16 BackgroundModeDataName(Profile* profile);

[Andrew T Wilson (Slow), 2011/12/06 06:46:02]

This is fine, although since we're already exposing GetBackgroundModeData() to
the tests via FRIEND_TEST_ALL_PREFIXES() they could also just call
GetBackgroundModeData(profile)->name().

[rpetterson, 2011/12/06 20:09:05]

Good point. I'd rather not have extraneous functions just for testing so this is
gone.

+
  private:
   friend class TestBackgroundModeManager;
   friend class BackgroundModeManagerTest;
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            BackgroundAppLoadUnload);
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            BackgroundLaunchOnStartup);
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            BackgroundAppInstallUninstallWhileDisabled);
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            EnableAfterBackgroundAppInstall);
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            MultiProfile);
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            ProfileInfoCacheStorage);
+  FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
+                           ProfileInfoCacheObserver);
 
   class BackgroundModeData : public ui::SimpleMenuModel::Delegate {
    public:
     explicit BackgroundModeData(
         int command_id,
-        Profile* profile,
-        BackgroundModeManager* background_mode_manager);
+        Profile* profile);
     virtual ~BackgroundModeData();
 
     // The cached list of BackgroundApplications.
     scoped_ptr<BackgroundApplicationListModel> applications_;
 
     // Overrides from SimpleMenuModel::Delegate implementation.
     virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
     virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE;
     virtual bool GetAcceleratorForCommandId(int command_id,
                                             ui::Accelerator* accelerator)
                                             OVERRIDE;
     virtual void ExecuteCommand(int command_id) OVERRIDE;
 
     // Returns a browser window, or creates one if none are open. Used by
     // operations (like displaying the preferences dialog) that require a
     // Browser window.
     Browser* GetBrowserWindow();
 
     // Returns the number of background apps for this profile.
     int GetBackgroundAppCount() const;
 
     // Builds the profile specific parts of the menu. The menu passed in may
     // be a submenu in the case of multi-profiles or the main menu in the case
     // of the single profile case. If containing_menu is valid, we will add
     // menu as a submenu to it.
     void BuildProfileMenu(ui::SimpleMenuModel* menu,
                           ui::SimpleMenuModel* containing_menu);
 
+    // Set the name associated with this background mode data for displaying in
+    // the status tray.
+    void SetName(const string16& new_profile_name);
+
+    // The name associated with this background mode data. This should match
+    // the name in the ProfileInfoCache for this profile.
+    string16 name();
+
     // Used for sorting BackgroundModeData*s.
     static bool BackgroundModeDataCompare(const BackgroundModeData* bmd1,
                                           const BackgroundModeData* bmd2);
 
    private:
     // Command id for the sub menu for this BackgroundModeData.
     int command_id_;
 
     // Name associated with this profile which is used to label its submenu.
     string16 name_;
 
     // The profile associated with this background app data.
     Profile* profile_;
-
-    // The background mode manager which owns this BackgroundModeData.
-    BackgroundModeManager* background_mode_manager_;
   };
 
   // Ideally we would want our BackgroundModeData to be scoped_ptrs,
   // but since maps copy their entries, we can't used scoped_ptrs.
   // Similarly, we can't just have a map of BackgroundModeData objects,
   // since BackgroundModeData contains a scoped_ptr which once again
   // can't be copied. So rather than using BackgroundModeData* which
   // we'd have to remember to delete, we use the ref-counted linked_ptr
   // which is similar to a shared_ptr.
   typedef linked_ptr<BackgroundModeData> BackgroundModeInfo;
 
+  typedef std::map<Profile*, BackgroundModeInfo> BackgroundModeInfoMap;
+
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // BackgroundApplicationListModel::Observer implementation.
   virtual void OnApplicationDataChanged(const Extension* extension,
                                         Profile* profile) OVERRIDE;
   virtual void OnApplicationListChanged(Profile* profile) OVERRIDE;
 
+  // Overrides from ProfileInfoCacheObserver
+  virtual void OnProfileAdded(const string16& profile_name,
+                              const string16& profile_base_dir) OVERRIDE;
+  virtual void OnProfileRemoved(const string16& profile_name) OVERRIDE;
+  virtual void OnProfileNameChanged(const string16& old_profile_name,
+                                    const string16& new_profile_name) OVERRIDE;
+
   // Overrides from SimpleMenuModel::Delegate implementation.
   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE;
   virtual bool GetAcceleratorForCommandId(int command_id,
                                           ui::Accelerator* accelerator)
                                           OVERRIDE;
   virtual void ExecuteCommand(int command_id) OVERRIDE;
 
   // Invoked when an extension is installed so we can ensure that
   // launch-on-startup is enabled if appropriate. |extension| can be NULL when
@@ skipping 42 matching lines @@
   // status tray icon which, among other things, allows the user to shutdown
   // Chrome when running in background mode. All profiles are listed under
   // the one context menu.
   virtual void UpdateStatusTrayIconContextMenu();
 
   // Returns the BackgroundModeData associated with this profile. If it does
   // not exist, returns NULL.
   BackgroundModeManager::BackgroundModeData* GetBackgroundModeData(
       Profile* const profile) const;
 
+  // Returns the iterator associated with a particular profile name.
+  // If it does not exist.

[Andrew T Wilson (Slow), 2011/12/06 06:46:02]

This comment seems truncated. Also, returning an iterator here is interesting -
no caller would ever actually use this to iterate, but instead it's returned so
the caller can efficiently remove the item from the underlying map if desired.
That's probably worth pointing out in the comment.

[rpetterson, 2011/12/06 20:09:05]

Done.

+  BackgroundModeInfoMap::iterator GetBackgroundModeIterator(
+      const string16& profile_name);
+
   // Returns true if the "Let chrome run in the background" pref is checked.
   // (virtual to allow overriding in tests).
   virtual bool IsBackgroundModePrefEnabled() const;
 
   // Turns off background mode if it's currently enabled.
   void DisableBackgroundMode();
 
   // Turns on background mode if it's currently disabled.
   void EnableBackgroundMode();
 
   // Returns the number of background apps in the system (virtual to allow
   // overriding in unit tests).
   virtual int GetBackgroundAppCount() const;
 
   // Returns the number of background apps for a profile.
   virtual int GetBackgroundAppCountForProfile(Profile* const profile) const;
 
   // Reference to the profile info cache. It is used to update the background
   // app status of profiles when they open/close background apps.
   ProfileInfoCache* profile_cache_;
 
   // Registrars for managing our change observers.
   content::NotificationRegistrar registrar_;
   PrefChangeRegistrar pref_registrar_;
 
   // The profile-keyed data for this background mode manager. Keyed on profile.
-  std::map<Profile*, BackgroundModeInfo> background_mode_data_;
+  BackgroundModeInfoMap background_mode_data_;
 
   // Reference to our status tray. If null, the platform doesn't support status
   // icons.
   StatusTray* status_tray_;
 
   // Reference to our status icon (if any) - owned by the StatusTray.
   StatusIcon* status_icon_;
 
   // Reference to our status icon's context menu (if any) - owned by the
   // status_icon_.
@@ skipping 14 matching lines @@
   // app).
   bool keep_alive_for_test_;
 
   // Provides a command id for each profile as they are created.
   int current_command_id_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundModeManager);
 };
 
 #endif  // CHROME_BROWSER_BACKGROUND_BACKGROUND_MODE_MANAGER_H_