Remove dependency on ui::ScaleFactor from ui/gfx

ui/gfx/image/image_unittest.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 "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
-#include "ui/base/layout.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_png_rep.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_unittest_util.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #include "ui/gfx/gtk_util.h"
 #elif defined(OS_IOS)
 #include "base/mac/foundation_util.h"
 #include "skia/ext/skia_utils_ios.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "skia/ext/skia_utils_mac.h"
 #endif
 
 namespace {
 
 #if defined(TOOLKIT_VIEWS) || defined(OS_ANDROID)
 const bool kUsesSkiaNatively = true;
 #else
 const bool kUsesSkiaNatively = false;
 #endif
 
 class ImageTest : public testing::Test {
+ public:
+  ImageTest() {
+    std::vector<float> scales;
+    scales.push_back(1.0f);
+#if !defined(OS_IOS)
+    scales.push_back(2.0f);
+#endif
+    gfx::ImageSkia::SetSupportedScales(scales);
+  }
 };
 
 namespace gt = gfx::test;
 
 TEST_F(ImageTest, EmptyImage) {
   // Test the default constructor.
   gfx::Image image;
   EXPECT_EQ(0U, image.RepresentationCount());
   EXPECT_TRUE(image.IsEmpty());
   EXPECT_EQ(0, image.Width());
@@ skipping 44 matching lines @@
   EXPECT_TRUE(image3.IsEmpty());
   EXPECT_EQ(0, image3.Width());
   EXPECT_EQ(0, image3.Height());
   EXPECT_EQ(0U, image3.RepresentationCount());
 }
 
 // The resulting Image should be empty when it is created using obviously
 // invalid data.
 TEST_F(ImageTest, EmptyImageFromObviouslyInvalidPNGImage) {
   std::vector<gfx::ImagePNGRep> image_png_reps1;
-  image_png_reps1.push_back(gfx::ImagePNGRep(NULL, ui::SCALE_FACTOR_100P));
+  image_png_reps1.push_back(gfx::ImagePNGRep(NULL, 1.0f));
   gfx::Image image1(image_png_reps1);
   EXPECT_TRUE(image1.IsEmpty());
   EXPECT_EQ(0U, image1.RepresentationCount());
 
   std::vector<gfx::ImagePNGRep> image_png_reps2;
   image_png_reps2.push_back(gfx::ImagePNGRep(
-      new base::RefCountedBytes(), ui::SCALE_FACTOR_100P));
+      new base::RefCountedBytes(), 1.0f));
   gfx::Image image2(image_png_reps2);
   EXPECT_TRUE(image2.IsEmpty());
   EXPECT_EQ(0U, image2.RepresentationCount());
 }
 
 // Test the Width, Height and Size of an empty and non-empty image.
 TEST_F(ImageTest, ImageSize) {
   gfx::Image image;
   EXPECT_EQ(0, image.Width());
   EXPECT_EQ(0, image.Height());
@@ skipping 43 matching lines @@
   EXPECT_FALSE(png_bytes->size());
 }
 
 // Check that getting the 1x PNG bytes from images which do not have a 1x
 // representation returns NULL.
 TEST_F(ImageTest, ImageNo1xToPNG) {
   // Image with 2x only.
   const int kSize2x = 50;
   gfx::ImageSkia image_skia;
   image_skia.AddRepresentation(gfx::ImageSkiaRep(gt::CreateBitmap(
-      kSize2x, kSize2x), ui::SCALE_FACTOR_200P));
+      kSize2x, kSize2x), 2.0f));
   gfx::Image image1(image_skia);
   scoped_refptr<base::RefCountedMemory> png_bytes1 = image1.As1xPNGBytes();
   EXPECT_TRUE(png_bytes1.get());
   EXPECT_FALSE(png_bytes1->size());
 
   std::vector<gfx::ImagePNGRep> image_png_reps;
   image_png_reps.push_back(gfx::ImagePNGRep(
-      gt::CreatePNGBytes(kSize2x), ui::SCALE_FACTOR_200P));
+      gt::CreatePNGBytes(kSize2x), 2.0f));
   gfx::Image image2(image_png_reps);
   EXPECT_FALSE(image2.IsEmpty());
   EXPECT_EQ(0, image2.Width());
   EXPECT_EQ(0, image2.Height());
   scoped_refptr<base::RefCountedMemory> png_bytes2 = image2.As1xPNGBytes();
   EXPECT_TRUE(png_bytes2.get());
   EXPECT_FALSE(png_bytes2->size());
 }
 
 // Check that for an image initialized with multi resolution PNG data,
 // As1xPNGBytes() returns the 1x bytes.
 TEST_F(ImageTest, CreateExtractPNGBytes) {
   const int kSize1x = 25;
   const int kSize2x = 50;
 
   scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
   std::vector<gfx::ImagePNGRep> image_png_reps;
-  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, ui::SCALE_FACTOR_100P));
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
   image_png_reps.push_back(gfx::ImagePNGRep(
-      gt::CreatePNGBytes(kSize2x), ui::SCALE_FACTOR_200P));
+      gt::CreatePNGBytes(kSize2x), 2.0f));
 
   gfx::Image image(image_png_reps);
   EXPECT_FALSE(image.IsEmpty());
   EXPECT_EQ(25, image.Width());
   EXPECT_EQ(25, image.Height());
 
   EXPECT_TRUE(std::equal(bytes1x->front(), bytes1x->front() + bytes1x->size(),
                          image.As1xPNGBytes()->front()));
 }
 
 TEST_F(ImageTest, MultiResolutionImageSkiaToPNG) {
   const int kSize1x = 25;
   const int kSize2x = 50;
 
   SkBitmap bitmap_1x = gt::CreateBitmap(kSize1x, kSize1x);
   gfx::ImageSkia image_skia;
   image_skia.AddRepresentation(gfx::ImageSkiaRep(bitmap_1x,
-                                                 ui::SCALE_FACTOR_100P));
+                                                 1.0f));
   image_skia.AddRepresentation(gfx::ImageSkiaRep(gt::CreateBitmap(
-      kSize2x, kSize2x), ui::SCALE_FACTOR_200P));
+      kSize2x, kSize2x), 2.0f));
   gfx::Image image(image_skia);
 
   EXPECT_TRUE(gt::IsEqual(image.As1xPNGBytes(), bitmap_1x));
   EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepPNG));
 }
 
 TEST_F(ImageTest, MultiResolutionPNGToImageSkia) {
   const int kSize1x = 25;
   const int kSize2x = 50;
 
   scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
   scoped_refptr<base::RefCountedMemory> bytes2x = gt::CreatePNGBytes(kSize2x);
 
   std::vector<gfx::ImagePNGRep> image_png_reps;
-  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, ui::SCALE_FACTOR_100P));
-  image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, ui::SCALE_FACTOR_200P));
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, 2.0f));
   gfx::Image image(image_png_reps);
 
