Remove useless FaviconHandler::PageChangedSinceFaviconWasRequested()

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 36 matching lines @@
 
   for (const auto& bitmap_result : bitmap_results) {
     if (favicon_url.icon_url != bitmap_result.icon_url ||
         icon_type != bitmap_result.icon_type) {
       return false;
     }
   }
   return true;
 }
 
-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);
-}
-
 // Return true if |bitmap_result| is expired.
 bool IsExpired(const favicon_base::FaviconRawBitmapResult& bitmap_result) {
   return bitmap_result.expired;
 }
 
 // Return true if |bitmap_result| is valid.
 bool IsValid(const favicon_base::FaviconRawBitmapResult& bitmap_result) {
   return bitmap_result.is_valid();
 }
 
@@ skipping 89 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::DownloadRequest::DownloadRequest()
     : icon_type(favicon_base::INVALID_ICON) {
 }
 
 FaviconHandler::DownloadRequest::~DownloadRequest() {
 }
 
 FaviconHandler::DownloadRequest::DownloadRequest(
-    const GURL& url,
     const GURL& image_url,
     favicon_base::IconType icon_type)
-    : url(url), image_url(image_url), icon_type(icon_type) {
+    : image_url(image_url), icon_type(icon_type) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::FaviconCandidate::FaviconCandidate()
     : score(0), icon_type(favicon_base::INVALID_ICON) {
 }
 
 FaviconHandler::FaviconCandidate::~FaviconCandidate() {
 }
 
 FaviconHandler::FaviconCandidate::FaviconCandidate(
-    const GURL& url,
     const GURL& image_url,
     const gfx::Image& image,
     float score,
     favicon_base::IconType icon_type)
-    : url(url),
-      image_url(image_url),
+    : image_url(image_url),
       image(image),
       score(score),
       icon_type(icon_type) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::FaviconHandler(FaviconService* service,
                                FaviconDriver* driver,
                                Type handler_type,
                                bool download_largest_icon)
@@ skipping 39 matching lines @@
   // 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_);
 }
 
-bool FaviconHandler::UpdateFaviconCandidate(const GURL& url,
-                                            const GURL& image_url,
+bool FaviconHandler::UpdateFaviconCandidate(const GURL& image_url,
                                             const gfx::Image& image,
                                             float score,
                                             favicon_base::IconType icon_type) {
   bool replace_best_favicon_candidate = false;
   bool exact_match = false;
   if (download_largest_icon_) {
     replace_best_favicon_candidate =
         image.Size().GetArea() >
         best_favicon_candidate_.image.Size().GetArea();
 
@@ skipping 16 matching lines @@
         (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(
-        url, image_url, image, score, icon_type);
+    best_favicon_candidate_ =
+        FaviconCandidate(image_url, image, score, icon_type);
   }
   return exact_match;
 }
 
-void FaviconHandler::SetFavicon(const GURL& url,
-                                const GURL& icon_url,
+void FaviconHandler::SetFavicon(const GURL& icon_url,
                                 const gfx::Image& image,
                                 favicon_base::IconType icon_type) {
-  if (ShouldSaveFavicon(url))
-    SetHistoryFavicons(url, icon_url, icon_type, image);
+  if (ShouldSaveFavicon())
+    SetHistoryFavicons(url_, icon_url, icon_type, image);
 
   NotifyFaviconAvailable(icon_url, image);
 }
 
 void FaviconHandler::NotifyFaviconAvailable(
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
   gfx::Image resized_image = favicon_base::SelectFaviconFramesFromPNGs(
       favicon_bitmap_results,
       favicon_base::GetFaviconScales(),
       preferred_icon_size());
   // The history service sends back results for a single icon URL, so it does
   // not matter which result we get the |icon_url| from.
   const GURL icon_url = favicon_bitmap_results.empty() ?
       GURL() : favicon_bitmap_results[0].icon_url;
   NotifyFaviconAvailable(icon_url, resized_image);
 }
 
 void FaviconHandler::NotifyFaviconAvailable(const GURL& icon_url,
                                             const gfx::Image& image) {
   gfx::Image image_with_adjusted_colorspace = image;
   favicon_base::SetFaviconColorSpace(&image_with_adjusted_colorspace);
 
   bool is_active_favicon =
       (handler_type_ == FAVICON && !download_largest_icon_);
 
   driver_->OnFaviconAvailable(
-      image_with_adjusted_colorspace, icon_url, is_active_favicon);
+      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();
 
   for (const FaviconURL& candidate : candidates) {
     if (!candidate.icon_url.is_empty() && (candidate.icon_type & icon_types_))
       image_urls_.push_back(candidate);
   }
 
   if (download_largest_icon_)
     SortAndPruneImageUrls();
 
   // TODO(davemoore) Should clear on empty url. Currently we ignore it.
   // This appears to be what FF does as well.
   if (!image_urls_.empty())
     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 (PageChangedSinceFaviconWasRequested() || !current_candidate())
+  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_) &&
              DoUrlsAndIconsMatch(*current_candidate(), history_results_)) {
     return;
   }
 
   if (got_favicon_from_history_)
-    DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
-                                       current_candidate()->icon_url,
+    DownloadFaviconOrAskFaviconService(current_candidate()->icon_url,
                                        current_candidate()->icon_type);
 }
 
 void FaviconHandler::OnDidDownloadFavicon(
     int id,
     const GURL& image_url,
     const std::vector<SkBitmap>& bitmaps,
     const std::vector<gfx::Size>& original_bitmap_sizes) {
   DownloadRequests::iterator i = download_requests_.find(id);
   if (i == download_requests_.end()) {
     // Currently WebContents notifies us of ANY downloads so that it is
     // possible to get here.
     return;
   }
 
   DownloadRequest download_request = i->second;
   download_requests_.erase(i);
 
-  if (PageChangedSinceFaviconWasRequested() ||
-      !current_candidate() ||
+  if (!current_candidate() ||
       !DoUrlAndIconMatch(*current_candidate(),
                          image_url,
                          download_request.icon_type)) {
     return;
   }
 
   bool request_next_icon = true;
   if (!bitmaps.empty()) {
     float score = 0.0f;
     gfx::ImageSkia image_skia;
@@ skipping 14 matching lines @@
       image_skia = CreateFaviconImageSkia(bitmaps,
                                           original_bitmap_sizes,
                                           preferred_icon_size(),
                                           &score);
     }
 
     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(
-          download_request.url, image_url, image, score,
-          download_request.icon_type);
+      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());
     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_.url, best_favicon_candidate_.image_url,
+      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();
     best_favicon_candidate_ = FaviconCandidate();
   }
 }
 
 bool FaviconHandler::HasPendingTasksForTest() {
   return !download_requests_.empty() ||
          cancelable_task_tracker_.HasTrackedTasks();
 }
 
