chrome/browser/ui/webui/extensions/extension_icon_source.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/ui/webui/extensions/extension_icon_source.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/memory/ref_counted_memory.h"
  10 #include "base/stl_util.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/string_split.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/threading/thread.h"
  16 #include "chrome/browser/extensions/extension_prefs.h"
  17 #include "chrome/browser/extensions/extension_service.h"
  18 #include "chrome/browser/extensions/extension_system.h"
  19 #include "chrome/browser/extensions/image_loader.h"
  20 #include "chrome/browser/favicon/favicon_service_factory.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/common/extensions/extension_constants.h"
  23 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
  24 #include "chrome/common/extensions/manifest_handlers/icons_handler.h"
  25 #include "chrome/common/url_constants.h"
  26 #include "extensions/common/extension.h"
  27 #include "extensions/common/extension_resource.h"
  28 #include "grit/component_extension_resources_map.h"
  29 #include "grit/theme_resources.h"
  30 #include "skia/ext/image_operations.h"
  31 #include "ui/base/layout.h"
  32 #include "ui/base/resource/resource_bundle.h"
  33 #include "ui/gfx/codec/png_codec.h"
  34 #include "ui/gfx/color_utils.h"
  35 #include "ui/gfx/favicon_size.h"
  36 #include "ui/gfx/size.h"
  37 #include "ui/gfx/skbitmap_operations.h"
  38 #include "url/gurl.h"
  39
  40 namespace extensions {
  41
  42 namespace {
  43
  44 scoped_refptr<base::RefCountedMemory> BitmapToMemory(const SkBitmap* image) {
  45   base::RefCountedBytes* image_bytes = new base::RefCountedBytes;
  46   gfx::PNGCodec::EncodeBGRASkBitmap(*image, false, &image_bytes->data());
  47   return image_bytes;
  48 }
  49
  50 SkBitmap DesaturateImage(const SkBitmap* image) {
  51   color_utils::HSL shift = {-1, 0, 0.6};
  52   return SkBitmapOperations::CreateHSLShiftedBitmap(*image, shift);
  53 }
  54
  55 SkBitmap* ToBitmap(const unsigned char* data, size_t size) {
  56   SkBitmap* decoded = new SkBitmap();
  57   bool success = gfx::PNGCodec::Decode(data, size, decoded);
  58   DCHECK(success);
  59   return decoded;
  60 }
  61
  62 }  // namespace
  63
  64 ExtensionIconSource::ExtensionIconSource(Profile* profile) : profile_(profile) {
  65 }
  66
  67 struct ExtensionIconSource::ExtensionIconRequest {
  68   content::URLDataSource::GotDataCallback callback;
  69   scoped_refptr<const Extension> extension;
  70   bool grayscale;
  71   int size;
  72   ExtensionIconSet::MatchType match;
  73 };
  74
  75 // static
  76 GURL ExtensionIconSource::GetIconURL(const Extension* extension,
  77                                      int icon_size,
  78                                      ExtensionIconSet::MatchType match,
  79                                      bool grayscale,
  80                                      bool* exists) {
  81   if (exists) {
  82     *exists =
  83         IconsInfo::GetIconURL(extension, icon_size, match) != GURL::EmptyGURL();
  84   }
  85
  86   GURL icon_url(base::StringPrintf("%s%s/%d/%d%s",
  87                                    chrome::kChromeUIExtensionIconURL,
  88                                    extension->id().c_str(),
  89                                    icon_size,
  90                                    match,
  91                                    grayscale ? "?grayscale=true" : ""));
  92   CHECK(icon_url.is_valid());
  93   return icon_url;
  94 }
  95
  96 // static
  97 SkBitmap* ExtensionIconSource::LoadImageByResourceId(int resource_id) {
  98   std::string contents = ResourceBundle::GetSharedInstance()
  99       .GetRawDataResourceForScale(resource_id,
 100                                   ui::SCALE_FACTOR_100P).as_string();
 101
 102   // Convert and return it.
 103   const unsigned char* data =
 104       reinterpret_cast<const unsigned char*>(contents.data());
 105   return ToBitmap(data, contents.length());
 106 }
 107
 108 std::string ExtensionIconSource::GetSource() const {
 109   return chrome::kChromeUIExtensionIconHost;
 110 }
 111
 112 std::string ExtensionIconSource::GetMimeType(const std::string&) const {
 113   // We need to explicitly return a mime type, otherwise if the user tries to
 114   // drag the image they get no extension.
 115   return "image/png";
 116 }
 117
 118 void ExtensionIconSource::StartDataRequest(
 119     const std::string& path,
 120     int render_process_id,
 121     int render_frame_id,
 122     const content::URLDataSource::GotDataCallback& callback) {
 123   // This is where everything gets started. First, parse the request and make
 124   // the request data available for later.
 125   static int next_id = 0;
 126   if (!ParseData(path, ++next_id, callback)) {
 127     // If the request data cannot be parsed, request parameters will not be
 128     // added to |request_map_|.
 129     // Send back the default application icon (not resized or desaturated) as
 130     // the default response.
 131     callback.Run(BitmapToMemory(GetDefaultAppImage()).get());
 132     return;
 133   }
 134
 135   ExtensionIconRequest* request = GetData(next_id);
 136   ExtensionResource icon = IconsInfo::GetIconResource(
 137       request->extension, request->size, request->match);
 138
 139   if (icon.relative_path().empty()) {
 140     LoadIconFailed(next_id);
 141   } else {
 142     LoadExtensionImage(icon, next_id);
 143   }
 144 }
 145
 146 ExtensionIconSource::~ExtensionIconSource() {
 147   // Clean up all the temporary data we're holding for requests.
 148   STLDeleteValues(&request_map_);
 149 }
 150
 151 const SkBitmap* ExtensionIconSource::GetDefaultAppImage() {
 152   if (!default_app_data_.get())
 153     default_app_data_.reset(LoadImageByResourceId(IDR_APP_DEFAULT_ICON));
 154
 155   return default_app_data_.get();
 156 }
 157
 158 const SkBitmap* ExtensionIconSource::GetDefaultExtensionImage() {
 159   if (!default_extension_data_.get()) {
 160     default_extension_data_.reset(
 161         LoadImageByResourceId(IDR_EXTENSION_DEFAULT_ICON));
 162   }
 163
 164   return default_extension_data_.get();
 165 }
 166
 167 void ExtensionIconSource::FinalizeImage(const SkBitmap* image,
 168                                         int request_id) {
 169   SkBitmap bitmap;
 170   ExtensionIconRequest* request = GetData(request_id);
 171   if (request->grayscale)
 172     bitmap = DesaturateImage(image);
 173   else
 174     bitmap = *image;
 175
 176   request->callback.Run(BitmapToMemory(&bitmap).get());
 177   ClearData(request_id);
 178 }
 179
 180 void ExtensionIconSource::LoadDefaultImage(int request_id) {
 181   ExtensionIconRequest* request = GetData(request_id);
 182   const SkBitmap* default_image = NULL;
 183
 184   if (request->extension->is_app())
 185     default_image = GetDefaultAppImage();
 186   else
 187     default_image = GetDefaultExtensionImage();
 188
 189   SkBitmap resized_image(skia::ImageOperations::Resize(
 190       *default_image, skia::ImageOperations::RESIZE_LANCZOS3,
 191       request->size, request->size));
 192
 193   // There are cases where Resize returns an empty bitmap, for example if you
 194   // ask for an image too large. In this case it is better to return the default
 195   // image than returning nothing at all.
 196   if (resized_image.empty())
 197     resized_image = *default_image;
 198
 199   FinalizeImage(&resized_image, request_id);
 200 }
 201
 202 void ExtensionIconSource::LoadExtensionImage(const ExtensionResource& icon,
 203                                              int request_id) {
 204   ExtensionIconRequest* request = GetData(request_id);
 205   ImageLoader::Get(profile_)->LoadImageAsync(
 206       request->extension, icon,
 207       gfx::Size(request->size, request->size),
 208       base::Bind(&ExtensionIconSource::OnImageLoaded, AsWeakPtr(), request_id));
 209 }
 210
 211 void ExtensionIconSource::LoadFaviconImage(int request_id) {
 212   FaviconService* favicon_service =
 213       FaviconServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
 214   // Fall back to the default icons if the service isn't available.
 215   if (favicon_service == NULL) {
 216     LoadDefaultImage(request_id);
 217     return;
 218   }
 219
 220   GURL favicon_url =
 221       AppLaunchInfo::GetFullLaunchURL(GetData(request_id)->extension);
 222   favicon_service->GetRawFaviconForURL(
 223       FaviconService::FaviconForURLParams(favicon_url, chrome::FAVICON,
 224                                           gfx::kFaviconSize),
 225       ui::SCALE_FACTOR_100P,
 226       base::Bind(&ExtensionIconSource::OnFaviconDataAvailable,
 227                  base::Unretained(this), request_id),
 228       &cancelable_task_tracker_);
 229 }
 230
 231 void ExtensionIconSource::OnFaviconDataAvailable(
 232     int request_id,
 233     const chrome::FaviconBitmapResult& bitmap_result) {
 234   ExtensionIconRequest* request = GetData(request_id);
 235
 236   // Fallback to the default icon if there wasn't a favicon.
 237   if (!bitmap_result.is_valid()) {
 238     LoadDefaultImage(request_id);
 239     return;
 240   }
 241
 242   if (!request->grayscale) {
 243     // If we don't need a grayscale image, then we can bypass FinalizeImage
 244     // to avoid unnecessary conversions.
 245     request->callback.Run(bitmap_result.bitmap_data.get());
 246     ClearData(request_id);
 247   } else {
 248     FinalizeImage(ToBitmap(bitmap_result.bitmap_data->front(),
 249                            bitmap_result.bitmap_data->size()), request_id);
 250   }
 251 }
 252
 253 void ExtensionIconSource::OnImageLoaded(int request_id,
 254                                         const gfx::Image& image) {
 255   if (image.IsEmpty())
 256     LoadIconFailed(request_id);
 257   else
 258     FinalizeImage(image.ToSkBitmap(), request_id);
 259 }
 260
 261 void ExtensionIconSource::LoadIconFailed(int request_id) {
 262   ExtensionIconRequest* request = GetData(request_id);
 263   ExtensionResource icon = IconsInfo::GetIconResource(
 264       request->extension, request->size, request->match);
 265
 266   if (request->size == extension_misc::EXTENSION_ICON_BITTY)
 267     LoadFaviconImage(request_id);
 268   else
 269     LoadDefaultImage(request_id);
 270 }
 271
 272 bool ExtensionIconSource::ParseData(
 273     const std::string& path,
 274     int request_id,
 275     const content::URLDataSource::GotDataCallback& callback) {
 276   // Extract the parameters from the path by lower casing and splitting.
 277   std::string path_lower = StringToLowerASCII(path);
 278   std::vector<std::string> path_parts;
 279
 280   base::SplitString(path_lower, '/', &path_parts);
 281   if (path_lower.empty() || path_parts.size() < 3)
 282     return false;
 283
 284   std::string size_param = path_parts.at(1);
 285   std::string match_param = path_parts.at(2);
 286   match_param = match_param.substr(0, match_param.find('?'));
 287
 288   int size;
 289   if (!base::StringToInt(size_param, &size))
 290     return false;
 291   if (size <= 0 || size > extension_misc::EXTENSION_ICON_GIGANTOR)
 292     return false;
 293
 294   ExtensionIconSet::MatchType match_type;
 295   int match_num;
 296   if (!base::StringToInt(match_param, &match_num))
 297     return false;
 298   match_type = static_cast<ExtensionIconSet::MatchType>(match_num);
 299   if (!(match_type == ExtensionIconSet::MATCH_EXACTLY ||
 300         match_type == ExtensionIconSet::MATCH_SMALLER ||
 301         match_type == ExtensionIconSet::MATCH_BIGGER))
 302     match_type = ExtensionIconSet::MATCH_EXACTLY;
 303
 304   std::string extension_id = path_parts.at(0);
 305   const Extension* extension = ExtensionSystem::Get(profile_)->
 306       extension_service()->GetInstalledExtension(extension_id);
 307   if (!extension)
 308     return false;
 309
 310   bool grayscale = path_lower.find("grayscale=true") != std::string::npos;
 311
 312   SetData(request_id, callback, extension, grayscale, size, match_type);
 313
 314   return true;
 315 }
 316
 317 void ExtensionIconSource::SetData(
 318     int request_id,
 319     const content::URLDataSource::GotDataCallback& callback,
 320     const Extension* extension,
 321     bool grayscale,
 322     int size,
 323     ExtensionIconSet::MatchType match) {
 324   ExtensionIconRequest* request = new ExtensionIconRequest();
 325   request->callback = callback;
 326   request->extension = extension;
 327   request->grayscale = grayscale;
 328   request->size = size;
 329   request->match = match;
 330   request_map_[request_id] = request;
 331 }
 332
 333 ExtensionIconSource::ExtensionIconRequest* ExtensionIconSource::GetData(
 334     int request_id) {
 335   return request_map_[request_id];
 336 }
 337
 338 void ExtensionIconSource::ClearData(int request_id) {
 339   std::map<int, ExtensionIconRequest*>::iterator i =
 340       request_map_.find(request_id);
 341   if (i == request_map_.end())
 342     return;
 343
 344   delete i->second;
 345   request_map_.erase(i);
 346 }
 347
 348 }  // namespace extensions