Fixes for getting themes to work well with Windows High DPI.

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/files/file.h"
 #include "base/memory/ref_counted_memory.h"
@@ skipping 226 matching lines @@
 // The order must match as the index is used in determining the raw id.
 bool InputScalesValid(const base::StringPiece& input,
                       const std::vector<ui::ScaleFactor>& expected) {
   size_t scales_size = static_cast<size_t>(input.size() / sizeof(float));
   if (scales_size != expected.size())
     return false;
   scoped_ptr<float[]> scales(new float[scales_size]);
   // Do a memcpy to avoid misaligned memory access.
   memcpy(scales.get(), input.data(), input.size());
   for (size_t index = 0; index < scales_size; ++index) {
-    if (scales[index] != ui::GetImageScale(expected[index]))
+    if (scales[index] != ui::GetScaleForScaleFactor(expected[index]))
       return false;
   }
   return true;
 }
 
 // Returns |scale_factors| as a string to be written to disk.
 std::string GetScaleFactorsAsString(
     const std::vector<ui::ScaleFactor>& scale_factors) {
   scoped_ptr<float[]> scales(new float[scale_factors.size()]);
   for (size_t i = 0; i < scale_factors.size(); ++i)
-    scales[i] = ui::GetImageScale(scale_factors[i]);
+    scales[i] = ui::GetScaleForScaleFactor(scale_factors[i]);
   std::string out_string = std::string(
       reinterpret_cast<const char*>(scales.get()),
       scale_factors.size() * sizeof(float));
   return out_string;
 }
 
 struct StringToIntTable {
   const char* key;
   ThemeProperties::OverwritableByUserThemeProperty id;
 };
@@ skipping 174 matching lines @@
       *src_image, hsl_shift));
 }
 
 // Computes a bitmap at one scale from a bitmap at a different scale.
 SkBitmap CreateLowQualityResizedBitmap(const SkBitmap& source_bitmap,
                                        ui::ScaleFactor source_scale_factor,
                                        ui::ScaleFactor desired_scale_factor) {
   gfx::Size scaled_size = gfx::ToCeiledSize(
       gfx::ScaleSize(gfx::Size(source_bitmap.width(),
                                source_bitmap.height()),
-                     ui::GetImageScale(desired_scale_factor) /
-                     ui::GetImageScale(source_scale_factor)));
+                     ui::GetScaleForScaleFactor(desired_scale_factor) /
+                     ui::GetScaleForScaleFactor(source_scale_factor)));
   SkBitmap scaled_bitmap;
   scaled_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                           scaled_size.width(),
                           scaled_size.height());
   if (!scaled_bitmap.allocPixels())
     SK_CRASH();
   scaled_bitmap.eraseARGB(0, 0, 0, 0);
   SkCanvas canvas(scaled_bitmap);
   SkRect scaled_bounds = RectToSkRect(gfx::Rect(scaled_size));
   // Note(oshima): The following scaling code doesn't work with
@@ skipping 62 matching lines @@
       bitmap_map_[scale_factor] = bitmap;
       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::GetImageScale(png_it->first) >
-          ui::GetImageScale(available_png_it->first)) {
+          ui::GetScaleForScaleFactor(png_it->first) >
+          ui::GetScaleForScaleFactor(available_png_it->first)) {
         available_png_it = png_it;
       }
     }
     if (available_png_it == png_map_.end())
       return gfx::ImageSkiaRep();
     ui::ScaleFactor available_scale_factor = available_png_it->first;
 
     // Look up the bitmap for |available_scale_factor| in the bitmap map.
     // If not found, decode the corresponging png data, store the result
     // in the bitmap map.
@@ skipping 199 matching lines @@
     return NULL;
   pack->source_images_ = reinterpret_cast<int*>(
       const_cast<char*>(pointer.data()));
 
   if (!pack->data_pack_->GetStringPiece(kScaleFactorsID, &pointer))
     return NULL;
 
   if (!InputScalesValid(pointer, pack->scale_factors_)) {
     DLOG(ERROR) << "BuildFromDataPack failure! The pack scale factors differ "
                 << "from those supported by platform.";
+    return NULL;
   }
   return pack;
 }
 
 // static
 void BrowserThemePack::GetThemeableImageIDRs(std::set<int>* result) {
   if (!result)
     return;
 
   result->clear();
@@ skipping 150 matching lines @@
 // private:
 
 BrowserThemePack::BrowserThemePack()
     : CustomThemeSupplier(EXTENSION),
       header_(NULL),
       tints_(NULL),
       colors_(NULL),
       display_properties_(NULL),
       source_images_(NULL) {
   scale_factors_ = ui::GetSupportedScaleFactors();
+  // On Windows with high DPI SCALE_FACTOR_100P may not be supported by
+  // default.
+  // Add it to the supported scale factors list as themes needs it.
+  if (!ui::IsScaleFactorSupported(ui::SCALE_FACTOR_100P))
+    scale_factors_.push_back(ui::SCALE_FACTOR_100P);
 }
 
 void BrowserThemePack::BuildHeader(const Extension* extension) {
   header_ = new BrowserThemePackHeader;
   header_->version = kThemePackVersion;
 
   // TODO(erg): Need to make this endian safe on other computers. Prerequisite
   // is that ui::DataPack removes this same check.
 #if defined(__BYTE_ORDER)
   // Linux check
@@ skipping 336 matching lines @@
         }
         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,
-                                  ui::GetImageScale(scale_factor)));
+                                  ui::GetScaleForScaleFactor(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 228 matching lines @@
   return -1;
 }
 
 bool BrowserThemePack::GetScaleFactorFromManifestKey(
     const std::string& key,
     ui::ScaleFactor* scale_factor) const {
   int percent = 0;
   if (base::StringToInt(key, &percent)) {
     float scale = static_cast<float>(percent) / 100.0f;
     for (size_t i = 0; i < scale_factors_.size(); ++i) {
-      if (fabs(ui::GetImageScale(scale_factors_[i]) - scale) < 0.001) {
+      if (fabs(ui::GetScaleForScaleFactor(scale_factors_[i]) - scale)
+              < 0.001) {
         *scale_factor = scale_factors_[i];
         return true;
       }
     }
   }
   return false;
 }
 
 void BrowserThemePack::GenerateRawImageForAllSupportedScales(int prs_id) {
   // Compute (by scaling) bitmaps for |prs_id| for any scale factors
@@ skipping 16 matching lines @@
     }
   }
   if (!image_missing)
     return;
 
   // Find available scale factor with highest scale.
   ui::ScaleFactor available_scale_factor = ui::SCALE_FACTOR_NONE;
   for (size_t i = 0; i < scale_factors_.size(); ++i) {
     int raw_id = GetRawIDByPersistentID(prs_id, scale_factors_[i]);
     if ((available_scale_factor == ui::SCALE_FACTOR_NONE ||
-         (ui::GetImageScale(scale_factors_[i]) >
-          ui::GetImageScale(available_scale_factor))) &&
+         (ui::GetScaleForScaleFactor(scale_factors_[i]) >
+          ui::GetScaleForScaleFactor(available_scale_factor))) &&
         image_memory_.find(raw_id) != image_memory_.end()) {
       available_scale_factor = scale_factors_[i];
     }
   }
   // If no scale factor is available, we're done.
   if (available_scale_factor == ui::SCALE_FACTOR_NONE)
     return;
 
   // Get bitmap for the available scale factor.
   int available_raw_id = GetRawIDByPersistentID(prs_id, available_scale_factor);
@@ skipping 21 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);
   }
 }