[Refactor] Change FaviconService API to take in a desired pixel size

chrome/browser/favicon/favicon_service.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_service.h"
 
 #include <cmath>
 
 #include "base/hash.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 76 matching lines @@
 
 // static
 void FaviconService::FaviconResultsCallbackRunner(
     const favicon_base::FaviconResultsCallback& callback,
     const std::vector<favicon_base::FaviconRawBitmapResult>* results) {
   callback.Run(*results);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImage(
     const GURL& icon_url,
-    favicon_base::IconType icon_type,
-    int desired_size_in_dip,
     const favicon_base::FaviconImageCallback& callback,
     base::CancelableTaskTracker* tracker) {
   favicon_base::FaviconResultsCallback callback_runner =
       Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults,
-           base::Unretained(this), callback, desired_size_in_dip);
+           base::Unretained(this), callback, gfx::kFaviconSize);
   if (history_service_) {
     std::vector<GURL> icon_urls;
     icon_urls.push_back(icon_url);
     return history_service_->GetFavicons(
         icon_urls,
-        icon_type,
-        GetPixelSizesForFaviconScales(desired_size_in_dip),
+        favicon_base::FAVICON,
+        GetPixelSizesForFaviconScales(gfx::kFaviconSize),
         callback_runner,
         tracker);
   }
   return RunWithEmptyResultAsync(callback_runner, tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetRawFavicon(
     const GURL& icon_url,
     favicon_base::IconType icon_type,
-    int desired_size_in_dip,
-    float desired_favicon_scale,
+    int desired_size_in_pixel,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
-  int desired_size_in_pixel =
-      std::ceil(desired_size_in_dip * desired_favicon_scale);
   favicon_base::FaviconResultsCallback callback_runner =
       Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
            base::Unretained(this),
            callback,
            desired_size_in_pixel);
 
   if (history_service_) {
     std::vector<GURL> icon_urls;
     icon_urls.push_back(icon_url);
     std::vector<int> desired_sizes_in_pixel;
@@ skipping 17 matching lines @@
     return history_service_->GetFavicons(
         icon_urls,
         icon_type,
         GetPixelSizesForFaviconScales(desired_size_in_dip),
         callback,
         tracker);
   }
   return RunWithEmptyResultAsync(callback, tracker);
 }
 
