Remove dependency on ui::ScaleFactor from ui/gfx

chrome/browser/extensions/extension_icon_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 "chrome/browser/extensions/extension_icon_image.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 68 matching lines @@
 
 class IconImage::Source : public gfx::ImageSkiaSource {
  public:
   Source(IconImage* host, const gfx::Size& size_in_dip);
   virtual ~Source();
 
   void ResetHost();
 
  private:
   // gfx::ImageSkiaSource overrides:
-  virtual gfx::ImageSkiaRep GetImageForScale(
-      ui::ScaleFactor scale_factor) OVERRIDE;
+  virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE;
 
   // Used to load images, possibly asynchronously. NULLed out when the IconImage
   // is destroyed.
   IconImage* host_;
 
   // Image whose representations will be used until |host_| loads the real
   // representations for the image.
   gfx::ImageSkia blank_image_;
 
   DISALLOW_COPY_AND_ASSIGN(Source);
 };
 
 IconImage::Source::Source(IconImage* host, const gfx::Size& size_in_dip)
     : host_(host),
       blank_image_(new BlankImageSource(size_in_dip), size_in_dip) {
 }
 
 IconImage::Source::~Source() {
 }
 
 void IconImage::Source::ResetHost() {
   host_ = NULL;
 }
 
-gfx::ImageSkiaRep IconImage::Source::GetImageForScale(
-    ui::ScaleFactor scale_factor) {
+gfx::ImageSkiaRep IconImage::Source::GetImageForScale(float scale) {
   gfx::ImageSkiaRep representation;
-  if (host_)
-    representation = host_->LoadImageForScaleFactor(scale_factor);
+  if (host_) {
+    representation =
+        host_->LoadImageForScaleFactor(ui::GetSupportedScaleFactor(scale));
+  }
 
   if (!representation.is_null())
     return representation;
 
-  return blank_image_.GetRepresentation(scale_factor);
+  return blank_image_.GetRepresentation(scale);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // IconImage
 
 IconImage::IconImage(
     Profile* profile,
     const Extension* extension,
     const ExtensionIconSet& icon_set,
     int resource_size_in_dip,
@@ skipping 21 matching lines @@
 IconImage::~IconImage() {
   source_->ResetHost();
 }
 
 gfx::ImageSkiaRep IconImage::LoadImageForScaleFactor(
     ui::ScaleFactor scale_factor) {
   // Do nothing if extension is unloaded.
   if (!extension_)
     return gfx::ImageSkiaRep();
 
-  const float scale = ui::GetScaleFactorScale(scale_factor);
+  const float scale = ui::GetImageScale(scale_factor);
   const int resource_size_in_pixel =
       static_cast<int>(resource_size_in_dip_ * scale);
 
   extensions::ExtensionResource resource;
 
   // Find extension resource for non bundled component extensions.
   // We try loading bigger image only if resource size is >= 32.
   if (resource_size_in_pixel >= kMatchBiggerTreshold) {
     resource = GetExtensionIconResource(extension_, icon_set_,
         resource_size_in_pixel, ExtensionIconSet::MATCH_BIGGER);
   }
 
   // If resource is not found by now, try matching smaller one.
   if (resource.empty()) {
     resource = GetExtensionIconResource(extension_, icon_set_,
         resource_size_in_pixel, ExtensionIconSet::MATCH_SMALLER);
   }
 
   // If there is no resource found, return default icon.
   if (resource.empty())
-    return default_icon_.GetRepresentation(scale_factor);
+    return default_icon_.GetRepresentation(scale);
 
   std::vector<ImageLoader::ImageRepresentation> info_list;
   info_list.push_back(ImageLoader::ImageRepresentation(
       resource,
       ImageLoader::ImageRepresentation::ALWAYS_RESIZE,
       gfx::ToFlooredSize(gfx::ScaleSize(
           gfx::Size(resource_size_in_dip_, resource_size_in_dip_), scale)),
       scale_factor));
 
   extensions::ImageLoader* loader = extensions::ImageLoader::Get(profile_);
   loader->LoadImagesAsync(extension_, info_list,
                           base::Bind(&IconImage::OnImageLoaded,
                                      weak_ptr_factory_.GetWeakPtr(),
-                                     scale_factor));
+                                     scale));
 
   return gfx::ImageSkiaRep();
 }
 
-void IconImage::OnImageLoaded(ui::ScaleFactor scale_factor,
-                              const gfx::Image& image_in) {
+void IconImage::OnImageLoaded(float scale, const gfx::Image& image_in) {
   const gfx::ImageSkia* image =
       image_in.IsEmpty() ? &default_icon_ : image_in.ToImageSkia();
 
   // Maybe default icon was not set.
   if (image->isNull())
     return;
 
-  gfx::ImageSkiaRep rep = image->GetRepresentation(scale_factor);
+  gfx::ImageSkiaRep rep = image->GetRepresentation(scale);
   DCHECK(!rep.is_null());
-  DCHECK_EQ(scale_factor, rep.scale_factor());
+  DCHECK_EQ(scale, rep.scale());
 
   // Remove old representation if there is one.
-  image_skia_.RemoveRepresentation(rep.scale_factor());
+  image_skia_.RemoveRepresentation(scale);
   image_skia_.AddRepresentation(rep);
 
   if (observer_)
     observer_->OnExtensionIconImageChanged(this);
 }
 
 void IconImage::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_EXTENSION_UNLOADED);
 
   const Extension* extension =
       content::Details<extensions::UnloadedExtensionInfo>(details)->extension;
 
   if (extension_ == extension)
     extension_ = NULL;
 }
 
 }  // namespace extensions