Rename FaviconBitmapXxx to FaviconRawBitmapXxx

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 43 matching lines @@
                        const GURL& url,
                        favicon_base::IconType icon_type) {
   return favicon_url.icon_url == url && favicon_url.icon_type == icon_type;
 }
 
 // Returns true if all of the icon URLs and icon types in |bitmap_results| are
 // identical and if they match the icon URL and icon type in |favicon_url|.
 // Returns false if |bitmap_results| is empty.
 bool DoUrlsAndIconsMatch(
     const FaviconURL& favicon_url,
-    const std::vector<favicon_base::FaviconBitmapResult>& bitmap_results) {
+    const std::vector<favicon_base::FaviconRawBitmapResult>& bitmap_results) {
   if (bitmap_results.empty())
     return false;
 
   const favicon_base::IconType icon_type = favicon_url.icon_type;
 
   for (size_t i = 0; i < bitmap_results.size(); ++i) {
     if (favicon_url.icon_url != bitmap_results[i].icon_url ||
         icon_type != bitmap_results[i].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::FaviconBitmapResult& bitmap_result) {
+bool IsExpired(const favicon_base::FaviconRawBitmapResult& bitmap_result) {
   return bitmap_result.expired;
 }
 
 // Return true if |bitmap_result| is valid.
-bool IsValid(const favicon_base::FaviconBitmapResult& bitmap_result) {
+bool IsValid(const favicon_base::FaviconRawBitmapResult& bitmap_result) {
   return bitmap_result.is_valid();
 }
 
 // Returns true if at least one of the bitmaps in |bitmap_results| is expired or
 // if |bitmap_results| is missing favicons for |desired_size_in_dip| and one of
 // the scale factors in FaviconUtil::GetFaviconScaleFactors().
 bool HasExpiredOrIncompleteResult(
     int desired_size_in_dip,
-    const std::vector<favicon_base::FaviconBitmapResult>& bitmap_results) {
+    const std::vector<favicon_base::FaviconRawBitmapResult>& bitmap_results) {
   // Check if at least one of the bitmaps is expired.
-  std::vector<favicon_base::FaviconBitmapResult>::const_iterator it =
+  std::vector<favicon_base::FaviconRawBitmapResult>::const_iterator it =
       std::find_if(bitmap_results.begin(), bitmap_results.end(), IsExpired);
   if (it != bitmap_results.end())
     return true;
 
   // Any favicon size is good if the desired size is 0.
   if (desired_size_in_dip == 0)
     return false;
 
   // Check if the favicon for at least one of the scale factors is missing.
   // |bitmap_results| should always be complete for data inserted by
@@ skipping 14 matching lines @@
     std::vector<gfx::Size>::iterator it = std::find(favicon_sizes.begin(),
         favicon_sizes.end(), gfx::Size(edge_size_in_pixel, edge_size_in_pixel));
     if (it == favicon_sizes.end())
       return true;
   }
   return false;
 }
 
 // Returns true if at least one of |bitmap_results| is valid.
 bool HasValidResult(
-    const std::vector<favicon_base::FaviconBitmapResult>& bitmap_results) {
+    const std::vector<favicon_base::FaviconRawBitmapResult>& bitmap_results) {
   return std::find_if(bitmap_results.begin(), bitmap_results.end(), IsValid) !=
       bitmap_results.end();
 }
 
 // Returns the index of the entry with the largest area that is not larger than
 // |max_area|; -1 if there is no such match.
 int GetLargestSizeIndex(const std::vector<gfx::Size>& sizes, int max_area) {
   DCHECK(!sizes.empty());
   int ret = -1;
   for (size_t i = 0; i < sizes.size(); ++i) {
@@ skipping 155 matching lines @@
   if (client_->GetFaviconService() && ShouldSaveFavicon(url))
     SetHistoryFavicons(url, icon_url, icon_type, image);
 
   if (UrlMatches(url, url_) && icon_type == favicon_base::FAVICON) {
     if (!PageChangedSinceFaviconWasRequested())
       SetFaviconOnActivePage(icon_url, image);
   }
 }
 
 void FaviconHandler::SetFaviconOnActivePage(const std::vector<
-    favicon_base::FaviconBitmapResult>& favicon_bitmap_results) {
+    favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results) {
   gfx::Image resized_image = FaviconUtil::SelectFaviconFramesFromPNGs(
       favicon_bitmap_results,
       FaviconUtil::GetFaviconScaleFactors(),
       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;
   SetFaviconOnActivePage(icon_url, resized_image);
 }
@@ skipping 177 matching lines @@
     base::CancelableTaskTracker* tracker) {
   client_->GetFaviconService()->GetFavicon(
       icon_url, icon_type, preferred_icon_size(), callback, tracker);
 }
 
 void FaviconHandler::GetFaviconForURLFromFaviconService(
     const GURL& page_url,
     int icon_types,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
-  client_->GetFaviconService()->GetFaviconForURL(
-      FaviconService::FaviconForURLParams(
+  client_->GetFaviconService()->GetFaviconForPageURL(
+      FaviconService::FaviconForPageURLParams(
           page_url, icon_types, preferred_icon_size()),
       callback,
       tracker);
 }
 
 void FaviconHandler::SetHistoryFavicons(const GURL& page_url,
                                         const GURL& icon_url,
                                         favicon_base::IconType icon_type,
                                         const gfx::Image& image) {
   client_->GetFaviconService()->SetFavicons(
       page_url, icon_url, icon_type, image);
 }
 
 bool FaviconHandler::ShouldSaveFavicon(const GURL& url) {
   if (!driver_->IsOffTheRecord())
     return true;
 
   // Otherwise store the favicon if the page is bookmarked.
   return client_->IsBookmarked(url);
 }
 
 void FaviconHandler::NotifyFaviconUpdated(bool icon_url_changed) {
   driver_->NotifyFaviconUpdated(icon_url_changed);
 }
 
 void FaviconHandler::OnFaviconDataForInitialURLFromFaviconService(
-    const std::vector<favicon_base::FaviconBitmapResult>&
+    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_ = has_results && HasExpiredOrIncompleteResult(
       preferred_icon_size(), favicon_bitmap_results);
   if (has_results && icon_types_ == favicon_base::FAVICON &&
       !driver_->GetActiveFaviconValidity() &&
@@ skipping 58 matching lines @@
       // This is asynchronous. The history service will call back when done.
       UpdateFaviconMappingAndFetch(
           page_url, icon_url, icon_type,
           base::Bind(&FaviconHandler::OnFaviconData, base::Unretained(this)),
           &cancelable_task_tracker_);
     }
   }
 }
 
 void FaviconHandler::OnFaviconData(const std::vector<
-    favicon_base::FaviconBitmapResult>& favicon_bitmap_results) {
+    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);
 
   if (has_results && icon_types_ == favicon_base::FAVICON) {
     if (HasValidResult(favicon_bitmap_results)) {
       // There is a favicon, set it now. If expired we'll download the current
@@ skipping 51 matching lines @@
     } else {
       gfx::Size largest = i->icon_sizes[index];
       i->icon_sizes.clear();
       i->icon_sizes.push_back(largest);
       ++i;
     }
   }
   std::stable_sort(image_urls_.begin(), image_urls_.end(),
                    CompareIconSize);
 }