Home | History | Annotate | Download | only in background 
      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 #include "chrome/browser/background/background_application_list_model.h"
      6 
      7 #include <algorithm>
      8 #include <set>
      9 
     10 #include "base/sha1.h"
     11 #include "base/stl_util.h"
     12 #include "base/strings/string_number_conversions.h"
     13 #include "base/strings/utf_string_conversions.h"
     14 #include "chrome/app/chrome_command_ids.h"
     15 #include "chrome/browser/background/background_contents_service.h"
     16 #include "chrome/browser/background/background_contents_service_factory.h"
     17 #include "chrome/browser/background/background_mode_manager.h"
     18 #include "chrome/browser/browser_process.h"
     19 #include "chrome/browser/chrome_notification_types.h"
     20 #include "chrome/browser/extensions/extension_service.h"
     21 #include "chrome/browser/profiles/profile.h"
     22 #include "chrome/common/extensions/extension_constants.h"
     23 #include "content/public/browser/notification_details.h"
     24 #include "content/public/browser/notification_source.h"
     25 #include "extensions/browser/extension_prefs.h"
     26 #include "extensions/browser/extension_registry.h"
     27 #include "extensions/browser/extension_system.h"
     28 #include "extensions/browser/extension_util.h"
     29 #include "extensions/browser/image_loader.h"
     30 #include "extensions/browser/notification_types.h"
     31 #include "extensions/common/extension.h"
     32 #include "extensions/common/extension_icon_set.h"
     33 #include "extensions/common/extension_resource.h"
     34 #include "extensions/common/extension_set.h"
     35 #include "extensions/common/manifest_handlers/background_info.h"
     36 #include "extensions/common/manifest_handlers/icons_handler.h"
     37 #include "extensions/common/permissions/permission_set.h"
     38 #include "extensions/common/permissions/permissions_data.h"
     39 #include "ui/base/l10n/l10n_util_collator.h"
     40 #include "ui/gfx/image/image.h"
     41 #include "ui/gfx/image/image_skia.h"
     42 
     43 using extensions::APIPermission;
     44 using extensions::Extension;
     45 using extensions::ExtensionList;
     46 using extensions::ExtensionRegistry;
     47 using extensions::ExtensionSet;
     48 using extensions::PermissionSet;
     49 using extensions::UnloadedExtensionInfo;
     50 using extensions::UpdatedExtensionPermissionsInfo;
     51 
     52 class ExtensionNameComparator {
     53  public:
     54   explicit ExtensionNameComparator(icu::Collator* collator);
     55   bool operator()(const scoped_refptr<const Extension>& x,
     56                   const scoped_refptr<const Extension>& y);
     57 
     58  private:
     59   icu::Collator* collator_;
     60 };
     61 
     62 ExtensionNameComparator::ExtensionNameComparator(icu::Collator* collator)
     63   : collator_(collator) {
     64 }
     65 
     66 bool ExtensionNameComparator::operator()(
     67     const scoped_refptr<const Extension>& x,
     68     const scoped_refptr<const Extension>& y) {
     69   return l10n_util::StringComparator<base::string16>(collator_)(
     70       base::UTF8ToUTF16(x->name()), base::UTF8ToUTF16(y->name()));
     71 }
     72 
     73 // Background application representation, private to the
     74 // BackgroundApplicationListModel class.
     75 class BackgroundApplicationListModel::Application
     76     : public base::SupportsWeakPtr<Application> {
     77  public:
     78   Application(BackgroundApplicationListModel* model,
     79               const Extension* an_extension);
     80 
     81   virtual ~Application();
     82 
     83   // Invoked when a request icon is available.
     84   void OnImageLoaded(const gfx::Image& image);
     85 
     86   // Uses the FILE thread to request this extension's icon, sized
     87   // appropriately.
     88   void RequestIcon(extension_misc::ExtensionIcons size);
     89 
     90   const Extension* extension_;
     91   scoped_ptr<gfx::ImageSkia> icon_;
     92   BackgroundApplicationListModel* model_;
     93 };
     94 
     95 namespace {
     96 void GetServiceApplications(ExtensionService* service,
     97                             ExtensionList* applications_result) {
     98   ExtensionRegistry* registry = ExtensionRegistry::Get(service->profile());
     99   const ExtensionSet& enabled_extensions = registry->enabled_extensions();
    100 
    101   for (ExtensionSet::const_iterator cursor = enabled_extensions.begin();
    102        cursor != enabled_extensions.end();
    103        ++cursor) {
    104     const Extension* extension = cursor->get();
    105     if (BackgroundApplicationListModel::IsBackgroundApp(*extension,
    106                                                         service->profile())) {
    107       applications_result->push_back(extension);
    108     }
    109   }
    110 
    111   // Walk the list of terminated extensions also (just because an extension
    112   // crashed doesn't mean we should ignore it).
    113   const ExtensionSet& terminated_extensions = registry->terminated_extensions();
    114   for (ExtensionSet::const_iterator cursor = terminated_extensions.begin();
    115        cursor != terminated_extensions.end();
    116        ++cursor) {
    117     const Extension* extension = cursor->get();
    118     if (BackgroundApplicationListModel::IsBackgroundApp(*extension,
    119                                                         service->profile())) {
    120       applications_result->push_back(extension);
    121     }
    122   }
    123 
    124   std::string locale = g_browser_process->GetApplicationLocale();
    125   icu::Locale loc(locale.c_str());
    126   UErrorCode error = U_ZERO_ERROR;
    127   scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(loc, error));
    128   std::sort(applications_result->begin(), applications_result->end(),
    129        ExtensionNameComparator(collator.get()));
    130 }
    131 
    132 }  // namespace
    133 
    134 void
    135 BackgroundApplicationListModel::Observer::OnApplicationDataChanged(
    136     const Extension* extension, Profile* profile) {
    137 }
    138 
    139 void
    140 BackgroundApplicationListModel::Observer::OnApplicationListChanged(
    141     Profile* profile) {
    142 }
    143 
    144 BackgroundApplicationListModel::Observer::~Observer() {
    145 }
    146 
    147 BackgroundApplicationListModel::Application::~Application() {
    148 }
    149 
    150 BackgroundApplicationListModel::Application::Application(
    151     BackgroundApplicationListModel* model,
    152     const Extension* extension)
    153     : extension_(extension), model_(model) {}
    154 
    155 void BackgroundApplicationListModel::Application::OnImageLoaded(
    156     const gfx::Image& image) {
    157   if (image.IsEmpty())
    158     return;
    159   icon_.reset(image.CopyImageSkia());
    160   model_->SendApplicationDataChangedNotifications(extension_);
    161 }
    162 
    163 void BackgroundApplicationListModel::Application::RequestIcon(
    164     extension_misc::ExtensionIcons size) {
    165   extensions::ExtensionResource resource =
    166       extensions::IconsInfo::GetIconResource(
    167           extension_, size, ExtensionIconSet::MATCH_BIGGER);
    168   extensions::ImageLoader::Get(model_->profile_)->LoadImageAsync(
    169       extension_, resource, gfx::Size(size, size),
    170       base::Bind(&Application::OnImageLoaded, AsWeakPtr()));
    171 }
    172 
    173 BackgroundApplicationListModel::~BackgroundApplicationListModel() {
    174   STLDeleteContainerPairSecondPointers(applications_.begin(),
    175                                        applications_.end());
    176 }
    177 
    178 BackgroundApplicationListModel::BackgroundApplicationListModel(Profile* profile)
    179     : profile_(profile),
    180       ready_(false) {
    181   DCHECK(profile_);
    182   registrar_.Add(this,
    183                  extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
    184                  content::Source<Profile>(profile));
    185   registrar_.Add(this,
    186                  extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
    187                  content::Source<Profile>(profile));
    188   registrar_.Add(this,
    189                  extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
    190                  content::Source<Profile>(profile));
    191   registrar_.Add(this,
    192                  extensions::NOTIFICATION_EXTENSION_PERMISSIONS_UPDATED,
    193                  content::Source<Profile>(profile));
    194   registrar_.Add(this,
    195                  chrome::NOTIFICATION_BACKGROUND_CONTENTS_SERVICE_CHANGED,
    196                  content::Source<Profile>(profile));
    197   ExtensionService* service = extensions::ExtensionSystem::Get(profile)->
    198       extension_service();
    199   if (service && service->is_ready()) {
    200     Update();
    201     ready_ = true;
    202   }
    203 }
    204 
    205 void BackgroundApplicationListModel::AddObserver(Observer* observer) {
    206   observers_.AddObserver(observer);
    207 }
    208 
    209 void BackgroundApplicationListModel::AssociateApplicationData(
    210     const Extension* extension) {
    211   DCHECK(IsBackgroundApp(*extension, profile_));
    212   Application* application = FindApplication(extension);
    213   if (!application) {
    214     // App position is used as a dynamic command and so must be less than any
    215     // predefined command id.
    216     if (applications_.size() >= IDC_MinimumLabelValue) {
    217       LOG(ERROR) << "Background application limit of " << IDC_MinimumLabelValue
    218                  << " exceeded.  Ignoring.";
    219       return;
    220     }
    221     application = new Application(this, extension);
    222     applications_[extension->id()] = application;
    223     Update();
    224     application->RequestIcon(extension_misc::EXTENSION_ICON_BITTY);
    225   }
    226 }
    227 
    228 void BackgroundApplicationListModel::DissociateApplicationData(
    229     const Extension* extension) {
    230   ApplicationMap::iterator found = applications_.find(extension->id());
    231   if (found != applications_.end()) {
    232     delete found->second;
    233     applications_.erase(found);
    234   }
    235 }
    236 
    237 const Extension* BackgroundApplicationListModel::GetExtension(
    238     int position) const {
    239   DCHECK(position >= 0 && static_cast<size_t>(position) < extensions_.size());
    240   return extensions_[position].get();
    241 }
    242 
    243 const BackgroundApplicationListModel::Application*
    244 BackgroundApplicationListModel::FindApplication(
    245     const Extension* extension) const {
    246   const std::string& id = extension->id();
    247   ApplicationMap::const_iterator found = applications_.find(id);
    248   return (found == applications_.end()) ? NULL : found->second;
    249 }
    250 
    251 BackgroundApplicationListModel::Application*
    252 BackgroundApplicationListModel::FindApplication(
    253     const Extension* extension) {
    254   const std::string& id = extension->id();
    255   ApplicationMap::iterator found = applications_.find(id);
    256   return (found == applications_.end()) ? NULL : found->second;
    257 }
    258 
    259 const gfx::ImageSkia* BackgroundApplicationListModel::GetIcon(
    260     const Extension* extension) {
    261   const Application* application = FindApplication(extension);
    262   if (application)
    263     return application->icon_.get();
    264   AssociateApplicationData(extension);
    265   return NULL;
    266 }
    267 
    268 int BackgroundApplicationListModel::GetPosition(
    269     const Extension* extension) const {
    270   int position = 0;
    271   const std::string& id = extension->id();
    272   for (ExtensionList::const_iterator cursor = extensions_.begin();
    273        cursor != extensions_.end();
    274        ++cursor, ++position) {
    275     if (id == cursor->get()->id())
    276       return position;
    277   }
    278   NOTREACHED();
    279   return -1;
    280 }
    281 
    282 // static
    283 bool BackgroundApplicationListModel::RequiresBackgroundModeForPushMessaging(
    284     const Extension& extension) {
    285   // No PushMessaging permission - does not require the background mode.
    286   if (!extension.permissions_data()->HasAPIPermission(
    287           APIPermission::kPushMessaging)) {
    288     return false;
    289   }
    290 
    291   // If in the whitelist, then does not require background mode even if
    292   // uses push messaging.
    293   // TODO(dimich): remove this whitelist once we have a better way to keep
    294   // listening for GCM. http://crbug.com/311268
    295   std::string id_hash = base::SHA1HashString(extension.id());
    296   std::string hexencoded_id_hash = base::HexEncode(id_hash.c_str(),
    297                                                    id_hash.length());
    298   // The id starting from "9A04..." is a one from unit test.
    299   if (hexencoded_id_hash == "C41AD9DCD670210295614257EF8C9945AD68D86E" ||
    300       hexencoded_id_hash == "9A0417016F345C934A1A88F55CA17C05014EEEBA")
    301      return false;
    302 
    303    return true;
    304  }
    305 
    306 // static
    307 bool BackgroundApplicationListModel::IsBackgroundApp(
    308     const Extension& extension, Profile* profile) {
    309   // An extension is a "background app" if it has the "background API"
    310   // permission, and meets one of the following criteria:
    311   // 1) It is an extension (not a hosted app).
    312   // 2) It is a hosted app, and has a background contents registered or in the
    313   //    manifest.
    314 
    315   // Ephemeral apps are denied any background activity after their event page
    316   // has been destroyed, thus they cannot be background apps.
    317   if (extensions::util::IsEphemeralApp(extension.id(), profile))
    318     return false;
    319 
    320   // Not a background app if we don't have the background permission or
    321   // the push messaging permission
    322   if (!extension.permissions_data()->HasAPIPermission(
    323           APIPermission::kBackground) &&
    324       !RequiresBackgroundModeForPushMessaging(extension))
    325     return false;
    326 
    327   // Extensions and packaged apps with background permission are always treated
    328   // as background apps.
    329   if (!extension.is_hosted_app())
    330     return true;
    331 
    332   // Hosted apps with manifest-provided background pages are background apps.
    333   if (extensions::BackgroundInfo::HasBackgroundPage(&extension))
    334     return true;
    335 
    336   BackgroundContentsService* service =
    337       BackgroundContentsServiceFactory::GetForProfile(profile);
    338   base::string16 app_id = base::ASCIIToUTF16(extension.id());
    339   // If we have an active or registered background contents for this app, then
    340   // it's a background app. This covers the cases where the app has created its
    341   // background contents, but it hasn't navigated yet, or the background
    342   // contents crashed and hasn't yet been restarted - in both cases we still
    343   // want to treat the app as a background app.
    344   if (service->GetAppBackgroundContents(app_id) ||
    345       service->HasRegisteredBackgroundContents(app_id)) {
    346     return true;
    347   }
    348 
    349   // Doesn't meet our criteria, so it's not a background app.
    350   return false;
    351 }
    352 
    353 void BackgroundApplicationListModel::Observe(
    354     int type,
    355     const content::NotificationSource& source,
    356     const content::NotificationDetails& details) {
    357   if (type == extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED) {
    358     Update();
    359     ready_ = true;
    360     return;
    361   }
    362   ExtensionService* service = extensions::ExtensionSystem::Get(profile_)->
    363       extension_service();
    364   if (!service || !service->is_ready())
    365     return;
    366 
    367   switch (type) {
    368     case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED:
    369       OnExtensionLoaded(content::Details<Extension>(details).ptr());
    370       break;
    371     case extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED:
    372       OnExtensionUnloaded(
    373           content::Details<UnloadedExtensionInfo>(details)->extension);
    374       break;
    375     case extensions::NOTIFICATION_EXTENSION_PERMISSIONS_UPDATED:
    376       OnExtensionPermissionsUpdated(
    377           content::Details<UpdatedExtensionPermissionsInfo>(details)->extension,
    378           content::Details<UpdatedExtensionPermissionsInfo>(details)->reason,
    379           content::Details<UpdatedExtensionPermissionsInfo>(details)->
    380               permissions);
    381       break;
    382     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_SERVICE_CHANGED:
    383       Update();
    384       break;
    385     default:
    386       NOTREACHED() << "Received unexpected notification";
    387   }
    388 }
    389 
    390 void BackgroundApplicationListModel::SendApplicationDataChangedNotifications(
    391     const Extension* extension) {
    392   FOR_EACH_OBSERVER(Observer, observers_, OnApplicationDataChanged(extension,
    393                                                                    profile_));
    394 }
    395 
    396 void BackgroundApplicationListModel::OnExtensionLoaded(
    397     const Extension* extension) {
    398   // We only care about extensions that are background applications
    399   if (!IsBackgroundApp(*extension, profile_))
    400     return;
    401   AssociateApplicationData(extension);
    402 }
    403 
    404 void BackgroundApplicationListModel::OnExtensionUnloaded(
    405     const Extension* extension) {
    406   if (!IsBackgroundApp(*extension, profile_))
    407     return;
    408   Update();
    409   DissociateApplicationData(extension);
    410 }
    411 
    412 void BackgroundApplicationListModel::OnExtensionPermissionsUpdated(
    413     const Extension* extension,
    414     UpdatedExtensionPermissionsInfo::Reason reason,
    415     const PermissionSet* permissions) {
    416   if (permissions->HasAPIPermission(APIPermission::kBackground)) {
    417     switch (reason) {
    418       case UpdatedExtensionPermissionsInfo::ADDED:
    419         DCHECK(IsBackgroundApp(*extension, profile_));
    420         OnExtensionLoaded(extension);
    421         break;
    422       case UpdatedExtensionPermissionsInfo::REMOVED:
    423         DCHECK(!IsBackgroundApp(*extension, profile_));
    424         Update();
    425         DissociateApplicationData(extension);
    426         break;
    427       default:
    428         NOTREACHED();
    429     }
    430   }
    431 }
    432 
    433 void BackgroundApplicationListModel::RemoveObserver(Observer* observer) {
    434   observers_.RemoveObserver(observer);
    435 }
    436 
    437 // Update queries the extensions service of the profile with which the model was
    438 // initialized to determine the current set of background applications.  If that
    439 // differs from the old list, it generates OnApplicationListChanged events for
    440 // each observer.
    441 void BackgroundApplicationListModel::Update() {
    442   ExtensionService* service = extensions::ExtensionSystem::Get(profile_)->
    443       extension_service();
    444 
    445   // Discover current background applications, compare with previous list, which
    446   // is consistently sorted, and notify observers if they differ.
    447   ExtensionList extensions;
    448   GetServiceApplications(service, &extensions);
    449   ExtensionList::const_iterator old_cursor = extensions_.begin();
    450   ExtensionList::const_iterator new_cursor = extensions.begin();
    451   while (old_cursor != extensions_.end() &&
    452          new_cursor != extensions.end() &&
    453          (*old_cursor)->name() == (*new_cursor)->name() &&
    454          (*old_cursor)->id() == (*new_cursor)->id()) {
    455     ++old_cursor;
    456     ++new_cursor;
    457   }
    458   if (old_cursor != extensions_.end() || new_cursor != extensions.end()) {
    459     extensions_ = extensions;
    460     FOR_EACH_OBSERVER(Observer, observers_, OnApplicationListChanged(profile_));
    461   }
    462 }
    463