content/renderer/image_loading_helper.cc

   1 // Copyright (c) 2013 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 "content/renderer/image_loading_helper.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "content/child/image_decoder.h"
  10 #include "content/common/image_messages.h"
  11 #include "content/public/renderer/render_frame.h"
  12 #include "content/renderer/fetchers/multi_resolution_image_resource_fetcher.h"
  13 #include "net/base/data_url.h"
  14 #include "skia/ext/image_operations.h"
  15 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  16 #include "third_party/WebKit/public/platform/WebVector.h"
  17 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  18 #include "third_party/WebKit/public/web/WebView.h"
  19 #include "ui/gfx/favicon_size.h"
  20 #include "ui/gfx/geometry/size.h"
  21 #include "ui/gfx/skbitmap_operations.h"
  22 #include "url/url_constants.h"
  23
  24 using blink::WebFrame;
  25 using blink::WebVector;
  26 using blink::WebURL;
  27 using blink::WebURLRequest;
  28
  29 namespace {
  30
  31 //  Proportionally resizes the |image| to fit in a box of size
  32 // |max_image_size|.
  33 SkBitmap ResizeImage(const SkBitmap& image, uint32_t max_image_size) {
  34   if (max_image_size == 0)
  35     return image;
  36   uint32_t max_dimension = std::max(image.width(), image.height());
  37   if (max_dimension <= max_image_size)
  38     return image;
  39   // Proportionally resize the minimal image to fit in a box of size
  40   // max_image_size.
  41   return skia::ImageOperations::Resize(
  42       image,
  43       skia::ImageOperations::RESIZE_BEST,
  44       static_cast<uint64_t>(image.width()) * max_image_size / max_dimension,
  45       static_cast<uint64_t>(image.height()) * max_image_size / max_dimension);
  46 }
  47
  48 // Filters the array of bitmaps, removing all images that do not fit in a box of
  49 // size |max_image_size|. Returns the result if it is not empty. Otherwise,
  50 // find the smallest image in the array and resize it proportionally to fit
  51 // in a box of size |max_image_size|.
  52 // Sets |original_image_sizes| to the sizes of |images| before resizing.
  53 void FilterAndResizeImagesForMaximalSize(
  54     const std::vector<SkBitmap>& unfiltered,
  55     uint32_t max_image_size,
  56     std::vector<SkBitmap>* images,
  57     std::vector<gfx::Size>* original_image_sizes) {
  58   images->clear();
  59   original_image_sizes->clear();
  60
  61   if (!unfiltered.size())
  62     return;
  63
  64   if (max_image_size == 0)
  65     max_image_size = std::numeric_limits<uint32_t>::max();
  66
  67   const SkBitmap* min_image = NULL;
  68   uint32_t min_image_size = std::numeric_limits<uint32_t>::max();
  69   // Filter the images by |max_image_size|, and also identify the smallest image
  70   // in case all the images are bigger than |max_image_size|.
  71   for (std::vector<SkBitmap>::const_iterator it = unfiltered.begin();
  72        it != unfiltered.end();
  73        ++it) {
  74     const SkBitmap& image = *it;
  75     uint32_t current_size = std::max(it->width(), it->height());
  76     if (current_size < min_image_size) {
  77       min_image = &image;
  78       min_image_size = current_size;
  79     }
  80     if (static_cast<uint32_t>(image.width()) <= max_image_size &&
  81         static_cast<uint32_t>(image.height()) <= max_image_size) {
  82       images->push_back(image);
  83       original_image_sizes->push_back(gfx::Size(image.width(), image.height()));
  84     }
  85   }
  86   DCHECK(min_image);
  87   if (images->size())
  88     return;
  89   // Proportionally resize the minimal image to fit in a box of size
  90   // |max_image_size|.
  91   images->push_back(ResizeImage(*min_image, max_image_size));
  92   original_image_sizes->push_back(
  93       gfx::Size(min_image->width(), min_image->height()));
  94 }
  95
  96 }  // namespace
  97
  98 namespace content {
  99
 100 ImageLoadingHelper::ImageLoadingHelper(RenderFrame* render_frame)
 101     : RenderFrameObserver(render_frame) {
 102 }
 103
 104 ImageLoadingHelper::~ImageLoadingHelper() {
 105 }
 106
 107 void ImageLoadingHelper::OnDownloadImage(
 108     int id,
 109     const GURL& image_url,
 110     bool is_favicon,
 111     uint32_t max_image_size,
 112     bool bypass_cache) {
 113   std::vector<SkBitmap> result_images;
 114   std::vector<gfx::Size> result_original_image_sizes;
 115   if (image_url.SchemeIs(url::kDataScheme)) {
 116     SkBitmap data_image = ImageFromDataUrl(image_url);
 117     if (!data_image.empty()) {
 118       result_images.push_back(ResizeImage(data_image, max_image_size));
 119       result_original_image_sizes.push_back(
 120           gfx::Size(data_image.width(), data_image.height()));
 121     }
 122   } else {
 123     if (DownloadImage(id, image_url, is_favicon, max_image_size,
 124                       bypass_cache)) {
 125       // Will complete asynchronously via ImageLoadingHelper::DidDownloadImage
 126       return;
 127     }
 128   }
 129
 130   Send(new ImageHostMsg_DidDownloadImage(routing_id(),
 131                                          id,
 132                                          0,
 133                                          image_url,
 134                                          result_images,
 135                                          result_original_image_sizes));
 136 }
 137
 138 bool ImageLoadingHelper::DownloadImage(
 139     int id,
 140     const GURL& image_url,
 141     bool is_favicon,
 142     uint32_t max_image_size,
 143     bool bypass_cache) {
 144   // Create an image resource fetcher and assign it with a call back object.
 145   image_fetchers_.push_back(new MultiResolutionImageResourceFetcher(
 146       image_url, render_frame()->GetWebFrame(), id,
 147       is_favicon ? WebURLRequest::RequestContextFavicon
 148                  : WebURLRequest::RequestContextImage,
 149       bypass_cache ? WebURLRequest::ReloadBypassingCache
 150                    : WebURLRequest::UseProtocolCachePolicy,
 151       base::Bind(&ImageLoadingHelper::DidDownloadImage, base::Unretained(this),
 152                  max_image_size)));
 153   return true;
 154 }
 155
 156 void ImageLoadingHelper::DidDownloadImage(
 157     uint32_t max_image_size,
 158     MultiResolutionImageResourceFetcher* fetcher,
 159     const std::vector<SkBitmap>& images) {
 160   std::vector<SkBitmap> result_images;
 161   std::vector<gfx::Size> result_original_image_sizes;
 162   FilterAndResizeImagesForMaximalSize(images, max_image_size, &result_images,
 163       &result_original_image_sizes);
 164
 165   // Notify requester of image download status.
 166   Send(new ImageHostMsg_DidDownloadImage(
 167       routing_id(),
 168       fetcher->id(),
 169       fetcher->http_status_code(),
 170       fetcher->image_url(),
 171       result_images,
 172       result_original_image_sizes));
 173
 174   // Remove the image fetcher from our pending list. We're in the callback from
 175   // MultiResolutionImageResourceFetcher, best to delay deletion.
 176   ImageResourceFetcherList::iterator iter =
 177       std::find(image_fetchers_.begin(), image_fetchers_.end(), fetcher);
 178   if (iter != image_fetchers_.end()) {
 179     image_fetchers_.weak_erase(iter);
 180     base::MessageLoop::current()->DeleteSoon(FROM_HERE, fetcher);
 181   }
 182 }
 183
 184 SkBitmap ImageLoadingHelper::ImageFromDataUrl(const GURL& url) const {
 185   std::string mime_type, char_set, data;
 186   if (net::DataURL::Parse(url, &mime_type, &char_set, &data) && !data.empty()) {
 187     // Decode the image using WebKit's image decoder.
 188     ImageDecoder decoder(gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize));
 189     const unsigned char* src_data =
 190         reinterpret_cast<const unsigned char*>(&data[0]);
 191
 192     return decoder.Decode(src_data, data.size());
 193   }
 194   return SkBitmap();
 195 }
 196
 197 bool ImageLoadingHelper::OnMessageReceived(const IPC::Message& message) {
 198   bool handled = true;
 199   IPC_BEGIN_MESSAGE_MAP(ImageLoadingHelper, message)
 200     IPC_MESSAGE_HANDLER(ImageMsg_DownloadImage, OnDownloadImage)
 201     IPC_MESSAGE_UNHANDLED(handled = false)
 202   IPC_END_MESSAGE_MAP()
 203
 204   return handled;
 205 }
 206
 207 }  // namespace content