Modifying the BackgroundModeManager to handle multiple profiles.

chrome/browser/background_application_list_model.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 "chrome/browser/background_application_list_model.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/stl_util-inl.h"
@@ skipping 30 matching lines @@
     UTF8ToUTF16(x->name()),
     UTF8ToUTF16(y->name()));
 }
 
 // Background application representation, private to the
 // BackgroundApplicationListModel class.
 class BackgroundApplicationListModel::Application
   : public ImageLoadingTracker::Observer {
  public:
   Application(BackgroundApplicationListModel* model,
-              const Extension* an_extension);
+              const Extension* an_extension,
+              Profile* profile_);

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

nit: remove trailing _ 

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

Done.

 
   virtual ~Application();
 
   // Invoked when a request icon is available.
   virtual void OnImageLoaded(SkBitmap* image,
                              const ExtensionResource& resource,
                              int index);
 
   // Uses the FILE thread to request this extension's icon, sized
   // appropriately.
   void RequestIcon(Extension::Icons size);
 
   const Extension* extension_;
   scoped_ptr<SkBitmap> icon_;
   BackgroundApplicationListModel* model_;
   ImageLoadingTracker tracker_;
+  Profile* profile_;
 };
 
 namespace {
 void GetServiceApplications(ExtensionService* service,
                             ExtensionList* applications_result) {
   const ExtensionList* extensions = service->extensions();
 
   for (ExtensionList::const_iterator cursor = extensions->begin();
        cursor != extensions->end();
        ++cursor) {
@@ skipping 11 matching lines @@
 
 bool HasBackgroundAppPermission(
     const std::set<std::string>& api_permissions) {
   return Extension::HasApiPermission(
       api_permissions, Extension::kBackgroundPermission);
 }
 }  // namespace
 
 void
 BackgroundApplicationListModel::Observer::OnApplicationDataChanged(
-    const Extension* extension) {
+    const Extension* extension, Profile* profile) {
 }
 
 void
-BackgroundApplicationListModel::Observer::OnApplicationListChanged() {
+BackgroundApplicationListModel::Observer::OnApplicationListChanged(
+    Profile* profile) {
 }
 
 BackgroundApplicationListModel::Observer::~Observer() {
 }
 
 BackgroundApplicationListModel::Application::~Application() {
 }
 
 BackgroundApplicationListModel::Application::Application(
     BackgroundApplicationListModel* model,
-    const Extension* extension)
+    const Extension* extension,
+    Profile* profile)
     : extension_(extension),
       icon_(NULL),
       model_(model),
+      profile_(profile),
       ALLOW_THIS_IN_INITIALIZER_LIST(tracker_(this)) {
 }
 
 void BackgroundApplicationListModel::Application::OnImageLoaded(
     SkBitmap* image,
     const ExtensionResource& resource,
     int index) {
   if (!image)
     return;
   icon_.reset(new SkBitmap(*image));
-  model_->OnApplicationDataChanged(extension_);
+  model_->OnApplicationDataChanged(extension_, profile_);
 }
 
 void BackgroundApplicationListModel::Application::RequestIcon(
     Extension::Icons size) {
   ExtensionResource resource = extension_->GetIconResource(
       size, ExtensionIconSet::MATCH_BIGGER);
   tracker_.LoadImage(extension_, resource, gfx::Size(size, size),
                      ImageLoadingTracker::CACHE);
 }
 
@@ skipping 28 matching lines @@
   DCHECK(IsBackgroundApp(*extension));
   Application* application = FindApplication(extension);
   if (!application) {
     // App position is used as a dynamic command and so must be less than any
     // predefined command id.
     if (applications_.size() >= IDC_MinimumLabelValue) {
       LOG(ERROR) << "Background application limit of " << IDC_MinimumLabelValue
                  << " exceeded.  Ignoring.";
       return;
     }
-    application = new Application(this, extension);
+    application = new Application(this, extension, profile_);
     applications_[extension->id()] = application;
     application->RequestIcon(Extension::EXTENSION_ICON_BITTY);
   }
 }
 
 void BackgroundApplicationListModel::DissociateApplicationData(
     const Extension* extension) {
   ApplicationMap::iterator found = applications_.find(extension->id());
   if (found != applications_.end()) {
     delete found->second;
@@ skipping 44 matching lines @@
   NOTREACHED();
   return -1;
 }
 
 // static
 bool BackgroundApplicationListModel::IsBackgroundApp(
     const Extension& extension) {
   return HasBackgroundAppPermission(extension.api_permissions());
 }
 
+bool BackgroundApplicationListModel::HasBackgroundApp() {
+  return (applications_.size() > 0);
+}
+
 void BackgroundApplicationListModel::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (type == NotificationType::EXTENSIONS_READY) {
     Update();
     return;
   }
   ExtensionService* service = profile_->GetExtensionService();
   if (!service || !service->is_ready())
     return;
 
   switch (type.value) {
     case NotificationType::EXTENSION_LOADED:
       OnExtensionLoaded(Details<Extension>(details).ptr());
       break;
     case NotificationType::EXTENSION_UNLOADED:
       OnExtensionUnloaded(Details<UnloadedExtensionInfo>(details)->extension);
       break;
     default:
       NOTREACHED() << "Received unexpected notification";
   }
 }
 
 void BackgroundApplicationListModel::OnApplicationDataChanged(
-    const Extension* extension) {
-  FOR_EACH_OBSERVER(Observer, observers_, OnApplicationDataChanged(extension));
+    const Extension* extension, Profile* profile) {
+  DCHECK(profile == profile_);

[Andrew T Wilson (Slow), 2011/05/20 16:52:46]

Keep in mind that this is *not* an implementation of the
Observer::OnApplicationDataChanged() interface, so this function does not have
to have the same signature (so you don't need to pass profile in here).

You might want to rename this as "SendApplicationDataChangedNotifications()" or
something similar just to avoid confusion in the future.

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

Thanks for clearing up this confusion. I am renaming it and have pulled out the
profile parameter.

+  FOR_EACH_OBSERVER(Observer, observers_, OnApplicationDataChanged(extension,
+                                                                   profile));
 }
 
 void BackgroundApplicationListModel::OnExtensionLoaded(Extension* extension) {
   // We only care about extensions that are background applications
   if (!IsBackgroundApp(*extension))
     return;
   AssociateApplicationData(extension);
   Update();
 }
 
@@ skipping 24 matching lines @@
   ExtensionList::const_iterator new_cursor = extensions.begin();
   while (old_cursor != extensions_.end() &&
          new_cursor != extensions.end() &&
          (*old_cursor)->name() == (*new_cursor)->name() &&
          (*old_cursor)->id() == (*new_cursor)->id()) {
     ++old_cursor;
     ++new_cursor;
   }
   if (old_cursor != extensions_.end() || new_cursor != extensions.end()) {
     extensions_ = extensions;
-    FOR_EACH_OBSERVER(Observer, observers_, OnApplicationListChanged());
+    FOR_EACH_OBSERVER(Observer, observers_, OnApplicationListChanged(profile_));
   }
 }