chrome/browser/favicon/favicon_service.cc

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