Enable hidpi on Linux, refactor a bit on Windows to share

ui/gfx/dpi.cc

Index: ui/gfx/dpi.cc
diff --git a/ui/gfx/dpi.cc b/ui/gfx/dpi.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fc5f72502815138b4c17b2b566e03b438c78d7dc
--- /dev/null
+++ b/ui/gfx/dpi.cc
@@ -0,0 +1,110 @@
+// 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/dpi.h"
+
+#include <algorithm>
+
+#include "base/logging.h"
+#include "ui/gfx/display.h"
+#include "ui/gfx/point_conversions.h"
+#include "ui/gfx/rect_conversions.h"
+#include "ui/gfx/size_conversions.h"
+
+namespace {
+
+int kDefaultDPI = 96;
+
+float g_device_scale_factor = 0.0f;
+
+float GetUnforcedDeviceScaleFactor() {
+  // 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.
+  if (g_device_scale_factor)
+    return g_device_scale_factor;
+  return static_cast<float>(gfx::GetDPI().width()) /
+         static_cast<float>(kDefaultDPI);
+}
+
+}  // namespace
+
+
+namespace gfx {
+
+void InitDeviceScaleFactor(float scale) {
+  DCHECK_NE(0.0f, scale);
+  g_device_scale_factor = std::max(1.f, scale);
+}
+
+float GetDeviceScaleFactor() {
+  DCHECK_NE(0.0f, g_device_scale_factor);
+  return g_device_scale_factor;
+}
+
+bool IsDeviceScaleFactorSet() {
+  return g_device_scale_factor != 0.0f;
+}
+
+void ForceHighDPISupportForTesting(float scale) {
+  g_device_scale_factor = scale;
+}
+
+bool IsInHighDPIMode() {
+  return GetDPIScale() > 1.0;
+}
+
+float GetDPIScale() {
+  if (IsHighDPIEnabled()) {
+    if (gfx::Display::HasForceDeviceScaleFactor())
+      return gfx::Display::GetForcedDeviceScaleFactor();
+    float dpi_scale = GetUnforcedDeviceScaleFactor();
+    if (dpi_scale <= 1.25) {
+      // Force 125% and below to 100% scale. We do this to maintain previous
+      // (non-DPI-aware) behavior where only the font size was boosted.
+      dpi_scale = 1.0;
+    }
+    return dpi_scale;
+  }
+  return 1.0;
+}
+
+Point ScreenToDIPPoint(const Point& pixel_point) {
+  return ToFlooredPoint(ScalePoint(pixel_point,
+                                   1.0f / GetDeviceScaleFactor()));
+}
+
+Point DIPToScreenPoint(const Point& dip_point) {
+  return ToFlooredPoint(ScalePoint(dip_point, GetDeviceScaleFactor()));
+}
+
+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()));
+}
+
+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()));
+}
+
+}  // namespace gfx