Change FaviconData to be able to return data for multiple bitmaps for same icon URL

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 <vector>
 
@@ skipping 43 matching lines @@
 std::string UrlWithoutFragment(const GURL& gurl) {
   GURL::Replacements replacements;
   replacements.ClearRef();
   return gurl.ReplaceComponents(replacements).spec();
 }
 
 bool UrlMatches(const GURL& gurl_a, const GURL& gurl_b) {
   return UrlWithoutFragment(gurl_a) == UrlWithoutFragment(gurl_b);
 }
 
+// Returns true if at least one of the bitmaps in |favicon_bitmap_results| is
+// expired.
+bool HasExpiredFaviconResult(
+    const std::vector<history::FaviconBitmapResult>& favicon_bitmap_results) {
+  for (size_t i = 0; i < favicon_bitmap_results.size(); ++i) {
+    if (favicon_bitmap_results[i].expired)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::DownloadRequest::DownloadRequest()
     : icon_type(history::INVALID_ICON) {
 }
 
 FaviconHandler::DownloadRequest::~DownloadRequest() {
 }
@@ skipping 197 matching lines @@
 
   // For FAVICON.
   if (current_candidate()->icon_type == FaviconURL::FAVICON) {
     if (!favicon_expired_ && 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_icon_.is_valid() &&
-              DoUrlAndIconMatch(
-                  *current_candidate(),
-                  history_icon_.icon_url, history_icon_.icon_type)) {
-    return;
+             !history_results_.empty()) {
+    history::FaviconBitmapResult bitmap_result = history_results_[0];
+    if (bitmap_result.is_valid() &&
+        DoUrlAndIconMatch(*current_candidate(), bitmap_result.icon_url,
+            bitmap_result.icon_type)) {
+      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,
                                           bool errored,
@@ skipping 53 matching lines @@
   }
   int id = delegate_->StartDownload(image_url, image_size);
   return id;
 }
 
 void FaviconHandler::UpdateFaviconMappingAndFetch(
     const GURL& page_url,
     const GURL& icon_url,
     history::IconType icon_type,
     CancelableRequestConsumerBase* consumer,
-    const FaviconService::FaviconDataCallback& callback) {
+    const FaviconService::FaviconResultsCallback& callback) {
   GetFaviconService()->UpdateFaviconMappingAndFetch(page_url, icon_url,
       icon_type, consumer, callback);
 }
 
 void FaviconHandler::GetFavicon(
     const GURL& icon_url,
     history::IconType icon_type,
     CancelableRequestConsumerBase* consumer,
-    const FaviconService::FaviconDataCallback& callback) {
-  GetFaviconService()->GetFavicon(icon_url, icon_type, consumer, callback);
+    const FaviconService::FaviconResultsCallback& callback) {
+  GetFaviconService()->GetFavicon(icon_url, icon_type, preferred_icon_size(),
+      ui::GetSupportedScaleFactors(), consumer, callback);
 }
 
 void FaviconHandler::GetFaviconForURL(
     const GURL& page_url,
     int icon_types,
     CancelableRequestConsumerBase* consumer,
-    const FaviconService::FaviconDataCallback& callback) {
+    const FaviconService::FaviconResultsCallback& callback) {
   GetFaviconService()->GetFaviconForURL(profile_, page_url, icon_types,
-                                        consumer, callback);
+      preferred_icon_size(), ui::GetSupportedScaleFactors(), consumer,
+      callback);
 }
 
 void FaviconHandler::SetHistoryFavicon(
     const GURL& page_url,
     const GURL& icon_url,
     const std::vector<unsigned char>& image_data,
     history::IconType icon_type) {
   GetFaviconService()->SetFavicon(page_url, icon_url, image_data, icon_type);
 }
 
 bool FaviconHandler::ShouldSaveFavicon(const GURL& url) {
   if (!profile_->IsOffTheRecord())
     return true;
 
   // Otherwise store the favicon if the page is bookmarked.
   BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForProfile(profile_);
   return bookmark_model && bookmark_model->IsBookmarked(url);
 }
 
 void FaviconHandler::OnFaviconDataForInitialURL(
     FaviconService::Handle handle,
-    history::FaviconData favicon) {
+    std::vector<history::FaviconBitmapResult> favicon_bitmap_results,
+    history::IconURLSizesMap icon_url_sizes) {
   NavigationEntry* entry = GetEntry();
   if (!entry)
     return;
 
   got_favicon_from_history_ = true;
-  history_icon_ = favicon;
+  history_results_ = favicon_bitmap_results;
 
-  favicon_expired_ = (favicon.known_icon && favicon.expired);
+  bool has_results = !favicon_bitmap_results.empty();
+  favicon_expired_ = (has_results &&
+                      HasExpiredFaviconResult(favicon_bitmap_results));
 
-  if (favicon.known_icon && favicon.icon_type == history::FAVICON &&
+  history::FaviconBitmapResult bitmap_result;
+  if (has_results)
+    bitmap_result = favicon_bitmap_results[0];
+
+  if (has_results && bitmap_result.icon_type == history::FAVICON &&
       !entry->GetFavicon().valid &&
       (!current_candidate() ||
-       DoUrlAndIconMatch(
-           *current_candidate(), favicon.icon_url, favicon.icon_type))) {
+       DoUrlAndIconMatch(*current_candidate(),
+                         bitmap_result.icon_url, bitmap_result.icon_type))) {
     // 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.
-    entry->GetFavicon().url = favicon.icon_url;
-    if (favicon.is_valid())
-      UpdateFavicon(entry, favicon.image_data);
+    entry->GetFavicon().url = bitmap_result.icon_url;
+    if (bitmap_result.is_valid())
+      UpdateFavicon(entry, bitmap_result.bitmap_data);
     entry->GetFavicon().valid = true;
   }
 
-  if (favicon.known_icon && !favicon.expired) {
+  if (has_results && !bitmap_result.expired) {
     if (current_candidate() &&
-        !DoUrlAndIconMatch(
-             *current_candidate(), favicon.icon_url, favicon.icon_type)) {
+        !DoUrlAndIconMatch(*current_candidate(),
+            bitmap_result.icon_url, bitmap_result.icon_type)) {
       // 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
@@ skipping 27 matching lines @@
       //    include the mapping between the page url and the favicon url.
       // This is asynchronous. The history service will call back when done.
       // Issue the request and associate the current page ID with it.
       UpdateFaviconMappingAndFetch(page_url, icon_url, icon_type,
           &cancelable_consumer_,
           base::Bind(&FaviconHandler::OnFaviconData, base::Unretained(this)));
     }
   }
 }
 
-void FaviconHandler::OnFaviconData(FaviconService::Handle handle,
-                                  history::FaviconData favicon) {
+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();
+  history::FaviconBitmapResult bitmap_result;
+  if (has_results)
+    bitmap_result = favicon_bitmap_results[0];
+
   // No need to update the favicon url. By the time we get here
   // UpdateFaviconURL will have set the favicon url.
-  if (favicon.icon_type == history::FAVICON) {
-    if (favicon.is_valid()) {
+  if (icon_types_ == history::FAVICON) {
+    if (has_results && bitmap_result.is_valid()) {
+      DCHECK_EQ(history::FAVICON, bitmap_result.icon_type);
+
       // 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.image_data);
+      UpdateFavicon(entry, bitmap_result.bitmap_data);
     }
-    if (!favicon.known_icon || favicon.expired) {
+    if (!has_results || HasExpiredFaviconResult(favicon_bitmap_results)) {
       // We don't know the favicon, or it 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() && (!favicon.known_icon || favicon.expired ||
-      !(DoUrlAndIconMatch(
-            *current_candidate(), favicon.icon_url, favicon.icon_type)))) {
+  } else if (current_candidate() &&
+      (!has_results || HasExpiredFaviconResult(favicon_bitmap_results) ||
+       !(DoUrlAndIconMatch(*current_candidate(), bitmap_result.icon_url,
+           bitmap_result.icon_type)))) {
     // 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_icon_ = favicon;
+  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) {
@@ skipping 13 matching lines @@
   int height = bitmap.height();
   if (width > 0 && height > 0) {
     gfx::CalculateFaviconTargetSize(&width, &height);
     return gfx::Image(skia::ImageOperations::Resize(
                           bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
                           width, height));
   }
 
   return image;
 }