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/ui/webui/chrome_web_ui_controller_factory.h" | 13 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h" |
14 #include "chrome/common/importer/imported_favicon_usage.h" | 14 #include "chrome/common/importer/imported_favicon_usage.h" |
15 #include "chrome/common/url_constants.h" | 15 #include "chrome/common/url_constants.h" |
16 #include "components/favicon_base/favicon_types.h" | 16 #include "components/favicon_base/favicon_types.h" |
17 #include "components/favicon_base/select_favicon_frames.h" | 17 #include "components/favicon_base/select_favicon_frames.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 base::CancelableTaskTracker::IsCanceledCallback& is_canceled, | 29 const base::CancelableTaskTracker::IsCanceledCallback& is_canceled, |
30 const FaviconService::FaviconResultsCallback& callback, | 30 const favicon_base::FaviconResultsCallback& callback, |
31 const std::vector<favicon_base::FaviconBitmapResult>& results) { | 31 const std::vector<favicon_base::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 base::CancelableTaskTracker::TaskId RunWithEmptyResultAsync( | 39 base::CancelableTaskTracker::TaskId RunWithEmptyResultAsync( |
40 const FaviconService::FaviconResultsCallback& callback, | 40 const favicon_base::FaviconResultsCallback& callback, |
41 base::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<favicon_base::FaviconBitmapResult>())); | 45 Bind(callback, std::vector<favicon_base::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 base::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 favicon_base::FaviconResultsCallback& callback, |
54 base::CancelableTaskTracker* tracker) { | 54 base::CancelableTaskTracker* tracker) { |
55 base::CancelableTaskTracker::IsCanceledCallback is_canceled_cb; | 55 base::CancelableTaskTracker::IsCanceledCallback is_canceled_cb; |
56 base::CancelableTaskTracker::TaskId id = | 56 base::CancelableTaskTracker::TaskId id = |
57 tracker->NewTrackedTaskId(&is_canceled_cb); | 57 tracker->NewTrackedTaskId(&is_canceled_cb); |
58 FaviconService::FaviconResultsCallback cancelable_cb = | 58 favicon_base::FaviconResultsCallback cancelable_cb = |
59 Bind(&CancelOrRunFaviconResultsCallback, is_canceled_cb, callback); | 59 Bind(&CancelOrRunFaviconResultsCallback, is_canceled_cb, callback); |
60 ChromeWebUIControllerFactory::GetInstance()->GetFaviconForURL(profile, | 60 ChromeWebUIControllerFactory::GetInstance()->GetFaviconForURL(profile, |
61 page_url, desired_scale_factors, cancelable_cb); | 61 page_url, desired_scale_factors, cancelable_cb); |
62 return id; | 62 return id; |
63 } | 63 } |
64 | 64 |
65 } // namespace | 65 } // namespace |
66 | 66 |
67 FaviconService::FaviconService(Profile* profile) | 67 FaviconService::FaviconService(Profile* profile) |
68 : history_service_(HistoryServiceFactory::GetForProfile( | 68 : history_service_(HistoryServiceFactory::GetForProfile( |
69 profile, Profile::EXPLICIT_ACCESS)), | 69 profile, Profile::EXPLICIT_ACCESS)), |
70 profile_(profile) { | 70 profile_(profile) { |
71 } | 71 } |
72 | 72 |
73 // static | 73 // static |
74 void FaviconService::FaviconResultsCallbackRunner( | 74 void FaviconService::FaviconResultsCallbackRunner( |
75 const FaviconResultsCallback& callback, | 75 const favicon_base::FaviconResultsCallback& callback, |
76 const std::vector<favicon_base::FaviconBitmapResult>* results) { | 76 const std::vector<favicon_base::FaviconBitmapResult>* results) { |
77 callback.Run(*results); | 77 callback.Run(*results); |
78 } | 78 } |
79 | 79 |
80 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImage( | 80 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImage( |
81 const GURL& icon_url, | 81 const GURL& icon_url, |
82 favicon_base::IconType icon_type, | 82 favicon_base::IconType icon_type, |
83 int desired_size_in_dip, | 83 int desired_size_in_dip, |
84 const FaviconImageCallback& callback, | 84 const favicon_base::FaviconImageCallback& callback, |
85 base::CancelableTaskTracker* tracker) { | 85 base::CancelableTaskTracker* tracker) { |
86 FaviconResultsCallback callback_runner = | 86 favicon_base::FaviconResultsCallback callback_runner = |
87 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, | 87 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, |
88 base::Unretained(this), callback, desired_size_in_dip); | 88 base::Unretained(this), callback, desired_size_in_dip); |
89 if (history_service_) { | 89 if (history_service_) { |
90 std::vector<GURL> icon_urls; | 90 std::vector<GURL> icon_urls; |
91 icon_urls.push_back(icon_url); | 91 icon_urls.push_back(icon_url); |
92 return history_service_->GetFavicons( | 92 return history_service_->GetFavicons( |
93 icon_urls, icon_type, desired_size_in_dip, | 93 icon_urls, icon_type, desired_size_in_dip, |
94 FaviconUtil::GetFaviconScaleFactors(), callback_runner, tracker); | 94 FaviconUtil::GetFaviconScaleFactors(), callback_runner, tracker); |
95 } else { | 95 } else { |
96 return RunWithEmptyResultAsync(callback_runner, tracker); | 96 return RunWithEmptyResultAsync(callback_runner, tracker); |
97 } | 97 } |
98 } | 98 } |
99 | 99 |
100 base::CancelableTaskTracker::TaskId FaviconService::GetRawFavicon( | 100 base::CancelableTaskTracker::TaskId FaviconService::GetRawFavicon( |
101 const GURL& icon_url, | 101 const GURL& icon_url, |
102 favicon_base::IconType icon_type, | 102 favicon_base::IconType icon_type, |
103 int desired_size_in_dip, | 103 int desired_size_in_dip, |
104 ui::ScaleFactor desired_scale_factor, | 104 ui::ScaleFactor desired_scale_factor, |
105 const FaviconRawCallback& callback, | 105 const favicon_base::FaviconRawCallback& callback, |
106 base::CancelableTaskTracker* tracker) { | 106 base::CancelableTaskTracker* tracker) { |
107 FaviconResultsCallback callback_runner = | 107 favicon_base::FaviconResultsCallback callback_runner = |
108 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, | 108 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, |
109 base::Unretained(this), | 109 base::Unretained(this), |
110 callback, desired_size_in_dip, desired_scale_factor); | 110 callback, desired_size_in_dip, desired_scale_factor); |
111 | 111 |
112 if (history_service_) { | 112 if (history_service_) { |
113 std::vector<GURL> icon_urls; | 113 std::vector<GURL> icon_urls; |
114 icon_urls.push_back(icon_url); | 114 icon_urls.push_back(icon_url); |
115 std::vector<ui::ScaleFactor> desired_scale_factors; | 115 std::vector<ui::ScaleFactor> desired_scale_factors; |
116 desired_scale_factors.push_back(desired_scale_factor); | 116 desired_scale_factors.push_back(desired_scale_factor); |
117 | 117 |
118 return history_service_->GetFavicons( | 118 return history_service_->GetFavicons( |
119 icon_urls, icon_type, desired_size_in_dip, desired_scale_factors, | 119 icon_urls, icon_type, desired_size_in_dip, desired_scale_factors, |
120 callback_runner, tracker); | 120 callback_runner, tracker); |
121 } else { | 121 } else { |
122 return RunWithEmptyResultAsync(callback_runner, tracker); | 122 return RunWithEmptyResultAsync(callback_runner, tracker); |
123 } | 123 } |
124 } | 124 } |
125 | 125 |
126 base::CancelableTaskTracker::TaskId FaviconService::GetFavicon( | 126 base::CancelableTaskTracker::TaskId FaviconService::GetFavicon( |
127 const GURL& icon_url, | 127 const GURL& icon_url, |
128 favicon_base::IconType icon_type, | 128 favicon_base::IconType icon_type, |
129 int desired_size_in_dip, | 129 int desired_size_in_dip, |
130 const FaviconResultsCallback& callback, | 130 const favicon_base::FaviconResultsCallback& callback, |
131 base::CancelableTaskTracker* tracker) { | 131 base::CancelableTaskTracker* tracker) { |
132 if (history_service_) { | 132 if (history_service_) { |
133 std::vector<GURL> icon_urls; | 133 std::vector<GURL> icon_urls; |
134 icon_urls.push_back(icon_url); | 134 icon_urls.push_back(icon_url); |
135 return history_service_->GetFavicons( | 135 return history_service_->GetFavicons( |
136 icon_urls, icon_type, desired_size_in_dip, | 136 icon_urls, icon_type, desired_size_in_dip, |
137 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); | 137 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); |
138 } else { | 138 } else { |
139 return RunWithEmptyResultAsync(callback, tracker); | 139 return RunWithEmptyResultAsync(callback, tracker); |
140 } | 140 } |
141 } | 141 } |
142 | 142 |
143 base::CancelableTaskTracker::TaskId | 143 base::CancelableTaskTracker::TaskId |
144 FaviconService::UpdateFaviconMappingsAndFetch( | 144 FaviconService::UpdateFaviconMappingsAndFetch( |
145 const GURL& page_url, | 145 const GURL& page_url, |
146 const std::vector<GURL>& icon_urls, | 146 const std::vector<GURL>& icon_urls, |
147 int icon_types, | 147 int icon_types, |
148 int desired_size_in_dip, | 148 int desired_size_in_dip, |
149 const FaviconResultsCallback& callback, | 149 const favicon_base::FaviconResultsCallback& callback, |
150 base::CancelableTaskTracker* tracker) { | 150 base::CancelableTaskTracker* tracker) { |
151 if (history_service_) { | 151 if (history_service_) { |
152 return history_service_->UpdateFaviconMappingsAndFetch( | 152 return history_service_->UpdateFaviconMappingsAndFetch( |
153 page_url, icon_urls, icon_types, desired_size_in_dip, | 153 page_url, icon_urls, icon_types, desired_size_in_dip, |
154 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); | 154 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); |
155 } else { | 155 } else { |
156 return RunWithEmptyResultAsync(callback, tracker); | 156 return RunWithEmptyResultAsync(callback, tracker); |
157 } | 157 } |
158 } | 158 } |
159 | 159 |
160 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImageForURL( | 160 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImageForURL( |
161 const FaviconForURLParams& params, | 161 const FaviconForURLParams& params, |
162 const FaviconImageCallback& callback, | 162 const favicon_base::FaviconImageCallback& callback, |
163 base::CancelableTaskTracker* tracker) { | 163 base::CancelableTaskTracker* tracker) { |
164 return GetFaviconForURLImpl( | 164 return GetFaviconForURLImpl( |
165 params, | 165 params, |
166 FaviconUtil::GetFaviconScaleFactors(), | 166 FaviconUtil::GetFaviconScaleFactors(), |
167 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, | 167 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, |
168 base::Unretained(this), | 168 base::Unretained(this), |
169 callback, | 169 callback, |
170 params.desired_size_in_dip), | 170 params.desired_size_in_dip), |
171 tracker); | 171 tracker); |
172 } | 172 } |
173 | 173 |
174 base::CancelableTaskTracker::TaskId FaviconService::GetRawFaviconForURL( | 174 base::CancelableTaskTracker::TaskId FaviconService::GetRawFaviconForURL( |
175 const FaviconForURLParams& params, | 175 const FaviconForURLParams& params, |
176 ui::ScaleFactor desired_scale_factor, | 176 ui::ScaleFactor desired_scale_factor, |
177 const FaviconRawCallback& callback, | 177 const favicon_base::FaviconRawCallback& callback, |
178 base::CancelableTaskTracker* tracker) { | 178 base::CancelableTaskTracker* tracker) { |
179 std::vector<ui::ScaleFactor> desired_scale_factors; | 179 std::vector<ui::ScaleFactor> desired_scale_factors; |
180 desired_scale_factors.push_back(desired_scale_factor); | 180 desired_scale_factors.push_back(desired_scale_factor); |
181 return GetFaviconForURLImpl( | 181 return GetFaviconForURLImpl( |
182 params, | 182 params, |
183 desired_scale_factors, | 183 desired_scale_factors, |
184 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, | 184 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, |
185 base::Unretained(this), | 185 base::Unretained(this), |
186 callback, | 186 callback, |
187 params.desired_size_in_dip, | 187 params.desired_size_in_dip, |
188 desired_scale_factor), | 188 desired_scale_factor), |
189 tracker); | 189 tracker); |
190 } | 190 } |
191 | 191 |
192 base::CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForURL( | 192 base::CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForURL( |
193 Profile* profile, | 193 Profile* profile, |
194 const GURL& page_url, | 194 const GURL& page_url, |
195 const std::vector<int>& icon_types, | 195 const std::vector<int>& icon_types, |
196 int minimum_size_in_pixels, | 196 int minimum_size_in_pixels, |
197 const FaviconRawCallback& callback, | 197 const favicon_base::FaviconRawCallback& callback, |
198 base::CancelableTaskTracker* tracker) { | 198 base::CancelableTaskTracker* tracker) { |
199 FaviconResultsCallback favicon_results_callback = | 199 favicon_base::FaviconResultsCallback favicon_results_callback = |
200 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, | 200 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, |
201 base::Unretained(this), callback, 0, ui::ScaleFactor()); | 201 base::Unretained(this), callback, 0, ui::ScaleFactor()); |
202 if (page_url.SchemeIs(content::kChromeUIScheme) || | 202 if (page_url.SchemeIs(content::kChromeUIScheme) || |
203 page_url.SchemeIs(extensions::kExtensionScheme)) { | 203 page_url.SchemeIs(extensions::kExtensionScheme)) { |
204 std::vector<ui::ScaleFactor> scale_factor; | 204 std::vector<ui::ScaleFactor> scale_factor; |
205 scale_factor.push_back(ui::SCALE_FACTOR_100P); | 205 scale_factor.push_back(ui::SCALE_FACTOR_100P); |
206 return GetFaviconForChromeURL(profile, page_url, scale_factor, | 206 return GetFaviconForChromeURL(profile, page_url, scale_factor, |
207 favicon_results_callback, tracker); | 207 favicon_results_callback, tracker); |
208 } else if (history_service_) { | 208 } else if (history_service_) { |
209 return history_service_->GetLargestFaviconForURL(page_url, icon_types, | 209 return history_service_->GetLargestFaviconForURL(page_url, icon_types, |
210 minimum_size_in_pixels, callback, tracker); | 210 minimum_size_in_pixels, callback, tracker); |
211 } | 211 } |
212 return RunWithEmptyResultAsync(favicon_results_callback, tracker); | 212 return RunWithEmptyResultAsync(favicon_results_callback, tracker); |
213 } | 213 } |
214 | 214 |
215 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForURL( | 215 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForURL( |
216 const FaviconForURLParams& params, | 216 const FaviconForURLParams& params, |
217 const FaviconResultsCallback& callback, | 217 const favicon_base::FaviconResultsCallback& callback, |
218 base::CancelableTaskTracker* tracker) { | 218 base::CancelableTaskTracker* tracker) { |
219 return GetFaviconForURLImpl(params, | 219 return GetFaviconForURLImpl(params, |
220 FaviconUtil::GetFaviconScaleFactors(), | 220 FaviconUtil::GetFaviconScaleFactors(), |
221 callback, | 221 callback, |
222 tracker); | 222 tracker); |
223 } | 223 } |
224 | 224 |
225 base::CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForID( | 225 base::CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForID( |
226 favicon_base::FaviconID favicon_id, | 226 favicon_base::FaviconID favicon_id, |
227 const FaviconRawCallback& callback, | 227 const favicon_base::FaviconRawCallback& callback, |
228 base::CancelableTaskTracker* tracker) { | 228 base::CancelableTaskTracker* tracker) { |
229 // 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| |
230 // without any resizing. | 230 // without any resizing. |
231 int desired_size_in_dip = 0; | 231 int desired_size_in_dip = 0; |
232 ui::ScaleFactor desired_scale_factor = ui::SCALE_FACTOR_100P; | 232 ui::ScaleFactor desired_scale_factor = ui::SCALE_FACTOR_100P; |
233 FaviconResultsCallback callback_runner = | 233 favicon_base::FaviconResultsCallback callback_runner = |
234 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, | 234 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, |
235 base::Unretained(this), | 235 base::Unretained(this), |
236 callback, desired_size_in_dip, desired_scale_factor); | 236 callback, desired_size_in_dip, desired_scale_factor); |
237 | 237 |
238 if (history_service_) { | 238 if (history_service_) { |
239 return history_service_->GetFaviconForID( | 239 return history_service_->GetFaviconForID( |
240 favicon_id, desired_size_in_dip, desired_scale_factor, | 240 favicon_id, desired_size_in_dip, desired_scale_factor, |
241 callback_runner, tracker); | 241 callback_runner, tracker); |
242 } else { | 242 } else { |
243 return RunWithEmptyResultAsync(callback_runner, tracker); | 243 return RunWithEmptyResultAsync(callback_runner, tracker); |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
316 | 316 |
317 void FaviconService::ClearUnableToDownloadFavicons() { | 317 void FaviconService::ClearUnableToDownloadFavicons() { |
318 missing_favicon_urls_.clear(); | 318 missing_favicon_urls_.clear(); |
319 } | 319 } |
320 | 320 |
321 FaviconService::~FaviconService() {} | 321 FaviconService::~FaviconService() {} |
322 | 322 |
323 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForURLImpl( | 323 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForURLImpl( |
324 const FaviconForURLParams& params, | 324 const FaviconForURLParams& params, |
325 const std::vector<ui::ScaleFactor>& desired_scale_factors, | 325 const std::vector<ui::ScaleFactor>& desired_scale_factors, |
326 const FaviconResultsCallback& callback, | 326 const favicon_base::FaviconResultsCallback& callback, |
327 base::CancelableTaskTracker* tracker) { | 327 base::CancelableTaskTracker* tracker) { |
328 if (params.page_url.SchemeIs(content::kChromeUIScheme) || | 328 if (params.page_url.SchemeIs(content::kChromeUIScheme) || |
329 params.page_url.SchemeIs(extensions::kExtensionScheme)) { | 329 params.page_url.SchemeIs(extensions::kExtensionScheme)) { |
330 return GetFaviconForChromeURL(profile_, params.page_url, | 330 return GetFaviconForChromeURL(profile_, params.page_url, |
331 desired_scale_factors, callback, tracker); | 331 desired_scale_factors, callback, tracker); |
332 } else if (history_service_) { | 332 } else if (history_service_) { |
333 return history_service_->GetFaviconsForURL(params.page_url, | 333 return history_service_->GetFaviconsForURL(params.page_url, |
334 params.icon_types, | 334 params.icon_types, |
335 params.desired_size_in_dip, | 335 params.desired_size_in_dip, |
336 desired_scale_factors, | 336 desired_scale_factors, |
337 callback, | 337 callback, |
338 tracker); | 338 tracker); |
339 } | 339 } |
340 return RunWithEmptyResultAsync(callback, tracker); | 340 return RunWithEmptyResultAsync(callback, tracker); |
341 } | 341 } |
342 | 342 |
343 void FaviconService::RunFaviconImageCallbackWithBitmapResults( | 343 void FaviconService::RunFaviconImageCallbackWithBitmapResults( |
344 const FaviconImageCallback& callback, | 344 const favicon_base::FaviconImageCallback& callback, |
345 int desired_size_in_dip, | 345 int desired_size_in_dip, |
346 const std::vector<favicon_base::FaviconBitmapResult>& | 346 const std::vector<favicon_base::FaviconBitmapResult>& |
347 favicon_bitmap_results) { | 347 favicon_bitmap_results) { |
348 favicon_base::FaviconImageResult image_result; | 348 favicon_base::FaviconImageResult image_result; |
349 image_result.image = FaviconUtil::SelectFaviconFramesFromPNGs( | 349 image_result.image = FaviconUtil::SelectFaviconFramesFromPNGs( |
350 favicon_bitmap_results, | 350 favicon_bitmap_results, |
351 FaviconUtil::GetFaviconScaleFactors(), | 351 FaviconUtil::GetFaviconScaleFactors(), |
352 desired_size_in_dip); | 352 desired_size_in_dip); |
353 FaviconUtil::SetFaviconColorSpace(&image_result.image); | 353 FaviconUtil::SetFaviconColorSpace(&image_result.image); |
354 | 354 |
355 image_result.icon_url = image_result.image.IsEmpty() ? | 355 image_result.icon_url = image_result.image.IsEmpty() ? |
356 GURL() : favicon_bitmap_results[0].icon_url; | 356 GURL() : favicon_bitmap_results[0].icon_url; |
357 callback.Run(image_result); | 357 callback.Run(image_result); |
358 } | 358 } |
359 | 359 |
360 void FaviconService::RunFaviconRawCallbackWithBitmapResults( | 360 void FaviconService::RunFaviconRawCallbackWithBitmapResults( |
361 const FaviconRawCallback& callback, | 361 const favicon_base::FaviconRawCallback& callback, |
362 int desired_size_in_dip, | 362 int desired_size_in_dip, |
363 ui::ScaleFactor desired_scale_factor, | 363 ui::ScaleFactor desired_scale_factor, |
364 const std::vector<favicon_base::FaviconBitmapResult>& | 364 const std::vector<favicon_base::FaviconBitmapResult>& |
365 favicon_bitmap_results) { | 365 favicon_bitmap_results) { |
366 if (favicon_bitmap_results.empty() || !favicon_bitmap_results[0].is_valid()) { | 366 if (favicon_bitmap_results.empty() || !favicon_bitmap_results[0].is_valid()) { |
367 callback.Run(favicon_base::FaviconBitmapResult()); | 367 callback.Run(favicon_base::FaviconBitmapResult()); |
368 return; | 368 return; |
369 } | 369 } |
370 | 370 |
371 DCHECK_EQ(1u, favicon_bitmap_results.size()); | 371 DCHECK_EQ(1u, favicon_bitmap_results.size()); |
(...skipping 29 matching lines...) Expand all Loading... |
401 if (!gfx::PNGCodec::EncodeBGRASkBitmap(resized_image.AsBitmap(), false, | 401 if (!gfx::PNGCodec::EncodeBGRASkBitmap(resized_image.AsBitmap(), false, |
402 &resized_bitmap_data)) { | 402 &resized_bitmap_data)) { |
403 callback.Run(favicon_base::FaviconBitmapResult()); | 403 callback.Run(favicon_base::FaviconBitmapResult()); |
404 return; | 404 return; |
405 } | 405 } |
406 | 406 |
407 bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector( | 407 bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector( |
408 &resized_bitmap_data); | 408 &resized_bitmap_data); |
409 callback.Run(bitmap_result); | 409 callback.Run(bitmap_result); |
410 } | 410 } |
OLD | NEW |