-bool FaviconHandler::PageChangedSinceFaviconWasRequested() {
-  if (UrlMatches(driver_->GetActiveURL(), url_) && url_.is_valid()) {
-    return false;
-  }
-  // If the URL has changed out from under us (as will happen with redirects)
-  // return true.
-  return true;
-}
-
 int FaviconHandler::DownloadFavicon(const GURL& image_url,
                                     int max_bitmap_size) {
   if (!image_url.is_valid()) {
     NOTREACHED();
     return 0;
   }
   return driver_->StartDownload(image_url, max_bitmap_size);
 }
 
 void FaviconHandler::UpdateFaviconMappingAndFetch(
@@ skipping 38 matching lines @@
 void FaviconHandler::SetHistoryFavicons(const GURL& page_url,
                                         const GURL& icon_url,
                                         favicon_base::IconType icon_type,
                                         const gfx::Image& image) {
   // TODO(huangs): Get the following to garbage collect if handler_type_ == ALL.
   if (service_) {
     service_->SetFavicons(page_url, icon_url, icon_type, image);
   }
 }
 
-bool FaviconHandler::ShouldSaveFavicon(const GURL& url) {
+bool FaviconHandler::ShouldSaveFavicon() {
   if (!driver_->IsOffTheRecord())
     return true;
 
   // Always save favicon if the page is bookmarked.
-  return driver_->IsBookmarked(url);
+  return driver_->IsBookmarked(url_);
 }
 
 int FaviconHandler::GetMaximalIconSize(favicon_base::IconType icon_type) {
   switch (icon_type) {
     case favicon_base::FAVICON:
 #if defined(OS_ANDROID)
       return 192;
 #else
       return gfx::ImageSkia::GetMaxSupportedScale() * gfx::kFaviconSize;
 #endif
     case favicon_base::TOUCH_ICON:
     case favicon_base::TOUCH_PRECOMPOSED_ICON:
       return kTouchIconSize;
     case favicon_base::INVALID_ICON:
       return 0;
   }
   NOTREACHED();
   return 0;
 }
 
 void FaviconHandler::OnFaviconDataForInitialURLFromFaviconService(
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
-  if (PageChangedSinceFaviconWasRequested())
-    return;
   got_favicon_from_history_ = true;
   history_results_ = favicon_bitmap_results;
   bool has_results = !favicon_bitmap_results.empty();
   favicon_expired_or_incomplete_ = HasExpiredOrIncompleteResult(
       preferred_icon_size(), favicon_bitmap_results);
   bool has_valid_result = HasValidResult(favicon_bitmap_results);
 
   if (has_results && handler_type_ == FAVICON &&
       !download_largest_icon_ && !driver_->GetActiveFaviconValidity() &&
       (!current_candidate() ||
@@ skipping 10 matching lines @@
       // TODO(pkotwicz): Do something better.
       favicon_expired_or_incomplete_ = true;
     }
   }
   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.
-      DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
-                                         current_candidate()->icon_url,
+      DownloadFaviconOrAskFaviconService(current_candidate()->icon_url,
                                          current_candidate()->icon_type);
     }
   } else if (current_candidate()) {
     // We know the official url for the favicon, but either don't have the
     // favicon or it's expired. Continue on to DownloadFaviconOrAskHistory to
     // either download or check history again.
-    DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
-                                       current_candidate()->icon_url,
+    DownloadFaviconOrAskFaviconService(current_candidate()->icon_url,
                                        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.
 
   if (has_valid_result && (handler_type_ != FAVICON || download_largest_icon_))
     NotifyFaviconAvailable(favicon_bitmap_results);
 }
 
 void FaviconHandler::DownloadFaviconOrAskFaviconService(
-    const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type) {
   if (favicon_expired_or_incomplete_) {
     // We have the mapping, but the favicon is out of date. Download it now.
-    ScheduleDownload(page_url, icon_url, icon_type);
+    ScheduleDownload(icon_url, icon_type);
   } else {
     // 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 (driver_->IsOffTheRecord()) {
       GetFaviconFromFaviconService(
           icon_url, icon_type,
           base::Bind(&FaviconHandler::OnFaviconData, base::Unretained(this)),
           &cancelable_task_tracker_);
     } else {
       // Ask the history service for the icon. This does two things:
       // 1. Attempts to fetch the favicon data from the database.
       // 2. If the favicon exists in the database, this updates the database to
       //    include the mapping between the page url and the favicon url.
       // This is asynchronous. The history service will call back when done.
       UpdateFaviconMappingAndFetch(
-          page_url, icon_url, icon_type,
+          url_, icon_url, icon_type,
           base::Bind(&FaviconHandler::OnFaviconData, base::Unretained(this)),
           &cancelable_task_tracker_);
     }
   }
 }
 
 void FaviconHandler::OnFaviconData(const std::vector<
     favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results) {
-  if (PageChangedSinceFaviconWasRequested())
-    return;
-
   bool has_results = !favicon_bitmap_results.empty();
   bool has_expired_or_incomplete_result = HasExpiredOrIncompleteResult(
       preferred_icon_size(), favicon_bitmap_results);
   bool has_valid_result = HasValidResult(favicon_bitmap_results);
   history_results_ = favicon_bitmap_results;
 
   if (has_valid_result) {
     // There is a valid favicon. Notify any observers. It is useful to notify
     // the observers even if the favicon is expired or incomplete (incorrect
     // size) because temporarily showing the user an expired favicon or
     // streched favicon is preferable to showing the user the default favicon.
     NotifyFaviconAvailable(favicon_bitmap_results);
   }
 
   if (!current_candidate() ||
       (has_results &&
        !DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results))) {
     // The icon URLs have been updated since the favicon data was requested.
     return;
   }
 
   if (!has_results || has_expired_or_incomplete_result) {
-    ScheduleDownload(driver_->GetActiveURL(),
-                     current_candidate()->icon_url,
+    ScheduleDownload(current_candidate()->icon_url,
                      current_candidate()->icon_type);
   }
 }
 
-void FaviconHandler::ScheduleDownload(const GURL& url,
-                                     const GURL& image_url,
-                                     favicon_base::IconType icon_type) {
+void FaviconHandler::ScheduleDownload(const GURL& image_url,
+                                      favicon_base::IconType icon_type) {
   // A max bitmap size is specified to avoid receiving huge bitmaps in
   // OnDidDownloadFavicon(). See FaviconDriver::StartDownload()
   // for more details about the max bitmap size.
   const int download_id = DownloadFavicon(image_url,
                                           GetMaximalIconSize(icon_type));
 
   // Download ids should be unique.
   DCHECK(download_requests_.find(download_id) == download_requests_.end());
-  download_requests_[download_id] = DownloadRequest(url, image_url, icon_type);
+  download_requests_[download_id] = DownloadRequest(image_url, icon_type);
 
   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