Remove dependency on ui::ScaleFactor from ui/gfx

ui/gfx/image/image.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 "ui/gfx/image/image.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 25 matching lines @@
 
 namespace gfx {
 
 namespace internal {
 
 #if defined(TOOLKIT_GTK)
 const ImageSkia ImageSkiaFromGdkPixbuf(GdkPixbuf* pixbuf) {
   CHECK(pixbuf);
   gfx::Canvas canvas(gfx::Size(gdk_pixbuf_get_width(pixbuf),
                                gdk_pixbuf_get_height(pixbuf)),
-                     ui::SCALE_FACTOR_100P,
+                     1.0f,
                      false);
   skia::ScopedPlatformPaint scoped_platform_paint(canvas.sk_canvas());
   cairo_t* cr = scoped_platform_paint.GetPlatformSurface();
   gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
   cairo_paint(cr);
   return ImageSkia(canvas.ExtractImageRep());
 }
 
 // Returns a 16x16 red pixbuf to visually show error in decoding PNG.
 // Also logs error to console.
 GdkPixbuf* GetErrorPixbuf() {
   LOG(ERROR) << "Unable to decode PNG.";
   GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 16, 16);
   gdk_pixbuf_fill(pixbuf, 0xff0000ff);
   return pixbuf;
 }
 
 GdkPixbuf* GdkPixbufFromPNG(
     const std::vector<gfx::ImagePNGRep>& image_png_reps) {
   scoped_refptr<base::RefCountedMemory> png_bytes(NULL);
   for (size_t i = 0; i < image_png_reps.size(); ++i) {
-    if (image_png_reps[i].scale_factor == ui::SCALE_FACTOR_100P)
+    if (image_png_reps[i].scale == 1.0f)
       png_bytes = image_png_reps[i].raw_data;
   }
 
   if (!png_bytes.get())
     return GetErrorPixbuf();
 
   GdkPixbuf* pixbuf = NULL;
   ui::ScopedGObject<GdkPixbufLoader>::Type loader(gdk_pixbuf_loader_new());
 
   bool ok = gdk_pixbuf_loader_write(loader.get(),
@@ skipping 56 matching lines @@
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
     const ImageSkia* skia);
 #else
 // Returns a 16x16 red image to visually show error in decoding PNG.
 // Caller takes ownership of returned ImageSkia.
 ImageSkia* GetErrorImageSkia() {
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16);
   bitmap.allocPixels();
   bitmap.eraseRGB(0xff, 0, 0);
-  return new gfx::ImageSkia(gfx::ImageSkiaRep(bitmap, ui::SCALE_FACTOR_100P));
+  return new gfx::ImageSkia(gfx::ImageSkiaRep(bitmap, 1.0f));
 }
 
 ImageSkia* ImageSkiaFromPNG(
     const std::vector<gfx::ImagePNGRep>& image_png_reps) {
   if (image_png_reps.empty())
     return GetErrorImageSkia();
 
   scoped_ptr<gfx::ImageSkia> image_skia(new ImageSkia());
   for (size_t i = 0; i < image_png_reps.size(); ++i) {
     scoped_refptr<base::RefCountedMemory> raw_data =
         image_png_reps[i].raw_data;
     CHECK(raw_data.get());
     SkBitmap bitmap;
     if (!gfx::PNGCodec::Decode(raw_data->front(), raw_data->size(),
                                &bitmap)) {
       LOG(ERROR) << "Unable to decode PNG for "
-                 << ui::GetScaleFactorScale(image_png_reps[i].scale_factor)
+                 << image_png_reps[i].scale
                  << ".";
       return GetErrorImageSkia();
     }
     image_skia->AddRepresentation(gfx::ImageSkiaRep(
-        bitmap, image_png_reps[i].scale_factor));
+        bitmap, image_png_reps[i].scale));
   }
   return image_skia.release();
 }
 
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
     const ImageSkia* image_skia) {
-  ImageSkiaRep image_skia_rep = image_skia->GetRepresentation(
-      ui::SCALE_FACTOR_100P);
+  ImageSkiaRep image_skia_rep = image_skia->GetRepresentation(1.0f);
 
   scoped_refptr<base::RefCountedBytes> png_bytes(new base::RefCountedBytes());
-  if (image_skia_rep.scale_factor() != ui::SCALE_FACTOR_100P ||
+  if (image_skia_rep.scale() != 1.0f ||
       !gfx::PNGCodec::EncodeBGRASkBitmap(image_skia_rep.sk_bitmap(), false,
           &png_bytes->data())) {
     return NULL;
   }
   return png_bytes;
 }
 #endif
 
 class ImageRepPNG;
 class ImageRepSkia;
@@ skipping 78 matching lines @@
 
   virtual int Height() const OVERRIDE {
     return Size().height();
   }
 
   virtual gfx::Size Size() const OVERRIDE {
     // Read the PNG data to get the image size, caching it.
     if (!size_cache_) {
       for (std::vector<ImagePNGRep>::const_iterator it = image_reps().begin();
            it != image_reps().end(); ++it) {
-        if (it->scale_factor == ui::SCALE_FACTOR_100P) {
+        if (it->scale == 1.0f) {
           size_cache_.reset(new gfx::Size(it->Size()));
           return *size_cache_;
         }
       }
       size_cache_.reset(new gfx::Size);
     }
 
     return *size_cache_;
   }
 
@@ skipping 309 matching lines @@
 
 // static
 Image Image::CreateFrom1xPNGBytes(const unsigned char* input,
                                   size_t input_size) {
   if (input_size == 0u)
     return gfx::Image();
 
   scoped_refptr<base::RefCountedBytes> raw_data(new base::RefCountedBytes());
   raw_data->data().assign(input, input + input_size);
   std::vector<gfx::ImagePNGRep> image_reps;
-  image_reps.push_back(ImagePNGRep(raw_data, ui::SCALE_FACTOR_100P));
+  image_reps.push_back(ImagePNGRep(raw_data, 1.0f));
   return gfx::Image(image_reps);
 }
 
 const SkBitmap* Image::ToSkBitmap() const {
   // Possibly create and cache an intermediate ImageRepSkia.
   return ToImageSkia()->bitmap();
 }
 
 const ImageSkia* Image::ToImageSkia() const {
   internal::ImageRep* rep = GetRepresentation(kImageRepSkia, false);
@@ skipping 147 matching lines @@
 scoped_refptr<base::RefCountedMemory> Image::As1xPNGBytes() const {
   if (IsEmpty())
     return new base::RefCountedBytes();
 
   internal::ImageRep* rep = GetRepresentation(kImageRepPNG, false);
 
   if (rep) {
     const std::vector<gfx::ImagePNGRep>& image_png_reps =
         rep->AsImageRepPNG()->image_reps();
     for (size_t i = 0; i < image_png_reps.size(); ++i) {
-      if (image_png_reps[i].scale_factor == ui::SCALE_FACTOR_100P)
+      if (image_png_reps[i].scale == 1.0f)
         return image_png_reps[i].raw_data;
     }
     return new base::RefCountedBytes();
   }
 
   scoped_refptr<base::RefCountedMemory> png_bytes(NULL);
   switch (DefaultRepresentationType()) {
 #if defined(TOOLKIT_GTK)
     case kImageRepGdk: {
       internal::ImageRepGdk* gdk_rep =
@@ skipping 34 matching lines @@
     return new base::RefCountedBytes();
   }
 
   // Do not insert representations for scale factors other than 1x even if
   // they are available because:
   // - Only the 1x PNG bytes can be accessed.
   // - ImageRepPNG is not used as an intermediate type in converting to a
   //   final type eg (converting from ImageRepSkia to ImageRepPNG to get an
   //   ImageRepCocoa).
   std::vector<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));
   rep = new internal::ImageRepPNG(image_png_reps);
   AddRepresentation(rep);
   return png_bytes;
 }
 
 SkBitmap Image::AsBitmap() const {
   return IsEmpty() ? SkBitmap() : *ToSkBitmap();
 }
 
 ImageSkia Image::AsImageSkia() const {
@@ skipping 106 matching lines @@
   }
   return it->second;
 }
 
 void Image::AddRepresentation(internal::ImageRep* rep) const {
   CHECK(storage_.get());
   storage_->representations().insert(std::make_pair(rep->type(), rep));
 }
 
 }  // namespace gfx