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

components/favicon_base/select_favicon_frames.cc

 // Copyright 2014 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_base/select_favicon_frames.h"
 
 #include <limits>
 #include <set>
 
 #include "skia/ext/image_operations.h"
@@ skipping 30 matching lines @@
     canvas.drawBitmapRect(contents, NULL, dest);
   }
 
   return bitmap;
 }
 
 enum ResizeMethod { NONE, SAMPLE_NEAREST_NEIGHBOUR, LANCZOS };
 
 size_t GetCandidateIndexWithBestScore(
     const std::vector<gfx::Size>& candidate_sizes_in_pixel,
-    ui::ScaleFactor scale_factor,
+    float scale,
     int desired_size_in_dip,
     float* score,
     ResizeMethod* resize_method) {
   DCHECK_NE(desired_size_in_dip, 0);
 
-  float scale = ui::GetScaleForScaleFactor(scale_factor);
   int desired_size_in_pixel =
       static_cast<int>(desired_size_in_dip * scale + 0.5f);
 
   // Try to find an exact match.
   for (size_t i = 0; i < candidate_sizes_in_pixel.size(); ++i) {
     if (candidate_sizes_in_pixel[i].width() == desired_size_in_pixel &&
         candidate_sizes_in_pixel[i].height() == desired_size_in_pixel) {
       *score = 1;
       *resize_method = NONE;
       return i;
@@ skipping 53 matching lines @@
   return candidate_index;
 }
 
 // Represents the index of the best candidate for a |scale_factor| from the
 // |candidate_sizes| passed into GetCandidateIndicesWithBestScores().
 struct SelectionResult {
   // index in |candidate_sizes| of the best candidate.
   size_t index;
 
   // The ScaleFactor for which |index| is the best candidate.
-  ui::ScaleFactor scale_factor;
+  float scale;
 
   // How the bitmap data that the bitmap with |candidate_sizes[index]| should
   // be resized for displaying in the UI.
   ResizeMethod resize_method;
 };
 
 void GetCandidateIndicesWithBestScores(
     const std::vector<gfx::Size>& candidate_sizes,
-    const std::vector<ui::ScaleFactor>& scale_factors,
+    const std::vector<float>& scales,
     int desired_size,
     float* match_score,
     std::vector<SelectionResult>* results) {
   if (candidate_sizes.empty()) {
     if (match_score)
       *match_score = 0.0f;
     return;
   }
 
   if (desired_size == 0) {
     // Just return the biggest image available.
     SelectionResult result;
     result.index = BiggestCandidate(candidate_sizes);
-    result.scale_factor = ui::SCALE_FACTOR_100P;
+    result.scale = 1.0f;
     result.resize_method = NONE;
     results->push_back(result);
     if (match_score)
       *match_score = 1.0f;
     return;
   }
 
   float total_score = 0;
-  for (size_t i = 0; i < scale_factors.size(); ++i) {
+  for (size_t i = 0; i < scales.size(); ++i) {
     float score;
     SelectionResult result;
-    result.scale_factor = scale_factors[i];
+    result.scale = scales[i];
     result.index = GetCandidateIndexWithBestScore(candidate_sizes,
-                                                  result.scale_factor,
+                                                  result.scale,
                                                   desired_size,
                                                   &score,
                                                   &result.resize_method);
     results->push_back(result);
     total_score += score;
   }
 
   if (match_score)
-    *match_score = total_score / scale_factors.size();
+    *match_score = total_score / scales.size();
 }
 
 // Resize |source_bitmap| using |resize_method|.
 SkBitmap GetResizedBitmap(const SkBitmap& source_bitmap,
                           int desired_size_in_dip,
-                          ui::ScaleFactor scale_factor,
+                          float scale,
                           ResizeMethod resize_method) {
-  float scale = ui::GetScaleForScaleFactor(scale_factor);
   int desired_size_in_pixel =
       static_cast<int>(desired_size_in_dip * scale + 0.5f);
 
   switch (resize_method) {
     case NONE:
       return source_bitmap;
     case SAMPLE_NEAREST_NEIGHBOUR:
       return SampleNearestNeighbor(source_bitmap, desired_size_in_pixel);
     case LANCZOS:
       return skia::ImageOperations::Resize(
           source_bitmap,
           skia::ImageOperations::RESIZE_LANCZOS3,
           desired_size_in_pixel,
           desired_size_in_pixel);
   }
   return source_bitmap;
 }
 
 }  // namespace
 
 const float kSelectFaviconFramesInvalidScore = -1.0f;
 
-gfx::ImageSkia SelectFaviconFrames(
-    const std::vector<SkBitmap>& bitmaps,
-    const std::vector<gfx::Size>& original_sizes,
-    const std::vector<ui::ScaleFactor>& scale_factors,
-    int desired_size,
-    float* match_score) {
+gfx::ImageSkia SelectFaviconFrames(const std::vector<SkBitmap>& bitmaps,
+                                   const std::vector<gfx::Size>& original_sizes,
+                                   const std::vector<float>& scales,
+                                   int desired_size,
+                                   float* match_score) {
   std::vector<SelectionResult> results;
   GetCandidateIndicesWithBestScores(
-      original_sizes, scale_factors, desired_size, match_score, &results);
+      original_sizes, scales, desired_size, match_score, &results);
 
   gfx::ImageSkia multi_image;
   for (size_t i = 0; i < results.size(); ++i) {
     const SelectionResult& result = results[i];
     SkBitmap resized_bitmap = GetResizedBitmap(bitmaps[result.index],
                                                desired_size,
-                                               result.scale_factor,
+                                               result.scale,
                                                result.resize_method);
-    multi_image.AddRepresentation(gfx::ImageSkiaRep(
-        resized_bitmap, ui::GetScaleForScaleFactor(result.scale_factor)));
+    multi_image.AddRepresentation(
+        gfx::ImageSkiaRep(resized_bitmap, result.scale));
   }
   return multi_image;
 }
 
-void SelectFaviconFrameIndices(
-    const std::vector<gfx::Size>& frame_pixel_sizes,
-    const std::vector<ui::ScaleFactor>& scale_factors,
-    int desired_size,
-    std::vector<size_t>* best_indices,
-    float* match_score) {
+void SelectFaviconFrameIndices(const std::vector<gfx::Size>& frame_pixel_sizes,
+                               const std::vector<float>& scales,
+                               int desired_size,
+                               std::vector<size_t>* best_indices,
+                               float* match_score) {
   std::vector<SelectionResult> results;
   GetCandidateIndicesWithBestScores(
-      frame_pixel_sizes, scale_factors, desired_size, match_score, &results);
+      frame_pixel_sizes, scales, desired_size, match_score, &results);
 
   std::set<size_t> already_added;
   for (size_t i = 0; i < results.size(); ++i) {
     size_t index = results[i].index;
     // GetCandidateIndicesWithBestScores() will return duplicate indices if the
     // bitmap data with |frame_pixel_sizes[index]| should be used for multiple
     // scale factors. Remove duplicates here such that |best_indices| contains
     // no duplicates.
     if (already_added.find(index) == already_added.end()) {
       already_added.insert(index);
       best_indices->push_back(index);
     }
   }
 }