extensions/browser/image_loader.cc

   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.
   4
   5 #include "extensions/browser/image_loader.h"
   6
   7 #include <map>
   8 #include <vector>
   9
  10 #include "base/callback.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/file_util.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "base/threading/sequenced_worker_pool.h"
  15 #include "content/public/browser/browser_thread.h"
  16 #include "extensions/browser/component_extension_resource_manager.h"
  17 #include "extensions/browser/extensions_browser_client.h"
  18 #include "extensions/browser/image_loader_factory.h"
  19 #include "extensions/common/extension.h"
  20 #include "skia/ext/image_operations.h"
  21 #include "ui/base/resource/resource_bundle.h"
  22 #include "ui/gfx/codec/png_codec.h"
  23 #include "ui/gfx/image/image_family.h"
  24 #include "ui/gfx/image/image_skia.h"
  25
  26 using content::BrowserThread;
  27 using extensions::Extension;
  28 using extensions::ExtensionsBrowserClient;
  29 using extensions::ImageLoader;
  30 using extensions::Manifest;
  31
  32 namespace {
  33
  34 bool ShouldResizeImageRepresentation(
  35     ImageLoader::ImageRepresentation::ResizeCondition resize_method,
  36     const gfx::Size& decoded_size,
  37     const gfx::Size& desired_size) {
  38   switch (resize_method) {
  39     case ImageLoader::ImageRepresentation::ALWAYS_RESIZE:
  40       return decoded_size != desired_size;
  41     case ImageLoader::ImageRepresentation::RESIZE_WHEN_LARGER:
  42       return decoded_size.width() > desired_size.width() ||
  43              decoded_size.height() > desired_size.height();
  44     case ImageLoader::ImageRepresentation::NEVER_RESIZE:
  45       return false;
  46     default:
  47       NOTREACHED();
  48       return false;
  49   }
  50 }
  51
  52 SkBitmap ResizeIfNeeded(const SkBitmap& bitmap,
  53                         const ImageLoader::ImageRepresentation& image_info) {
  54   gfx::Size original_size(bitmap.width(), bitmap.height());
  55   if (ShouldResizeImageRepresentation(image_info.resize_condition,
  56                                       original_size,
  57                                       image_info.desired_size)) {
  58     return skia::ImageOperations::Resize(
  59         bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
  60         image_info.desired_size.width(), image_info.desired_size.height());
  61   }
  62
  63   return bitmap;
  64 }
  65
  66 void LoadResourceOnUIThread(int resource_id, SkBitmap* bitmap) {
  67   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  68
  69   gfx::ImageSkia image(
  70       *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id));
  71   image.MakeThreadSafe();
  72   *bitmap = *image.bitmap();
  73 }
  74
  75 void LoadImageOnBlockingPool(const ImageLoader::ImageRepresentation& image_info,
  76                              SkBitmap* bitmap) {
  77   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
  78
  79   // Read the file from disk.
  80   std::string file_contents;
  81   base::FilePath path = image_info.resource.GetFilePath();
  82   if (path.empty() || !base::ReadFileToString(path, &file_contents)) {
  83     return;
  84   }
  85
  86   const unsigned char* data =
  87       reinterpret_cast<const unsigned char*>(file_contents.data());
  88   // Note: This class only decodes bitmaps from extension resources. Chrome
  89   // doesn't (for security reasons) directly load extension resources provided
  90   // by the extension author, but instead decodes them in a separate
  91   // locked-down utility process. Only if the decoding succeeds is the image
  92   // saved from memory to disk and subsequently used in the Chrome UI.
  93   // Chrome is therefore decoding bitmaps here that were generated by Chrome.
  94   gfx::PNGCodec::Decode(data, file_contents.length(), bitmap);
  95 }
  96
  97 std::vector<SkBitmap> LoadResourceBitmaps(
  98     const Extension* extension,
  99     const std::vector<ImageLoader::ImageRepresentation>& info_list) {
 100   // Loading resources has to happen on the UI thread. So do this first, and
 101   // pass the rest of the work off as a blocking pool task.
 102   std::vector<SkBitmap> bitmaps;
 103   bitmaps.resize(info_list.size());
 104
 105   int i = 0;
 106   for (std::vector<ImageLoader::ImageRepresentation>::const_iterator
 107            it = info_list.begin();
 108        it != info_list.end();
 109        ++it, ++i) {
 110     DCHECK(it->resource.relative_path().empty() ||
 111            extension->path() == it->resource.extension_root());
 112
 113     int resource_id;
 114     if (extension->location() == Manifest::COMPONENT) {
 115       extensions::ComponentExtensionResourceManager* manager =
 116           extensions::ExtensionsBrowserClient::Get()->
 117           GetComponentExtensionResourceManager();
 118       if (manager && manager->IsComponentExtensionResource(
 119               extension->path(), it->resource.relative_path(), &resource_id)) {
 120         LoadResourceOnUIThread(resource_id, &bitmaps[i]);
 121       }
 122     }
 123   }
 124   return bitmaps;
 125 }
 126
 127 }  // namespace
 128
 129 namespace extensions {
 130
 131 ////////////////////////////////////////////////////////////////////////////////
 132 // ImageLoader::ImageRepresentation
 133
 134 ImageLoader::ImageRepresentation::ImageRepresentation(
 135     const ExtensionResource& resource,
 136     ResizeCondition resize_condition,
 137     const gfx::Size& desired_size,
 138     ui::ScaleFactor scale_factor)
 139     : resource(resource),
 140       resize_condition(resize_condition),
 141       desired_size(desired_size),
 142       scale_factor(scale_factor) {
 143 }
 144
 145 ImageLoader::ImageRepresentation::~ImageRepresentation() {
 146 }
 147
 148 ////////////////////////////////////////////////////////////////////////////////
 149 // ImageLoader::LoadResult
 150
 151 struct ImageLoader::LoadResult  {
 152   LoadResult(const SkBitmap& bitmap,
 153              const gfx::Size& original_size,
 154              const ImageRepresentation& image_representation);
 155   ~LoadResult();
 156
 157   SkBitmap bitmap;
 158   gfx::Size original_size;
 159   ImageRepresentation image_representation;
 160 };
 161
 162 ImageLoader::LoadResult::LoadResult(
 163     const SkBitmap& bitmap,
 164     const gfx::Size& original_size,
 165     const ImageLoader::ImageRepresentation& image_representation)
 166     : bitmap(bitmap),
 167       original_size(original_size),
 168       image_representation(image_representation) {
 169 }
 170
 171 ImageLoader::LoadResult::~LoadResult() {
 172 }
 173
 174 namespace {
 175
 176 // Need to be after ImageRepresentation and LoadResult are defined.
 177 std::vector<ImageLoader::LoadResult> LoadImagesOnBlockingPool(
 178     const std::vector<ImageLoader::ImageRepresentation>& info_list,
 179     const std::vector<SkBitmap>& bitmaps) {
 180   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 181   std::vector<ImageLoader::LoadResult> load_result;
 182
 183   for (size_t i = 0; i < info_list.size(); ++i) {
 184     const ImageLoader::ImageRepresentation& image = info_list[i];
 185
 186     // If we don't have a path there isn't anything we can do, just skip it.
 187     if (image.resource.relative_path().empty())
 188       continue;
 189
 190     SkBitmap bitmap;
 191     if (bitmaps[i].isNull())
 192       LoadImageOnBlockingPool(image, &bitmap);
 193     else
 194       bitmap = bitmaps[i];
 195
 196     // If the image failed to load, skip it.
 197     if (bitmap.isNull() || bitmap.empty())
 198       continue;
 199
 200     gfx::Size original_size(bitmap.width(), bitmap.height());
 201     bitmap = ResizeIfNeeded(bitmap, image);
 202
 203     load_result.push_back(
 204         ImageLoader::LoadResult(bitmap, original_size, image));
 205   }
 206
 207   return load_result;
 208 }
 209
 210 }  // namespace
 211
 212 ////////////////////////////////////////////////////////////////////////////////
 213 // ImageLoader
 214
 215 ImageLoader::ImageLoader()
 216     : weak_ptr_factory_(this) {
 217 }
 218
 219 ImageLoader::~ImageLoader() {
 220 }
 221
 222 // static
 223 ImageLoader* ImageLoader::Get(content::BrowserContext* context) {
 224   return ImageLoaderFactory::GetForBrowserContext(context);
 225 }
 226
 227 void ImageLoader::LoadImageAsync(const Extension* extension,
 228                                  const ExtensionResource& resource,
 229                                  const gfx::Size& max_size,
 230                                  const ImageLoaderImageCallback& callback) {
 231   std::vector<ImageRepresentation> info_list;
 232   info_list.push_back(ImageRepresentation(
 233       resource,
 234       ImageRepresentation::RESIZE_WHEN_LARGER,
 235       max_size,
 236       ui::SCALE_FACTOR_100P));
 237   LoadImagesAsync(extension, info_list, callback);
 238 }
 239
 240 void ImageLoader::LoadImagesAsync(
 241     const Extension* extension,
 242     const std::vector<ImageRepresentation>& info_list,
 243     const ImageLoaderImageCallback& callback) {
 244   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 245   DCHECK(!BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 246   base::PostTaskAndReplyWithResult(
 247       BrowserThread::GetBlockingPool(),
 248       FROM_HERE,
 249       base::Bind(LoadImagesOnBlockingPool,
 250                  info_list,
 251                  LoadResourceBitmaps(extension, info_list)),
 252       base::Bind(
 253           &ImageLoader::ReplyBack, weak_ptr_factory_.GetWeakPtr(), callback));
 254 }
 255
 256 void ImageLoader::LoadImageFamilyAsync(
 257     const extensions::Extension* extension,
 258     const std::vector<ImageRepresentation>& info_list,
 259     const ImageLoaderImageFamilyCallback& callback) {
 260   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 261   DCHECK(!BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 262   base::PostTaskAndReplyWithResult(
 263       BrowserThread::GetBlockingPool(),
 264       FROM_HERE,
 265       base::Bind(LoadImagesOnBlockingPool,
 266                  info_list,
 267                  LoadResourceBitmaps(extension, info_list)),
 268       base::Bind(&ImageLoader::ReplyBackWithImageFamily,
 269                  weak_ptr_factory_.GetWeakPtr(),
 270                  callback));
 271 }
 272
 273 void ImageLoader::ReplyBack(const ImageLoaderImageCallback& callback,
 274                             const std::vector<LoadResult>& load_result) {
 275   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 276
 277   gfx::ImageSkia image_skia;
 278
 279   for (std::vector<LoadResult>::const_iterator it = load_result.begin();
 280        it != load_result.end(); ++it) {
 281     const SkBitmap& bitmap = it->bitmap;
 282     const ImageRepresentation& image_rep = it->image_representation;
 283
 284     image_skia.AddRepresentation(gfx::ImageSkiaRep(
 285         bitmap,
 286         ui::GetScaleForScaleFactor(image_rep.scale_factor)));
 287   }
 288
 289   gfx::Image image;
 290   if (!image_skia.isNull()) {
 291     image_skia.MakeThreadSafe();
 292     image = gfx::Image(image_skia);
 293   }
 294
 295   callback.Run(image);
 296 }
 297
 298 void ImageLoader::ReplyBackWithImageFamily(
 299     const ImageLoaderImageFamilyCallback& callback,
 300     const std::vector<LoadResult>& load_result) {
 301   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 302
 303   std::map<std::pair<int, int>, gfx::ImageSkia> image_skia_map;
 304   gfx::ImageFamily image_family;
 305
 306   for (std::vector<LoadResult>::const_iterator it = load_result.begin();
 307        it != load_result.end();
 308        ++it) {
 309     const SkBitmap& bitmap = it->bitmap;
 310     const ImageRepresentation& image_rep = it->image_representation;
 311     const std::pair<int, int> key = std::make_pair(
 312         image_rep.desired_size.width(), image_rep.desired_size.height());
 313     // Create a new ImageSkia for this width/height, or add a representation to
 314     // an existing ImageSkia with the same width/height.
 315     image_skia_map[key].AddRepresentation(
 316         gfx::ImageSkiaRep(bitmap,
 317                           ui::GetScaleForScaleFactor(image_rep.scale_factor)));
 318   }
 319
 320   for (std::map<std::pair<int, int>, gfx::ImageSkia>::iterator it =
 321            image_skia_map.begin();
 322        it != image_skia_map.end();
 323        ++it) {
 324     it->second.MakeThreadSafe();
 325     image_family.Add(it->second);
 326   }
 327
 328   callback.Run(image_family);
 329 }
 330
 331 }  // namespace extensions