Remove dependency on ui::ScaleFactor from ui/gfx

ui/gfx/image/image_unittest_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.
 
 // Because the unit tests for gfx::Image are spread across multiple
 // implementation files, this header contains the reusable components.
 
 #include "ui/gfx/image/image_unittest_util.h"
 
 #include <cmath>
@@ skipping 30 matching lines @@
 bool ColorsClose(SkColor color1, SkColor color2) {
   // Be tolerant of floating point rounding and lossy color space conversions.
   return ColorComponentsClose(SkColorGetR(color1), SkColorGetR(color2)) &&
          ColorComponentsClose(SkColorGetG(color1), SkColorGetG(color2)) &&
          ColorComponentsClose(SkColorGetB(color1), SkColorGetB(color2)) &&
          ColorComponentsClose(SkColorGetA(color1), SkColorGetA(color2));
 }
 
 }  // namespace
 
-std::vector<ui::ScaleFactor> Get1xAnd2xScaleFactors() {
-  std::vector<ui::ScaleFactor> scale_factors;
-  scale_factors.push_back(ui::SCALE_FACTOR_100P);
-  scale_factors.push_back(ui::SCALE_FACTOR_200P);
-  return scale_factors;
+std::vector<float> Get1xAnd2xScales() {
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
+  return scales;
 }
 
 const SkBitmap CreateBitmap(int width, int height) {
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
   bitmap.allocPixels();
   bitmap.eraseRGB(0, 255, 0);
   return bitmap;
 }
 
@@ skipping 16 matching lines @@
   return gfx::Image::CreateFrom1xBitmap(CreateBitmap(width, height));
 }
 
 bool IsEqual(const gfx::Image& img1, const gfx::Image& img2) {
   std::vector<gfx::ImageSkiaRep> img1_reps = img1.AsImageSkia().image_reps();
   gfx::ImageSkia image_skia2 = img2.AsImageSkia();
   if (image_skia2.image_reps().size() != img1_reps.size())
     return false;
 
   for (size_t i = 0; i < img1_reps.size(); ++i) {
-    ui::ScaleFactor scale_factor = img1_reps[i].scale_factor();
-    const gfx::ImageSkiaRep& image_rep2 = image_skia2.GetRepresentation(
-        scale_factor);
-    if (image_rep2.scale_factor() != scale_factor ||
+    float scale = img1_reps[i].scale();
+    const gfx::ImageSkiaRep& image_rep2 = image_skia2.GetRepresentation(scale);
+    if (image_rep2.scale() != scale ||
         !IsEqual(img1_reps[i].sk_bitmap(), image_rep2.sk_bitmap())) {
       return false;
     }
   }
   return true;
 }
 
 bool IsEqual(const SkBitmap& bmp1, const SkBitmap& bmp2) {
   if (bmp1.isNull() && bmp2.isNull())
     return true;
@@ skipping 37 matching lines @@
   EXPECT_LE(16, bitmap.width());
   EXPECT_LE(16, bitmap.height());
   SkAutoLockPixels auto_lock(bitmap);
   CheckColors(bitmap.getColor(10, 10), SK_ColorRED);
 }
 
 bool ImageSkiaStructureMatches(
     const gfx::ImageSkia& image_skia,
     int width,
     int height,
-    const std::vector<ui::ScaleFactor>& scale_factors) {
+    const std::vector<float>& scales) {
   if (image_skia.isNull() ||
       image_skia.width() != width ||
       image_skia.height() != height ||
-      image_skia.image_reps().size() != scale_factors.size()) {
+      image_skia.image_reps().size() != scales.size()) {
     return false;
   }
 
-  for (size_t i = 0; i < scale_factors.size(); ++i) {
+  for (size_t i = 0; i < scales.size(); ++i) {
     gfx::ImageSkiaRep image_rep =
-        image_skia.GetRepresentation(scale_factors[i]);
-    if (image_rep.is_null() ||
-        image_rep.scale_factor() != scale_factors[i])
+        image_skia.GetRepresentation(scales[i]);
+    if (image_rep.is_null() || image_rep.scale() != scales[i])
       return false;
 
-    float scale = ui::GetScaleFactorScale(scale_factors[i]);
-    if (image_rep.pixel_width() != static_cast<int>(width * scale) ||
-        image_rep.pixel_height() != static_cast<int>(height * scale)) {
+    if (image_rep.pixel_width() != static_cast<int>(width * scales[i]) ||
+        image_rep.pixel_height() != static_cast<int>(height * scales[i])) {
       return false;
     }
   }
   return true;
 }
 
 bool IsEmpty(const gfx::Image& image) {
   const SkBitmap& bmp = *image.ToSkBitmap();
   return bmp.isNull() ||
          (bmp.width() == 0 && bmp.height() == 0);
 }
 
 PlatformImage CreatePlatformImage() {
   const SkBitmap bitmap(CreateBitmap(25, 25));
 #if defined(OS_IOS)
-  ui::ScaleFactor scale_factor = ui::GetMaxScaleFactor();
-  float scale = ui::GetScaleFactorScale(scale_factor);
+  float scale = ImageSkia::GetSupportedScales().back();
 
   base::ScopedCFTypeRef<CGColorSpaceRef> color_space(
       CGColorSpaceCreateDeviceRGB());
   UIImage* image =
       gfx::SkBitmapToUIImageWithColorSpace(bitmap, scale, color_space);
   base::mac::NSObjectRetain(image);
   return image;
 #elif defined(OS_MACOSX)
   NSImage* image = gfx::SkBitmapToNSImage(bitmap);
   base::mac::NSObjectRetain(image);
@@ skipping 80 matching lines @@
 bool PlatformImagesEqual(PlatformImage image1, PlatformImage image2) {
 #if defined(OS_MACOSX) || defined(TOOLKIT_GTK)
   return image1 == image2;
 #else
   return image1.BackedBySameObjectAs(image2);
 #endif
 }
 
 }  // namespace test
 }  // namespace gfx