Remove dependency on ui::ScaleFactor from ui/gfx

chrome/browser/themes/browser_theme_pack.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/themes/browser_theme_pack.h"
 
 #include <limits>
 
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 459 matching lines @@
 }
 
 // A ImageSkiaSource that scales 100P image to the target scale factor
 // if the ImageSkiaRep for the target scale factor isn't available.
 class ThemeImageSource: public gfx::ImageSkiaSource {
  public:
   explicit ThemeImageSource(const gfx::ImageSkia& source) : source_(source) {
   }
   virtual ~ThemeImageSource() {}
 
-  virtual gfx::ImageSkiaRep GetImageForScale(
-      ui::ScaleFactor scale_factor) OVERRIDE {
-    if (source_.HasRepresentation(scale_factor))
-      return source_.GetRepresentation(scale_factor);
+  virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
+    if (source_.HasRepresentation(scale))
+      return source_.GetRepresentation(scale);
     const gfx::ImageSkiaRep& rep_100p =
-        source_.GetRepresentation(ui::SCALE_FACTOR_100P);
+        source_.GetRepresentation(1.0f);
     SkBitmap scaled_bitmap = CreateLowQualityResizedBitmap(
         rep_100p.sk_bitmap(),
         ui::SCALE_FACTOR_100P,
-        scale_factor);
-    return gfx::ImageSkiaRep(scaled_bitmap, scale_factor);
+        ui::GetScaleFactorFromScale(scale));
+    return gfx::ImageSkiaRep(scaled_bitmap, scale);
   }
 
  private:
   const gfx::ImageSkia source_;
 
   DISALLOW_COPY_AND_ASSIGN(ThemeImageSource);
 };
 
 // An ImageSkiaSource that delays decoding PNG data into bitmaps until
 // needed. Missing data for a scale factor is computed by scaling data for an
 // available scale factor. Computed bitmaps are stored for future look up.
 class ThemeImagePngSource : public gfx::ImageSkiaSource {
  public:
   typedef std::map<ui::ScaleFactor,
                    scoped_refptr<base::RefCountedMemory> > PngMap;
 
   explicit ThemeImagePngSource(const PngMap& png_map) : png_map_(png_map) {}
 
   virtual ~ThemeImagePngSource() {}
 
  private:
-  virtual gfx::ImageSkiaRep GetImageForScale(
-      ui::ScaleFactor scale_factor) OVERRIDE {
+  virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
+    ui::ScaleFactor scale_factor = ui::GetScaleFactorFromScale(scale);
     // Look up the bitmap for |scale factor| in the bitmap map. If found
     // return it.
     BitmapMap::const_iterator exact_bitmap_it = bitmap_map_.find(scale_factor);
     if (exact_bitmap_it != bitmap_map_.end())
-      return gfx::ImageSkiaRep(exact_bitmap_it->second, scale_factor);
+      return gfx::ImageSkiaRep(exact_bitmap_it->second, scale);
 
     // Look up the raw PNG data for |scale_factor| in the png map. If found,
     // decode it, store the result in the bitmap map and return it.
     PngMap::const_iterator exact_png_it = png_map_.find(scale_factor);
     if (exact_png_it != png_map_.end()) {
       SkBitmap bitmap;
       if (!gfx::PNGCodec::Decode(exact_png_it->second->front(),
                                  exact_png_it->second->size(),
                                  &bitmap)) {
         NOTREACHED();
         return gfx::ImageSkiaRep();
       }
       bitmap_map_[scale_factor] = bitmap;
-      return gfx::ImageSkiaRep(bitmap, scale_factor);
+      return gfx::ImageSkiaRep(bitmap, scale);
     }
 
     // Find an available PNG for another scale factor. We want to use the
     // highest available scale factor.
     PngMap::const_iterator available_png_it = png_map_.end();
     for (PngMap::const_iterator png_it = png_map_.begin();
          png_it != png_map_.end(); ++png_it) {
       if (available_png_it == png_map_.end() ||
           ui::GetScaleFactorScale(png_it->first) >
           ui::GetScaleFactorScale(available_png_it->first)) {
@@ skipping 21 matching lines @@
       available_bitmap_it = bitmap_map_.find(available_scale_factor);
     }
 
     // Scale the available bitmap to the desired scale factor, store the result
     // in the bitmap map and return it.
     SkBitmap scaled_bitmap = CreateLowQualityResizedBitmap(
         available_bitmap_it->second,
         available_scale_factor,
         scale_factor);
     bitmap_map_[scale_factor] = scaled_bitmap;
-    return gfx::ImageSkiaRep(scaled_bitmap, scale_factor);
+    return gfx::ImageSkiaRep(scaled_bitmap, scale);
   }
 
   PngMap png_map_;
 
   typedef std::map<ui::ScaleFactor, SkBitmap> BitmapMap;
   BitmapMap bitmap_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ThemeImagePngSource);
 };
 
@@ skipping 693 matching lines @@
           return false;
         }
         if (is_copyable) {
           int raw_id = GetRawIDByPersistentID(prs_id, scale_factor);
           image_memory_[raw_id] = raw_data;
         } else {
           SkBitmap bitmap;
           if (gfx::PNGCodec::Decode(raw_data->front(), raw_data->size(),
                                     &bitmap)) {
             image_skia.AddRepresentation(
-                gfx::ImageSkiaRep(bitmap, scale_factor));
+                gfx::ImageSkiaRep(bitmap,
+                                  ui::GetScaleFactorScale(scale_factor)));
           } else {
             NOTREACHED() << "Unable to decode theme image resource "
                          << it->first;
           }
         }
       }
     }
     if (!is_copyable && !image_skia.isNull())
       (*image_cache)[prs_id] = gfx::Image(image_skia);
   }
@@ skipping 167 matching lines @@
       NOTREACHED() << "No image reps for resource " << it->first << ".";
     }
     for (ImageSkiaReps::iterator rep_it = image_reps.begin();
          rep_it != image_reps.end(); ++rep_it) {
       std::vector<unsigned char> bitmap_data;
       if (!gfx::PNGCodec::EncodeBGRASkBitmap(rep_it->sk_bitmap(), false,
                                              &bitmap_data)) {
         NOTREACHED() << "Image file for resource " << it->first
                      << " could not be encoded.";
       }
-      int raw_id = GetRawIDByPersistentID(it->first, rep_it->scale_factor());
+      int raw_id = GetRawIDByPersistentID(
+          it->first,
+          ui::GetScaleFactorFromScale(rep_it->scale()));
       (*reencoded_images)[raw_id] =
           base::RefCountedBytes::TakeVector(&bitmap_data);
     }
   }
 }
 
 void BrowserThemePack::MergeImageCaches(
     const ImageCache& source, ImageCache* destination) const {
   for (ImageCache::const_iterator it = source.begin(); it != source.end();
        ++it) {
@@ skipping 119 matching lines @@
                                            false,
                                            &bitmap_data)) {
       NOTREACHED() << "Unable to encode theme image for prs_id="
                    << prs_id << " for scale_factor=" << scale_factors_[i];
       break;
     }
     image_memory_[scaled_raw_id] =
         base::RefCountedBytes::TakeVector(&bitmap_data);
   }
 }