OLD | NEW |
| (Empty) |
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 = ℑ | |
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 | |
OLD | NEW |