extensions/browser/image_loader.cc - chromium/src.git - Git at Google

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "extensions/browser/image_loader.h"

 #include <stddef.h>

 #include <map>
 #include <vector>

 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_scheduler/post_task.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/component_extension_resource_manager.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/image_loader_factory.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image_family.h"
 #include "ui/gfx/image/image_skia.h"

 using content::BrowserThread;

 namespace extensions {

 namespace {

 bool ShouldResizeImageRepresentation(
     ImageLoader::ImageRepresentation::ResizeCondition resize_method,
     const gfx::Size& decoded_size,
     const gfx::Size& desired_size) {
   switch (resize_method) {
     case ImageLoader::ImageRepresentation::ALWAYS_RESIZE:
       return decoded_size != desired_size;
     case ImageLoader::ImageRepresentation::RESIZE_WHEN_LARGER:
       return decoded_size.width() > desired_size.width() ||
              decoded_size.height() > desired_size.height();
     case ImageLoader::ImageRepresentation::NEVER_RESIZE:
       return false;
     default:
       NOTREACHED();
       return false;
   }
 }

 SkBitmap ResizeIfNeeded(const SkBitmap& bitmap,
                         const ImageLoader::ImageRepresentation& image_info) {
   gfx::Size original_size(bitmap.width(), bitmap.height());
   if (ShouldResizeImageRepresentation(image_info.resize_condition,
                                       original_size,
                                       image_info.desired_size)) {
     return skia::ImageOperations::Resize(
         bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
         image_info.desired_size.width(), image_info.desired_size.height());
   }

   return bitmap;
 }

 void LoadResourceOnUIThread(int resource_id, SkBitmap* bitmap) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);

   gfx::ImageSkia image(
       *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id));
   image.MakeThreadSafe();
   *bitmap = *image.bitmap();
 }

 void LoadImageBlocking(const ImageLoader::ImageRepresentation& image_info,
                        SkBitmap* bitmap) {
   // Read the file from disk.
   std::string file_contents;
   base::FilePath path = image_info.resource.GetFilePath();
   if (path.empty() || !base::ReadFileToString(path, &file_contents)) {
     return;
   }

   const unsigned char* data =
       reinterpret_cast<const unsigned char*>(file_contents.data());
   // Note: This class only decodes bitmaps from extension resources. Chrome
   // doesn't (for security reasons) directly load extension resources provided
   // by the extension author, but instead decodes them in a separate
   // locked-down utility process. Only if the decoding succeeds is the image
   // saved from memory to disk and subsequently used in the Chrome UI.
   // Chrome is therefore decoding bitmaps here that were generated by Chrome.
   gfx::PNGCodec::Decode(data, file_contents.length(), bitmap);
 }

 std::vector<SkBitmap> LoadResourceBitmaps(
     const Extension* extension,
     const std::vector<ImageLoader::ImageRepresentation>& info_list) {
   // Loading resources has to happen on the UI thread. So do this first, and
   // pass the rest of the work off as a blocking pool task.
   std::vector<SkBitmap> bitmaps;
   bitmaps.resize(info_list.size());

   int i = 0;
   for (std::vector<ImageLoader::ImageRepresentation>::const_iterator
            it = info_list.begin();
        it != info_list.end();
        ++it, ++i) {
     DCHECK(it->resource.relative_path().empty() ||
            extension->path() == it->resource.extension_root());

     int resource_id;
     if (extension->location() == Manifest::COMPONENT) {
       const extensions::ComponentExtensionResourceManager* manager =
           extensions::ExtensionsBrowserClient::Get()
               ->GetComponentExtensionResourceManager();
       if (manager && manager->IsComponentExtensionResource(
               extension->path(), it->resource.relative_path(), &resource_id)) {
         LoadResourceOnUIThread(resource_id, &bitmaps[i]);
       }
     }
   }
   return bitmaps;
 }

 }  // namespace

 ////////////////////////////////////////////////////////////////////////////////
 // ImageLoader::ImageRepresentation

 ImageLoader::ImageRepresentation::ImageRepresentation(
     const ExtensionResource& resource,
     ResizeCondition resize_condition,
     const gfx::Size& desired_size,
     float scale_factor)
     : resource(resource),
       resize_condition(resize_condition),
       desired_size(desired_size),
       scale_factor(scale_factor) {}

 ImageLoader::ImageRepresentation::~ImageRepresentation() {
 }

 ////////////////////////////////////////////////////////////////////////////////
 // ImageLoader::LoadResult

 struct ImageLoader::LoadResult  {
   LoadResult(const SkBitmap& bitmap,
              const gfx::Size& original_size,
              const ImageRepresentation& image_representation);
   ~LoadResult();

   SkBitmap bitmap;
   gfx::Size original_size;
   ImageRepresentation image_representation;
 };

 ImageLoader::LoadResult::LoadResult(
     const SkBitmap& bitmap,
     const gfx::Size& original_size,
     const ImageLoader::ImageRepresentation& image_representation)
     : bitmap(bitmap),
       original_size(original_size),
       image_representation(image_representation) {
 }

 ImageLoader::LoadResult::~LoadResult() {
 }

 namespace {

 // Need to be after ImageRepresentation and LoadResult are defined.
 std::vector<ImageLoader::LoadResult> LoadImagesBlocking(
     const std::vector<ImageLoader::ImageRepresentation>& info_list,
     const std::vector<SkBitmap>& bitmaps) {
   std::vector<ImageLoader::LoadResult> load_result;

   for (size_t i = 0; i < info_list.size(); ++i) {
     const ImageLoader::ImageRepresentation& image = info_list[i];

     // If we don't have a path there isn't anything we can do, just skip it.
     if (image.resource.relative_path().empty())
       continue;

     SkBitmap bitmap;
     if (bitmaps[i].isNull())
       LoadImageBlocking(image, &bitmap);
     else
       bitmap = bitmaps[i];

     // If the image failed to load, skip it.
     if (bitmap.isNull() || bitmap.empty())
       continue;

     gfx::Size original_size(bitmap.width(), bitmap.height());
     bitmap = ResizeIfNeeded(bitmap, image);

     load_result.push_back(
         ImageLoader::LoadResult(bitmap, original_size, image));
   }

   return load_result;
 }

 }  // namespace

 ////////////////////////////////////////////////////////////////////////////////
 // ImageLoader

 ImageLoader::ImageLoader()
     : weak_ptr_factory_(this) {
 }

 ImageLoader::~ImageLoader() {
 }

 // static
 ImageLoader* ImageLoader::Get(content::BrowserContext* context) {
   return ImageLoaderFactory::GetForBrowserContext(context);
 }

 void ImageLoader::LoadImageAsync(const Extension* extension,
                                  const ExtensionResource& resource,
                                  const gfx::Size& max_size,
                                  const ImageLoaderImageCallback& callback) {
   std::vector<ImageRepresentation> info_list;
   info_list.push_back(ImageRepresentation(
       resource, ImageRepresentation::RESIZE_WHEN_LARGER, max_size, 1.f));
   LoadImagesAsync(extension, info_list, callback);
 }

 void ImageLoader::LoadImageAtEveryScaleFactorAsync(
     const Extension* extension,
     const gfx::Size& dip_size,
     const ImageLoaderImageCallback& callback) {
   std::vector<ImageRepresentation> info_list;

   std::set<float> scales;
   for (auto scale : ui::GetSupportedScaleFactors())
     scales.insert(ui::GetScaleForScaleFactor(scale));

   // There may not be a screen in unit tests.
   auto* screen = display::Screen::GetScreen();
   if (screen) {
     for (const auto& display : screen->GetAllDisplays())
       scales.insert(display.device_scale_factor());
   }

   for (auto scale : scales) {
     const gfx::Size px_size = gfx::ScaleToFlooredSize(dip_size, scale);
     ExtensionResource image = IconsInfo::GetIconResource(
         extension, px_size.width(), ExtensionIconSet::MATCH_BIGGER);
     info_list.push_back(ImageRepresentation(
         image, ImageRepresentation::ALWAYS_RESIZE, px_size, scale));
   }
   LoadImagesAsync(extension, info_list, callback);
 }

 void ImageLoader::LoadImagesAsync(
     const Extension* extension,
     const std::vector<ImageRepresentation>& info_list,
     const ImageLoaderImageCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
       base::Bind(LoadImagesBlocking, info_list,
                  LoadResourceBitmaps(extension, info_list)),
       base::Bind(&ImageLoader::ReplyBack, weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }

 void ImageLoader::LoadImageFamilyAsync(
     const Extension* extension,
     const std::vector<ImageRepresentation>& info_list,
     const ImageLoaderImageFamilyCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
       base::Bind(LoadImagesBlocking, info_list,
                  LoadResourceBitmaps(extension, info_list)),
       base::Bind(&ImageLoader::ReplyBackWithImageFamily,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }

 void ImageLoader::ReplyBack(const ImageLoaderImageCallback& callback,
                             const std::vector<LoadResult>& load_result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);

   gfx::ImageSkia image_skia;

   for (std::vector<LoadResult>::const_iterator it = load_result.begin();
        it != load_result.end(); ++it) {
     const SkBitmap& bitmap = it->bitmap;
     const ImageRepresentation& image_rep = it->image_representation;

     image_skia.AddRepresentation(
         gfx::ImageSkiaRep(bitmap, image_rep.scale_factor));
   }

   gfx::Image image;
   if (!image_skia.isNull()) {
     image_skia.MakeThreadSafe();
     image = gfx::Image(image_skia);
   }

   callback.Run(image);
 }

 void ImageLoader::ReplyBackWithImageFamily(
     const ImageLoaderImageFamilyCallback& callback,
     const std::vector<LoadResult>& load_result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);

   std::map<std::pair<int, int>, gfx::ImageSkia> image_skia_map;
   gfx::ImageFamily image_family;

   for (std::vector<LoadResult>::const_iterator it = load_result.begin();
        it != load_result.end();
        ++it) {
     const SkBitmap& bitmap = it->bitmap;
     const ImageRepresentation& image_rep = it->image_representation;
     const std::pair<int, int> key = std::make_pair(
         image_rep.desired_size.width(), image_rep.desired_size.height());
     // Create a new ImageSkia for this width/height, or add a representation to
     // an existing ImageSkia with the same width/height.
     image_skia_map[key].AddRepresentation(
         gfx::ImageSkiaRep(bitmap, image_rep.scale_factor));
   }

   for (std::map<std::pair<int, int>, gfx::ImageSkia>::iterator it =
            image_skia_map.begin();
        it != image_skia_map.end();
        ++it) {
     it->second.MakeThreadSafe();
     image_family.Add(it->second);
   }

   callback.Run(std::move(image_family));
 }

 }  // namespace extensions
	// Copyright 2014 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "extensions/browser/image_loader.h"

	#include <stddef.h>

	#include <map>
	#include <vector>

	#include "base/callback.h"
	#include "base/compiler_specific.h"
	#include "base/files/file_util.h"
	#include "base/strings/string_number_conversions.h"
	#include "base/task_scheduler/post_task.h"
	#include "content/public/browser/browser_thread.h"
	#include "extensions/browser/component_extension_resource_manager.h"
	#include "extensions/browser/extensions_browser_client.h"
	#include "extensions/browser/image_loader_factory.h"
	#include "extensions/common/extension.h"
	#include "extensions/common/manifest_handlers/icons_handler.h"
	#include "skia/ext/image_operations.h"
	#include "ui/base/layout.h"
	#include "ui/base/resource/resource_bundle.h"
	#include "ui/display/display.h"
	#include "ui/display/screen.h"
	#include "ui/gfx/codec/png_codec.h"
	#include "ui/gfx/image/image_family.h"
	#include "ui/gfx/image/image_skia.h"

	using content::BrowserThread;

	namespace extensions {

	namespace {

	bool ShouldResizeImageRepresentation(
	ImageLoader::ImageRepresentation::ResizeCondition resize_method,
	const gfx::Size& decoded_size,
	const gfx::Size& desired_size) {
	switch (resize_method) {
	case ImageLoader::ImageRepresentation::ALWAYS_RESIZE:
	return decoded_size != desired_size;
	case ImageLoader::ImageRepresentation::RESIZE_WHEN_LARGER:
	return decoded_size.width() > desired_size.width() \|\|
	decoded_size.height() > desired_size.height();
	case ImageLoader::ImageRepresentation::NEVER_RESIZE:
	return false;
	default:
	NOTREACHED();
	return false;
	}
	}

	SkBitmap ResizeIfNeeded(const SkBitmap& bitmap,
	const ImageLoader::ImageRepresentation& image_info) {
	gfx::Size original_size(bitmap.width(), bitmap.height());
	if (ShouldResizeImageRepresentation(image_info.resize_condition,
	original_size,
	image_info.desired_size)) {
	return skia::ImageOperations::Resize(
	bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
	image_info.desired_size.width(), image_info.desired_size.height());
	}

	return bitmap;
	}

	void LoadResourceOnUIThread(int resource_id, SkBitmap* bitmap) {
	DCHECK_CURRENTLY_ON(BrowserThread::UI);

	gfx::ImageSkia image(
	*ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id));
	image.MakeThreadSafe();
	bitmap = image.bitmap();
	}

	void LoadImageBlocking(const ImageLoader::ImageRepresentation& image_info,
	SkBitmap* bitmap) {
	// Read the file from disk.
	std::string file_contents;
	base::FilePath path = image_info.resource.GetFilePath();
	if (path.empty() \|\| !base::ReadFileToString(path, &file_contents)) {
	return;
	}

	const unsigned char* data =
	reinterpret_cast<const unsigned char*>(file_contents.data());
	// Note: This class only decodes bitmaps from extension resources. Chrome
	// doesn't (for security reasons) directly load extension resources provided
	// by the extension author, but instead decodes them in a separate
	// locked-down utility process. Only if the decoding succeeds is the image
	// saved from memory to disk and subsequently used in the Chrome UI.
	// Chrome is therefore decoding bitmaps here that were generated by Chrome.
	gfx::PNGCodec::Decode(data, file_contents.length(), bitmap);
	}

	std::vector<SkBitmap> LoadResourceBitmaps(
	const Extension* extension,
	const std::vector<ImageLoader::ImageRepresentation>& info_list) {
	// Loading resources has to happen on the UI thread. So do this first, and
	// pass the rest of the work off as a blocking pool task.
	std::vector<SkBitmap> bitmaps;
	bitmaps.resize(info_list.size());

	int i = 0;
	for (std::vector<ImageLoader::ImageRepresentation>::const_iterator
	it = info_list.begin();
	it != info_list.end();
	++it, ++i) {
	DCHECK(it->resource.relative_path().empty() \|\|
	extension->path() == it->resource.extension_root());

	int resource_id;
	if (extension->location() == Manifest::COMPONENT) {
	const extensions::ComponentExtensionResourceManager* manager =
	extensions::ExtensionsBrowserClient::Get()
	->GetComponentExtensionResourceManager();
	if (manager && manager->IsComponentExtensionResource(
	extension->path(), it->resource.relative_path(), &resource_id)) {
	LoadResourceOnUIThread(resource_id, &bitmaps[i]);
	}
	}
	}
	return bitmaps;
	}

	} // namespace

	////////////////////////////////////////////////////////////////////////////////
	// ImageLoader::ImageRepresentation

	ImageLoader::ImageRepresentation::ImageRepresentation(
	const ExtensionResource& resource,
	ResizeCondition resize_condition,
	const gfx::Size& desired_size,
	float scale_factor)
	: resource(resource),
	resize_condition(resize_condition),
	desired_size(desired_size),
	scale_factor(scale_factor) {}

	ImageLoader::ImageRepresentation::~ImageRepresentation() {
	}

	////////////////////////////////////////////////////////////////////////////////
	// ImageLoader::LoadResult

	struct ImageLoader::LoadResult {
	LoadResult(const SkBitmap& bitmap,
	const gfx::Size& original_size,
	const ImageRepresentation& image_representation);
	~LoadResult();

	SkBitmap bitmap;
	gfx::Size original_size;
	ImageRepresentation image_representation;
	};

	ImageLoader::LoadResult::LoadResult(
	const SkBitmap& bitmap,
	const gfx::Size& original_size,
	const ImageLoader::ImageRepresentation& image_representation)
	: bitmap(bitmap),
	original_size(original_size),
	image_representation(image_representation) {
	}

	ImageLoader::LoadResult::~LoadResult() {
	}

	namespace {

	// Need to be after ImageRepresentation and LoadResult are defined.
	std::vector<ImageLoader::LoadResult> LoadImagesBlocking(
	const std::vector<ImageLoader::ImageRepresentation>& info_list,
	const std::vector<SkBitmap>& bitmaps) {
	std::vector<ImageLoader::LoadResult> load_result;

	for (size_t i = 0; i < info_list.size(); ++i) {
	const ImageLoader::ImageRepresentation& image = info_list[i];

	// If we don't have a path there isn't anything we can do, just skip it.
	if (image.resource.relative_path().empty())
	continue;

	SkBitmap bitmap;
	if (bitmaps[i].isNull())
	LoadImageBlocking(image, &bitmap);
	else
	bitmap = bitmaps[i];

	// If the image failed to load, skip it.
	if (bitmap.isNull() \|\| bitmap.empty())
	continue;

	gfx::Size original_size(bitmap.width(), bitmap.height());
	bitmap = ResizeIfNeeded(bitmap, image);

	load_result.push_back(
	ImageLoader::LoadResult(bitmap, original_size, image));
	}

	return load_result;
	}

	} // namespace

	////////////////////////////////////////////////////////////////////////////////
	// ImageLoader

	ImageLoader::ImageLoader()
	: weak_ptr_factory_(this) {
	}

	ImageLoader::~ImageLoader() {
	}

	// static
	ImageLoader* ImageLoader::Get(content::BrowserContext* context) {
	return ImageLoaderFactory::GetForBrowserContext(context);
	}

	void ImageLoader::LoadImageAsync(const Extension* extension,
	const ExtensionResource& resource,
	const gfx::Size& max_size,
	const ImageLoaderImageCallback& callback) {
	std::vector<ImageRepresentation> info_list;
	info_list.push_back(ImageRepresentation(
	resource, ImageRepresentation::RESIZE_WHEN_LARGER, max_size, 1.f));
	LoadImagesAsync(extension, info_list, callback);
	}

	void ImageLoader::LoadImageAtEveryScaleFactorAsync(
	const Extension* extension,
	const gfx::Size& dip_size,
	const ImageLoaderImageCallback& callback) {
	std::vector<ImageRepresentation> info_list;

	std::set<float> scales;
	for (auto scale : ui::GetSupportedScaleFactors())
	scales.insert(ui::GetScaleForScaleFactor(scale));

	// There may not be a screen in unit tests.
	auto* screen = display::Screen::GetScreen();
	if (screen) {
	for (const auto& display : screen->GetAllDisplays())
	scales.insert(display.device_scale_factor());
	}

	for (auto scale : scales) {
	const gfx::Size px_size = gfx::ScaleToFlooredSize(dip_size, scale);
	ExtensionResource image = IconsInfo::GetIconResource(
	extension, px_size.width(), ExtensionIconSet::MATCH_BIGGER);
	info_list.push_back(ImageRepresentation(
	image, ImageRepresentation::ALWAYS_RESIZE, px_size, scale));
	}
	LoadImagesAsync(extension, info_list, callback);
	}

	void ImageLoader::LoadImagesAsync(
	const Extension* extension,
	const std::vector<ImageRepresentation>& info_list,
	const ImageLoaderImageCallback& callback) {
	DCHECK_CURRENTLY_ON(BrowserThread::UI);
	base::PostTaskWithTraitsAndReplyWithResult(
	FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
	base::Bind(LoadImagesBlocking, info_list,
	LoadResourceBitmaps(extension, info_list)),
	base::Bind(&ImageLoader::ReplyBack, weak_ptr_factory_.GetWeakPtr(),
	callback));
	}

	void ImageLoader::LoadImageFamilyAsync(
	const Extension* extension,
	const std::vector<ImageRepresentation>& info_list,
	const ImageLoaderImageFamilyCallback& callback) {
	DCHECK_CURRENTLY_ON(BrowserThread::UI);
	base::PostTaskWithTraitsAndReplyWithResult(
	FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
	base::Bind(LoadImagesBlocking, info_list,
	LoadResourceBitmaps(extension, info_list)),
	base::Bind(&ImageLoader::ReplyBackWithImageFamily,
	weak_ptr_factory_.GetWeakPtr(), callback));
	}

	void ImageLoader::ReplyBack(const ImageLoaderImageCallback& callback,
	const std::vector<LoadResult>& load_result) {
	DCHECK_CURRENTLY_ON(BrowserThread::UI);

	gfx::ImageSkia image_skia;

	for (std::vector<LoadResult>::const_iterator it = load_result.begin();
	it != load_result.end(); ++it) {
	const SkBitmap& bitmap = it->bitmap;
	const ImageRepresentation& image_rep = it->image_representation;

	image_skia.AddRepresentation(
	gfx::ImageSkiaRep(bitmap, image_rep.scale_factor));
	}

	gfx::Image image;
	if (!image_skia.isNull()) {
	image_skia.MakeThreadSafe();
	image = gfx::Image(image_skia);
	}

	callback.Run(image);
	}

	void ImageLoader::ReplyBackWithImageFamily(
	const ImageLoaderImageFamilyCallback& callback,
	const std::vector<LoadResult>& load_result) {
	DCHECK_CURRENTLY_ON(BrowserThread::UI);

	std::map<std::pair<int, int>, gfx::ImageSkia> image_skia_map;
	gfx::ImageFamily image_family;

	for (std::vector<LoadResult>::const_iterator it = load_result.begin();
	it != load_result.end();
	++it) {
	const SkBitmap& bitmap = it->bitmap;
	const ImageRepresentation& image_rep = it->image_representation;
	const std::pair<int, int> key = std::make_pair(
	image_rep.desired_size.width(), image_rep.desired_size.height());
	// Create a new ImageSkia for this width/height, or add a representation to
	// an existing ImageSkia with the same width/height.
	image_skia_map[key].AddRepresentation(
	gfx::ImageSkiaRep(bitmap, image_rep.scale_factor));
	}

	for (std::map<std::pair<int, int>, gfx::ImageSkia>::iterator it =
	image_skia_map.begin();
	it != image_skia_map.end();
	++it) {
	it->second.MakeThreadSafe();
	image_family.Add(it->second);
	}

	callback.Run(std::move(image_family));
	}

	} // namespace extensions