Convert ui::ScaleFactor -> float in favicon/history code

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 41 matching lines @@
     Profile* profile,
     const GURL& page_url,
     const std::vector<int>& desired_sizes_in_pixel,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   base::CancelableTaskTracker::IsCanceledCallback is_canceled_cb;
   base::CancelableTaskTracker::TaskId id =
       tracker->NewTrackedTaskId(&is_canceled_cb);
   favicon_base::FaviconResultsCallback cancelable_cb =
       Bind(&CancelOrRunFaviconResultsCallback, is_canceled_cb, callback);
-  ChromeWebUIControllerFactory::GetInstance()->GetFaviconForURL(profile,
-      page_url, desired_sizes_in_pixel, cancelable_cb);
+  ChromeWebUIControllerFactory::GetInstance()->GetFaviconForURL(
+      profile, page_url, desired_sizes_in_pixel, cancelable_cb);
   return id;
 }
 
-// Returns the size in pixel that a favicon should be based on |size_in_dip|
-// and |scale_factor|.
-int GetSizeInPixel(int size_in_dip, ui::ScaleFactor scale_factor) {
-  return ceil(size_in_dip * ui::GetScaleForScaleFactor(scale_factor));
-}
-
 // Returns a vector of pixel edge sizes from |size_in_dip| and
-// favicon_base::GetFaviconScaleFactors().
+// favicon_base::GetFaviconScales().
 std::vector<int> GetPixelSizesForFaviconScales(int size_in_dip) {
-  std::vector<ui::ScaleFactor> scale_factors =
-      favicon_base::GetFaviconScaleFactors();
+  std::vector<float> scales = favicon_base::GetFaviconScales();
   std::vector<int> sizes_in_pixel;
-  for (size_t i = 0; i < scale_factors.size(); ++i) {
-    sizes_in_pixel.push_back(GetSizeInPixel(size_in_dip, scale_factors[i]));
+  for (size_t i = 0; i < scales.size(); ++i) {
+    sizes_in_pixel.push_back(std::ceil(size_in_dip * scales[i]));
   }
   return sizes_in_pixel;
 }
 
 }  // namespace
 
 FaviconService::FaviconService(Profile* profile)
     : history_service_(HistoryServiceFactory::GetForProfile(
           profile, Profile::EXPLICIT_ACCESS)),
       profile_(profile) {
@@ skipping 25 matching lines @@
         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,
-    ui::ScaleFactor desired_scale_factor,
+    float desired_favicon_scale,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
   int desired_size_in_pixel =
-      GetSizeInPixel(desired_size_in_dip, desired_scale_factor);
+      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 53 matching lines @@
       GetPixelSizesForFaviconScales(params.desired_size_in_dip),
       Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults,
            base::Unretained(this),
            callback,
            params.desired_size_in_dip),
       tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetRawFaviconForPageURL(
     const FaviconForPageURLParams& params,
-    ui::ScaleFactor desired_scale_factor,
+    float desired_favicon_scale,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
   int desired_size_in_pixel =
-      GetSizeInPixel(params.desired_size_in_dip, desired_scale_factor);
+      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,
       desired_sizes_in_pixel,
       Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
            base::Unretained(this),
            callback,
            desired_size_in_pixel),
       tracker);
 }
 
 base::CancelableTaskTracker::TaskId
 FaviconService::GetLargestRawFaviconForPageURL(
     Profile* profile,
     const GURL& page_url,
     const std::vector<int>& icon_types,
     int minimum_size_in_pixels,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
   favicon_base::FaviconResultsCallback favicon_results_callback =
       Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
            base::Unretained(this),
            callback,
            0);
   if (page_url.SchemeIs(content::kChromeUIScheme) ||
       page_url.SchemeIs(extensions::kExtensionScheme)) {
     std::vector<int> desired_sizes_in_pixel;
     desired_sizes_in_pixel.push_back(0);
-    return GetFaviconForChromeURL(profile, page_url, desired_sizes_in_pixel,
-                                  favicon_results_callback, tracker);
+    return GetFaviconForChromeURL(profile,
+                                  page_url,
+                                  desired_sizes_in_pixel,
+                                  favicon_results_callback,
+                                  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,
@@ skipping 102 matching lines @@
 
 FaviconService::~FaviconService() {}
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForPageURLImpl(
     const FaviconForPageURLParams& params,
     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)) {
-    return GetFaviconForChromeURL(profile_, params.page_url,
-                                  desired_sizes_in_pixel, callback, tracker);
+    return GetFaviconForChromeURL(
+        profile_, params.page_url, desired_sizes_in_pixel, callback, tracker);
   }
   if (history_service_) {
     return history_service_->GetFaviconsForURL(params.page_url,
                                                params.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,
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
   favicon_base::FaviconImageResult image_result;
   image_result.image = favicon_base::SelectFaviconFramesFromPNGs(
       favicon_bitmap_results,
-      favicon_base::GetFaviconScaleFactors(),
+      favicon_base::GetFaviconScales(),
       desired_size_in_dip);
   favicon_base::SetFaviconColorSpace(&image_result.image);
 
   image_result.icon_url = image_result.image.IsEmpty() ?
       GURL() : favicon_bitmap_results[0].icon_url;
   callback.Run(image_result);
 }
 
 void FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults(
     const favicon_base::FaviconRawBitmapCallback& callback,
@@ skipping 19 matching lines @@
 
   // If history bitmap is already desired pixel size, return early.
   if (bitmap_result.pixel_size.width() == desired_size_in_pixel &&
       bitmap_result.pixel_size.height() == desired_size_in_pixel) {
     callback.Run(bitmap_result);
     return;
   }
 
   // Convert raw bytes to SkBitmap, resize via SelectFaviconFrames(), then
   // convert back.
-  std::vector<ui::ScaleFactor> desired_scale_factors;
-  desired_scale_factors.push_back(ui::SCALE_FACTOR_100P);
+  std::vector<float> desired_favicon_scales;
+  desired_favicon_scales.push_back(1.0f);
   gfx::Image resized_image = favicon_base::SelectFaviconFramesFromPNGs(
-      favicon_bitmap_results, desired_scale_factors, desired_size_in_pixel);
+      favicon_bitmap_results, desired_favicon_scales, desired_size_in_pixel);
 
   std::vector<unsigned char> resized_bitmap_data;
   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);
 }