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 "base/hash.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_service.h"
@@ skipping 31 matching lines @@
   return tracker->PostTask(
       base::MessageLoopProxy::current().get(),
       FROM_HERE,
       Bind(callback, std::vector<favicon_base::FaviconRawBitmapResult>()));
 }
 
 // Return the TaskId to retreive the favicon from chrome specific URL.
 base::CancelableTaskTracker::TaskId GetFaviconForChromeURL(
     Profile* profile,
     const GURL& page_url,
-    const std::vector<ui::ScaleFactor>& desired_scale_factors,
+    const std::vector<float>& desired_favicon_scales,
     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_scale_factors, cancelable_cb);
+  ChromeWebUIControllerFactory::GetInstance()->GetFaviconForURL(
+      profile, page_url, desired_favicon_scales, cancelable_cb);
   return id;
 }
 
 }  // namespace
 
 FaviconService::FaviconService(Profile* profile)
     : history_service_(HistoryServiceFactory::GetForProfile(
           profile, Profile::EXPLICIT_ACCESS)),
       profile_(profile) {
 }
@@ skipping 13 matching lines @@
     base::CancelableTaskTracker* tracker) {
   favicon_base::FaviconResultsCallback callback_runner =
       Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults,
            base::Unretained(this), callback, desired_size_in_dip);
   if (history_service_) {
     std::vector<GURL> icon_urls;
     icon_urls.push_back(icon_url);
     return history_service_->GetFavicons(icon_urls,
                                          icon_type,
                                          desired_size_in_dip,
-                                         favicon_base::GetFaviconScaleFactors(),
+                                         favicon_base::GetFaviconScales(),
                                          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) {
   favicon_base::FaviconResultsCallback callback_runner =
       Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
            base::Unretained(this),
            callback,
            desired_size_in_dip,
-           desired_scale_factor);
+           desired_favicon_scale);
 
   if (history_service_) {
     std::vector<GURL> icon_urls;
     icon_urls.push_back(icon_url);
-    std::vector<ui::ScaleFactor> desired_scale_factors;
-    desired_scale_factors.push_back(desired_scale_factor);
+    std::vector<float> desired_favicon_scales;
+    desired_favicon_scales.push_back(desired_favicon_scale);
 
-    return history_service_->GetFavicons(
-        icon_urls, icon_type, desired_size_in_dip, desired_scale_factors,
-        callback_runner, tracker);
+    return history_service_->GetFavicons(icon_urls,
+                                         icon_type,
+                                         desired_size_in_dip,
+                                         desired_favicon_scales,
+                                         callback_runner,
+                                         tracker);
   }
   return RunWithEmptyResultAsync(callback_runner, tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFavicon(
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     int desired_size_in_dip,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   if (history_service_) {
     std::vector<GURL> icon_urls;
     icon_urls.push_back(icon_url);
     return history_service_->GetFavicons(icon_urls,
                                          icon_type,
                                          desired_size_in_dip,
-                                         favicon_base::GetFaviconScaleFactors(),
+                                         favicon_base::GetFaviconScales(),
                                          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,
         desired_size_in_dip,
-        favicon_base::GetFaviconScaleFactors(),
+        favicon_base::GetFaviconScales(),
         callback,
         tracker);
   }
   return RunWithEmptyResultAsync(callback, tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImageForPageURL(
     const FaviconForPageURLParams& params,
     const favicon_base::FaviconImageCallback& callback,
     base::CancelableTaskTracker* tracker) {
   return GetFaviconForPageURLImpl(
       params,
-      favicon_base::GetFaviconScaleFactors(),
+      favicon_base::GetFaviconScales(),
       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) {
-  std::vector<ui::ScaleFactor> desired_scale_factors;
-  desired_scale_factors.push_back(desired_scale_factor);
+  std::vector<float> desired_favicon_scales;
+  desired_favicon_scales.push_back(desired_favicon_scale);
   return GetFaviconForPageURLImpl(
       params,
-      desired_scale_factors,
+      desired_favicon_scales,
       Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
            base::Unretained(this),
            callback,
            params.desired_size_in_dip,
-           desired_scale_factor),
+           desired_favicon_scale),
       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,
-           ui::ScaleFactor());
+           1.0f);
   if (page_url.SchemeIs(content::kChromeUIScheme) ||
       page_url.SchemeIs(extensions::kExtensionScheme)) {
-    std::vector<ui::ScaleFactor> scale_factor;
-    scale_factor.push_back(ui::SCALE_FACTOR_100P);
-    return GetFaviconForChromeURL(profile, page_url, scale_factor,
-                                  favicon_results_callback, tracker);
+    std::vector<float> scale;
+    scale.push_back(1.0f);
+    return GetFaviconForChromeURL(
+        profile, page_url, scale, 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,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   return GetFaviconForPageURLImpl(
-      params, favicon_base::GetFaviconScaleFactors(), callback, tracker);
+      params, favicon_base::GetFaviconScales(), 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_in_dip| to get the largest bitmap for |favicon_id|
   // without any resizing.
   int desired_size_in_dip = 0;
-  ui::ScaleFactor desired_scale_factor = ui::SCALE_FACTOR_100P;
+  float desired_favicon_scale = 1.0f;
   favicon_base::FaviconResultsCallback callback_runner =
       Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
            base::Unretained(this),
            callback,
            desired_size_in_dip,
-           desired_scale_factor);
+           desired_favicon_scale);
 
   if (history_service_) {
-    return history_service_->GetFaviconForID(
-        favicon_id, desired_size_in_dip, desired_scale_factor,
-        callback_runner, tracker);
+    return history_service_->GetFaviconForID(favicon_id,
+                                             desired_size_in_dip,
+                                             desired_favicon_scale,
+                                             callback_runner,
+                                             tracker);
   }
   return RunWithEmptyResultAsync(callback_runner, tracker);
 }
 
 void FaviconService::SetFaviconOutOfDateForPage(const GURL& page_url) {
   if (history_service_)
     history_service_->SetFaviconsOutOfDateForPage(page_url);
 }
 
 void FaviconService::CloneFavicon(const GURL& old_page_url,
@@ skipping 62 matching lines @@
 }
 
 void FaviconService::ClearUnableToDownloadFavicons() {
   missing_favicon_urls_.clear();
 }
 
 FaviconService::~FaviconService() {}
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForPageURLImpl(
     const FaviconForPageURLParams& params,
-    const std::vector<ui::ScaleFactor>& desired_scale_factors,
+    const std::vector<float>& desired_favicon_scales,
     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_scale_factors, callback, tracker);
+    return GetFaviconForChromeURL(
+        profile_, params.page_url, desired_favicon_scales, callback, tracker);
   }
   if (history_service_) {
     return history_service_->GetFaviconsForURL(params.page_url,
                                                params.icon_types,
                                                params.desired_size_in_dip,
-                                               desired_scale_factors,
+                                               desired_favicon_scales,
                                                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,
     int desired_size_in_dip,
-    ui::ScaleFactor desired_scale_factor,
+    float desired_favicon_scale,
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
   if (favicon_bitmap_results.empty() || !favicon_bitmap_results[0].is_valid()) {
     callback.Run(favicon_base::FaviconRawBitmapResult());
     return;
   }
 
   DCHECK_EQ(1u, favicon_bitmap_results.size());
   favicon_base::FaviconRawBitmapResult bitmap_result =
       favicon_bitmap_results[0];
 
   // If the desired size is 0, SelectFaviconFrames() will return the largest
   // bitmap without doing any resizing. As |favicon_bitmap_results| has bitmap
   // data for a single bitmap, return it and avoid an unnecessary decode.
   if (desired_size_in_dip == 0) {
     callback.Run(bitmap_result);
     return;
   }
 
   // If history bitmap is already desired pixel size, return early.
-  float desired_scale = ui::GetScaleForScaleFactor(desired_scale_factor);
-  int desired_edge_width_in_pixel = static_cast<int>(
-      desired_size_in_dip * desired_scale + 0.5f);
+  int desired_edge_width_in_pixel =
+      static_cast<int>(desired_size_in_dip * desired_favicon_scale + 0.5f);
 
   gfx::Size desired_size_in_pixel(desired_edge_width_in_pixel,
                                   desired_edge_width_in_pixel);
   if (bitmap_result.pixel_size == 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(desired_scale_factor);
+  std::vector<float> desired_favicon_scales;
+  desired_favicon_scales.push_back(desired_favicon_scale);
   gfx::Image resized_image = favicon_base::SelectFaviconFramesFromPNGs(
-      favicon_bitmap_results, desired_scale_factors, desired_size_in_dip);
+      favicon_bitmap_results, desired_favicon_scales, desired_size_in_dip);
 
   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);
 }