chrome/browser/extensions/extension_icon_image.cc

   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/extensions/extension_icon_image.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "chrome/browser/chrome_notification_types.h"
  11 #include "chrome/browser/extensions/image_loader.h"
  12 #include "content/public/browser/notification_service.h"
  13 #include "extensions/common/extension.h"
  14 #include "ui/gfx/canvas.h"
  15 #include "ui/gfx/image/canvas_image_source.h"
  16 #include "ui/gfx/image/image.h"
  17 #include "ui/gfx/image/image_skia_operations.h"
  18 #include "ui/gfx/image/image_skia_source.h"
  19 #include "ui/gfx/size.h"
  20 #include "ui/gfx/size_conversions.h"
  21
  22 // The ImageSkia provided by extensions::IconImage contains ImageSkiaReps that
  23 // are computed and updated using the following algorithm (if no default icon
  24 // was supplied, transparent icon is considered the default):
  25 // - |LoadImageForScaleFactors()| searches the extension for an icon of an
  26 //   appropriate size. If the extension doesn't have a icon resource needed for
  27 //   the image representation, the default icon's representation for the
  28 //   requested scale factor is returned by ImageSkiaSource.
  29 // - If the extension has the resource, IconImage tries to load it using
  30 //   ImageLoader.
  31 // - |ImageLoader| is asynchronous.
  32 //  - ImageSkiaSource will initially return transparent image resource of the
  33 //    desired size.
  34 //  - The image will be updated with an appropriate image representation when
  35 //    the |ImageLoader| finishes. The image representation is chosen the same
  36 //    way as in the synchronous case. The observer is notified of the image
  37 //    change, unless the added image representation is transparent (in which
  38 //    case the image had already contained the appropriate image
  39 //    representation).
  40
  41 namespace {
  42
  43 const int kMatchBiggerTreshold = 32;
  44
  45 extensions::ExtensionResource GetExtensionIconResource(
  46     const extensions::Extension* extension,
  47     const ExtensionIconSet& icons,
  48     int size,
  49     ExtensionIconSet::MatchType match_type) {
  50   std::string path = icons.Get(size, match_type);
  51   if (path.empty())
  52     return extensions::ExtensionResource();
  53
  54   return extension->GetResource(path);
  55 }
  56
  57 class BlankImageSource : public gfx::CanvasImageSource {
  58  public:
  59   explicit BlankImageSource(const gfx::Size& size_in_dip)
  60       : CanvasImageSource(size_in_dip, /*is_opaque =*/ false) {
  61   }
  62   virtual ~BlankImageSource() {}
  63
  64  private:
  65   // gfx::CanvasImageSource overrides:
  66   virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
  67     canvas->DrawColor(SkColorSetARGB(0, 0, 0, 0));
  68   }
  69
  70   DISALLOW_COPY_AND_ASSIGN(BlankImageSource);
  71 };
  72
  73 }  // namespace
  74
  75 namespace extensions {
  76
  77 ////////////////////////////////////////////////////////////////////////////////
  78 // IconImage::Source
  79
  80 class IconImage::Source : public gfx::ImageSkiaSource {
  81  public:
  82   Source(IconImage* host, const gfx::Size& size_in_dip);
  83   virtual ~Source();
  84
  85   void ResetHost();
  86
  87  private:
  88   // gfx::ImageSkiaSource overrides:
  89   virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE;
  90
  91   // Used to load images, possibly asynchronously. NULLed out when the IconImage
  92   // is destroyed.
  93   IconImage* host_;
  94
  95   // Image whose representations will be used until |host_| loads the real
  96   // representations for the image.
  97   gfx::ImageSkia blank_image_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(Source);
 100 };
 101
 102 IconImage::Source::Source(IconImage* host, const gfx::Size& size_in_dip)
 103     : host_(host),
 104       blank_image_(new BlankImageSource(size_in_dip), size_in_dip) {
 105 }
 106
 107 IconImage::Source::~Source() {
 108 }
 109
 110 void IconImage::Source::ResetHost() {
 111   host_ = NULL;
 112 }
 113
 114 gfx::ImageSkiaRep IconImage::Source::GetImageForScale(float scale) {
 115   gfx::ImageSkiaRep representation;
 116   if (host_) {
 117     representation =
 118         host_->LoadImageForScaleFactor(ui::GetSupportedScaleFactor(scale));
 119   }
 120
 121   if (!representation.is_null())
 122     return representation;
 123
 124   return blank_image_.GetRepresentation(scale);
 125 }
 126
 127 ////////////////////////////////////////////////////////////////////////////////
 128 // IconImage
 129
 130 IconImage::IconImage(
 131     content::BrowserContext* context,
 132     const Extension* extension,
 133     const ExtensionIconSet& icon_set,
 134     int resource_size_in_dip,
 135     const gfx::ImageSkia& default_icon,
 136     Observer* observer)
 137     : browser_context_(context),
 138       extension_(extension),
 139       icon_set_(icon_set),
 140       resource_size_in_dip_(resource_size_in_dip),
 141       observer_(observer),
 142       source_(NULL),
 143       default_icon_(gfx::ImageSkiaOperations::CreateResizedImage(
 144           default_icon,
 145           skia::ImageOperations::RESIZE_BEST,
 146           gfx::Size(resource_size_in_dip, resource_size_in_dip))),
 147       weak_ptr_factory_(this) {
 148   gfx::Size resource_size(resource_size_in_dip, resource_size_in_dip);
 149   source_ = new Source(this, resource_size);
 150   image_skia_ = gfx::ImageSkia(source_, resource_size);
 151
 152   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
 153                  content::NotificationService::AllSources());
 154 }
 155
 156 IconImage::~IconImage() {
 157   source_->ResetHost();
 158 }
 159
 160 gfx::ImageSkiaRep IconImage::LoadImageForScaleFactor(
 161     ui::ScaleFactor scale_factor) {
 162   // Do nothing if extension is unloaded.
 163   if (!extension_)
 164     return gfx::ImageSkiaRep();
 165
 166   const float scale = ui::GetImageScale(scale_factor);
 167   const int resource_size_in_pixel =
 168       static_cast<int>(resource_size_in_dip_ * scale);
 169
 170   extensions::ExtensionResource resource;
 171
 172   // Find extension resource for non bundled component extensions.
 173   // We try loading bigger image only if resource size is >= 32.
 174   if (resource_size_in_pixel >= kMatchBiggerTreshold) {
 175     resource = GetExtensionIconResource(extension_, icon_set_,
 176         resource_size_in_pixel, ExtensionIconSet::MATCH_BIGGER);
 177   }
 178
 179   // If resource is not found by now, try matching smaller one.
 180   if (resource.empty()) {
 181     resource = GetExtensionIconResource(extension_, icon_set_,
 182         resource_size_in_pixel, ExtensionIconSet::MATCH_SMALLER);
 183   }
 184
 185   // If there is no resource found, return default icon.
 186   if (resource.empty())
 187     return default_icon_.GetRepresentation(scale);
 188
 189   std::vector<ImageLoader::ImageRepresentation> info_list;
 190   info_list.push_back(ImageLoader::ImageRepresentation(
 191       resource,
 192       ImageLoader::ImageRepresentation::ALWAYS_RESIZE,
 193       gfx::ToFlooredSize(gfx::ScaleSize(
 194           gfx::Size(resource_size_in_dip_, resource_size_in_dip_), scale)),
 195       scale_factor));
 196
 197   extensions::ImageLoader* loader =
 198       extensions::ImageLoader::Get(browser_context_);
 199   loader->LoadImagesAsync(extension_, info_list,
 200                           base::Bind(&IconImage::OnImageLoaded,
 201                                      weak_ptr_factory_.GetWeakPtr(),
 202                                      scale));
 203
 204   return gfx::ImageSkiaRep();
 205 }
 206
 207 void IconImage::OnImageLoaded(float scale, const gfx::Image& image_in) {
 208   const gfx::ImageSkia* image =
 209       image_in.IsEmpty() ? &default_icon_ : image_in.ToImageSkia();
 210
 211   // Maybe default icon was not set.
 212   if (image->isNull())
 213     return;
 214
 215   gfx::ImageSkiaRep rep = image->GetRepresentation(scale);
 216   DCHECK(!rep.is_null());
 217   DCHECK_EQ(scale, rep.scale());
 218
 219   // Remove old representation if there is one.
 220   image_skia_.RemoveRepresentation(scale);
 221   image_skia_.AddRepresentation(rep);
 222
 223   if (observer_)
 224     observer_->OnExtensionIconImageChanged(this);
 225 }
 226
 227 void IconImage::Observe(int type,
 228                         const content::NotificationSource& source,
 229                         const content::NotificationDetails& details) {
 230   DCHECK_EQ(type, chrome::NOTIFICATION_EXTENSION_UNLOADED);
 231
 232   const Extension* extension =
 233       content::Details<extensions::UnloadedExtensionInfo>(details)->extension;
 234
 235   if (extension_ == extension)
 236     extension_ = NULL;
 237 }
 238
 239 }  // namespace extensions