Home | History | Annotate | Download | only in renderer 
      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/common/url_constants.h"
     12 #include "content/public/renderer/render_view.h"
     13 #include "content/renderer/fetchers/multi_resolution_image_resource_fetcher.h"
     14 #include "net/base/data_url.h"
     15 #include "skia/ext/image_operations.h"
     16 #include "third_party/WebKit/public/platform/WebURLRequest.h"
     17 #include "third_party/WebKit/public/platform/WebVector.h"
     18 #include "third_party/WebKit/public/web/WebFrame.h"
     19 #include "third_party/WebKit/public/web/WebView.h"
     20 #include "ui/gfx/favicon_size.h"
     21 #include "ui/gfx/size.h"
     22 #include "ui/gfx/skbitmap_operations.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(RenderView* render_view)
    101     : RenderViewObserver(render_view) {
    102 }
    103 
    104 ImageLoadingHelper::~ImageLoadingHelper() {
    105 }
    106 
    107 void ImageLoadingHelper::OnDownloadImage(int id,
    108                                          const GURL& image_url,
    109                                          bool is_favicon,
    110                                          uint32_t max_image_size) {
    111   std::vector<SkBitmap> result_images;
    112   std::vector<gfx::Size> result_original_image_sizes;
    113   if (image_url.SchemeIs(chrome::kDataScheme)) {
    114     SkBitmap data_image = ImageFromDataUrl(image_url);
    115     if (!data_image.empty()) {
    116       result_images.push_back(ResizeImage(data_image, max_image_size));
    117       result_original_image_sizes.push_back(
    118           gfx::Size(data_image.width(), data_image.height()));
    119     }
    120   } else {
    121     if (DownloadImage(id, image_url, is_favicon, max_image_size)) {
    122       // Will complete asynchronously via ImageLoadingHelper::DidDownloadImage
    123       return;
    124     }
    125   }
    126 
    127   Send(new ImageHostMsg_DidDownloadImage(routing_id(),
    128                                          id,
    129                                          0,
    130                                          image_url,
    131                                          result_images,
    132                                          result_original_image_sizes));
    133 }
    134 
    135 bool ImageLoadingHelper::DownloadImage(int id,
    136                                        const GURL& image_url,
    137                                        bool is_favicon,
    138                                        uint32_t max_image_size) {
    139   // Make sure webview was not shut down.
    140   if (!render_view()->GetWebView())
    141     return false;
    142   // Create an image resource fetcher and assign it with a call back object.
    143   image_fetchers_.push_back(new MultiResolutionImageResourceFetcher(
    144       image_url,
    145       render_view()->GetWebView()->mainFrame(),
    146       id,
    147       is_favicon ? WebURLRequest::TargetIsFavicon :
    148                    WebURLRequest::TargetIsImage,
    149       base::Bind(&ImageLoadingHelper::DidDownloadImage,
    150                  base::Unretained(this),
    151                  max_image_size)));
    152   return true;
    153 }
    154 
    155 void ImageLoadingHelper::DidDownloadImage(
    156     uint32_t max_image_size,
    157     MultiResolutionImageResourceFetcher* fetcher,
    158     const std::vector<SkBitmap>& images) {
    159   std::vector<SkBitmap> result_images;
    160   std::vector<gfx::Size> result_original_image_sizes;
    161   FilterAndResizeImagesForMaximalSize(images, max_image_size, &result_images,
    162       &result_original_image_sizes);
    163 
    164   // Notify requester of image download status.
    165   Send(new ImageHostMsg_DidDownloadImage(
    166       routing_id(),
    167       fetcher->id(),
    168       fetcher->http_status_code(),
    169       fetcher->image_url(),
    170       result_images,
    171       result_original_image_sizes));
    172 
    173   // Remove the image fetcher from our pending list. We're in the callback from
    174   // MultiResolutionImageResourceFetcher, best to delay deletion.
    175   ImageResourceFetcherList::iterator iter =
    176       std::find(image_fetchers_.begin(), image_fetchers_.end(), fetcher);
    177   if (iter != image_fetchers_.end()) {
    178     image_fetchers_.weak_erase(iter);
    179     base::MessageLoop::current()->DeleteSoon(FROM_HERE, fetcher);
    180   }
    181 }
    182 
    183 SkBitmap ImageLoadingHelper::ImageFromDataUrl(const GURL& url) const {
    184   std::string mime_type, char_set, data;
    185   if (net::DataURL::Parse(url, &mime_type, &char_set, &data) && !data.empty()) {
    186     // Decode the image using WebKit's image decoder.
    187     ImageDecoder decoder(gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize));
    188     const unsigned char* src_data =
    189         reinterpret_cast<const unsigned char*>(&data[0]);
    190 
    191     return decoder.Decode(src_data, data.size());
    192   }
    193   return SkBitmap();
    194 }
    195 
    196 bool ImageLoadingHelper::OnMessageReceived(const IPC::Message& message) {
    197   bool handled = true;
    198   IPC_BEGIN_MESSAGE_MAP(ImageLoadingHelper, message)
    199     IPC_MESSAGE_HANDLER(ImageMsg_DownloadImage, OnDownloadImage)
    200     IPC_MESSAGE_UNHANDLED(handled = false)
    201   IPC_END_MESSAGE_MAP()
    202 
    203   return handled;
    204 }
    205 
    206 }  // namespace content
    207