-  std::vector<ui::ScaleFactor> scale_factors;
-  scale_factors.push_back(ui::SCALE_FACTOR_100P);
-  scale_factors.push_back(ui::SCALE_FACTOR_200P);
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
   gfx::ImageSkia image_skia = image.AsImageSkia();
   EXPECT_TRUE(gt::ImageSkiaStructureMatches(image_skia, kSize1x, kSize1x,
-                                            scale_factors));
+                                            scales));
   EXPECT_TRUE(gt::IsEqual(bytes1x,
-      image_skia.GetRepresentation(ui::SCALE_FACTOR_100P).sk_bitmap()));
+      image_skia.GetRepresentation(1.0f).sk_bitmap()));
   EXPECT_TRUE(gt::IsEqual(bytes2x,
-      image_skia.GetRepresentation(ui::SCALE_FACTOR_200P).sk_bitmap()));
+      image_skia.GetRepresentation(2.0f).sk_bitmap()));
 }
 
 TEST_F(ImageTest, MultiResolutionPNGToPlatform) {
   const int kSize1x = 25;
   const int kSize2x = 50;
 
   scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
   scoped_refptr<base::RefCountedMemory> bytes2x = gt::CreatePNGBytes(kSize2x);
   std::vector<gfx::ImagePNGRep> image_png_reps;
-  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, ui::SCALE_FACTOR_100P));
-  image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, ui::SCALE_FACTOR_200P));
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, 2.0f));
 
   gfx::Image from_png(image_png_reps);
   gfx::Image from_platform(gt::CopyPlatformType(from_png));
 #if defined(OS_IOS)
   // On iOS the platform type (UIImage) only supports one resolution.