-base::CancelableTaskTracker::TaskId
-FaviconService::UpdateFaviconMappingsAndFetch(
-    const GURL& page_url,
-    const std::vector<GURL>& icon_urls,
-    int icon_types,
-    int desired_size_in_dip,
-    const favicon_base::FaviconResultsCallback& callback,
-    base::CancelableTaskTracker* tracker) {
-  if (history_service_) {
-    return history_service_->UpdateFaviconMappingsAndFetch(
-        page_url,
-        icon_urls,
-        icon_types,
-        GetPixelSizesForFaviconScales(desired_size_in_dip),
-        callback,
-        tracker);
-  }
-  return RunWithEmptyResultAsync(callback, tracker);
-}
-
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImageForPageURL(
-    const FaviconForPageURLParams& params,
+    const GURL& page_url,
     const favicon_base::FaviconImageCallback& callback,
     base::CancelableTaskTracker* tracker) {
   return GetFaviconForPageURLImpl(
-      params,
-      GetPixelSizesForFaviconScales(params.desired_size_in_dip),
+      page_url,
+      favicon_base::FAVICON,
+      GetPixelSizesForFaviconScales(gfx::kFaviconSize),
       Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults,
            base::Unretained(this),
            callback,
-           params.desired_size_in_dip),
+           gfx::kFaviconSize),
       tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetRawFaviconForPageURL(
-    const FaviconForPageURLParams& params,
-    float desired_favicon_scale,
+    const GURL& page_url,
+    int icon_types,
+    int desired_size_in_pixel,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
-  int desired_size_in_pixel =
-      std::ceil(params.desired_size_in_dip * desired_favicon_scale);
   std::vector<int> desired_sizes_in_pixel;
   desired_sizes_in_pixel.push_back(desired_size_in_pixel);
   return GetFaviconForPageURLImpl(
-      params,
+      page_url,
+      icon_types,
       desired_sizes_in_pixel,
       Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
            base::Unretained(this),
            callback,
            desired_size_in_pixel),
       tracker);
 }
 
 base::CancelableTaskTracker::TaskId
 FaviconService::GetLargestRawFaviconForPageURL(
@@ skipping 18 matching lines @@
                                   tracker);
   }
   if (history_service_) {
     return history_service_->GetLargestFaviconForURL(page_url, icon_types,
         minimum_size_in_pixels, callback, tracker);
   }
   return RunWithEmptyResultAsync(favicon_results_callback, tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForPageURL(
-    const FaviconForPageURLParams& params,
+    const GURL& page_url,
+    int icon_types,
+    int desired_size_in_dip,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   return GetFaviconForPageURLImpl(
-      params,
-      GetPixelSizesForFaviconScales(params.desired_size_in_dip),
+      page_url,
+      icon_types,
+      GetPixelSizesForFaviconScales(desired_size_in_dip),
       callback,
       tracker);
 }
 
+base::CancelableTaskTracker::TaskId
+FaviconService::UpdateFaviconMappingsAndFetch(
+    const GURL& page_url,
+    const std::vector<GURL>& icon_urls,
+    int icon_types,
+    int desired_size_in_dip,
+    const favicon_base::FaviconResultsCallback& callback,
+    base::CancelableTaskTracker* tracker) {
+  if (history_service_) {
+    return history_service_->UpdateFaviconMappingsAndFetch(
+        page_url,
+        icon_urls,
+        icon_types,
+        GetPixelSizesForFaviconScales(desired_size_in_dip),
+        callback,
+        tracker);
+  }
+  return RunWithEmptyResultAsync(callback, tracker);
+}
+
 base::CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForID(
     favicon_base::FaviconID favicon_id,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
   // Use 0 as |desired_size| to get the largest bitmap for |favicon_id| without
   // any resizing.
   int desired_size = 0;
   favicon_base::FaviconResultsCallback callback_runner =
       Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
            base::Unretained(this),
@@ skipping 84 matching lines @@
   return missing_favicon_urls_.find(url_hash) != missing_favicon_urls_.end();
 }
 
 void FaviconService::ClearUnableToDownloadFavicons() {
   missing_favicon_urls_.clear();
 }
 
 FaviconService::~FaviconService() {}
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForPageURLImpl(
-    const FaviconForPageURLParams& params,
+    const GURL& page_url,
+    int icon_types,
     const std::vector<int>& desired_sizes_in_pixel,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
-  if (params.page_url.SchemeIs(content::kChromeUIScheme) ||
-      params.page_url.SchemeIs(extensions::kExtensionScheme)) {
+  if (page_url.SchemeIs(content::kChromeUIScheme) ||
+      page_url.SchemeIs(extensions::kExtensionScheme)) {
     return GetFaviconForChromeURL(
-        profile_, params.page_url, desired_sizes_in_pixel, callback, tracker);
+        profile_, page_url, desired_sizes_in_pixel, callback, tracker);
   }
   if (history_service_) {
-    return history_service_->GetFaviconsForURL(params.page_url,
-                                               params.icon_types,
+    return history_service_->GetFaviconsForURL(page_url,
+                                               icon_types,
                                                desired_sizes_in_pixel,
                                                callback,
                                                tracker);
   }
   return RunWithEmptyResultAsync(callback, tracker);
 }
 
 void FaviconService::RunFaviconImageCallbackWithBitmapResults(
     const favicon_base::FaviconImageCallback& callback,
     int desired_size_in_dip,
@@ skipping 51 matching lines @@
   if (!gfx::PNGCodec::EncodeBGRASkBitmap(resized_image.AsBitmap(), false,
                                          &resized_bitmap_data)) {
     callback.Run(favicon_base::FaviconRawBitmapResult());
     return;
   }
 
   bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector(
       &resized_bitmap_data);
   callback.Run(bitmap_result);
 }