chrome/browser/favicon/favicon_handler.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_handler.h"
   6
   7 #include <algorithm>
   8 #include <cmath>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "base/bind_helpers.h"
  13 #include "base/memory/ref_counted_memory.h"
  14 #include "build/build_config.h"
  15 #include "chrome/browser/favicon/favicon_service.h"
  16 #include "components/favicon/core/browser/favicon_client.h"
  17 #include "components/favicon/core/favicon_driver.h"
  18 #include "components/favicon_base/favicon_util.h"
  19 #include "components/favicon_base/select_favicon_frames.h"
  20 #include "skia/ext/image_operations.h"
  21 #include "ui/gfx/codec/png_codec.h"
  22 #include "ui/gfx/image/image_skia.h"
  23 #include "ui/gfx/image/image_util.h"
  24
  25 using favicon::FaviconURL;
  26
  27 namespace {
  28
  29 // Size (along each axis) of a touch icon. This currently corresponds to
  30 // the apple touch icon for iPad.
  31 const int kTouchIconSize = 144;
  32
  33 // Get the maximal icon size in pixels for a icon of type |icon_type| for the
  34 // current platform.
  35 int GetMaximalIconSize(favicon_base::IconType icon_type) {
  36   switch (icon_type) {
  37     case favicon_base::FAVICON:
  38 #if defined(OS_ANDROID)
  39       return 192;
  40 #else
  41       return gfx::ImageSkia::GetMaxSupportedScale() * gfx::kFaviconSize;
  42 #endif
  43     case favicon_base::TOUCH_ICON:
  44     case favicon_base::TOUCH_PRECOMPOSED_ICON:
  45       return kTouchIconSize;
  46     case favicon_base::INVALID_ICON:
  47       return 0;
  48   }
  49   NOTREACHED();
  50   return 0;
  51 }
  52
  53 bool DoUrlAndIconMatch(const FaviconURL& favicon_url,
  54                        const GURL& url,
  55                        favicon_base::IconType icon_type) {
  56   return favicon_url.icon_url == url && favicon_url.icon_type == icon_type;
  57 }
  58
  59 // Returns true if all of the icon URLs and icon types in |bitmap_results| are
  60 // identical and if they match the icon URL and icon type in |favicon_url|.
  61 // Returns false if |bitmap_results| is empty.
  62 bool DoUrlsAndIconsMatch(
  63     const FaviconURL& favicon_url,
  64     const std::vector<favicon_base::FaviconRawBitmapResult>& bitmap_results) {
  65   if (bitmap_results.empty())
  66     return false;
  67
  68   const favicon_base::IconType icon_type = favicon_url.icon_type;
  69
  70   for (size_t i = 0; i < bitmap_results.size(); ++i) {
  71     if (favicon_url.icon_url != bitmap_results[i].icon_url ||
  72         icon_type != bitmap_results[i].icon_type) {
  73       return false;
  74     }
  75   }
  76   return true;
  77 }
  78
  79 std::string UrlWithoutFragment(const GURL& gurl) {
  80   GURL::Replacements replacements;
  81   replacements.ClearRef();
  82   return gurl.ReplaceComponents(replacements).spec();
  83 }
  84
  85 bool UrlMatches(const GURL& gurl_a, const GURL& gurl_b) {
  86   return UrlWithoutFragment(gurl_a) == UrlWithoutFragment(gurl_b);
  87 }
  88
  89 // Return true if |bitmap_result| is expired.
  90 bool IsExpired(const favicon_base::FaviconRawBitmapResult& bitmap_result) {
  91   return bitmap_result.expired;
  92 }
  93
  94 // Return true if |bitmap_result| is valid.
  95 bool IsValid(const favicon_base::FaviconRawBitmapResult& bitmap_result) {
  96   return bitmap_result.is_valid();
  97 }
  98
  99 // Returns true if at least one of the bitmaps in |bitmap_results| is expired or
 100 // if |bitmap_results| is missing favicons for |desired_size_in_dip| and one of
 101 // the scale factors in favicon_base::GetFaviconScales().
 102 bool HasExpiredOrIncompleteResult(
 103     int desired_size_in_dip,
 104     const std::vector<favicon_base::FaviconRawBitmapResult>& bitmap_results) {
 105   // Check if at least one of the bitmaps is expired.
 106   std::vector<favicon_base::FaviconRawBitmapResult>::const_iterator it =
 107       std::find_if(bitmap_results.begin(), bitmap_results.end(), IsExpired);
 108   if (it != bitmap_results.end())
 109     return true;
 110
 111   // Any favicon size is good if the desired size is 0.
 112   if (desired_size_in_dip == 0)
 113     return false;
 114
 115   // Check if the favicon for at least one of the scale factors is missing.
 116   // |bitmap_results| should always be complete for data inserted by
 117   // FaviconHandler as the FaviconHandler stores favicons resized to all
 118   // of favicon_base::GetFaviconScales() into the history backend.
 119   // Examples of when |bitmap_results| can be incomplete:
 120   // - Favicons inserted into the history backend by sync.
 121   // - Favicons for imported bookmarks.
 122   std::vector<gfx::Size> favicon_sizes;
 123   for (size_t i = 0; i < bitmap_results.size(); ++i)
 124     favicon_sizes.push_back(bitmap_results[i].pixel_size);
 125
 126   std::vector<float> favicon_scales = favicon_base::GetFaviconScales();
 127   for (size_t i = 0; i < favicon_scales.size(); ++i) {
 128     int edge_size_in_pixel = std::ceil(desired_size_in_dip * favicon_scales[i]);
 129     std::vector<gfx::Size>::iterator it = std::find(favicon_sizes.begin(),
 130         favicon_sizes.end(), gfx::Size(edge_size_in_pixel, edge_size_in_pixel));
 131     if (it == favicon_sizes.end())
 132       return true;
 133   }
 134   return false;
 135 }
 136
 137 // Returns true if at least one of |bitmap_results| is valid.
 138 bool HasValidResult(
 139     const std::vector<favicon_base::FaviconRawBitmapResult>& bitmap_results) {
 140   return std::find_if(bitmap_results.begin(), bitmap_results.end(), IsValid) !=
 141       bitmap_results.end();
 142 }
 143
 144 // Returns the index of the entry with the largest area that is not larger than
 145 // |max_area|; -1 if there is no such match.
 146 int GetLargestSizeIndex(const std::vector<gfx::Size>& sizes, int max_area) {
 147   DCHECK(!sizes.empty());
 148   int ret = -1;
 149   for (size_t i = 0; i < sizes.size(); ++i) {
 150     int area = sizes[i].GetArea();
 151     if ((ret == -1 || sizes[ret].GetArea() < area) && area <= max_area)
 152       ret = i;
 153   }
 154   return ret;
 155 }
 156
 157 // Return the index of a size which is same as the given |size|, -1 returned if
 158 // there is no such bitmap.
 159 int GetIndexBySize(const std::vector<gfx::Size>& sizes,
 160                    const gfx::Size& size) {
 161   DCHECK(!sizes.empty());
 162   std::vector<gfx::Size>::const_iterator i =
 163       std::find(sizes.begin(), sizes.end(), size);
 164   if (i == sizes.end())
 165     return -1;
 166
 167   return static_cast<int>(i - sizes.begin());
 168 }
 169
 170 // Compare function used for std::stable_sort to sort as descend.
 171 bool CompareIconSize(const FaviconURL& b1, const FaviconURL& b2) {
 172   int area1 = 0;
 173   if (!b1.icon_sizes.empty())
 174     area1 = b1.icon_sizes.front().GetArea();
 175
 176   int area2 = 0;
 177   if (!b2.icon_sizes.empty())
 178     area2 = b2.icon_sizes.front().GetArea();
 179
 180   return area1 > area2;
 181 }
 182
 183 }  // namespace
 184
 185 ////////////////////////////////////////////////////////////////////////////////
 186
 187 FaviconHandler::DownloadRequest::DownloadRequest()
 188     : icon_type(favicon_base::INVALID_ICON) {}
 189
 190 FaviconHandler::DownloadRequest::~DownloadRequest() {
 191 }
 192
 193 FaviconHandler::DownloadRequest::DownloadRequest(
 194     const GURL& url,
 195     const GURL& image_url,
 196     favicon_base::IconType icon_type)
 197     : url(url), image_url(image_url), icon_type(icon_type) {}
 198
 199 ////////////////////////////////////////////////////////////////////////////////
 200
 201 FaviconHandler::FaviconCandidate::FaviconCandidate()
 202     : score(0), icon_type(favicon_base::INVALID_ICON) {}
 203
 204 FaviconHandler::FaviconCandidate::~FaviconCandidate() {
 205 }
 206
 207 FaviconHandler::FaviconCandidate::FaviconCandidate(
 208     const GURL& url,
 209     const GURL& image_url,
 210     const gfx::Image& image,
 211     float score,
 212     favicon_base::IconType icon_type)
 213     : url(url),
 214       image_url(image_url),
 215       image(image),
 216       score(score),
 217       icon_type(icon_type) {}
 218
 219 ////////////////////////////////////////////////////////////////////////////////
 220
 221 FaviconHandler::FaviconHandler(FaviconClient* client,
 222                                FaviconDriver* driver,
 223                                Type icon_type,
 224                                bool download_largest_icon)
 225     : got_favicon_from_history_(false),
 226       favicon_expired_or_incomplete_(false),
 227       icon_types_(icon_type == FAVICON
 228                       ? favicon_base::FAVICON
 229                       : favicon_base::TOUCH_ICON |
 230                             favicon_base::TOUCH_PRECOMPOSED_ICON),
 231       download_largest_icon_(download_largest_icon),
 232       client_(client),
 233       driver_(driver) {
 234   DCHECK(driver_);
 235 }
 236
 237 FaviconHandler::~FaviconHandler() {
 238 }
 239
 240 void FaviconHandler::FetchFavicon(const GURL& url) {
 241   cancelable_task_tracker_.TryCancelAll();
 242
 243   url_ = url;
 244
 245   favicon_expired_or_incomplete_ = got_favicon_from_history_ = false;
 246   image_urls_.clear();
 247
 248   // Request the favicon from the history service. In parallel to this the
 249   // renderer is going to notify us (well WebContents) when the favicon url is
 250   // available.
 251   if (client_->GetFaviconService()) {
 252     GetFaviconForURLFromFaviconService(
 253         url_,
 254         icon_types_,
 255         base::Bind(
 256             &FaviconHandler::OnFaviconDataForInitialURLFromFaviconService,
 257             base::Unretained(this)),
 258         &cancelable_task_tracker_);
 259   }
 260 }
 261
 262 bool FaviconHandler::UpdateFaviconCandidate(const GURL& url,
 263                                             const GURL& image_url,
 264                                             const gfx::Image& image,
 265                                             float score,
 266                                             favicon_base::IconType icon_type) {
 267   bool replace_best_favicon_candidate = false;
 268   bool exact_match = false;
 269   if (download_largest_icon_) {
 270     replace_best_favicon_candidate =
 271         image.Size().GetArea() >
 272         best_favicon_candidate_.image.Size().GetArea();
 273
 274     gfx::Size largest = best_favicon_candidate_.image.Size();
 275     if (replace_best_favicon_candidate)
 276       largest = image.Size();
 277
 278     // exact match (stop downloading next icon) only if
 279     // - current candidate is only candidate.
 280     // - next candidate doesn't have sizes attributes, in this case, the rest
 281     //   candidates don't have sizes attribute either, stop downloading now,
 282     //   otherwise, all favicon without sizes attribute are downloaded.
 283     // - next candidate has sizes attribute and it is not larger than largest.
 284     exact_match = image_urls_.size() == 1 ||
 285         image_urls_[1].icon_sizes.empty() ||
 286         image_urls_[1].icon_sizes[0].GetArea() < largest.GetArea();
 287   } else {
 288     exact_match = score == 1 || preferred_icon_size() == 0;
 289     replace_best_favicon_candidate =
 290         exact_match ||
 291         best_favicon_candidate_.icon_type == favicon_base::INVALID_ICON ||
 292         score > best_favicon_candidate_.score;
 293   }
 294   if (replace_best_favicon_candidate) {
 295     best_favicon_candidate_ = FaviconCandidate(
 296         url, image_url, image, score, icon_type);
 297   }
 298   return exact_match;
 299 }
 300
 301 void FaviconHandler::SetFavicon(const GURL& url,
 302                                 const GURL& icon_url,
 303                                 const gfx::Image& image,
 304                                 favicon_base::IconType icon_type) {
 305   if (client_->GetFaviconService() && ShouldSaveFavicon(url))
 306     SetHistoryFavicons(url, icon_url, icon_type, image);
 307
 308   if (UrlMatches(url, url_) && icon_type == favicon_base::FAVICON) {
 309     if (!PageChangedSinceFaviconWasRequested())
 310       SetFaviconOnActivePage(icon_url, image);
 311   }
 312 }
 313
 314 void FaviconHandler::SetFaviconOnActivePage(const std::vector<
 315     favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results) {
 316   gfx::Image resized_image = favicon_base::SelectFaviconFramesFromPNGs(
 317       favicon_bitmap_results,
 318       favicon_base::GetFaviconScales(),
 319       preferred_icon_size());
 320   // The history service sends back results for a single icon URL, so it does
 321   // not matter which result we get the |icon_url| from.
 322   const GURL icon_url = favicon_bitmap_results.empty() ?
 323       GURL() : favicon_bitmap_results[0].icon_url;
 324   SetFaviconOnActivePage(icon_url, resized_image);
 325 }
 326
 327 void FaviconHandler::SetFaviconOnActivePage(const GURL& icon_url,
 328                                             const gfx::Image& image) {
 329   // No matter what happens, we need to mark the favicon as being set.
 330   driver_->SetActiveFaviconValidity(true);
 331
 332   bool icon_url_changed = driver_->GetActiveFaviconURL() != icon_url;
 333   driver_->SetActiveFaviconURL(icon_url);
 334
 335   if (image.IsEmpty())
 336     return;
 337
 338   gfx::Image image_with_adjusted_colorspace = image;
 339   favicon_base::SetFaviconColorSpace(&image_with_adjusted_colorspace);
 340
 341   driver_->SetActiveFaviconImage(image_with_adjusted_colorspace);
 342   NotifyFaviconUpdated(icon_url_changed);
 343 }
 344
 345 void FaviconHandler::OnUpdateFaviconURL(
 346     const std::vector<FaviconURL>& candidates) {
 347   image_urls_.clear();
 348   best_favicon_candidate_ = FaviconCandidate();
 349   for (std::vector<FaviconURL>::const_iterator i = candidates.begin();
 350        i != candidates.end(); ++i) {
 351     if (!i->icon_url.is_empty() && (i->icon_type & icon_types_))
 352       image_urls_.push_back(*i);
 353   }
 354
 355   if (!client_->GetFaviconService())
 356     return;
 357
 358   if (download_largest_icon_)
 359     SortAndPruneImageUrls();
 360
 361   // TODO(davemoore) Should clear on empty url. Currently we ignore it.
 362   // This appears to be what FF does as well.
 363   if (!image_urls_.empty())
 364     ProcessCurrentUrl();
 365 }
 366
 367 void FaviconHandler::ProcessCurrentUrl() {
 368   DCHECK(!image_urls_.empty());
 369
 370   // current_candidate() may return NULL if download_largest_icon_ is true and
 371   // all the sizes are larger than the max.
 372   if (PageChangedSinceFaviconWasRequested() || !current_candidate())
 373     return;
 374
 375   if (current_candidate()->icon_type == favicon_base::FAVICON) {
 376     if (!favicon_expired_or_incomplete_ &&
 377         driver_->GetActiveFaviconValidity() &&
 378         DoUrlAndIconMatch(*current_candidate(),
 379                           driver_->GetActiveFaviconURL(),
 380                           favicon_base::FAVICON))
 381       return;
 382   } else if (!favicon_expired_or_incomplete_ && got_favicon_from_history_ &&
 383              HasValidResult(history_results_) &&
 384              DoUrlsAndIconsMatch(*current_candidate(), history_results_)) {
 385     return;
 386   }
 387
 388   if (got_favicon_from_history_)
 389     DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
 390                                        current_candidate()->icon_url,
 391                                        current_candidate()->icon_type);
 392 }
 393
 394 void FaviconHandler::OnDidDownloadFavicon(
 395     int id,
 396     const GURL& image_url,
 397     const std::vector<SkBitmap>& bitmaps,
 398     const std::vector<gfx::Size>& original_bitmap_sizes) {
 399   DownloadRequests::iterator i = download_requests_.find(id);
 400   if (i == download_requests_.end()) {
 401     // Currently WebContents notifies us of ANY downloads so that it is
 402     // possible to get here.
 403     return;
 404   }
 405
 406   if (current_candidate() &&
 407       DoUrlAndIconMatch(*current_candidate(), image_url, i->second.icon_type)) {
 408     bool request_next_icon = true;
 409     float score = 0.0f;
 410     gfx::ImageSkia image_skia;
 411     if (download_largest_icon_ && !bitmaps.empty()) {
 412       int index = -1;
 413       int max_size = GetMaximalIconSize(i->second.icon_type);
 414       // Use the largest bitmap if FaviconURL doesn't have sizes attribute.
 415       if (current_candidate()->icon_sizes.empty()) {
 416         index = GetLargestSizeIndex(original_bitmap_sizes, max_size * max_size);
 417       } else {
 418         index = GetIndexBySize(original_bitmap_sizes,
 419                                current_candidate()->icon_sizes[0]);
 420         // Find largest bitmap if there is no one exactly matched.
 421         if (index == -1) {
 422           index = GetLargestSizeIndex(original_bitmap_sizes,
 423                                       max_size * max_size);
 424         }
 425       }
 426       if (index != -1)
 427         image_skia = gfx::ImageSkia(gfx::ImageSkiaRep(bitmaps[index], 1));
 428     } else {
 429       image_skia = CreateFaviconImageSkia(bitmaps,
 430                                           original_bitmap_sizes,
 431                                           preferred_icon_size(),
 432                                           &score);
 433     }
 434
 435     if (!image_skia.isNull()) {
 436       gfx::Image image(image_skia);
 437       // The downloaded icon is still valid when there is no FaviconURL update
 438       // during the downloading.
 439       if (!bitmaps.empty()) {
 440         request_next_icon = !UpdateFaviconCandidate(
 441             i->second.url, image_url, image, score, i->second.icon_type);
 442       }
 443     }
 444     if (request_next_icon && !PageChangedSinceFaviconWasRequested() &&
 445         image_urls_.size() > 1) {
 446       // Remove the first member of image_urls_ and process the remaining.
 447       image_urls_.erase(image_urls_.begin());
 448       ProcessCurrentUrl();
 449     } else if (best_favicon_candidate_.icon_type !=
 450                favicon_base::INVALID_ICON) {
 451       // No more icons to request, set the favicon from the candidate.
 452       SetFavicon(best_favicon_candidate_.url,
 453                  best_favicon_candidate_.image_url,
 454                  best_favicon_candidate_.image,
 455                  best_favicon_candidate_.icon_type);
 456       // Reset candidate.
 457       image_urls_.clear();
 458       best_favicon_candidate_ = FaviconCandidate();
 459     }
 460   }
 461   download_requests_.erase(i);
 462 }
 463
 464 bool FaviconHandler::PageChangedSinceFaviconWasRequested() {
 465   if (UrlMatches(driver_->GetActiveURL(), url_) && url_.is_valid()) {
 466     return false;
 467   }
 468   // If the URL has changed out from under us (as will happen with redirects)
 469   // return true.
 470   return true;
 471 }
 472
 473 int FaviconHandler::DownloadFavicon(const GURL& image_url,
 474                                     int max_bitmap_size) {
 475   if (!image_url.is_valid()) {
 476     NOTREACHED();
 477     return 0;
 478   }
 479   return driver_->StartDownload(image_url, max_bitmap_size);
 480 }
 481
 482 void FaviconHandler::UpdateFaviconMappingAndFetch(
 483     const GURL& page_url,
 484     const GURL& icon_url,
 485     favicon_base::IconType icon_type,
 486     const favicon_base::FaviconResultsCallback& callback,
 487     base::CancelableTaskTracker* tracker) {
 488   // TODO(pkotwicz): pass in all of |image_urls_| to
 489   // UpdateFaviconMappingsAndFetch().
 490   std::vector<GURL> icon_urls;
 491   icon_urls.push_back(icon_url);
 492   client_->GetFaviconService()->UpdateFaviconMappingsAndFetch(
 493       page_url, icon_urls, icon_type, preferred_icon_size(), callback, tracker);
 494 }
 495
 496 void FaviconHandler::GetFaviconFromFaviconService(
 497     const GURL& icon_url,
 498     favicon_base::IconType icon_type,
 499     const favicon_base::FaviconResultsCallback& callback,
 500     base::CancelableTaskTracker* tracker) {
 501   client_->GetFaviconService()->GetFavicon(
 502       icon_url, icon_type, preferred_icon_size(), callback, tracker);
 503 }
 504
 505 void FaviconHandler::GetFaviconForURLFromFaviconService(
 506     const GURL& page_url,
 507     int icon_types,
 508     const favicon_base::FaviconResultsCallback& callback,
 509     base::CancelableTaskTracker* tracker) {
 510   client_->GetFaviconService()->GetFaviconForPageURL(
 511       page_url,
 512       icon_types,
 513       preferred_icon_size(),
 514       callback,
 515       tracker);
 516 }
 517
 518 void FaviconHandler::SetHistoryFavicons(const GURL& page_url,
 519                                         const GURL& icon_url,
 520                                         favicon_base::IconType icon_type,
 521                                         const gfx::Image& image) {
 522   client_->GetFaviconService()->SetFavicons(
 523       page_url, icon_url, icon_type, image);
 524 }
 525
 526 bool FaviconHandler::ShouldSaveFavicon(const GURL& url) {
 527   if (!driver_->IsOffTheRecord())
 528     return true;
 529
 530   // Otherwise store the favicon if the page is bookmarked.
 531   return client_->IsBookmarked(url);
 532 }
 533
 534 void FaviconHandler::NotifyFaviconUpdated(bool icon_url_changed) {
 535   driver_->NotifyFaviconUpdated(icon_url_changed);
 536 }
 537
 538 void FaviconHandler::OnFaviconDataForInitialURLFromFaviconService(
 539     const std::vector<favicon_base::FaviconRawBitmapResult>&
 540         favicon_bitmap_results) {
 541   if (PageChangedSinceFaviconWasRequested())
 542     return;
 543   got_favicon_from_history_ = true;
 544   history_results_ = favicon_bitmap_results;
 545   bool has_results = !favicon_bitmap_results.empty();
 546   favicon_expired_or_incomplete_ = has_results && HasExpiredOrIncompleteResult(
 547       preferred_icon_size(), favicon_bitmap_results);
 548   if (has_results && icon_types_ == favicon_base::FAVICON &&
 549       !driver_->GetActiveFaviconValidity() &&
 550       (!current_candidate() ||
 551        DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results))) {
 552     if (HasValidResult(favicon_bitmap_results)) {
 553       // The db knows the favicon (although it may be out of date) and the entry
 554       // doesn't have an icon. Set the favicon now, and if the favicon turns out
 555       // to be expired (or the wrong url) we'll fetch later on. This way the
 556       // user doesn't see a flash of the default favicon.
 557       SetFaviconOnActivePage(favicon_bitmap_results);
 558     } else {
 559       // If |favicon_bitmap_results| does not have any valid results, treat the
 560       // favicon as if it's expired.
 561       // TODO(pkotwicz): Do something better.
 562       favicon_expired_or_incomplete_ = true;
 563     }
 564   }
 565   if (has_results && !favicon_expired_or_incomplete_) {
 566     if (current_candidate() &&
 567         !DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results)) {
 568       // Mapping in the database is wrong. DownloadFavIconOrAskHistory will
 569       // update the mapping for this url and download the favicon if we don't
 570       // already have it.
 571       DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
 572                                          current_candidate()->icon_url,
 573                                          current_candidate()->icon_type);
 574     }
 575   } else if (current_candidate()) {
 576     // We know the official url for the favicon, but either don't have the
 577     // favicon or it's expired. Continue on to DownloadFaviconOrAskHistory to
 578     // either download or check history again.
 579     DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
 580                                        current_candidate()->icon_url,
 581                                        current_candidate()->icon_type);
 582   }
 583   // else we haven't got the icon url. When we get it we'll ask the
 584   // renderer to download the icon.
 585 }
 586
 587 void FaviconHandler::DownloadFaviconOrAskFaviconService(
 588     const GURL& page_url,
 589     const GURL& icon_url,
 590     favicon_base::IconType icon_type) {
 591   if (favicon_expired_or_incomplete_) {
 592     // We have the mapping, but the favicon is out of date. Download it now.
 593     ScheduleDownload(page_url, icon_url, icon_type);
 594   } else if (client_->GetFaviconService()) {
 595     // We don't know the favicon, but we may have previously downloaded the
 596     // favicon for another page that shares the same favicon. Ask for the
 597     // favicon given the favicon URL.
 598     if (driver_->IsOffTheRecord()) {
 599       GetFaviconFromFaviconService(
 600           icon_url, icon_type,
 601           base::Bind(&FaviconHandler::OnFaviconData, base::Unretained(this)),
 602           &cancelable_task_tracker_);
 603     } else {
 604       // Ask the history service for the icon. This does two things:
 605       // 1. Attempts to fetch the favicon data from the database.
 606       // 2. If the favicon exists in the database, this updates the database to
 607       //    include the mapping between the page url and the favicon url.
 608       // This is asynchronous. The history service will call back when done.
 609       UpdateFaviconMappingAndFetch(
 610           page_url, icon_url, icon_type,
 611           base::Bind(&FaviconHandler::OnFaviconData, base::Unretained(this)),
 612           &cancelable_task_tracker_);
 613     }
 614   }
 615 }
 616
 617 void FaviconHandler::OnFaviconData(const std::vector<
 618     favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results) {
 619   if (PageChangedSinceFaviconWasRequested())
 620     return;
 621
 622   bool has_results = !favicon_bitmap_results.empty();
 623   bool has_expired_or_incomplete_result = HasExpiredOrIncompleteResult(
 624       preferred_icon_size(), favicon_bitmap_results);
 625
 626   if (has_results && icon_types_ == favicon_base::FAVICON) {
 627     if (HasValidResult(favicon_bitmap_results)) {
 628       // There is a favicon, set it now. If expired we'll download the current
 629       // one again, but at least the user will get some icon instead of the
 630       // default and most likely the current one is fine anyway.
 631       SetFaviconOnActivePage(favicon_bitmap_results);
 632     }
 633     if (has_expired_or_incomplete_result) {
 634       // The favicon is out of date. Request the current one.
 635       ScheduleDownload(driver_->GetActiveURL(),
 636                        driver_->GetActiveFaviconURL(),
 637                        favicon_base::FAVICON);
 638     }
 639   } else if (current_candidate() &&
 640       (!has_results || has_expired_or_incomplete_result ||
 641        !(DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results)))) {
 642     // We don't know the favicon, it is out of date or its type is not same as
 643     // one got from page. Request the current one.
 644     ScheduleDownload(driver_->GetActiveURL(),
 645                      current_candidate()->icon_url,
 646                      current_candidate()->icon_type);
 647   }
 648   history_results_ = favicon_bitmap_results;
 649 }
 650
 651 int FaviconHandler::ScheduleDownload(const GURL& url,
 652                                      const GURL& image_url,
 653                                      favicon_base::IconType icon_type) {
 654   // A max bitmap size is specified to avoid receiving huge bitmaps in
 655   // OnDidDownloadFavicon(). See FaviconDriver::StartDownload()
 656   // for more details about the max bitmap size.
 657   const int download_id = DownloadFavicon(image_url,
 658                                           GetMaximalIconSize(icon_type));
 659   if (download_id) {
 660     // Download ids should be unique.
 661     DCHECK(download_requests_.find(download_id) == download_requests_.end());
 662     download_requests_[download_id] =
 663         DownloadRequest(url, image_url, icon_type);
 664   }
 665
 666   return download_id;
 667 }
 668
 669 void FaviconHandler::SortAndPruneImageUrls() {
 670   for (std::vector<FaviconURL>::iterator i = image_urls_.begin();
 671        i != image_urls_.end();) {
 672     if (i->icon_sizes.empty()) {
 673       ++i;
 674       continue;
 675     }
 676     int max_size = GetMaximalIconSize(i->icon_type);
 677     int index = GetLargestSizeIndex(i->icon_sizes, max_size * max_size);
 678     if (index == -1) {
 679       i = image_urls_.erase(i);
 680     } else {
 681       gfx::Size largest = i->icon_sizes[index];
 682       i->icon_sizes.clear();
 683       i->icon_sizes.push_back(largest);
 684       ++i;
 685     }
 686   }
 687   std::stable_sort(image_urls_.begin(), image_urls_.end(),
 688                    CompareIconSize);
 689 }