-  std::vector<ui::ScaleFactor> scale_factors = ui::GetSupportedScaleFactors();
-  EXPECT_EQ(scale_factors.size(), 1U);
-  if (scale_factors[0] == ui::SCALE_FACTOR_100P)
+  std::vector<float> scales = gfx::ImageSkia::GetSupportedScales();
+  EXPECT_EQ(scales.size(), 1U);
+  if (scales[0] == 1.0f)
     EXPECT_TRUE(gt::IsEqual(bytes1x, from_platform.AsBitmap()));
-  else if (scale_factors[0] == ui::SCALE_FACTOR_200P)
+  else if (scales[0] == 2.0f)
     EXPECT_TRUE(gt::IsEqual(bytes2x, from_platform.AsBitmap()));
   else
     ADD_FAILURE() << "Unexpected platform scale factor.";
 #else
   EXPECT_TRUE(gt::IsEqual(bytes1x, from_platform.AsBitmap()));
 #endif  // defined(OS_IOS)
 }
 
 
 TEST_F(ImageTest, PlatformToPNGEncodeAndDecode) {
   gfx::Image image(gt::CreatePlatformImage());
   scoped_refptr<base::RefCountedMemory> png_data = image.As1xPNGBytes();
   EXPECT_TRUE(png_data.get());
   EXPECT_TRUE(png_data->size());
   EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepPNG));
 
   std::vector<gfx::ImagePNGRep> image_png_reps;
-  image_png_reps.push_back(gfx::ImagePNGRep(png_data, ui::SCALE_FACTOR_100P));
+  image_png_reps.push_back(gfx::ImagePNGRep(png_data, 1.0f));
   gfx::Image from_png(image_png_reps);
 
   EXPECT_TRUE(from_png.HasRepresentation(gfx::Image::kImageRepPNG));
   EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(from_png)));
 }
 
 // The platform types use the platform provided encoding/decoding of PNGs. Make
 // sure these work with the Skia Encode/Decode.
 TEST_F(ImageTest, PNGEncodeFromSkiaDecodeToPlatform) {
   // Force the conversion sequence skia to png to platform_type.
-  ui::ScaleFactor ideal_scale_factor = ui::GetScaleFactorFromScale(1.0f);
-
   gfx::Image from_bitmap = gfx::Image::CreateFrom1xBitmap(
       gt::CreateBitmap(25, 25));
   scoped_refptr<base::RefCountedMemory> png_bytes =
       from_bitmap.As1xPNGBytes();
 
   std::vector<gfx::ImagePNGRep> image_png_reps;
-  image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, ideal_scale_factor));
+  image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, 1.0f));
   gfx::Image from_png(image_png_reps);
 
   gfx::Image from_platform(gt::CopyPlatformType(from_png));
 
   EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(from_platform)));
   EXPECT_TRUE(gt::IsEqual(png_bytes, from_platform.AsBitmap()));
 }
 
 TEST_F(ImageTest, PNGEncodeFromPlatformDecodeToSkia) {
   // Force the conversion sequence platform_type to png to skia.
   gfx::Image from_platform(gt::CreatePlatformImage());
   scoped_refptr<base::RefCountedMemory> png_bytes =
       from_platform.As1xPNGBytes();
   std::vector<gfx::ImagePNGRep> image_png_reps;
-  image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, ui::SCALE_FACTOR_100P));
+  image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, 1.0f));
   gfx::Image from_png(image_png_reps);
 
   EXPECT_TRUE(gt::IsEqual(from_platform.AsBitmap(), from_png.AsBitmap()));
 }
 
 TEST_F(ImageTest, PNGDecodeToSkiaFailure) {
   scoped_refptr<base::RefCountedBytes> invalid_bytes(
       new base::RefCountedBytes());
   invalid_bytes->data().push_back('0');
   std::vector<gfx::ImagePNGRep> image_png_reps;
   image_png_reps.push_back(gfx::ImagePNGRep(
-      invalid_bytes, ui::SCALE_FACTOR_100P));
+      invalid_bytes, 1.0f));
   gfx::Image image(image_png_reps);
   gt::CheckImageIndicatesPNGDecodeFailure(image);
 }
 
 TEST_F(ImageTest, PNGDecodeToPlatformFailure) {
   scoped_refptr<base::RefCountedBytes> invalid_bytes(
       new base::RefCountedBytes());
   invalid_bytes->data().push_back('0');
   std::vector<gfx::ImagePNGRep> image_png_reps;
   image_png_reps.push_back(gfx::ImagePNGRep(
-      invalid_bytes, ui::SCALE_FACTOR_100P));
+      invalid_bytes, 1.0f));
   gfx::Image from_png(image_png_reps);
   gfx::Image from_platform(gt::CopyPlatformType(from_png));
   gt::CheckImageIndicatesPNGDecodeFailure(from_platform);
 }
 
 TEST_F(ImageTest, SkiaToPlatform) {
   gfx::Image image(gt::CreateImageSkia(25, 25));
   EXPECT_EQ(25, image.Width());
   EXPECT_EQ(25, image.Height());
   const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U;
@@ skipping 277 matching lines @@
 
 TEST_F(ImageTest, MultiResolutionImageSkia) {
   const int kWidth1x = 10;
   const int kHeight1x = 12;
   const int kWidth2x = 20;
   const int kHeight2x = 24;
 
   gfx::ImageSkia image_skia;
   image_skia.AddRepresentation(gfx::ImageSkiaRep(
       gt::CreateBitmap(kWidth1x, kHeight1x),
-      ui::SCALE_FACTOR_100P));
+      1.0f));
   image_skia.AddRepresentation(gfx::ImageSkiaRep(
       gt::CreateBitmap(kWidth2x, kHeight2x),
-      ui::SCALE_FACTOR_200P));
+      2.0f));
 
