Modifying the BackgroundModeManager to handle multiple profiles.

chrome/browser/background_mode_manager.cc

 // 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.
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
@@ skipping 12 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_type.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
-void BackgroundModeManager::OnApplicationDataChanged(
-    const Extension* extension) {
-  UpdateContextMenuEntryIcon(extension);
+BackgroundModeManager::BackgroundModeData::BackgroundModeData(Profile* profile)
+    : applications_(new BackgroundApplicationListModel(profile)),
+      status_icon_(NULL),
+      context_menu_(NULL),
+      context_menu_application_offset_(0) {
 }
 
-void BackgroundModeManager::OnApplicationListChanged() {
-  UpdateStatusTrayIconContextMenu();
+BackgroundModeManager::BackgroundModeData::~BackgroundModeData() {
 }
 
-BackgroundModeManager::BackgroundModeManager(Profile* profile,
-                                             CommandLine* command_line)
-    : profile_(profile),
-      applications_(profile),
+void BackgroundModeManager::OnApplicationDataChanged(
+    const Extension* extension, Profile* profile) {
+  UpdateContextMenuEntryIcon(extension, profile);
+}
+
+void BackgroundModeManager::OnApplicationListChanged(Profile* profile) {
+  UpdateStatusTrayIconContextMenu(profile);
+}
+
+BackgroundModeManager::BackgroundModeManager(CommandLine* command_line)
+    : status_tray_(NULL),
       background_app_count_(0),
-      context_menu_(NULL),
-      context_menu_application_offset_(0),
       in_background_mode_(false),
-      keep_alive_for_startup_(false),
-      status_tray_(NULL),
-      status_icon_(NULL) {
+      keep_alive_for_startup_(false) {
   // If background mode is currently disabled, just exit - don't listen for any
   // notifications.
   if (IsBackgroundModePermanentlyDisabled(command_line))
     return;
 
   // Listen for the background mode preference changing.
   if (g_browser_process->local_state()) {  // Skip for unit tests
     pref_registrar_.Init(g_browser_process->local_state());
     pref_registrar_.Add(prefs::kBackgroundModeEnabled, this);
   }
 
   // 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;
     BrowserList::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 (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKeepAliveForTest))
+  if (command_line->HasSwitch(switches::kKeepAliveForTest))
     OnBackgroundAppLoaded();
 
+  // Listen for the application shutting down so we can decrement our KeepAlive
+  // count.
+  registrar_.Add(this, NotificationType::APP_TERMINATING,
+                 NotificationService::AllSources());
+}
+
+BackgroundModeManager::~BackgroundModeManager() {
+  for (std::map<Profile*, BackgroundModeInfo>::iterator it =
+       background_mode_data_.begin();
+       it != background_mode_data_.end();
+       ++it) {
+    it->second->applications_->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();
+}
+
+void BackgroundModeManager::RegisterProfile(Profile* profile) {
+  // We don't want to register multiple times for one profile.
+  DCHECK(background_mode_data_.find(profile) == background_mode_data_.end());
+  BackgroundModeInfo bmd(new BackgroundModeData(profile));
+  background_mode_data_[profile] = bmd;
+
   // Listen for when extensions are loaded/unloaded so we can track the
   // number of background apps and modify our keep-alive and launch-on-startup
   // state appropriately.
   registrar_.Add(this, NotificationType::EXTENSION_LOADED,
                  Source<Profile>(profile));
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                  Source<Profile>(profile));
 
   // Check for the presence of background apps after all extensions have been
   // loaded, to handle the case where an extension has been manually removed
   // while Chrome was not running.
   registrar_.Add(this, NotificationType::EXTENSIONS_READY,
                  Source<Profile>(profile));
 
-  // Listen for the application shutting down so we can decrement our KeepAlive
-  // count.
-  registrar_.Add(this, NotificationType::APP_TERMINATING,
-                 NotificationService::AllSources());
-
-  applications_.AddObserver(this);
-}
-
-BackgroundModeManager::~BackgroundModeManager() {
-  applications_.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();
+  background_mode_data_[profile]->applications_->AddObserver(this);
 }
 
 void BackgroundModeManager::Observe(NotificationType type,
                                     const NotificationSource& source,
                                     const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::PREF_CHANGED:
       DCHECK(*Details<std::string>(details).ptr() ==
              prefs::kBackgroundModeEnabled);
       if (IsBackgroundModePrefEnabled())
@@ skipping 14 matching lines @@
       // launch on startup even after the user removes the LoginItem manually.
 #if !defined(OS_MACOSX)
       EnableLaunchOnStartup(background_app_count_ > 0);
 #endif
       break;
     case NotificationType::EXTENSION_LOADED: {
         Extension* extension = Details<Extension>(details).ptr();
         if (BackgroundApplicationListModel::IsBackgroundApp(*extension)) {
           // Extensions loaded after the ExtensionsService is ready should be
           // treated as new installs.
-          if (profile_->GetExtensionService()->is_ready())
-            OnBackgroundAppInstalled(extension);
+
+          Profile* profile = Source<Profile>(source).ptr();
+          if (profile->GetExtensionService()->is_ready())
+            OnBackgroundAppInstalled(extension, profile);
           OnBackgroundAppLoaded();
         }
       }
       break;
     case NotificationType::EXTENSION_UNLOADED:
       if (BackgroundApplicationListModel::IsBackgroundApp(
               *Details<UnloadedExtensionInfo>(details)->extension)) {
         Details<UnloadedExtensionInfo> info =
             Details<UnloadedExtensionInfo>(details);
         // If we already got an unload notification when it was disabled, ignore
@@ skipping 30 matching lines @@
     // keep-alive (which can shutdown Chrome) before the message loop has
     // started.
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableFunction(BrowserList::EndKeepAlive));
   }
 }
 
 void BackgroundModeManager::OnBackgroundAppLoaded() {
   // When a background app loads, increment our count and also enable
   // KeepAlive mode if the preference is set.
+  // The count here is across all profiles since we must have background
+  // mode if there is even one.
   background_app_count_++;
   if (background_app_count_ == 1)
     StartBackgroundMode();
 }
 
 void BackgroundModeManager::StartBackgroundMode() {
   // Don't bother putting ourselves in background mode if we're already there
   // or if background mode is disabled.
   if (in_background_mode_ || !IsBackgroundModePrefEnabled())
     return;
 
   // Mark ourselves as running in background mode.
   in_background_mode_ = true;
 
   // Put ourselves in KeepAlive mode and create a status tray icon.
   BrowserList::StartKeepAlive();
 
   // Display a status icon to exit Chrome.
-  CreateStatusTrayIcon();
+  InitStatusTrayIcons();
+}
+
+void BackgroundModeManager::InitStatusTrayIcons() {
+  // Only initiali status tray icons for those profiles which actually

[Miranda Callahan, 2011/05/20 15:16:53]

nit: initiali...

[rpetterson, 2011/05/23 03:23:19]

Done.

+  // have a background app running.
+  for (std::map<Profile*, BackgroundModeInfo>::iterator it =
+       background_mode_data_.begin();
+       it != background_mode_data_.end();
+       ++it) {
+    if (it->second->applications_->HasBackgroundApp()) {
+      CreateStatusTrayIcon(it->first);
+    }
+  }
 }
 
 void BackgroundModeManager::OnBackgroundAppUnloaded() {
   // When a background app unloads, decrement our count and also end
   // KeepAlive mode if appropriate.
   background_app_count_--;
   DCHECK_GE(background_app_count_, 0);
   if (background_app_count_ == 0)
     EndBackgroundMode();
 }
 
 void BackgroundModeManager::EndBackgroundMode() {
   if (!in_background_mode_)
     return;
   in_background_mode_ = false;
 
   // End KeepAlive mode and blow away our status tray icon.
   BrowserList::EndKeepAlive();
-  RemoveStatusTrayIcon();
+  // There is a status tray icon for each profile. Blow them all away.
+  for (std::map<Profile*, BackgroundModeInfo>::iterator it =
+       background_mode_data_.begin();
+       it != background_mode_data_.end();
+       ++it) {
+    RemoveStatusTrayIcon(it->first);
+  }
 }
 
 void BackgroundModeManager::EnableBackgroundMode() {
   DCHECK(IsBackgroundModePrefEnabled());
   // If background mode should be enabled, but isn't, turn it on.
   if (background_app_count_ > 0 && !in_background_mode_) {
     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::OnBackgroundAppInstalled(
-    const Extension* extension) {
+    const Extension* extension, Profile* profile) {
   // Background mode is disabled - don't do anything.
   if (!IsBackgroundModePrefEnabled())
     return;
 
   // We're installing a background app. If this is the first background app
   // being installed, make sure we are set to launch on startup.
   if (background_app_count_ == 0)
     EnableLaunchOnStartup(true);
 
   // Notify the user that a background app has been installed.
   if (extension)  // NULL when called by unit tests.
-    DisplayAppInstalledNotification(extension);
+    DisplayAppInstalledNotification(extension, profile);
 }
 
 void BackgroundModeManager::OnBackgroundAppUninstalled() {
   // When uninstalling a background app, disable launch on startup if
   // we have no more background apps.
   if (background_app_count_ == 0)
     EnableLaunchOnStartup(false);
 }
 
-void BackgroundModeManager::CreateStatusTrayIcon() {
+void BackgroundModeManager::CreateStatusTrayIcon(Profile* profile) {
   // Only need status icons on windows/linux. ChromeOS doesn't allow exiting
   // Chrome and Mac can use the dock icon instead.
+
+  // All profiles should point to the same status tray so we can just use the
+  // first profile to get the status tray.

[Miranda Callahan, 2011/05/20 15:16:53]

looks like you changed this to use the g_browser_process -- comment change as
well?

[rpetterson, 2011/05/23 03:23:19]

Done.

 #if !defined(OS_MACOSX) && !defined(OS_CHROMEOS)
   if (!status_tray_)
-    status_tray_ = profile_->GetStatusTray();
+    status_tray_ = g_browser_process->status_tray();
 #endif
 
   // If the platform doesn't support status icons, or we've already created
   // our status icon, just return.
-  if (!status_tray_ || status_icon_)
-    return;
-  status_icon_ = status_tray_->CreateStatusIcon();
-  if (!status_icon_)
+  BackgroundModeInfo bmd = GetBackgroundModeInfo(profile);
+  if (!status_tray_ || bmd->status_icon_)
     return;
 
-  // Set the image and add ourselves as a click observer on it
+  bmd->status_icon_ = status_tray_->CreateStatusIcon();
+  if (!bmd->status_icon_)
+    return;
+
+  // Set the image and add ourselves as a click observer on it.
+  // TODO(rlp): Status tray icon should have submenus for each profile.
   SkBitmap* bitmap = ResourceBundle::GetSharedInstance().GetBitmapNamed(
       IDR_STATUS_TRAY_ICON);
-  status_icon_->SetImage(*bitmap);
-  status_icon_->SetToolTip(l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
-  UpdateStatusTrayIconContextMenu();
+  bmd->status_icon_->SetImage(*bitmap);
+  bmd->status_icon_->SetToolTip(l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
+  UpdateStatusTrayIconContextMenu(profile);
 }
 
 void BackgroundModeManager::UpdateContextMenuEntryIcon(
-    const Extension* extension) {
-  if (!context_menu_)
+    const Extension* extension, Profile* profile) {
+  BackgroundModeInfo bmd = GetBackgroundModeInfo(profile);
+
+  if (!bmd->context_menu_)
     return;
-  context_menu_->SetIcon(
-      context_menu_application_offset_ + applications_.GetPosition(extension),
-      *(applications_.GetIcon(extension)));
-  status_icon_->SetContextMenu(context_menu_);  // for Update effect
+  bmd->context_menu_->SetIcon(
+      bmd->context_menu_application_offset_ +
+      bmd->applications_->GetPosition(extension),
+      *(bmd->applications_->GetIcon(extension)));
+
+  bmd->status_icon_->SetContextMenu(bmd->context_menu_);  // for Update effect
 }
 
-void BackgroundModeManager::UpdateStatusTrayIconContextMenu() {
-  if (!status_icon_)
+void BackgroundModeManager::UpdateStatusTrayIconContextMenu(Profile* profile) {
+  BackgroundModeInfo bmd = GetBackgroundModeInfo(profile);
+  if (!bmd->status_icon_)
     return;
 
+  // TODO(rlp): Add current profile color.
   // Create a context menu item for Chrome.
-  ui::SimpleMenuModel* menu = new ui::SimpleMenuModel(this);
+  ProfileStatusMenuModel* menu = new ProfileStatusMenuModel(this, profile);
   // Add About item
   menu->AddItem(IDC_ABOUT, l10n_util::GetStringFUTF16(IDS_ABOUT,
       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
   menu->AddItem(IDC_OPTIONS, GetPreferencesMenuLabel());
   menu->AddItemWithStringId(IDC_TASK_MANAGER, IDS_TASK_MANAGER);
   menu->AddSeparator();
   int position = 0;
-  context_menu_application_offset_ = menu->GetItemCount();
-  for (ExtensionList::const_iterator cursor = applications_.begin();
-       cursor != applications_.end();
+  bmd->context_menu_application_offset_ = menu->GetItemCount();
+  for (ExtensionList::const_iterator cursor = bmd->applications_->begin();
+       cursor != bmd->applications_->end();
        ++cursor, ++position) {
-    const SkBitmap* icon = applications_.GetIcon(*cursor);
-    DCHECK(position == applications_.GetPosition(*cursor));
+    const SkBitmap* icon = bmd->applications_->GetIcon(*cursor);
+    DCHECK(position == bmd->applications_->GetPosition(*cursor));
     const std::string& name = (*cursor)->name();
     menu->AddItem(position, UTF8ToUTF16(name));
     if (icon)
       menu->SetIcon(menu->GetItemCount() - 1, *icon);
   }
-  if (applications_.size() > 0)
+  if (bmd->applications_->size() > 0)
     menu->AddSeparator();
   menu->AddCheckItemWithStringId(
       IDC_STATUS_TRAY_KEEP_CHROME_RUNNING_IN_BACKGROUND,
       IDS_STATUS_TRAY_KEEP_CHROME_RUNNING_IN_BACKGROUND);
   menu->AddItemWithStringId(IDC_EXIT, IDS_EXIT);
-  context_menu_ = menu;
-  status_icon_->SetContextMenu(menu);
+  bmd->context_menu_ = menu;
+  bmd->status_icon_->SetContextMenu(menu);
 }
 
 bool BackgroundModeManager::IsCommandIdChecked(int command_id) const {
   DCHECK(command_id == IDC_STATUS_TRAY_KEEP_CHROME_RUNNING_IN_BACKGROUND);
   return true;
 }
 
 bool BackgroundModeManager::IsCommandIdEnabled(int command_id) const {
   // For now, we do not support disabled items.
   return true;
 }
 
 bool BackgroundModeManager::GetAcceleratorForCommandId(
     int command_id,
     ui::Accelerator* accelerator) {
   // No accelerators for status icon context menus.
   return false;
 }
 
-void BackgroundModeManager::RemoveStatusTrayIcon() {
-  if (status_icon_)
-    status_tray_->RemoveStatusIcon(status_icon_);
-  status_icon_ = NULL;
-  context_menu_ = NULL;  // Do not delete, points within |status_icon_|.
+void BackgroundModeManager::RemoveStatusTrayIcon(Profile* profile) {
+  BackgroundModeInfo bmd = GetBackgroundModeInfo(profile);
+  if (bmd->status_icon_)
+    status_tray_->RemoveStatusIcon(bmd->status_icon_);
+  bmd->status_icon_ = NULL;
+  bmd->context_menu_ = NULL;  // Do not delete, points within |status_icon_|.
 }
 
-void BackgroundModeManager::ExecuteApplication(int item) {
-  DCHECK(item >= 0 && item < static_cast<int>(applications_.size()));
-  Browser* browser = BrowserList::GetLastActive();
-  if (!browser) {
-    Browser::OpenEmptyWindow(profile_);
-    browser = BrowserList::GetLastActive();
-  }
-  const Extension* extension = applications_.GetExtension(item);
-  browser->OpenApplicationTab(profile_, extension, NEW_FOREGROUND_TAB);
+void BackgroundModeManager::ExecuteApplication(int item, Profile* profile) {
+  BackgroundModeInfo bmd = GetBackgroundModeInfo(profile);
+  DCHECK(item >= 0 && item < static_cast<int>(bmd->applications_->size()));
+
+  Browser* browser = GetBrowserWindow(profile);
+  const Extension* extension = bmd->applications_->GetExtension(item);
+  browser->OpenApplicationTab(profile, extension, NEW_FOREGROUND_TAB);
 }
 
 void BackgroundModeManager::ExecuteCommand(int item) {
+  // We only use the version with profile information.
+  NOTREACHED();
+}
+
+void BackgroundModeManager::ExecuteCommand(int item, Profile* profile) {
   switch (item) {
     case IDC_ABOUT:
-      GetBrowserWindow()->OpenAboutChromeDialog();
+      GetBrowserWindow(profile)->OpenAboutChromeDialog();
       break;
     case IDC_EXIT:
       UserMetrics::RecordAction(UserMetricsAction("Exit"));
       BrowserList::CloseAllBrowsersAndExit();
       break;
     case IDC_OPTIONS:
-      GetBrowserWindow()->OpenOptionsDialog();
+      GetBrowserWindow(profile)->OpenOptionsDialog();
       break;
     case IDC_TASK_MANAGER:
-      GetBrowserWindow()->OpenTaskManager(true);
+      GetBrowserWindow(profile)->OpenTaskManager(true);
       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(BrowserList::WillKeepAlive());
       if (BrowserList::size() == 0) {
         // There are no windows open - unchecking this will exit Chrome. Warn
         // the user.
         string16 tab_title = l10n_util::GetStringFUTF16(IDS_OPTIONS_TAB_TITLE,
@@ skipping 11 matching lines @@
       }
 
       // Set the background mode pref to "disabled" - the resulting notification
       // will result in a call to DisableBackgroundMode().
       PrefService* service = g_browser_process->local_state();
       DCHECK(service);
       service->SetBoolean(prefs::kBackgroundModeEnabled, false);
       break;
     }
     default:
-      ExecuteApplication(item);
+      ExecuteApplication(item, profile);
       break;
   }
 }
 
-Browser* BackgroundModeManager::GetBrowserWindow() {
+Browser* BackgroundModeManager::GetBrowserWindow(Profile* profile) {
   Browser* browser = BrowserList::GetLastActive();

[Miranda Callahan, 2011/05/20 15:16:53]

This should be changed to BrowserList::GetLastActiveForProfile(profile), or it
may bring up a browser window associated with a different profile.

[rpetterson, 2011/05/23 03:23:19]

Done.

   if (!browser) {
-    Browser::OpenEmptyWindow(profile_);
+    Browser::OpenEmptyWindow(profile);
     browser = BrowserList::GetLastActive();

[Miranda Callahan, 2011/05/20 15:16:53]

...should probably also be GetLastActiveForProfile here too.

[rpetterson, 2011/05/23 03:23:19]

Done.

   }
   return browser;
 }
 
+BackgroundModeManager::BackgroundModeInfo
+    BackgroundModeManager::GetBackgroundModeInfo(

[Miranda Callahan, 2011/05/20 15:16:53]

Join this line and the one below.

[rpetterson, 2011/05/23 03:23:19]

Done.

+        Profile* profile) {
+  DCHECK(background_mode_data_.find(profile) != background_mode_data_.end());
+  return background_mode_data_[profile];
+}
+
 // static
 bool BackgroundModeManager::IsBackgroundModePermanentlyDisabled(
     const CommandLine* command_line) {
 
   // Background mode is disabled if the appropriate flag is passed, or if
   // extensions are disabled, or if the associated preference is unset. It's
   // always disabled on chromeos since chrome is always running on that
   // platform, making it superfluous.
 #if defined(OS_CHROMEOS)
   return true;
 #else
   bool background_mode_disabled =
       command_line->HasSwitch(switches::kDisableBackgroundMode) ||
       command_line->HasSwitch(switches::kDisableExtensions);
   return background_mode_disabled;
 #endif
 }
 
 bool BackgroundModeManager::IsBackgroundModePrefEnabled() {
   PrefService* service = g_browser_process->local_state();
   DCHECK(service);
   return service->GetBoolean(prefs::kBackgroundModeEnabled);
 }
 
 // static
 void BackgroundModeManager::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kUserCreatedLoginItem, false);
   prefs->RegisterBooleanPref(prefs::kBackgroundModeEnabled, true);
 }