Remove dependency on ui::ScaleFactor from ui/gfx

ui/base/resource/resource_bundle.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/base/resource/resource_bundle.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 22 matching lines @@
 #include "ui/gfx/safe_integer_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skbitmap_operations.h"
 
 #if defined(OS_CHROMEOS)
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/platform_font_pango.h"
 #endif
 
+#if defined(OS_WIN)
+#include "ui/gfx/win/dpi.h"
+#endif
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+#include "base/mac/mac_util.h"
+#endif
+
 namespace ui {
 
 namespace {
 
 // Font sizes relative to base font.
 const int kSmallFontSizeDelta = -1;
 const int kMediumFontSizeDelta = 3;
 const int kLargeFontSizeDelta = 8;
 
 // PNG-related constants.
@@ skipping 20 matching lines @@
 // scaled image is not exactly |scale_factor| * the size of the 1x resource.
 // When --highlight-missing-scaled-resources flag is specified, scaled 1x images
 // are higlighted by blending them with red.
 class ResourceBundle::ResourceBundleImageSource : public gfx::ImageSkiaSource {
  public:
   ResourceBundleImageSource(ResourceBundle* rb, int resource_id)
       : rb_(rb), resource_id_(resource_id) {}
   virtual ~ResourceBundleImageSource() {}
 
   // gfx::ImageSkiaSource overrides:
-  virtual gfx::ImageSkiaRep GetImageForScale(
-      ui::ScaleFactor scale_factor) OVERRIDE {
+  virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
     SkBitmap image;
     bool fell_back_to_1x = false;
+    ScaleFactor scale_factor = GetSupportedScaleFactor(scale);
     bool found = rb_->LoadBitmap(resource_id_, &scale_factor,
                                  &image, &fell_back_to_1x);
+    // Force to a supported scale.
+    scale = ui::GetImageScale(scale_factor);
     if (!found)
       return gfx::ImageSkiaRep();
 
     if (fell_back_to_1x) {
       // GRIT fell back to the 100% image, so rescale it to the correct size.
-      float scale = GetScaleFactorScale(scale_factor);
       image = skia::ImageOperations::Resize(
           image,
           skia::ImageOperations::RESIZE_LANCZOS3,
           gfx::ToCeiledInt(image.width() * scale),
           gfx::ToCeiledInt(image.height() * scale));
       // If --highlight-missing-scaled-resources is specified, log the resource
       // id and blend the created resource with red.
       if (ShouldHighlightMissingScaledResources()) {
         LOG(ERROR) << "Missing " << scale << "x scaled resource. id="
                    << resource_id_;
 
         SkBitmap mask;
         mask.setConfig(SkBitmap::kARGB_8888_Config,
                        image.width(), image.height());
         mask.allocPixels();
         mask.eraseColor(SK_ColorRED);
         image = SkBitmapOperations::CreateBlendedBitmap(image, mask, 0.2);
       }
     }
 
-    return gfx::ImageSkiaRep(image, scale_factor);
+    return gfx::ImageSkiaRep(image, scale);
   }
 
  private:
   ResourceBundle* rb_;
   const int resource_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceBundleImageSource);
 };
 
 // static
 std::string ResourceBundle::InitSharedInstanceWithLocale(
     const std::string& pref_locale, Delegate* delegate) {
-  DCHECK(g_shared_instance_ == NULL) << "ResourceBundle initialized twice";
-  g_shared_instance_ = new ResourceBundle(delegate);
-
+  InitSharedInstance(delegate);
   g_shared_instance_->LoadCommonResources();
   std::string result = g_shared_instance_->LoadLocaleResources(pref_locale);
   InitDefaultFont();
   return result;
 }
 
 // static
 std::string ResourceBundle::InitSharedInstanceLocaleOnly(
     const std::string& pref_locale, Delegate* delegate) {
-  DCHECK(g_shared_instance_ == NULL) << "ResourceBundle initialized twice";
-  g_shared_instance_ = new ResourceBundle(delegate);
-
+  InitSharedInstance(delegate);
   std::string result = g_shared_instance_->LoadLocaleResources(pref_locale);
   InitDefaultFont();
   return result;
 }
 
 // static
 void ResourceBundle::InitSharedInstanceWithPakFile(
     base::PlatformFile pak_file, bool should_load_common_resources) {
-  DCHECK(g_shared_instance_ == NULL) << "ResourceBundle initialized twice";
-  g_shared_instance_ = new ResourceBundle(NULL);
-
+  InitSharedInstance(NULL);
   if (should_load_common_resources)
     g_shared_instance_->LoadCommonResources();
 
   scoped_ptr<DataPack> data_pack(
       new DataPack(SCALE_FACTOR_100P));
   if (!data_pack->LoadFromFile(pak_file)) {
     NOTREACHED() << "failed to load pak file";
     return;
   }
   g_shared_instance_->locale_resources_data_.reset(data_pack.release());
   InitDefaultFont();
 }
 
 // static
 void ResourceBundle::InitSharedInstanceWithPakPath(const base::FilePath& path) {
-  DCHECK(g_shared_instance_ == NULL) << "ResourceBundle initialized twice";
-  g_shared_instance_ = new ResourceBundle(NULL);
-
+  InitSharedInstance(NULL);
   g_shared_instance_->LoadTestResources(path, path);
 
   InitDefaultFont();
 }
 
 // static
 void ResourceBundle::CleanupSharedInstance() {
   if (g_shared_instance_) {
     delete g_shared_instance_;
     g_shared_instance_ = NULL;
@@ skipping 152 matching lines @@
   }
 
   gfx::Image image;
   if (delegate_)
     image = delegate_->GetImageNamed(resource_id);
 
   if (image.IsEmpty()) {
     DCHECK(!data_packs_.empty()) <<
         "Missing call to SetResourcesDataDLL?";
 
+#if defined(OS_CHROMEOS)
+    ui::ScaleFactor scale_factor_to_load = GetMaxScaleFactor();
+#else
+    ui::ScaleFactor scale_factor_to_load = ui::SCALE_FACTOR_100P;
+#endif
+
+    float scale = GetImageScale(scale_factor_to_load);
     // TODO(oshima): Consider reading the image size from png IHDR chunk and
     // skip decoding here and remove #ifdef below.
     // ResourceBundle::GetSharedInstance() is destroyed after the
     // BrowserMainLoop has finished running. |image_skia| is guaranteed to be
     // destroyed before the resource bundle is destroyed.
-#if defined(OS_CHROMEOS)
-    ui::ScaleFactor scale_factor_to_load = ui::GetMaxScaleFactor();
-#else
-    ui::ScaleFactor scale_factor_to_load = ui::SCALE_FACTOR_100P;
-#endif
     gfx::ImageSkia image_skia(new ResourceBundleImageSource(this, resource_id),
-                              scale_factor_to_load);
+                              scale);
     if (image_skia.isNull()) {
       LOG(WARNING) << "Unable to load image with id " << resource_id;
       NOTREACHED();  // Want to assert in debug mode.
       // The load failed to retrieve the image; show a debugging red square.
       return GetEmptyImage();
     }
     image_skia.SetReadOnly();
     image = gfx::Image(image_skia);
   }
 
@@ skipping 137 matching lines @@
 const gfx::Font& ResourceBundle::GetFont(FontStyle style) {
   return GetFontList(style).GetPrimaryFont();
 }
 
 void ResourceBundle::ReloadFonts() {
   base::AutoLock lock_scope(*images_and_fonts_lock_);
   base_font_list_.reset();
   LoadFontsIfNecessary();
 }
 
+ScaleFactor ResourceBundle::GetMaxScaleFactor() const {
+#if defined(OS_CHROMEOS)
+  return max_scale_factor_;
+#else
+  return GetSupportedScaleFactors().back();
+#endif
+}
+
 ResourceBundle::ResourceBundle(Delegate* delegate)
     : delegate_(delegate),
       images_and_fonts_lock_(new base::Lock),
       locale_resources_data_lock_(new base::Lock),
       max_scale_factor_(SCALE_FACTOR_100P) {
 }
 
 ResourceBundle::~ResourceBundle() {
   FreeImages();
   UnloadLocaleResources();
 }
 
+// static
+void ResourceBundle::InitSharedInstance(Delegate* delegate) {
+  DCHECK(g_shared_instance_ == NULL) << "ResourceBundle initialized twice";
+  g_shared_instance_ = new ResourceBundle(delegate);
+  static std::vector<ScaleFactor> supported_scale_factors;
+#if !defined(OS_IOS)
+  // On platforms other than iOS, 100P is always a supported scale factor.
+  supported_scale_factors.push_back(SCALE_FACTOR_100P);
+#endif
+
+#if defined(OS_ANDROID)
+  const gfx::Display display =
+      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
+  const float display_density = display.device_scale_factor();
+  const ScaleFactor closest = FindClosestScaleFactorUnsafe(display_density);
+  if (closest != SCALE_FACTOR_100P)
+    supported_scale_factors.push_back(closest);
+#elif defined(OS_IOS)
+    gfx::Display display = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
+  if (display.device_scale_factor() > 1.0) {
+    DCHECK_EQ(2.0, display.device_scale_factor());
+    supported_scale_factors.push_back(SCALE_FACTOR_200P);
+  } else {
+    supported_scale_factors.push_back(SCALE_FACTOR_100P);
+  }
+#elif defined(OS_MACOSX)
+  if (base::mac::IsOSLionOrLater())
+    supported_scale_factors.push_back(SCALE_FACTOR_200P);
+#elif defined(OS_WIN)
+  // Have high-DPI resources for 140% and 180% scaling on Windows based on
+  // default scaling for Metro mode.  Round to nearest supported scale in
+  // all cases.
+  if (gfx::IsInHighDPIMode()) {
+    supported_scale_factors.push_back(SCALE_FACTOR_140P);
+    supported_scale_factors.push_back(SCALE_FACTOR_180P);
+  }
+#elif defined(OS_CHROMEOS)
+  // TODO(oshima): Include 200P only if the device support 200P
+  supported_scale_factors.push_back(SCALE_FACTOR_200P);
+#endif
+  ui::SetSupportedScaleFactors(supported_scale_factors);
+}
+
 void ResourceBundle::FreeImages() {
   images_.clear();
 }
 
 void ResourceBundle::AddDataPackFromPathInternal(const base::FilePath& path,
                                                  ScaleFactor scale_factor,
                                                  bool optional) {
   // Do not pass an empty |path| value to this method. If the absolute path is
   // unknown pass just the pack file name.
   DCHECK(!path.empty());
@@ skipping 12 matching lines @@
     AddDataPack(data_pack.release());
   } else if (!optional) {
     LOG(ERROR) << "Failed to load " << pack_path.value()
                << "\nSome features may not be available.";
   }
 }
 
 void ResourceBundle::AddDataPack(DataPack* data_pack) {
   data_packs_.push_back(data_pack);
 
-  if (GetScaleFactorScale(data_pack->GetScaleFactor()) >
-      GetScaleFactorScale(max_scale_factor_))
+  if (GetImageScale(data_pack->GetScaleFactor()) >
+      GetImageScale(max_scale_factor_))
     max_scale_factor_ = data_pack->GetScaleFactor();
 }
 
 void ResourceBundle::LoadFontsIfNecessary() {
   images_and_fonts_lock_->AssertAcquired();
   if (!base_font_list_.get()) {
     if (delegate_) {
       base_font_list_ = GetFontListFromDelegate(BaseFont);
       bold_font_list_ = GetFontListFromDelegate(BoldFont);
       small_font_list_ = GetFontListFromDelegate(SmallFont);
@@ skipping 175 matching lines @@
 // static
 bool ResourceBundle::DecodePNG(const unsigned char* buf,
                                size_t size,
                                SkBitmap* bitmap,
                                bool* fell_back_to_1x) {
   *fell_back_to_1x = PNGContainsFallbackMarker(buf, size);
   return gfx::PNGCodec::Decode(buf, size, bitmap);
 }
 
 }  // namespace ui