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_);
 
   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_;

[Andrew T Wilson (Slow), 2011/05/20 00:22:09]

See my previous comment - do we really need to track profile_ here, given that
it's only used to pass back to the BackgroundApplicationListModel, which already
has a reference to this profile?

[rpetterson, 2011/05/20 05:53:17]

It doesn't pass back just to the BackgroundApplicationListModel. It also passes
back to the BackgroundModeManager (which also inherits
BackgroundApplicationListModel::Application) and needs a way to know which
profile's status icon to update.

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

But BackgroundApplicationListModel::Application never talks directly to
BackgroundModeManager - it always goes through BackgroundApplicationListModel,
which has the profile and can pass that along.

I think this is easier to think about if you rename
BackgroundApplicationListManager::OnApplicationList/DataChanged() to something
else so it doesn't get confused with
BackgroundApplicationListManager::Observer::OnApplicationList/DataChanged() -
the latter needs a Profile, the former doesn't.

 };
 
 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 69 matching lines @@
       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) {
+  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_));
   }
 }