-  std::vector<ui::ScaleFactor> scale_factors;
-  scale_factors.push_back(ui::SCALE_FACTOR_100P);
-  scale_factors.push_back(ui::SCALE_FACTOR_200P);
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
   EXPECT_TRUE(gt::ImageSkiaStructureMatches(image_skia, kWidth1x, kHeight1x,
-                                            scale_factors));
+                                            scales));
 
   // Check that the image has a single representation.
   gfx::Image image(image_skia);
   EXPECT_EQ(1u, image.RepresentationCount());
   EXPECT_EQ(kWidth1x, image.Width());
   EXPECT_EQ(kHeight1x, image.Height());
 }
 
 TEST_F(ImageTest, RemoveFromMultiResolutionImageSkia) {
   const int kWidth2x = 20;
   const int kHeight2x = 24;
 
   gfx::ImageSkia image_skia;
 
   image_skia.AddRepresentation(gfx::ImageSkiaRep(
-      gt::CreateBitmap(kWidth2x, kHeight2x), ui::SCALE_FACTOR_200P));
+      gt::CreateBitmap(kWidth2x, kHeight2x), 2.0f));
   EXPECT_EQ(1u, image_skia.image_reps().size());
 
-  image_skia.RemoveRepresentation(ui::SCALE_FACTOR_100P);
+  image_skia.RemoveRepresentation(1.0f);
   EXPECT_EQ(1u, image_skia.image_reps().size());
 
-  image_skia.RemoveRepresentation(ui::SCALE_FACTOR_200P);
+  image_skia.RemoveRepresentation(2.0f);
   EXPECT_EQ(0u, image_skia.image_reps().size());
 }
 
 // Tests that gfx::Image does indeed take ownership of the SkBitmap it is
 // passed.
 TEST_F(ImageTest, OwnershipTest) {
   gfx::Image image;
   {
     SkBitmap bitmap(gt::CreateBitmap(10, 10));
     EXPECT_TRUE(!bitmap.isNull());
     image = gfx::Image(gfx::ImageSkia(
-        gfx::ImageSkiaRep(bitmap, ui::SCALE_FACTOR_100P)));
+        gfx::ImageSkiaRep(bitmap, 1.0f)));
   }
   EXPECT_TRUE(!image.ToSkBitmap()->isNull());
 }
 
 // Integration tests with UI toolkit frameworks require linking against the
 // Views library and cannot be here (ui_unittests doesn't include it). They
 // instead live in /chrome/browser/ui/tests/ui_gfx_image_unittest.cc.
 
 }  // namespace