remove ui::gfx::GetDeviceScaleFactor

ui/gfx/win/dpi.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/gfx/win/dpi.h"
 
 #include <windows.h>
 #include "base/win/scoped_hdc.h"
 #include "base/win/windows_version.h"
 #include "base/win/registry.h"
@@ skipping 14 matching lines @@
   IsProcessDPIAwarePtr is_process_dpi_aware_func =
       reinterpret_cast<IsProcessDPIAwarePtr>(
           GetProcAddress(GetModuleHandleA("user32.dll"), "IsProcessDPIAware"));
   if (is_process_dpi_aware_func)
     return is_process_dpi_aware_func();
   return FALSE;
 }
 
 float g_device_scale_factor = 0.0f;
 
 float GetUnforcedDeviceScaleFactor() {

[sky, 2014/10/23 16:51:51]

Can you reanme devicescalefactor to dpiscale everywhere? If you want to do in a
separate patch, that's fine by me.

   // If the global device scale factor is initialized use it. This is to ensure
-  // we use the same scale factor across all callsites. We don't use the
-  // GetDeviceScaleFactor function here because it fires a DCHECK if the
-  // g_device_scale_factor global is 0.
+  // we use the same scale factor across all callsites.
   if (g_device_scale_factor)
     return g_device_scale_factor;
   return static_cast<float>(gfx::GetDPI().width()) /
       static_cast<float>(kDefaultDPIX);
 }
 
 // Duplicated from Win8.1 SDK ShellScalingApi.h
 typedef enum PROCESS_DPI_AWARENESS {
     PROCESS_DPI_UNAWARE = 0,
     PROCESS_SYSTEM_DPI_AWARE = 1,
@@ skipping 115 matching lines @@
     SetProcessDPIAwareWrapper();
   }
 }
 
 namespace win {
 
 GFX_EXPORT const wchar_t kRegistryProfilePath[] =
     L"Software\\Google\\Chrome\\Profile";
 GFX_EXPORT const wchar_t kHighDPISupportW[] = L"high-dpi-support";
 
-float GetDeviceScaleFactor() {
-  DCHECK_NE(0.0f, g_device_scale_factor);
-  return g_device_scale_factor;
-}
-
 Point ScreenToDIPPoint(const Point& pixel_point) {
-  return ToFlooredPoint(ScalePoint(pixel_point,
-                                   1.0f / GetDeviceScaleFactor()));
+  return ToFlooredPoint(ScalePoint(pixel_point, 1.0f / GetDPIScale()));
 }
 
 Point DIPToScreenPoint(const Point& dip_point) {
-  return ToFlooredPoint(ScalePoint(dip_point, GetDeviceScaleFactor()));
+  return ToFlooredPoint(ScalePoint(dip_point, GetDPIScale()));
 }
 
 Rect ScreenToDIPRect(const Rect& pixel_bounds) {
   // It's important we scale the origin and size separately. If we instead
   // calculated the size from the floored origin and ceiled right the size could
   // vary depending upon where the two points land. That would cause problems
   // for the places this code is used (in particular mapping from native window
   // bounds to DIPs).
   return Rect(ScreenToDIPPoint(pixel_bounds.origin()),
               ScreenToDIPSize(pixel_bounds.size()));
 }
 
 Rect DIPToScreenRect(const Rect& dip_bounds) {
   // See comment in ScreenToDIPRect for why we calculate size like this.
   return Rect(DIPToScreenPoint(dip_bounds.origin()),
               DIPToScreenSize(dip_bounds.size()));
 }
 
 Size ScreenToDIPSize(const Size& size_in_pixels) {
   // Always ceil sizes. Otherwise we may be leaving off part of the bounds.
-  return ToCeiledSize(
-      ScaleSize(size_in_pixels, 1.0f / GetDeviceScaleFactor()));
+  return ToCeiledSize(ScaleSize(size_in_pixels, 1.0f / GetDPIScale()));
 }
 
 Size DIPToScreenSize(const Size& dip_size) {
   // Always ceil sizes. Otherwise we may be leaving off part of the bounds.
-  return ToCeiledSize(ScaleSize(dip_size, GetDeviceScaleFactor()));
+  return ToCeiledSize(ScaleSize(dip_size, GetDPIScale()));
 }
 
 int GetSystemMetricsInDIP(int metric) {
-  return static_cast<int>(GetSystemMetrics(metric) /
-      GetDeviceScaleFactor() + 0.5);
+  return static_cast<int>(GetSystemMetrics(metric) / GetDPIScale() + 0.5);
 }
 
 bool IsDeviceScaleFactorSet() {
   return g_device_scale_factor != 0.0f;
 }
 
 }  // namespace win
 }  // namespace gfx