1 // Copyright 2014 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.
5 #include "extensions/browser/extension_icon_image.h"
10 #include "content/public/browser/notification_service.h"
11 #include "extensions/browser/image_loader.h"
12 #include "extensions/browser/notification_types.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"
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
31 // - |ImageLoader| is asynchronous.
32 // - ImageSkiaSource will initially return transparent image resource of the
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
43 const int kMatchBiggerTreshold = 32;
45 extensions::ExtensionResource GetExtensionIconResource(
46 const extensions::Extension* extension,
47 const ExtensionIconSet& icons,
49 ExtensionIconSet::MatchType match_type) {
50 const std::string& path = icons.Get(size, match_type);
51 return path.empty() ? extensions::ExtensionResource()
52 : extension->GetResource(path);
55 class BlankImageSource : public gfx::CanvasImageSource {
57 explicit BlankImageSource(const gfx::Size& size_in_dip)
58 : CanvasImageSource(size_in_dip, /*is_opaque =*/ false) {
60 virtual ~BlankImageSource() {}
63 // gfx::CanvasImageSource overrides:
64 virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
65 canvas->DrawColor(SkColorSetARGB(0, 0, 0, 0));
68 DISALLOW_COPY_AND_ASSIGN(BlankImageSource);
73 namespace extensions {
75 ////////////////////////////////////////////////////////////////////////////////
78 class IconImage::Source : public gfx::ImageSkiaSource {
80 Source(IconImage* host, const gfx::Size& size_in_dip);
86 // gfx::ImageSkiaSource overrides:
87 virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE;
89 // Used to load images, possibly asynchronously. NULLed out when the IconImage
93 // Image whose representations will be used until |host_| loads the real
94 // representations for the image.
95 gfx::ImageSkia blank_image_;
97 DISALLOW_COPY_AND_ASSIGN(Source);
100 IconImage::Source::Source(IconImage* host, const gfx::Size& size_in_dip)
102 blank_image_(new BlankImageSource(size_in_dip), size_in_dip) {
105 IconImage::Source::~Source() {
108 void IconImage::Source::ResetHost() {
112 gfx::ImageSkiaRep IconImage::Source::GetImageForScale(float scale) {
113 gfx::ImageSkiaRep representation;
116 host_->LoadImageForScaleFactor(ui::GetSupportedScaleFactor(scale));
119 if (!representation.is_null())
120 return representation;
122 return blank_image_.GetRepresentation(scale);
125 ////////////////////////////////////////////////////////////////////////////////
128 IconImage::IconImage(
129 content::BrowserContext* context,
130 const Extension* extension,
131 const ExtensionIconSet& icon_set,
132 int resource_size_in_dip,
133 const gfx::ImageSkia& default_icon,
135 : browser_context_(context),
136 extension_(extension),
138 resource_size_in_dip_(resource_size_in_dip),
141 default_icon_(gfx::ImageSkiaOperations::CreateResizedImage(
143 skia::ImageOperations::RESIZE_BEST,
144 gfx::Size(resource_size_in_dip, resource_size_in_dip))),
145 weak_ptr_factory_(this) {
146 gfx::Size resource_size(resource_size_in_dip, resource_size_in_dip);
147 source_ = new Source(this, resource_size);
148 image_skia_ = gfx::ImageSkia(source_, resource_size);
151 extensions::NOTIFICATION_EXTENSION_REMOVED,
152 content::NotificationService::AllSources());
155 IconImage::~IconImage() {
156 source_->ResetHost();
159 gfx::ImageSkiaRep IconImage::LoadImageForScaleFactor(
160 ui::ScaleFactor scale_factor) {
161 // Do nothing if extension is unloaded.
163 return gfx::ImageSkiaRep();
165 const float scale = ui::GetScaleForScaleFactor(scale_factor);
166 const int resource_size_in_pixel =
167 static_cast<int>(resource_size_in_dip_ * scale);
169 extensions::ExtensionResource resource;
171 // Find extension resource for non bundled component extensions.
172 // We try loading bigger image only if resource size is >= 32.
173 if (resource_size_in_pixel >= kMatchBiggerTreshold) {
174 resource = GetExtensionIconResource(extension_, icon_set_,
175 resource_size_in_pixel, ExtensionIconSet::MATCH_BIGGER);
178 // If resource is not found by now, try matching smaller one.
179 if (resource.empty()) {
180 resource = GetExtensionIconResource(extension_, icon_set_,
181 resource_size_in_pixel, ExtensionIconSet::MATCH_SMALLER);
184 // If there is no resource found, return default icon.
185 if (resource.empty())
186 return default_icon_.GetRepresentation(scale);
188 std::vector<ImageLoader::ImageRepresentation> info_list;
189 info_list.push_back(ImageLoader::ImageRepresentation(
191 ImageLoader::ImageRepresentation::ALWAYS_RESIZE,
192 gfx::ToFlooredSize(gfx::ScaleSize(
193 gfx::Size(resource_size_in_dip_, resource_size_in_dip_), scale)),
196 extensions::ImageLoader* loader =
197 extensions::ImageLoader::Get(browser_context_);
198 loader->LoadImagesAsync(extension_, info_list,
199 base::Bind(&IconImage::OnImageLoaded,
200 weak_ptr_factory_.GetWeakPtr(),
203 return gfx::ImageSkiaRep();
206 void IconImage::OnImageLoaded(float scale, const gfx::Image& image_in) {
207 const gfx::ImageSkia* image =
208 image_in.IsEmpty() ? &default_icon_ : image_in.ToImageSkia();
210 // Maybe default icon was not set.
214 gfx::ImageSkiaRep rep = image->GetRepresentation(scale);
215 DCHECK(!rep.is_null());
216 DCHECK_EQ(scale, rep.scale());
218 // Remove old representation if there is one.
219 image_skia_.RemoveRepresentation(scale);
220 image_skia_.AddRepresentation(rep);
223 observer_->OnExtensionIconImageChanged(this);
226 void IconImage::Observe(int type,
227 const content::NotificationSource& source,
228 const content::NotificationDetails& details) {
229 DCHECK_EQ(type, extensions::NOTIFICATION_EXTENSION_REMOVED);
231 const Extension* extension = content::Details<const Extension>(details).ptr();
233 if (extension_ == extension)
237 } // namespace extensions