Remove dependency on ui::ScaleFactor from ui/gfx

ui/gfx/image/image_skia.h

 // 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.
 
 #ifndef UI_GFX_IMAGE_IMAGE_SKIA_H_
 #define UI_GFX_IMAGE_IMAGE_SKIA_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 29 matching lines @@
 
   // Creates an instance with no bitmaps.
   ImageSkia();
 
   // Creates an instance that will use the |source| to get the image
   // for scale factors. |size| specifes the size of the image in DIP.
   // ImageSkia owns |source|.
   ImageSkia(ImageSkiaSource* source, const gfx::Size& size);
 
   // Creates an instance that uses the |source|. The constructor loads the image
-  // at |scale_factor| and uses its dimensions to calculate the size in DIP.
-  // ImageSkia owns |source|.
-  ImageSkia(ImageSkiaSource* source, ui::ScaleFactor scale_factor);
+  // at |scale| and uses its dimensions to calculate the size in DIP. ImageSkia
+  // owns |source|.
+  ImageSkia(ImageSkiaSource* source, float scale);
 
   explicit ImageSkia(const gfx::ImageSkiaRep& image_rep);
 
   // Copies a reference to |other|'s storage.
   ImageSkia(const ImageSkia& other);
 
   // Copies a reference to |other|'s storage.
   ImageSkia& operator=(const ImageSkia& other);
 
   ~ImageSkia();
 
+  // Changes the value of GetSupportedScales() to |scales|.
+  static void SetSupportedScales(const std::vector<float>& scales);
+
+  // Returns a vector with the scale factors which are supported by this
+  // platform, in ascending order.
+  static const std::vector<float>& GetSupportedScales();
+
+  // Returns the maximum scale supported by this platform.
+  static float GetMaxSupportedScale();
+
   // Creates an image from the passed in bitmap.
   // DIP width and height are based on scale factor of 1x.
   // Adds ref to passed in bitmap.
   // WARNING: The resulting image will be pixelated when painted on a high
   // density display.
   static ImageSkia CreateFrom1xBitmap(const SkBitmap& bitmap);
 
   // Returns a deep copy of this ImageSkia which has its own storage with
   // the ImageSkiaRep instances that this ImageSkia currently has.
   // This can be safely passed to and manipulated by another thread.
   // Note that this does NOT generate ImageSkiaReps from its source.
   // If you want to create a deep copy with ImageSkiaReps for supported
   // scale factors, you need to explicitly call
-  // |EnsureRepsForSupportedScaleFactors()| first.
+  // |EnsureRepsForSupportedScales()| first.
   scoped_ptr<ImageSkia> DeepCopy() const;
 
   // Returns true if this object is backed by the same ImageSkiaStorage as
   // |other|. Will also return true if both images are isNull().
   bool BackedBySameObjectAs(const gfx::ImageSkia& other) const;
 
   // Adds |image_rep| to the image reps contained by this object.
   void AddRepresentation(const gfx::ImageSkiaRep& image_rep);
 
-  // Removes the image rep of |scale_factor| if present.
-  void RemoveRepresentation(ui::ScaleFactor scale_factor);
+  // Removes the image rep of |scale| if present.
+  void RemoveRepresentation(float scale);
 
   // Returns true if the object owns an image rep whose density matches
-  // |scale_factor| exactly.
-  bool HasRepresentation(ui::ScaleFactor scale_factor) const;
+  // |scale| exactly.
+  bool HasRepresentation(float scale) const;
 
-  // Returns the image rep whose density best matches
-  // |scale_factor|.
+  // Returns the image rep whose density best matches |scale|.
   // Returns a null image rep if the object contains no image reps.
-  const gfx::ImageSkiaRep& GetRepresentation(
-      ui::ScaleFactor scale_factor) const;
+  const gfx::ImageSkiaRep& GetRepresentation(float scale) const;
 
   // Make the ImageSkia instance read-only. Note that this only prevent
   // modification from client code, and the storage may still be
   // modified by the source if any (thus, it's not thread safe).  This
   // detaches the storage from currently accessing thread, so its safe
   // to pass it to other thread as long as it is accessed only by that
   // thread. If this ImageSkia's storage will be accessed by multiple
   // threads, use |MakeThreadSafe()| method.
   void SetReadOnly();
 
@@ skipping 20 matching lines @@
   const SkBitmap* bitmap() const { return &GetBitmap(); }
 
   // Returns a vector with the image reps contained in this object.
   // There is no guarantee that this will return all images rep for
   // supported scale factors.
   std::vector<gfx::ImageSkiaRep> image_reps() const;
 
   // When the source is available, generates all ImageReps for
   // supported scale factors. This method is defined as const as
   // the state change in the storage is agnostic to the caller.
-  void EnsureRepsForSupportedScaleFactors() const;
+  void EnsureRepsForSupportedScales() const;
 
  private:
   friend class test::TestOnThread;
   FRIEND_TEST_ALL_PREFIXES(ImageSkiaTest, EmptyOnThreadTest);
   FRIEND_TEST_ALL_PREFIXES(ImageSkiaTest, StaticOnThreadTest);
   FRIEND_TEST_ALL_PREFIXES(ImageSkiaTest, SourceOnThreadTest);
 
   // Initialize ImageSkiaStorage with passed in parameters.
   // If the image rep's bitmap is empty, ImageStorage is set to NULL.
   void Init(const gfx::ImageSkiaRep& image_rep);
 
   SkBitmap& GetBitmap() const;
 
   // Checks if the current thread can read/modify the ImageSkia.
   bool CanRead() const;
   bool CanModify() const;
 
   // Detach the storage from the currently assinged thread
   // so that other thread can access the storage.
   void DetachStorageFromThread();
 
   // A refptr so that ImageRepSkia can be copied cheaply.
   scoped_refptr<internal::ImageSkiaStorage> storage_;
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_IMAGE_IMAGE_SKIA_H_