Ignore duplicate FaviconHandler::OnUpdateFaviconURL() calls

components/favicon/core/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 "components/favicon/core/favicon_handler.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
@@ skipping 133 matching lines @@
   if (!b1.icon_sizes.empty())
     area1 = b1.icon_sizes.front().GetArea();
 
   int area2 = 0;
   if (!b2.icon_sizes.empty())
     area2 = b2.icon_sizes.front().GetArea();
 
   return area1 > area2;
 }
 
+// Sorts the entries in |image_urls| by icon size in descending order.
+// Discards all but the largest size for each FaviconURL.
+void SortAndPruneImageUrls(std::vector<FaviconURL>* image_urls) {
+  // Not using const-reference since the loop mutates FaviconURL::icon_sizes.
+  for (FaviconURL& image_url : *image_urls) {
+    if (image_url.icon_sizes.empty())
+      continue;
+
+    gfx::Size largest =
+        image_url.icon_sizes[GetLargestSizeIndex(image_url.icon_sizes)];
+    image_url.icon_sizes.clear();
+    image_url.icon_sizes.push_back(largest);
+  }
+  std::stable_sort(image_urls->begin(), image_urls->end(), CompareIconSize);
+}
+
+// Checks whether two FaviconURLs are equal ignoring the icon sizes.
+bool FaviconURLsEqualIgnoringSizes(const FaviconURL& u1, const FaviconURL& u2) {
+  return u1.icon_type == u2.icon_type && u1.icon_url == u2.icon_url;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::DownloadRequest::DownloadRequest()
     : icon_type(favicon_base::INVALID_ICON) {
 }
 
 FaviconHandler::DownloadRequest::~DownloadRequest() {
 }
@@ skipping 28 matching lines @@
 FaviconHandler::FaviconHandler(FaviconService* service,
                                FaviconDriver* driver,
                                Type handler_type,
                                bool download_largest_icon)
     : got_favicon_from_history_(false),
       favicon_expired_or_incomplete_(false),
       handler_type_(handler_type),
       icon_types_(FaviconHandler::GetIconTypesFromHandlerType(handler_type)),
       download_largest_icon_(download_largest_icon),
       service_(service),
-      driver_(driver) {
+      driver_(driver),
+      current_candidate_index_(0u) {
   DCHECK(driver_);
 }
 
 FaviconHandler::~FaviconHandler() {
 }
 
 // static
 int FaviconHandler::GetIconTypesFromHandlerType(
     FaviconHandler::Type handler_type) {
   switch (handler_type) {
@@ skipping 10 matching lines @@
 
 void FaviconHandler::FetchFavicon(const GURL& url) {
   cancelable_task_tracker_.TryCancelAll();
 
   url_ = url;
 
   favicon_expired_or_incomplete_ = got_favicon_from_history_ = false;
   download_requests_.clear();
   image_urls_.clear();
   history_results_.clear();
+  current_candidate_index_ = 0u;
   best_favicon_candidate_ = FaviconCandidate();
 
   // 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.
   GetFaviconForURLFromFaviconService(
       url_, icon_types_,
       base::Bind(&FaviconHandler::OnFaviconDataForInitialURLFromFaviconService,
                  base::Unretained(this)),
       &cancelable_task_tracker_);
@@ skipping 16 matching lines @@
 
     // The size of the downloaded icon may not match the declared size. Stop
     // downloading if:
     // - current candidate is only candidate.
     // - next candidate doesn't have sizes attributes, in this case, the rest
     //   candidates don't have sizes attribute either, stop downloading now,
     //   otherwise, all favicon without sizes attribute are downloaded.
     // - next candidate has sizes attribute and it is not larger than largest,
     // - current candidate is maximal one we want.
     const int maximal_size = GetMaximalIconSize(icon_type);
-    exact_match = image_urls_.size() == 1 ||
-        image_urls_[1].icon_sizes.empty() ||
-        image_urls_[1].icon_sizes[0].GetArea() <= largest.GetArea() ||
-        (image.Size().width() == maximal_size &&
-         image.Size().height() == maximal_size);
+    if (current_candidate_index_ + 1 >= image_urls_.size()) {
+      exact_match = true;
+    } else {
+      FaviconURL next_image_url = image_urls_[current_candidate_index_ + 1];
+      exact_match = next_image_url.icon_sizes.empty() ||
+          next_image_url.icon_sizes[0].GetArea() <= largest.GetArea() ||
+          (image.Size().width() == maximal_size &&
+           image.Size().height() == maximal_size);
+    }
   } else {
     exact_match = score == 1 || preferred_icon_size() == 0;
     replace_best_favicon_candidate =
         exact_match ||
         best_favicon_candidate_.icon_type == favicon_base::INVALID_ICON ||
         score > best_favicon_candidate_.score;
   }
   if (replace_best_favicon_candidate) {
     best_favicon_candidate_ =
         FaviconCandidate(image_url, image, score, icon_type);
@@ skipping 35 matching lines @@
   driver_->OnFaviconAvailable(
       url_, icon_url, image_with_adjusted_colorspace, is_active_favicon);
 }
 
 void FaviconHandler::OnUpdateFaviconURL(
     const GURL& page_url,
     const std::vector<FaviconURL>& candidates) {
   if (page_url != url_)
     return;
 
-  download_requests_.clear();
-  image_urls_.clear();
-  best_favicon_candidate_ = FaviconCandidate();
-
+  std::vector<FaviconURL> pruned_candidates;
   for (const FaviconURL& candidate : candidates) {
     if (!candidate.icon_url.is_empty() && (candidate.icon_type & icon_types_))
-      image_urls_.push_back(candidate);
+      pruned_candidates.push_back(candidate);
   }
 
   if (download_largest_icon_)
-    SortAndPruneImageUrls();
+    SortAndPruneImageUrls(&pruned_candidates);
+
+  // Ignore FaviconURL::icon_sizes because FaviconURL::icon_sizes is not stored
+  // in the history database.
+  if (image_urls_.size() == pruned_candidates.size() &&
+      std::equal(pruned_candidates.begin(), pruned_candidates.end(),
+                 image_urls_.begin(), FaviconURLsEqualIgnoringSizes)) {
+    return;
+  }
+
+  download_requests_.clear();
+  image_urls_ = pruned_candidates;
+  current_candidate_index_ = 0u;
+  best_favicon_candidate_ = FaviconCandidate();
 
   // TODO(davemoore) Should clear on empty url. Currently we ignore it.
   // This appears to be what FF does as well.
-  if (!image_urls_.empty())
+  if (current_candidate())
     ProcessCurrentUrl();
 }
 
 void FaviconHandler::ProcessCurrentUrl() {
   DCHECK(!image_urls_.empty());
 
-  // current_candidate() may return NULL if download_largest_icon_ is true and
-  // all the sizes are larger than the max.
-  if (!current_candidate())
-    return;
-
   if (current_candidate()->icon_type == favicon_base::FAVICON &&
       !download_largest_icon_) {
     if (!favicon_expired_or_incomplete_ &&
         driver_->GetActiveFaviconValidity() &&
         DoUrlAndIconMatch(*current_candidate(),
                           driver_->GetActiveFaviconURL(),
                           favicon_base::FAVICON))
       return;
   } else if (!favicon_expired_or_incomplete_ && got_favicon_from_history_ &&
              HasValidResult(history_results_) &&
@@ skipping 54 matching lines @@
 
     if (!image_skia.isNull()) {
       gfx::Image image(image_skia);
       // The downloaded icon is still valid when there is no FaviconURL update
       // during the downloading.
       request_next_icon = !UpdateFaviconCandidate(image_url, image, score,
                                                   download_request.icon_type);
     }
   }
 
-  if (request_next_icon && image_urls_.size() > 1) {
-    // Remove the first member of image_urls_ and process the remaining.
-    image_urls_.erase(image_urls_.begin());
+  if (request_next_icon && current_candidate_index_ + 1 < image_urls_.size()) {
+    // Process the next candidate.
+    ++current_candidate_index_;
     ProcessCurrentUrl();
   } else {
     // We have either found the ideal candidate or run out of candidates.
     if (best_favicon_candidate_.icon_type != favicon_base::INVALID_ICON) {
       // No more icons to request, set the favicon from the candidate.
       SetFavicon(best_favicon_candidate_.image_url,
                  best_favicon_candidate_.image,
                  best_favicon_candidate_.icon_type);
     }
     // Clear download related state.
-    image_urls_.clear();
     download_requests_.clear();
+    current_candidate_index_ = image_urls_.size();
     best_favicon_candidate_ = FaviconCandidate();
   }
 }
 
 bool FaviconHandler::HasPendingTasksForTest() {
   return !download_requests_.empty() ||
          cancelable_task_tracker_.HasTrackedTasks();
 }
 
 int FaviconHandler::DownloadFavicon(const GURL& image_url,
@@ skipping 203 matching lines @@
   if (download_id == 0) {
     // If DownloadFavicon() did not start a download, it returns a download id
     // of 0. We still need to call OnDidDownloadFavicon() because the method is
     // responsible for initiating the data request for the next candidate.
     OnDidDownloadFavicon(download_id, image_url, std::vector<SkBitmap>(),
                          std::vector<gfx::Size>());
 
   }
 }
 
-void FaviconHandler::SortAndPruneImageUrls() {
-  // Not using const-reference since the loop mutates FaviconURL::icon_sizes.
-  for (FaviconURL& image_url : image_urls_) {
-    if (image_url.icon_sizes.empty())
-      continue;
-
-    gfx::Size largest =
-        image_url.icon_sizes[GetLargestSizeIndex(image_url.icon_sizes)];
-    image_url.icon_sizes.clear();
-    image_url.icon_sizes.push_back(largest);
-  }
-  std::stable_sort(image_urls_.begin(), image_urls_.end(),
-                   CompareIconSize);
-}
-
 }  // namespace favicon