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 <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 70 matching lines @@
         (candidate_sizes[i].width() + candidate_sizes[i].height()) / 2.0f;
 
     float score = 0;
     if (candidate_sizes[i].width() >= kHugeEdgeSize ||
         candidate_sizes[i].height() >= kHugeEdgeSize) {
       score = std::min(1.0f, desired_size / average_edge) * 0.01f;
     } else if (candidate_sizes[i].width() >= desired_size &&
                candidate_sizes[i].height() >= desired_size) {
       score = desired_size / average_edge * 0.01f + 0.15f;
     } else {
-      score = std::min(1.0f, average_edge / desired_size) *
-                  0.01f +
-              0.1f;
+      score = std::min(1.0f, average_edge / desired_size) * 0.01f + 0.1f;
     }
 
     if (candidate_index == std::numeric_limits<size_t>::max() ||
         score > candidate_score) {
       candidate_index = i;
       candidate_score = score;
     }
   }
   *score = candidate_score;
 
@@ skipping 29 matching lines @@
     const std::vector<gfx::Size>& candidate_sizes,
     const std::vector<int>& desired_sizes,
     float* match_score,
     std::vector<SelectionResult>* results) {
   if (candidate_sizes.empty() || desired_sizes.empty()) {
     if (match_score)
       *match_score = 0.0f;
     return;
   }
 
-  std::vector<int>::const_iterator zero_size_it = std::find(
-      desired_sizes.begin(), desired_sizes.end(), 0);
+  std::vector<int>::const_iterator zero_size_it =
+      std::find(desired_sizes.begin(), desired_sizes.end(), 0);
   if (zero_size_it != desired_sizes.end()) {
     // Just return the biggest image available.
     SelectionResult result;
     result.index = BiggestCandidate(candidate_sizes);
     result.desired_size = 0;
     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 < desired_sizes.size(); ++i) {
     float score;
     SelectionResult result;
     result.desired_size = desired_sizes[i];
-    result.index = GetCandidateIndexWithBestScore(candidate_sizes,
-                                                  result.desired_size,
-                                                  &score,
-                                                  &result.resize_method);
+    result.index = GetCandidateIndexWithBestScore(
+        candidate_sizes, result.desired_size, &score, &result.resize_method);
     results->push_back(result);
     total_score += score;
   }
 
   if (match_score)
     *match_score = total_score / desired_sizes.size();
 }
 
 // Resize |source_bitmap| using |resize_method|.
 SkBitmap GetResizedBitmap(const SkBitmap& source_bitmap,
@@ skipping 11 matching lines @@
           desired_size,
           desired_size);
   }
   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_in_dip,
-    float* match_score) {
+gfx::ImageSkia SelectFaviconFrames(const std::vector<SkBitmap>& bitmaps,
+                                   const std::vector<gfx::Size>& original_sizes,
+                                   const std::vector<float>& favicon_scales,
+                                   int desired_size_in_dip,
+                                   float* match_score) {
   std::vector<int> desired_sizes;
   std::map<int, float> scale_map;
   if (desired_size_in_dip == 0) {
     desired_sizes.push_back(0);
     scale_map[0] = 1.0f;
   } else {
-    for (size_t i = 0; i < scale_factors.size(); ++i) {
-      float scale = ui::GetScaleForScaleFactor(scale_factors[i]);
+    for (size_t i = 0; i < favicon_scales.size(); ++i) {
+      float scale = favicon_scales[i];
       int desired_size = ceil(desired_size_in_dip * scale);
       desired_sizes.push_back(desired_size);
       scale_map[desired_size] = scale;
     }
   }
 
   std::vector<SelectionResult> results;
   GetCandidateIndicesWithBestScores(
       original_sizes, desired_sizes, 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],
-                                               result.desired_size,
-                                               result.resize_method);
+    SkBitmap resized_bitmap = GetResizedBitmap(
+        bitmaps[result.index], result.desired_size, result.resize_method);
 
-    std::map<int, float>::const_iterator it = scale_map.find(
-        result.desired_size);
+    std::map<int, float>::const_iterator it =
+        scale_map.find(result.desired_size);
     DCHECK(it != scale_map.end());
     float scale = it->second;
     multi_image.AddRepresentation(gfx::ImageSkiaRep(resized_bitmap, scale));
   }
   return multi_image;
 }
 
-void SelectFaviconFrameIndices(
-    const std::vector<gfx::Size>& frame_pixel_sizes,
-    const std::vector<int>& desired_sizes,
-    std::vector<size_t>* best_indices,
-    float* match_score) {
+void SelectFaviconFrameIndices(const std::vector<gfx::Size>& frame_pixel_sizes,
+                               const std::vector<int>& desired_sizes,
+                               std::vector<size_t>* best_indices,
+                               float* match_score) {
   std::vector<SelectionResult> results;
   GetCandidateIndicesWithBestScores(
       frame_pixel_sizes, desired_sizes, 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);
     }
   }
 }