Remove ui::GetImageScale

chrome/browser/favicon/favicon_util.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_util.h"
 
 #include "components/favicon_base/favicon_types.h"
 #include "components/favicon_base/select_favicon_frames.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 35 matching lines @@
     png_reps.push_back(gfx::ImagePNGRep(best_candidate, 1.0f));
     return png_reps;
   }
 
   // Cache the scale factor for each pixel size as |scale_factors| may contain
   // any of GetFaviconScaleFactors() which may include scale factors not
   // supported by the platform. (ui::GetSupportedScaleFactor() cannot be used.)
   std::map<int, ui::ScaleFactor> desired_pixel_sizes;
   for (size_t i = 0; i < scale_factors.size(); ++i) {
     int pixel_size = floor(favicon_size *
-        ui::GetImageScale(scale_factors[i]));
+        ui::GetScaleForScaleFactor(scale_factors[i]));
     desired_pixel_sizes[pixel_size] = scale_factors[i];
   }
 
   for (size_t i = 0; i < png_data.size(); ++i) {
     if (!png_data[i].is_valid())
       continue;
 
     const gfx::Size& pixel_size = png_data[i].pixel_size;
     if (pixel_size.width() != pixel_size.height())
       continue;
 
     std::map<int, ui::ScaleFactor>::iterator it = desired_pixel_sizes.find(
         pixel_size.width());
     if (it == desired_pixel_sizes.end())
       continue;
 
     png_reps.push_back(
         gfx::ImagePNGRep(png_data[i].bitmap_data,
-                         ui::GetImageScale(it->second)));
+                         ui::GetScaleForScaleFactor(it->second)));
   }
 
   return png_reps;
 }
 
 // Returns a resampled bitmap of
 // |desired_size_in_pixel| x |desired_size_in_pixel| by resampling the best
 // bitmap out of |input_bitmaps|. ResizeBitmapByDownsamplingIfPossible() is
 // similar to SelectFaviconFrames() but it operates on bitmaps which have
 // already been resampled via SelectFaviconFrames().
@@ skipping 45 matching lines @@
   return skia::ImageOperations::Resize(best_bitmap,
                                        skia::ImageOperations::RESIZE_LANCZOS3,
                                        desired_size_in_pixel,
                                        desired_size_in_pixel);
 }
 
 }  // namespace
 
 // static
 std::vector<ui::ScaleFactor> FaviconUtil::GetFaviconScaleFactors() {
-  const float kScale1x = ui::GetImageScale(ui::SCALE_FACTOR_100P);
+  const float kScale1x = 1.0f;
   std::vector<ui::ScaleFactor> favicon_scale_factors =
       ui::GetSupportedScaleFactors();
 
   // The scale factors returned from ui::GetSupportedScaleFactors() are sorted.
   // Insert the 1x scale factor such that GetFaviconScaleFactors() is sorted as
   // well.
   size_t insert_index = favicon_scale_factors.size();
   for (size_t i = 0; i < favicon_scale_factors.size(); ++i) {
-    float scale = ui::GetImageScale(favicon_scale_factors[i]);
+    float scale = ui::GetScaleForScaleFactor(favicon_scale_factors[i]);
     if (scale == kScale1x) {
       return favicon_scale_factors;
     } else if (scale > kScale1x) {
       insert_index = i;
       break;
     }
   }
   // TODO(ios): 100p should not be necessary on iOS retina devices. However
   // the sync service only supports syncing 100p favicons. Until sync supports
   // other scales 100p is needed in the list of scale factors to retrieve and
@@ skipping 33 matching lines @@
 
   // SelectFaviconFramesFromPNGsWithoutResizing() should have selected the
   // largest favicon if |favicon_size| == 0.
   if (favicon_size == 0)
     return gfx::Image(png_reps);
 
   std::vector<ui::ScaleFactor> scale_factors_to_generate = scale_factors;
   for (size_t i = 0; i < png_reps.size(); ++i) {
     for (int j = static_cast<int>(scale_factors_to_generate.size()) - 1;
          j >= 0; --j) {
-      if (png_reps[i].scale == ui::GetImageScale(scale_factors_to_generate[j]))
+      if (png_reps[i].scale == ui::GetScaleForScaleFactor(
+              scale_factors_to_generate[j])) {
         scale_factors_to_generate.erase(scale_factors_to_generate.begin() + j);
+      }
     }
   }
 
   if (scale_factors_to_generate.empty())
     return gfx::Image(png_reps);
 
   std::vector<SkBitmap> bitmaps;
   for (size_t i = 0; i < png_data.size(); ++i) {
     if (!png_data[i].is_valid())
       continue;
 
     SkBitmap bitmap;
     if (gfx::PNGCodec::Decode(png_data[i].bitmap_data->front(),
                               png_data[i].bitmap_data->size(),
                               &bitmap)) {
       bitmaps.push_back(bitmap);
     }
   }
 
   if (bitmaps.empty())
     return gfx::Image();
 
   gfx::ImageSkia resized_image_skia;
   for (size_t i = 0; i < scale_factors_to_generate.size(); ++i) {
-    float scale = ui::GetImageScale(scale_factors_to_generate[i]);
+    float scale = ui::GetScaleForScaleFactor(scale_factors_to_generate[i]);
     int desired_size_in_pixel = ceil(favicon_size * scale);
     SkBitmap bitmap = ResizeBitmapByDownsamplingIfPossible(
         bitmaps, desired_size_in_pixel);
     resized_image_skia.AddRepresentation(gfx::ImageSkiaRep(bitmap, scale));
   }
 
   if (png_reps.empty())
     return gfx::Image(resized_image_skia);
 
   std::vector<gfx::ImageSkiaRep> resized_image_skia_reps =
       resized_image_skia.image_reps();
   for (size_t i = 0; i < resized_image_skia_reps.size(); ++i) {
     scoped_refptr<base::RefCountedBytes> png_bytes(new base::RefCountedBytes());
     if (gfx::PNGCodec::EncodeBGRASkBitmap(
         resized_image_skia_reps[i].sk_bitmap(), false, &png_bytes->data())) {
       png_reps.push_back(gfx::ImagePNGRep(png_bytes,
           resized_image_skia_reps[i].scale()));
     }
   }
 
   return gfx::Image(png_reps);
 }