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 3 // found in the LICENSE file. 4 5 #include "chrome/browser/favicon/favicon_service.h" 6 7 #include "base/hash.h" 8 #include "base/message_loop/message_loop_proxy.h" 9 #include "chrome/browser/favicon/favicon_util.h" 10 #include "chrome/browser/history/history_backend.h" 11 #include "chrome/browser/history/history_service.h" 12 #include "chrome/browser/history/history_service_factory.h" 13 #include "chrome/browser/history/select_favicon_frames.h" 14 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h" 15 #include "chrome/common/favicon/favicon_types.h" 16 #include "chrome/common/importer/imported_favicon_usage.h" 17 #include "chrome/common/url_constants.h" 18 #include "extensions/common/constants.h" 19 #include "third_party/skia/include/core/SkBitmap.h" 20 #include "ui/gfx/codec/png_codec.h" 21 #include "ui/gfx/favicon_size.h" 22 #include "ui/gfx/image/image_skia.h" 23 24 using base::Bind; 25 26 namespace { 27 28 void CancelOrRunFaviconResultsCallback( 29 const CancelableTaskTracker::IsCanceledCallback& is_canceled, 30 const FaviconService::FaviconResultsCallback& callback, 31 const std::vector<chrome::FaviconBitmapResult>& results) { 32 if (is_canceled.Run()) 33 return; 34 callback.Run(results); 35 } 36 37 // Helper to run callback with empty results if we cannot get the history 38 // service. 39 CancelableTaskTracker::TaskId RunWithEmptyResultAsync( 40 const FaviconService::FaviconResultsCallback& callback, 41 CancelableTaskTracker* tracker) { 42 return tracker->PostTask( 43 base::MessageLoopProxy::current().get(), 44 FROM_HERE, 45 Bind(callback, std::vector<chrome::FaviconBitmapResult>())); 46 } 47 48 // Return the TaskId to retreive the favicon from chrome specific URL. 49 CancelableTaskTracker::TaskId GetFaviconForChromeURL( 50 Profile* profile, 51 const GURL& page_url, 52 const std::vector<ui::ScaleFactor>& desired_scale_factors, 53 const FaviconService::FaviconResultsCallback& callback, 54 CancelableTaskTracker* tracker) { 55 CancelableTaskTracker::IsCanceledCallback is_canceled_cb; 56 CancelableTaskTracker::TaskId id = tracker->NewTrackedTaskId(&is_canceled_cb); 57 FaviconService::FaviconResultsCallback cancelable_cb = 58 Bind(&CancelOrRunFaviconResultsCallback, is_canceled_cb, callback); 59 ChromeWebUIControllerFactory::GetInstance()->GetFaviconForURL(profile, 60 page_url, desired_scale_factors, cancelable_cb); 61 return id; 62 } 63 64 } // namespace 65 66 FaviconService::FaviconService(Profile* profile) 67 : history_service_(HistoryServiceFactory::GetForProfile( 68 profile, Profile::EXPLICIT_ACCESS)), 69 profile_(profile) { 70 } 71 72 // static 73 void FaviconService::FaviconResultsCallbackRunner( 74 const FaviconResultsCallback& callback, 75 const std::vector<chrome::FaviconBitmapResult>* results) { 76 callback.Run(*results); 77 } 78 79 CancelableTaskTracker::TaskId FaviconService::GetFaviconImage( 80 const GURL& icon_url, 81 chrome::IconType icon_type, 82 int desired_size_in_dip, 83 const FaviconImageCallback& callback, 84 CancelableTaskTracker* tracker) { 85 FaviconResultsCallback callback_runner = 86 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, 87 base::Unretained(this), callback, desired_size_in_dip); 88 if (history_service_) { 89 std::vector<GURL> icon_urls; 90 icon_urls.push_back(icon_url); 91 return history_service_->GetFavicons( 92 icon_urls, icon_type, desired_size_in_dip, 93 FaviconUtil::GetFaviconScaleFactors(), callback_runner, tracker); 94 } else { 95 return RunWithEmptyResultAsync(callback_runner, tracker); 96 } 97 } 98 99 CancelableTaskTracker::TaskId FaviconService::GetRawFavicon( 100 const GURL& icon_url, 101 chrome::IconType icon_type, 102 int desired_size_in_dip, 103 ui::ScaleFactor desired_scale_factor, 104 const FaviconRawCallback& callback, 105 CancelableTaskTracker* tracker) { 106 FaviconResultsCallback callback_runner = 107 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, 108 base::Unretained(this), 109 callback, desired_size_in_dip, desired_scale_factor); 110 111 if (history_service_) { 112 std::vector<GURL> icon_urls; 113 icon_urls.push_back(icon_url); 114 std::vector<ui::ScaleFactor> desired_scale_factors; 115 desired_scale_factors.push_back(desired_scale_factor); 116 117 return history_service_->GetFavicons( 118 icon_urls, icon_type, desired_size_in_dip, desired_scale_factors, 119 callback_runner, tracker); 120 } else { 121 return RunWithEmptyResultAsync(callback_runner, tracker); 122 } 123 } 124 125 CancelableTaskTracker::TaskId FaviconService::GetFavicon( 126 const GURL& icon_url, 127 chrome::IconType icon_type, 128 int desired_size_in_dip, 129 const FaviconResultsCallback& callback, 130 CancelableTaskTracker* tracker) { 131 if (history_service_) { 132 std::vector<GURL> icon_urls; 133 icon_urls.push_back(icon_url); 134 return history_service_->GetFavicons( 135 icon_urls, icon_type, desired_size_in_dip, 136 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); 137 } else { 138 return RunWithEmptyResultAsync(callback, tracker); 139 } 140 } 141 142 CancelableTaskTracker::TaskId FaviconService::UpdateFaviconMappingsAndFetch( 143 const GURL& page_url, 144 const std::vector<GURL>& icon_urls, 145 int icon_types, 146 int desired_size_in_dip, 147 const FaviconResultsCallback& callback, 148 CancelableTaskTracker* tracker) { 149 if (history_service_) { 150 return history_service_->UpdateFaviconMappingsAndFetch( 151 page_url, icon_urls, icon_types, desired_size_in_dip, 152 FaviconUtil::GetFaviconScaleFactors(), callback, tracker); 153 } else { 154 return RunWithEmptyResultAsync(callback, tracker); 155 } 156 } 157 158 CancelableTaskTracker::TaskId FaviconService::GetFaviconImageForURL( 159 const FaviconForURLParams& params, 160 const FaviconImageCallback& callback, 161 CancelableTaskTracker* tracker) { 162 return GetFaviconForURLImpl( 163 params, 164 FaviconUtil::GetFaviconScaleFactors(), 165 Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults, 166 base::Unretained(this), 167 callback, 168 params.desired_size_in_dip), 169 tracker); 170 } 171 172 CancelableTaskTracker::TaskId FaviconService::GetRawFaviconForURL( 173 const FaviconForURLParams& params, 174 ui::ScaleFactor desired_scale_factor, 175 const FaviconRawCallback& callback, 176 CancelableTaskTracker* tracker) { 177 std::vector<ui::ScaleFactor> desired_scale_factors; 178 desired_scale_factors.push_back(desired_scale_factor); 179 return GetFaviconForURLImpl( 180 params, 181 desired_scale_factors, 182 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, 183 base::Unretained(this), 184 callback, 185 params.desired_size_in_dip, 186 desired_scale_factor), 187 tracker); 188 } 189 190 CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForURL( 191 Profile* profile, 192 const GURL& page_url, 193 const std::vector<int>& icon_types, 194 int minimum_size_in_pixels, 195 const FaviconRawCallback& callback, 196 CancelableTaskTracker* tracker) { 197 FaviconResultsCallback favicon_results_callback = 198 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, 199 base::Unretained(this), callback, 0, ui::ScaleFactor()); 200 if (page_url.SchemeIs(chrome::kChromeUIScheme) || 201 page_url.SchemeIs(extensions::kExtensionScheme)) { 202 std::vector<ui::ScaleFactor> scale_factor; 203 scale_factor.push_back(ui::SCALE_FACTOR_100P); 204 return GetFaviconForChromeURL(profile, page_url, scale_factor, 205 favicon_results_callback, tracker); 206 } else if (history_service_) { 207 return history_service_->GetLargestFaviconForURL(page_url, icon_types, 208 minimum_size_in_pixels, callback, tracker); 209 } 210 return RunWithEmptyResultAsync(favicon_results_callback, tracker); 211 } 212 213 CancelableTaskTracker::TaskId FaviconService::GetFaviconForURL( 214 const FaviconForURLParams& params, 215 const FaviconResultsCallback& callback, 216 CancelableTaskTracker* tracker) { 217 return GetFaviconForURLImpl(params, 218 FaviconUtil::GetFaviconScaleFactors(), 219 callback, 220 tracker); 221 } 222 223 CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForID( 224 chrome::FaviconID favicon_id, 225 const FaviconRawCallback& callback, 226 CancelableTaskTracker* tracker) { 227 // Use 0 as |desired_size_in_dip| to get the largest bitmap for |favicon_id| 228 // without any resizing. 229 int desired_size_in_dip = 0; 230 ui::ScaleFactor desired_scale_factor = ui::SCALE_FACTOR_100P; 231 FaviconResultsCallback callback_runner = 232 Bind(&FaviconService::RunFaviconRawCallbackWithBitmapResults, 233 base::Unretained(this), 234 callback, desired_size_in_dip, desired_scale_factor); 235 236 if (history_service_) { 237 return history_service_->GetFaviconForID( 238 favicon_id, desired_size_in_dip, desired_scale_factor, 239 callback_runner, tracker); 240 } else { 241 return RunWithEmptyResultAsync(callback_runner, tracker); 242 } 243 } 244 245 void FaviconService::SetFaviconOutOfDateForPage(const GURL& page_url) { 246 if (history_service_) 247 history_service_->SetFaviconsOutOfDateForPage(page_url); 248 } 249 250 void FaviconService::CloneFavicon(const GURL& old_page_url, 251 const GURL& new_page_url) { 252 if (history_service_) 253 history_service_->CloneFavicons(old_page_url, new_page_url); 254 } 255 256 void FaviconService::SetImportedFavicons( 257 const std::vector<ImportedFaviconUsage>& favicon_usage) { 258 if (history_service_) 259 history_service_->SetImportedFavicons(favicon_usage); 260 } 261 262 void FaviconService::MergeFavicon( 263 const GURL& page_url, 264 const GURL& icon_url, 265 chrome::IconType icon_type, 266 scoped_refptr<base::RefCountedMemory> bitmap_data, 267 const gfx::Size& pixel_size) { 268 if (history_service_) { 269 history_service_->MergeFavicon(page_url, icon_url, icon_type, bitmap_data, 270 pixel_size); 271 } 272 } 273 274 void FaviconService::SetFavicons(const GURL& page_url, 275 const GURL& icon_url, 276 chrome::IconType icon_type, 277 const gfx::Image& image) { 278 if (!history_service_) 279 return; 280 281 gfx::ImageSkia image_skia = image.AsImageSkia(); 282 image_skia.EnsureRepsForSupportedScales(); 283 const std::vector<gfx::ImageSkiaRep>& image_reps = image_skia.image_reps(); 284 std::vector<chrome::FaviconBitmapData> favicon_bitmap_data; 285 for (size_t i = 0; i < image_reps.size(); ++i) { 286 scoped_refptr<base::RefCountedBytes> bitmap_data( 287 new base::RefCountedBytes()); 288 if (gfx::PNGCodec::EncodeBGRASkBitmap(image_reps[i].sk_bitmap(), 289 false, 290 &bitmap_data->data())) { 291 gfx::Size pixel_size(image_reps[i].pixel_width(), 292 image_reps[i].pixel_height()); 293 chrome::FaviconBitmapData bitmap_data_element; 294 bitmap_data_element.bitmap_data = bitmap_data; 295 bitmap_data_element.pixel_size = pixel_size; 296 bitmap_data_element.icon_url = icon_url; 297 298 favicon_bitmap_data.push_back(bitmap_data_element); 299 } 300 } 301 302 history_service_->SetFavicons(page_url, icon_type, favicon_bitmap_data); 303 } 304 305 void FaviconService::UnableToDownloadFavicon(const GURL& icon_url) { 306 MissingFaviconURLHash url_hash = base::Hash(icon_url.spec()); 307 missing_favicon_urls_.insert(url_hash); 308 } 309 310 bool FaviconService::WasUnableToDownloadFavicon(const GURL& icon_url) const { 311 MissingFaviconURLHash url_hash = base::Hash(icon_url.spec()); 312 return missing_favicon_urls_.find(url_hash) != missing_favicon_urls_.end(); 313 } 314 315 void FaviconService::ClearUnableToDownloadFavicons() { 316 missing_favicon_urls_.clear(); 317 } 318 319 FaviconService::~FaviconService() {} 320 321 CancelableTaskTracker::TaskId FaviconService::GetFaviconForURLImpl( 322 const FaviconForURLParams& params, 323 const std::vector<ui::ScaleFactor>& desired_scale_factors, 324 const FaviconResultsCallback& callback, 325 CancelableTaskTracker* tracker) { 326 if (params.page_url.SchemeIs(chrome::kChromeUIScheme) || 327 params.page_url.SchemeIs(extensions::kExtensionScheme)) { 328 return GetFaviconForChromeURL(profile_, params.page_url, 329 desired_scale_factors, callback, tracker); 330 } else if (history_service_) { 331 return history_service_->GetFaviconsForURL(params.page_url, 332 params.icon_types, 333 params.desired_size_in_dip, 334 desired_scale_factors, 335 callback, 336 tracker); 337 } 338 return RunWithEmptyResultAsync(callback, tracker); 339 } 340 341 void FaviconService::RunFaviconImageCallbackWithBitmapResults( 342 const FaviconImageCallback& callback, 343 int desired_size_in_dip, 344 const std::vector<chrome::FaviconBitmapResult>& favicon_bitmap_results) { 345 chrome::FaviconImageResult image_result; 346 image_result.image = FaviconUtil::SelectFaviconFramesFromPNGs( 347 favicon_bitmap_results, 348 FaviconUtil::GetFaviconScaleFactors(), 349 desired_size_in_dip); 350 FaviconUtil::SetFaviconColorSpace(&image_result.image); 351 352 image_result.icon_url = image_result.image.IsEmpty() ? 353 GURL() : favicon_bitmap_results[0].icon_url; 354 callback.Run(image_result); 355 } 356 357 void FaviconService::RunFaviconRawCallbackWithBitmapResults( 358 const FaviconRawCallback& callback, 359 int desired_size_in_dip, 360 ui::ScaleFactor desired_scale_factor, 361 const std::vector<chrome::FaviconBitmapResult>& favicon_bitmap_results) { 362 if (favicon_bitmap_results.empty() || !favicon_bitmap_results[0].is_valid()) { 363 callback.Run(chrome::FaviconBitmapResult()); 364 return; 365 } 366 367 DCHECK_EQ(1u, favicon_bitmap_results.size()); 368 chrome::FaviconBitmapResult bitmap_result = favicon_bitmap_results[0]; 369 370 // If the desired size is 0, SelectFaviconFrames() will return the largest 371 // bitmap without doing any resizing. As |favicon_bitmap_results| has bitmap 372 // data for a single bitmap, return it and avoid an unnecessary decode. 373 if (desired_size_in_dip == 0) { 374 callback.Run(bitmap_result); 375 return; 376 } 377 378 // If history bitmap is already desired pixel size, return early. 379 float desired_scale = ui::GetImageScale(desired_scale_factor); 380 int desired_edge_width_in_pixel = static_cast<int>( 381 desired_size_in_dip * desired_scale + 0.5f); 382 gfx::Size desired_size_in_pixel(desired_edge_width_in_pixel, 383 desired_edge_width_in_pixel); 384 if (bitmap_result.pixel_size == desired_size_in_pixel) { 385 callback.Run(bitmap_result); 386 return; 387 } 388 389 // Convert raw bytes to SkBitmap, resize via SelectFaviconFrames(), then 390 // convert back. 391 std::vector<ui::ScaleFactor> desired_scale_factors; 392 desired_scale_factors.push_back(desired_scale_factor); 393 gfx::Image resized_image = FaviconUtil::SelectFaviconFramesFromPNGs( 394 favicon_bitmap_results, desired_scale_factors, desired_size_in_dip); 395 396 std::vector<unsigned char> resized_bitmap_data; 397 if (!gfx::PNGCodec::EncodeBGRASkBitmap(resized_image.AsBitmap(), false, 398 &resized_bitmap_data)) { 399 callback.Run(chrome::FaviconBitmapResult()); 400 return; 401 } 402 403 bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector( 404 &resized_bitmap_data); 405 callback.Run(bitmap_result); 406 } 407
