Expire favicons which were added with default favicon sizes

chrome/browser/favicon/favicon_handler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/favicon/favicon_handler.h"
 
 #include "build/build_config.h"
 
 #include <algorithm>
 #include <vector>
@@ skipping 77 matching lines @@
 // Return true if |bitmap_result| is expired.
 bool IsExpired(const history::FaviconBitmapResult& bitmap_result) {
   return bitmap_result.expired;
 }
 
 // Return true if |bitmap_result| is valid.
 bool IsValid(const history::FaviconBitmapResult& bitmap_result) {
   return bitmap_result.is_valid();
 }
 
-// Returns true if at least one of the bitmaps in |bitmap_results| is expired.
-bool HasExpiredResult(
-    const std::vector<history::FaviconBitmapResult>& bitmap_results) {
+// Return list with the current value and historical values of
+// history::GetDefaultFaviconSizes().
+const std::vector<history::FaviconSizes>& GetHistoricalDefaultFaviconSizes() {
+  CR_DEFINE_STATIC_LOCAL(
+      std::vector<history::FaviconSizes>, kHistoricalFaviconSizes, ());
+  if (kHistoricalFaviconSizes.empty()) {
+    kHistoricalFaviconSizes.push_back(history::GetDefaultFaviconSizes());
+    // The default favicon sizes used to be a single empty size.
+    history::FaviconSizes old_favicon_sizes;
+    old_favicon_sizes.push_back(gfx::Size());
+    kHistoricalFaviconSizes.push_back(old_favicon_sizes);
+  }
+  return kHistoricalFaviconSizes;
+}
+
+// Returns true if at least one of the bitmaps in |bitmap_results| is expired or
+// if |bitmap_results| is known to be incomplete.
+bool HasExpiredOrIncompleteResult(
+    const std::vector<history::FaviconBitmapResult>& bitmap_results,
+    const history::IconURLSizesMap& icon_url_sizes) {
+  // Check if at least one of the bitmaps is expired.
   std::vector<history::FaviconBitmapResult>::const_iterator it =
       std::find_if(bitmap_results.begin(), bitmap_results.end(), IsExpired);
-  return it != bitmap_results.end();
+  if (it != bitmap_results.end())
+    return true;
+
+  // |bitmap_results| is known to be incomplete if the favicon sizes in
+  // |icon_url_sizes| for any of the icon URLs in |bitmap_results| are unknown.
+  // The favicon sizes for an icon URL are unknown if MergeFavicon() has set
+  // them to the default favicon sizes.
+
+  std::set<GURL> icon_urls;
+  for (size_t i = 0; i < bitmap_results.size(); ++i)
+    icon_urls.insert(bitmap_results[i].icon_url);
+
+  for (std::set<GURL>::iterator it = icon_urls.begin(); it != icon_urls.end();
+       ++it) {
+    const GURL& icon_url = *it;
+    history::IconURLSizesMap::const_iterator icon_url_sizes_it =
+        icon_url_sizes.find(icon_url);
+    if (icon_url_sizes_it == icon_url_sizes.end()) {
+      // |icon_url_sizes| should have an entry for each icon URL in
+      // |bitmap_results|.
+      NOTREACHED();
+      return true;
+    }
+
+    const history::FaviconSizes& sizes = icon_url_sizes_it->second;
+    const std::vector<history::FaviconSizes>& historical_sizes =
+        GetHistoricalDefaultFaviconSizes();
+    std::vector<history::FaviconSizes>::const_iterator historical_it =
+        std::find(historical_sizes.begin(), historical_sizes.end(), sizes);
+    if (historical_it != historical_sizes.end())
+      return true;
+  }
+  return false;
 }
 
 // Returns true if at least one of |bitmap_results| is valid.
 bool HasValidResult(
     const std::vector<history::FaviconBitmapResult>& bitmap_results) {
   std::vector<history::FaviconBitmapResult>::const_iterator it =
       std::find_if(bitmap_results.begin(), bitmap_results.end(), IsValid);
   return it != bitmap_results.end();
 }
 
@@ skipping 41 matching lines @@
       score(score),
       icon_type(icon_type) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::FaviconHandler(Profile* profile,
                                FaviconHandlerDelegate* delegate,
                                Type icon_type)
     : got_favicon_from_history_(false),
-      favicon_expired_(false),
+      favicon_expired_or_incomplete_(false),
       icon_types_(icon_type == FAVICON ? history::FAVICON :
           history::TOUCH_ICON | history::TOUCH_PRECOMPOSED_ICON),
       profile_(profile),
       delegate_(delegate) {
   DCHECK(profile_);
   DCHECK(delegate_);
 }
 
 FaviconHandler::~FaviconHandler() {
   // Call pending download callbacks with error to allow caller to clean up.
   for (DownloadRequests::iterator i = download_requests_.begin();
        i != download_requests_.end(); ++i) {
     if (!i->second.callback.is_null()) {
       i->second.callback.Run(i->first, true, SkBitmap());
     }
   }
 }
 
 void FaviconHandler::FetchFavicon(const GURL& url) {
   cancelable_consumer_.CancelAllRequests();
 
   url_ = url;
 
-  favicon_expired_ = got_favicon_from_history_ = false;
+  favicon_expired_or_incomplete_ = got_favicon_from_history_ = false;
   image_urls_.clear();
 
   // Request the favicon from the history service. In parallel to this the
   // renderer is going to notify us (well WebContents) when the favicon url is
   // available.
   if (GetFaviconService()) {
     GetFaviconForURL(url_, icon_types_, &cancelable_consumer_,
         base::Bind(&FaviconHandler::OnFaviconDataForInitialURL,
                    base::Unretained(this)));
   }
@@ skipping 108 matching lines @@
 
 void FaviconHandler::ProcessCurrentUrl() {
   DCHECK(!image_urls_.empty());
 
   NavigationEntry* entry = GetEntry();
   if (!entry)
     return;
 
   // For FAVICON.
   if (current_candidate()->icon_type == FaviconURL::FAVICON) {
-    if (!favicon_expired_ && entry->GetFavicon().valid &&
+    if (!favicon_expired_or_incomplete_ && entry->GetFavicon().valid &&
         DoUrlAndIconMatch(*current_candidate(), entry->GetFavicon().url,
                           history::FAVICON))
       return;
 
     entry->GetFavicon().url = current_candidate()->icon_url;
-  } else if (!favicon_expired_ && got_favicon_from_history_ &&
-             !history_results_.empty()) {
-    const history::FaviconBitmapResult& bitmap_result = history_results_[0];
-    if (bitmap_result.is_valid() &&
-        DoUrlAndIconMatch(*current_candidate(), bitmap_result.icon_url,
-            bitmap_result.icon_type)) {
-      return;
-    }
+  } else if (!favicon_expired_or_incomplete_ && got_favicon_from_history_ &&
+             HasValidResult(history_results_) &&
+             DoUrlsAndIconsMatch(*current_candidate(), history_results_)) {
+    return;
   }
 
   if (got_favicon_from_history_)
     DownloadFaviconOrAskHistory(entry->GetURL(), current_candidate()->icon_url,
         ToHistoryIconType(current_candidate()->icon_type));
 }
 
 void FaviconHandler::OnDidDownloadFavicon(
     int id,
     const GURL& image_url,
@@ skipping 130 matching lines @@
     std::vector<history::FaviconBitmapResult> favicon_bitmap_results,
     history::IconURLSizesMap icon_url_sizes) {
   NavigationEntry* entry = GetEntry();
   if (!entry)
     return;
 
   got_favicon_from_history_ = true;
   history_results_ = favicon_bitmap_results;
 
   bool has_results = !favicon_bitmap_results.empty();
-  favicon_expired_ = (has_results && HasExpiredResult(favicon_bitmap_results));
+  favicon_expired_or_incomplete_ = has_results && HasExpiredOrIncompleteResult(
+      favicon_bitmap_results, icon_url_sizes);
 
   if (has_results && icon_types_ == history::FAVICON &&
       !entry->GetFavicon().valid &&
       (!current_candidate() ||
        DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results))) {
     // The db knows the favicon (although it may be out of date) and the entry
     // doesn't have an icon. Set the favicon now, and if the favicon turns out
     // to be expired (or the wrong url) we'll fetch later on. This way the
     // user doesn't see a flash of the default favicon.
 
     // The history service sends back results for a single icon URL, so it does
     // not matter which result we get the |icon_url| from.
     entry->GetFavicon().url = favicon_bitmap_results[0].icon_url;
     if (HasValidResult(favicon_bitmap_results))
       UpdateFavicon(entry, favicon_bitmap_results);
     entry->GetFavicon().valid = true;
   }
 
-  if (has_results && !HasExpiredResult(favicon_bitmap_results)) {
+  if (has_results && !favicon_expired_or_incomplete_) {
     if (current_candidate() &&
         !DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results)) {
       // Mapping in the database is wrong. DownloadFavIconOrAskHistory will
       // update the mapping for this url and download the favicon if we don't
       // already have it.
       DownloadFaviconOrAskHistory(entry->GetURL(),
           current_candidate()->icon_url,
           static_cast<history::IconType>(current_candidate()->icon_type));
     }
   } else if (current_candidate()) {
     // We know the official url for the favicon, by either don't have the
     // favicon or its expired. Continue on to DownloadFaviconOrAskHistory to
     // either download or check history again.
     DownloadFaviconOrAskHistory(entry->GetURL(), current_candidate()->icon_url,
         ToHistoryIconType(current_candidate()->icon_type));
   }
   // else we haven't got the icon url. When we get it we'll ask the
   // renderer to download the icon.
 }
 
 void FaviconHandler::DownloadFaviconOrAskHistory(
     const GURL& page_url,
     const GURL& icon_url,
     history::IconType icon_type) {
-  if (favicon_expired_) {
+  if (favicon_expired_or_incomplete_) {
     // We have the mapping, but the favicon is out of date. Download it now.
     ScheduleDownload(page_url, icon_url, preferred_icon_size(), icon_type,
                      FaviconTabHelper::ImageDownloadCallback());
   } else if (GetFaviconService()) {
     // We don't know the favicon, but we may have previously downloaded the
     // favicon for another page that shares the same favicon. Ask for the
     // favicon given the favicon URL.
     if (profile_->IsOffTheRecord()) {
       GetFavicon(icon_url, icon_type, &cancelable_consumer_,
           base::Bind(&FaviconHandler::OnFaviconData, base::Unretained(this)));
@@ skipping 13 matching lines @@
 
 void FaviconHandler::OnFaviconData(
     FaviconService::Handle handle,
     std::vector<history::FaviconBitmapResult> favicon_bitmap_results,
     history::IconURLSizesMap icon_url_sizes) {
   NavigationEntry* entry = GetEntry();
   if (!entry)
     return;
 
   bool has_results = !favicon_bitmap_results.empty();
+  bool has_expired_or_incomplete_result = HasExpiredOrIncompleteResult(
+      favicon_bitmap_results, icon_url_sizes);
 
   // No need to update the favicon url. By the time we get here
   // UpdateFaviconURL will have set the favicon url.
   if (has_results && icon_types_ == history::FAVICON) {
     if (HasValidResult(favicon_bitmap_results)) {
       // There is a favicon, set it now. If expired we'll download the current
       // one again, but at least the user will get some icon instead of the
       // default and most likely the current one is fine anyway.
       UpdateFavicon(entry, favicon_bitmap_results);
     }
-    if (HasExpiredResult(favicon_bitmap_results)) {
+    if (has_expired_or_incomplete_result) {
       // The favicon is out of date. Request the current one.
       ScheduleDownload(entry->GetURL(), entry->GetFavicon().url,
                        preferred_icon_size(),
                        history::FAVICON,
                        FaviconTabHelper::ImageDownloadCallback());
     }
   } else if (current_candidate() &&
-      (!has_results || HasExpiredResult(favicon_bitmap_results) ||
+      (!has_results || has_expired_or_incomplete_result ||
        !(DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results)))) {
     // We don't know the favicon, it is out of date or its type is not same as
     // one got from page. Request the current one.
     ScheduleDownload(entry->GetURL(), current_candidate()->icon_url,
         preferred_icon_size(),
         ToHistoryIconType(current_candidate()->icon_type),
         FaviconTabHelper::ImageDownloadCallback());
   }
   history_results_ = favicon_bitmap_results;
 }
 
 int FaviconHandler::ScheduleDownload(
     const GURL& url,
     const GURL& image_url,
     int image_size,
     history::IconType icon_type,
     const FaviconTabHelper::ImageDownloadCallback& callback) {
   const int download_id = DownloadFavicon(image_url, image_size);
   if (download_id) {
     // Download ids should be unique.
     DCHECK(download_requests_.find(download_id) == download_requests_.end());
     download_requests_[download_id] =
         DownloadRequest(url, image_url, callback, icon_type);
   }
 
   return download_id;
 }