OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/favicon/favicon_service.h" | 5 #include "chrome/browser/favicon/favicon_service.h" |
6 | 6 |
7 #include "base/hash.h" | 7 #include "base/hash.h" |
8 #include "base/message_loop/message_loop_proxy.h" | 8 #include "base/message_loop/message_loop_proxy.h" |
9 #include "chrome/browser/favicon/favicon_util.h" | 9 #include "chrome/browser/favicon/favicon_util.h" |
10 #include "chrome/browser/history/history_backend.h" | 10 #include "chrome/browser/history/history_backend.h" |
11 #include "chrome/browser/history/history_service.h" | 11 #include "chrome/browser/history/history_service.h" |
12 #include "chrome/browser/history/history_service_factory.h" | 12 #include "chrome/browser/history/history_service_factory.h" |
13 #include "chrome/browser/history/select_favicon_frames.h" | 13 #include "chrome/browser/history/select_favicon_frames.h" |
14 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h" | 14 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h" |
15 #include "chrome/common/favicon/favicon_types.h" | 15 #include "chrome/common/favicon/favicon_types.h" |
16 #include "chrome/common/importer/imported_favicon_usage.h" | 16 #include "chrome/common/importer/imported_favicon_usage.h" |
17 #include "chrome/common/url_constants.h" | 17 #include "chrome/common/url_constants.h" |
18 #include "extensions/common/constants.h" | 18 #include "extensions/common/constants.h" |
19 #include "third_party/skia/include/core/SkBitmap.h" | 19 #include "third_party/skia/include/core/SkBitmap.h" |
20 #include "ui/gfx/codec/png_codec.h" | 20 #include "ui/gfx/codec/png_codec.h" |
21 #include "ui/gfx/favicon_size.h" | 21 #include "ui/gfx/favicon_size.h" |
22 #include "ui/gfx/image/image_skia.h" | 22 #include "ui/gfx/image/image_skia.h" |
23 | 23 |
24 using base::Bind; | 24 using base::Bind; |
25 | 25 |
26 namespace { | 26 namespace { |
27 | 27 |
28 void CancelOrRunFaviconResultsCallback( | 28 void CancelOrRunFaviconResultsCallback( |
29 const CancelableTaskTracker::IsCanceledCallback& is_canceled, | 29 const base::CancelableTaskTracker::IsCanceledCallback& is_canceled, |
30 const FaviconService::FaviconResultsCallback& callback, | 30 const FaviconService::FaviconResultsCallback& callback, |
31 const std::vector<chrome::FaviconBitmapResult>& results) { | 31 const std::vector<chrome::FaviconBitmapResult>& results) { |
32 if (is_canceled.Run()) | 32 if (is_canceled.Run()) |
33 return; | 33 return; |
34 callback.Run(results); | 34 callback.Run(results); |
35 } | 35 } |
36 | 36 |
37 // Helper to run callback with empty results if we cannot get the history | 37 // Helper to run callback with empty results if we cannot get the history |
38 // service. | 38 // service. |
39 CancelableTaskTracker::TaskId RunWithEmptyResultAsync( | 39 base::CancelableTaskTracker::TaskId RunWithEmptyResultAsync( |
40 const FaviconService::FaviconResultsCallback& callback, | 40 const FaviconService::FaviconResultsCallback& callback, |
41 CancelableTaskTracker* tracker) { | 41 base::CancelableTaskTracker* tracker) { |
42 return tracker->PostTask( | 42 return tracker->PostTask( |
43 base::MessageLoopProxy::current().get(), | 43 base::MessageLoopProxy::current().get(), |
44 FROM_HERE, | 44 FROM_HERE, |
45 Bind(callback, std::vector<chrome::FaviconBitmapResult>())); | 45 Bind(callback, std::vector<chrome::FaviconBitmapResult>())); |
46 } | 46 } |
47 | 47 |
48 // Return the TaskId to retreive the favicon from chrome specific URL. | 48 // Return the TaskId to retreive the favicon from chrome specific URL. |
49 CancelableTaskTracker::TaskId GetFaviconForChromeURL( | 49 base::CancelableTaskTracker::TaskId GetFaviconForChromeURL( |
50 Profile* profile, | 50 Profile* profile, |
51 const GURL& page_url, | 51 const GURL& page_url, |
52 const std::vector<ui::ScaleFactor>& desired_scale_factors, | 52 const std::vector<ui::ScaleFactor>& desired_scale_factors, |
53 const FaviconService::FaviconResultsCallback& callback, | 53 const FaviconService::FaviconResultsCallback& callback, |
54 CancelableTaskTracker* tracker) { | 54 base::CancelableTaskTracker* tracker) { |
55 CancelableTaskTracker::IsCanceledCallback is_canceled_cb; | 55 base::CancelableTaskTracker::IsCanceledCallback is_canceled_cb; |
56 CancelableTaskTracker::TaskId id = tracker->NewTrackedTaskId(&is_canceled_cb); | 56 base::CancelableTaskTracker::TaskId id = |
| 57 tracker->NewTrackedTaskId(&is_canceled_cb); |
57 FaviconService::FaviconResultsCallback cancelable_cb = | 58 FaviconService::FaviconResultsCallback cancelable_cb = |
58 Bind(&CancelOrRunFaviconResultsCallback, is_canceled_cb, callback); | 59 Bind(&CancelOrRunFaviconResultsCallback, is_canceled_cb, callback); |
59 ChromeWebUIControllerFactory::GetInstance()->GetFaviconForURL(profile, | 60 ChromeWebUIControllerFactory::GetInstance()->GetFaviconForURL(profile, |
60 page_url, desired_scale_factors, cancelable_cb); | 61 page_url, desired_scale_factors, cancelable_cb); |
61 return id; | 62 return id; |
62 } | 63 } |
63 | 64 |
64 } // namespace | 65 } // namespace |
65 | 66 |
66 FaviconService::FaviconService(Profile* profile) | 67 FaviconService::FaviconService(Profile* profile) |
67 : history_service_(HistoryServiceFactory::GetForProfile( | 68 : history_service_(HistoryServiceFactory::GetForProfile( |
68 profile, Profile::EXPLICIT_ACCESS)), | 69 profile, Profile::EXPLICIT_ACCESS)), |
69 profile_(profile) { | 70 profile_(profile) { |
70 } | 71 } |
71 | 72 |
72 // static | 73 // static |
73 void FaviconService::FaviconResultsCallbackRunner( | 74 void FaviconService::FaviconResultsCallbackRunner( |
74 const FaviconResultsCallback& callback, | 75 const FaviconResultsCallback& callback, |
75 const std::vector<chrome::FaviconBitmapResult>* results) { | 76 const std::vector<chrome::FaviconBitmapResult>* results) { |
76 callback.Run(*results); | 77 callback.Run(*results); |
77 } | 78 } |
78 | 79 |
79 CancelableTaskTracker::TaskId FaviconService::GetFaviconImage( | 80 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImage( |
80 const GURL& icon_url, | 81 const GURL& icon_url, |
81 chrome::IconType icon_type, | 82 chrome::IconType icon_type, |
82 int desired_size_in_dip, | 83 int desired_size_in_dip, |
83 const FaviconImageCallback& callback, | 84 const FaviconImageCallback& callback, |
84 CancelableTaskTracker* tracker) { | 85 base::CancelableTaskTracker* tracker) { |
85 FaviconResultsCallback callback_runner = | 86 FaviconResultsCallback callback_runner = |
86 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, | 87 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, |
87 base::Unretained(this), callback, desired_size_in_dip); | 88 base::Unretained(this), callback, desired_size_in_dip); |
88 if (history_service_) { | 89 if (history_service_) { |
89 std::vector<GURL> icon_urls; | 90 std::vector<GURL> icon_urls; |
90 icon_urls.push_back(icon_url); | 91 icon_urls.push_back(icon_url); |
91 return history_service_->GetFavicons( | 92 return history_service_->GetFavicons( |
92 icon_urls, icon_type, desired_size_in_dip, | 93 icon_urls, icon_type, desired_size_in_dip, |
93 FaviconUtil::GetFaviconScaleFactors(), callback_runner, tracker); | 94 FaviconUtil::GetFaviconScaleFactors(), callback_runner, tracker); |
94 } else { | 95 } else { |
95 return RunWithEmptyResultAsync(callback_runner, tracker); | 96 return RunWithEmptyResultAsync(callback_runner, tracker); |
96 } | 97 } |
97 } | 98 } |
98 | 99 |
99 CancelableTaskTracker::TaskId FaviconService::GetRawFavicon( | 100 base::CancelableTaskTracker::TaskId FaviconService::GetRawFavicon( |
100 const GURL& icon_url, | 101 const GURL& icon_url, |
101 chrome::IconType icon_type, | 102 chrome::IconType icon_type, |
102 int desired_size_in_dip, | 103 int desired_size_in_dip, |
103 ui::ScaleFactor desired_scale_factor, | 104 ui::ScaleFactor desired_scale_factor, |
104 const FaviconRawCallback& callback, | 105 const FaviconRawCallback& callback, |
105 CancelableTaskTracker* tracker) { | 106 base::CancelableTaskTracker* tracker) { |
106 FaviconResultsCallback callback_runner = | 107 FaviconResultsCallback callback_runner = |
107 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, | 108 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, |
108 base::Unretained(this), | 109 base::Unretained(this), |
109 callback, desired_size_in_dip, desired_scale_factor); | 110 callback, desired_size_in_dip, desired_scale_factor); |
110 | 111 |
111 if (history_service_) { | 112 if (history_service_) { |
112 std::vector<GURL> icon_urls; | 113 std::vector<GURL> icon_urls; |
113 icon_urls.push_back(icon_url); | 114 icon_urls.push_back(icon_url); |
114 std::vector<ui::ScaleFactor> desired_scale_factors; | 115 std::vector<ui::ScaleFactor> desired_scale_factors; |
115 desired_scale_factors.push_back(desired_scale_factor); | 116 desired_scale_factors.push_back(desired_scale_factor); |
116 | 117 |
117 return history_service_->GetFavicons( | 118 return history_service_->GetFavicons( |
118 icon_urls, icon_type, desired_size_in_dip, desired_scale_factors, | 119 icon_urls, icon_type, desired_size_in_dip, desired_scale_factors, |
119 callback_runner, tracker); | 120 callback_runner, tracker); |
120 } else { | 121 } else { |
121 return RunWithEmptyResultAsync(callback_runner, tracker); | 122 return RunWithEmptyResultAsync(callback_runner, tracker); |
122 } | 123 } |
123 } | 124 } |
124 | 125 |
125 CancelableTaskTracker::TaskId FaviconService::GetFavicon( | 126 base::CancelableTaskTracker::TaskId FaviconService::GetFavicon( |
126 const GURL& icon_url, | 127 const GURL& icon_url, |
127 chrome::IconType icon_type, | 128 chrome::IconType icon_type, |
128 int desired_size_in_dip, | 129 int desired_size_in_dip, |
129 const FaviconResultsCallback& callback, | 130 const FaviconResultsCallback& callback, |
130 CancelableTaskTracker* tracker) { | 131 base::CancelableTaskTracker* tracker) { |
131 if (history_service_) { | 132 if (history_service_) { |
132 std::vector<GURL> icon_urls; | 133 std::vector<GURL> icon_urls; |
133 icon_urls.push_back(icon_url); | 134 icon_urls.push_back(icon_url); |
134 return history_service_->GetFavicons( | 135 return history_service_->GetFavicons( |
135 icon_urls, icon_type, desired_size_in_dip, | 136 icon_urls, icon_type, desired_size_in_dip, |
136 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); | 137 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); |
137 } else { | 138 } else { |
138 return RunWithEmptyResultAsync(callback, tracker); | 139 return RunWithEmptyResultAsync(callback, tracker); |
139 } | 140 } |
140 } | 141 } |
141 | 142 |
142 CancelableTaskTracker::TaskId FaviconService::UpdateFaviconMappingsAndFetch( | 143 base::CancelableTaskTracker::TaskId |
| 144 FaviconService::UpdateFaviconMappingsAndFetch( |
143 const GURL& page_url, | 145 const GURL& page_url, |
144 const std::vector<GURL>& icon_urls, | 146 const std::vector<GURL>& icon_urls, |
145 int icon_types, | 147 int icon_types, |
146 int desired_size_in_dip, | 148 int desired_size_in_dip, |
147 const FaviconResultsCallback& callback, | 149 const FaviconResultsCallback& callback, |
148 CancelableTaskTracker* tracker) { | 150 base::CancelableTaskTracker* tracker) { |
149 if (history_service_) { | 151 if (history_service_) { |
150 return history_service_->UpdateFaviconMappingsAndFetch( | 152 return history_service_->UpdateFaviconMappingsAndFetch( |
151 page_url, icon_urls, icon_types, desired_size_in_dip, | 153 page_url, icon_urls, icon_types, desired_size_in_dip, |
152 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); | 154 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); |
153 } else { | 155 } else { |
154 return RunWithEmptyResultAsync(callback, tracker); | 156 return RunWithEmptyResultAsync(callback, tracker); |
155 } | 157 } |
156 } | 158 } |
157 | 159 |
158 CancelableTaskTracker::TaskId FaviconService::GetFaviconImageForURL( | 160 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImageForURL( |
159 const FaviconForURLParams& params, | 161 const FaviconForURLParams& params, |
160 const FaviconImageCallback& callback, | 162 const FaviconImageCallback& callback, |
161 CancelableTaskTracker* tracker) { | 163 base::CancelableTaskTracker* tracker) { |
162 return GetFaviconForURLImpl( | 164 return GetFaviconForURLImpl( |
163 params, | 165 params, |
164 FaviconUtil::GetFaviconScaleFactors(), | 166 FaviconUtil::GetFaviconScaleFactors(), |
165 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, | 167 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, |
166 base::Unretained(this), | 168 base::Unretained(this), |
167 callback, | 169 callback, |
168 params.desired_size_in_dip), | 170 params.desired_size_in_dip), |
169 tracker); | 171 tracker); |
170 } | 172 } |
171 | 173 |
172 CancelableTaskTracker::TaskId FaviconService::GetRawFaviconForURL( | 174 base::CancelableTaskTracker::TaskId FaviconService::GetRawFaviconForURL( |
173 const FaviconForURLParams& params, | 175 const FaviconForURLParams& params, |
174 ui::ScaleFactor desired_scale_factor, | 176 ui::ScaleFactor desired_scale_factor, |
175 const FaviconRawCallback& callback, | 177 const FaviconRawCallback& callback, |
176 CancelableTaskTracker* tracker) { | 178 base::CancelableTaskTracker* tracker) { |
177 std::vector<ui::ScaleFactor> desired_scale_factors; | 179 std::vector<ui::ScaleFactor> desired_scale_factors; |
178 desired_scale_factors.push_back(desired_scale_factor); | 180 desired_scale_factors.push_back(desired_scale_factor); |
179 return GetFaviconForURLImpl( | 181 return GetFaviconForURLImpl( |
180 params, | 182 params, |
181 desired_scale_factors, | 183 desired_scale_factors, |
182 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, | 184 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, |
183 base::Unretained(this), | 185 base::Unretained(this), |
184 callback, | 186 callback, |
185 params.desired_size_in_dip, | 187 params.desired_size_in_dip, |
186 desired_scale_factor), | 188 desired_scale_factor), |
187 tracker); | 189 tracker); |
188 } | 190 } |
189 | 191 |
190 CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForURL( | 192 base::CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForURL( |
191 Profile* profile, | 193 Profile* profile, |
192 const GURL& page_url, | 194 const GURL& page_url, |
193 const std::vector<int>& icon_types, | 195 const std::vector<int>& icon_types, |
194 int minimum_size_in_pixels, | 196 int minimum_size_in_pixels, |
195 const FaviconRawCallback& callback, | 197 const FaviconRawCallback& callback, |
196 CancelableTaskTracker* tracker) { | 198 base::CancelableTaskTracker* tracker) { |
197 FaviconResultsCallback favicon_results_callback = | 199 FaviconResultsCallback favicon_results_callback = |
198 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, | 200 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, |
199 base::Unretained(this), callback, 0, ui::ScaleFactor()); | 201 base::Unretained(this), callback, 0, ui::ScaleFactor()); |
200 if (page_url.SchemeIs(chrome::kChromeUIScheme) || | 202 if (page_url.SchemeIs(chrome::kChromeUIScheme) || |
201 page_url.SchemeIs(extensions::kExtensionScheme)) { | 203 page_url.SchemeIs(extensions::kExtensionScheme)) { |
202 std::vector<ui::ScaleFactor> scale_factor; | 204 std::vector<ui::ScaleFactor> scale_factor; |
203 scale_factor.push_back(ui::SCALE_FACTOR_100P); | 205 scale_factor.push_back(ui::SCALE_FACTOR_100P); |
204 return GetFaviconForChromeURL(profile, page_url, scale_factor, | 206 return GetFaviconForChromeURL(profile, page_url, scale_factor, |
205 favicon_results_callback, tracker); | 207 favicon_results_callback, tracker); |
206 } else if (history_service_) { | 208 } else if (history_service_) { |
207 return history_service_->GetLargestFaviconForURL(page_url, icon_types, | 209 return history_service_->GetLargestFaviconForURL(page_url, icon_types, |
208 minimum_size_in_pixels, callback, tracker); | 210 minimum_size_in_pixels, callback, tracker); |
209 } | 211 } |
210 return RunWithEmptyResultAsync(favicon_results_callback, tracker); | 212 return RunWithEmptyResultAsync(favicon_results_callback, tracker); |
211 } | 213 } |
212 | 214 |
213 CancelableTaskTracker::TaskId FaviconService::GetFaviconForURL( | 215 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForURL( |
214 const FaviconForURLParams& params, | 216 const FaviconForURLParams& params, |
215 const FaviconResultsCallback& callback, | 217 const FaviconResultsCallback& callback, |
216 CancelableTaskTracker* tracker) { | 218 base::CancelableTaskTracker* tracker) { |
217 return GetFaviconForURLImpl(params, | 219 return GetFaviconForURLImpl(params, |
218 FaviconUtil::GetFaviconScaleFactors(), | 220 FaviconUtil::GetFaviconScaleFactors(), |
219 callback, | 221 callback, |
220 tracker); | 222 tracker); |
221 } | 223 } |
222 | 224 |
223 CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForID( | 225 base::CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForID( |
224 chrome::FaviconID favicon_id, | 226 chrome::FaviconID favicon_id, |
225 const FaviconRawCallback& callback, | 227 const FaviconRawCallback& callback, |
226 CancelableTaskTracker* tracker) { | 228 base::CancelableTaskTracker* tracker) { |
227 // Use 0 as |desired_size_in_dip| to get the largest bitmap for |favicon_id| | 229 // Use 0 as |desired_size_in_dip| to get the largest bitmap for |favicon_id| |
228 // without any resizing. | 230 // without any resizing. |
229 int desired_size_in_dip = 0; | 231 int desired_size_in_dip = 0; |
230 ui::ScaleFactor desired_scale_factor = ui::SCALE_FACTOR_100P; | 232 ui::ScaleFactor desired_scale_factor = ui::SCALE_FACTOR_100P; |
231 FaviconResultsCallback callback_runner = | 233 FaviconResultsCallback callback_runner = |
232 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, | 234 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, |
233 base::Unretained(this), | 235 base::Unretained(this), |
234 callback, desired_size_in_dip, desired_scale_factor); | 236 callback, desired_size_in_dip, desired_scale_factor); |
235 | 237 |
236 if (history_service_) { | 238 if (history_service_) { |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
311 MissingFaviconURLHash url_hash = base::Hash(icon_url.spec()); | 313 MissingFaviconURLHash url_hash = base::Hash(icon_url.spec()); |
312 return missing_favicon_urls_.find(url_hash) != missing_favicon_urls_.end(); | 314 return missing_favicon_urls_.find(url_hash) != missing_favicon_urls_.end(); |
313 } | 315 } |
314 | 316 |
315 void FaviconService::ClearUnableToDownloadFavicons() { | 317 void FaviconService::ClearUnableToDownloadFavicons() { |
316 missing_favicon_urls_.clear(); | 318 missing_favicon_urls_.clear(); |
317 } | 319 } |
318 | 320 |
319 FaviconService::~FaviconService() {} | 321 FaviconService::~FaviconService() {} |
320 | 322 |
321 CancelableTaskTracker::TaskId FaviconService::GetFaviconForURLImpl( | 323 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForURLImpl( |
322 const FaviconForURLParams& params, | 324 const FaviconForURLParams& params, |
323 const std::vector<ui::ScaleFactor>& desired_scale_factors, | 325 const std::vector<ui::ScaleFactor>& desired_scale_factors, |
324 const FaviconResultsCallback& callback, | 326 const FaviconResultsCallback& callback, |
325 CancelableTaskTracker* tracker) { | 327 base::CancelableTaskTracker* tracker) { |
326 if (params.page_url.SchemeIs(chrome::kChromeUIScheme) || | 328 if (params.page_url.SchemeIs(chrome::kChromeUIScheme) || |
327 params.page_url.SchemeIs(extensions::kExtensionScheme)) { | 329 params.page_url.SchemeIs(extensions::kExtensionScheme)) { |
328 return GetFaviconForChromeURL(profile_, params.page_url, | 330 return GetFaviconForChromeURL(profile_, params.page_url, |
329 desired_scale_factors, callback, tracker); | 331 desired_scale_factors, callback, tracker); |
330 } else if (history_service_) { | 332 } else if (history_service_) { |
331 return history_service_->GetFaviconsForURL(params.page_url, | 333 return history_service_->GetFaviconsForURL(params.page_url, |
332 params.icon_types, | 334 params.icon_types, |
333 params.desired_size_in_dip, | 335 params.desired_size_in_dip, |
334 desired_scale_factors, | 336 desired_scale_factors, |
335 callback, | 337 callback, |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
397 if (!gfx::PNGCodec::EncodeBGRASkBitmap(resized_image.AsBitmap(), false, | 399 if (!gfx::PNGCodec::EncodeBGRASkBitmap(resized_image.AsBitmap(), false, |
398 &resized_bitmap_data)) { | 400 &resized_bitmap_data)) { |
399 callback.Run(chrome::FaviconBitmapResult()); | 401 callback.Run(chrome::FaviconBitmapResult()); |
400 return; | 402 return; |
401 } | 403 } |
402 | 404 |
403 bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector( | 405 bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector( |
404 &resized_bitmap_data); | 406 &resized_bitmap_data); |
405 callback.Run(bitmap_result); | 407 callback.Run(bitmap_result); |
406 } | 408 } |
OLD | NEW |