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

ui/views/widget/desktop_aura/desktop_window_tree_host_x11.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/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 13 matching lines @@
 #include "ui/base/dragdrop/os_exchange_data_provider_aurax11.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/events/x/device_data_manager_x11.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/display.h"
+#include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/path_x11.h"
+#include "ui/gfx/point.h"
 #include "ui/gfx/screen.h"
+#include "ui/gfx/size.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/corewm/tooltip_aura.h"
 #include "ui/views/ime/input_method.h"
 #include "ui/views/linux_ui/linux_ui.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/views_switches.h"
 #include "ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_observer_x11.h"
@@ skipping 66 matching lines @@
   "XdndPosition",
   "XdndProxy",  // Proxy windows?
   "XdndSelection",
   "XdndStatus",
   "XdndTypeList",
   NULL
 };
 
 }  // namespace
 
+float GetDeviceScaleFactor() {
+  gfx::Display display = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
+  return display.device_scale_factor();
+}
+
+gfx::Point ScreenToDIPPoint(const gfx::Point& pixel_point) {
+  return ToFlooredPoint(ScalePoint(pixel_point, 1.0f / GetDeviceScaleFactor()));
+}
+
+gfx::Point DIPToScreenPoint(const gfx::Point& dip_point) {
+  return ToFlooredPoint(gfx::ScalePoint(dip_point, GetDeviceScaleFactor()));
+}
+
+gfx::Size ScreenToDIPSize(const gfx::Size& size_in_pixels) {
+  // Always ceil sizes. Otherwise we may be leaving off part of the bounds.
+  return gfx::ToCeiledSize(
+      gfx::ScaleSize(size_in_pixels, 1.0f / GetDeviceScaleFactor()));
+}
+
+gfx::Size DIPToScreenSize(const gfx::Size& dip_size) {
+  // Always ceil sizes. Otherwise we may be leaving off part of the bounds.
+  return gfx::ToCeiledSize(gfx::ScaleSize(dip_size, GetDeviceScaleFactor()));
+}
+
+gfx::Rect DIPToScreenRect(const gfx::Rect& dip_bounds) {
+  // See comment in ScreenToDIPRect for why we calculate size like this.
+  return gfx::Rect(DIPToScreenPoint(dip_bounds.origin()),
+                   DIPToScreenSize(dip_bounds.size()));
+}
+
+gfx::Rect ScreenToDIPRect(const gfx::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 gfx::Rect(ScreenToDIPPoint(pixel_bounds.origin()),
+                   ScreenToDIPSize(pixel_bounds.size()));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostX11, public:
 
 DesktopWindowTreeHostX11::DesktopWindowTreeHostX11(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura)
     : xdisplay_(gfx::GetXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       atom_cache_(xdisplay_, kAtomsToCache),
@@ skipping 242 matching lines @@
   ShowWindowWithState(ui::SHOW_STATE_MAXIMIZED);
   // Enforce |restored_bounds_| since calling Maximize() could have reset it.
   restored_bounds_ = restored_bounds;
 }
 
 bool DesktopWindowTreeHostX11::IsVisible() const {
   return window_mapped_;
 }
 
 void DesktopWindowTreeHostX11::SetSize(const gfx::Size& requested_size) {
-  gfx::Size size = AdjustSize(requested_size);
+  gfx::Size size = AdjustSize(DIPToScreenSize(requested_size));
   bool size_changed = bounds_.size() != size;
   XResizeWindow(xdisplay_, xwindow_, size.width(), size.height());
   bounds_.set_size(size);
   if (size_changed) {
     OnHostResized(size);
     ResetWindowRegion();
   }
 }
 
 void DesktopWindowTreeHostX11::StackAtTop() {
   XRaiseWindow(xdisplay_, xwindow_);
 }
 
-void DesktopWindowTreeHostX11::CenterWindow(const gfx::Size& size) {
+void DesktopWindowTreeHostX11::CenterWindow(const gfx::Size& size_dip) {
   gfx::Rect parent_bounds = GetWorkAreaBoundsInScreen();
 
+  gfx::Size size = DIPToScreenSize(size_dip);
+
   // If |window_|'s transient parent bounds are big enough to contain |size|,
   // use them instead.
   if (wm::GetTransientParent(content_window_)) {
     gfx::Rect transient_parent_rect =
         wm::GetTransientParent(content_window_)->GetBoundsInScreen();
     if (transient_parent_rect.height() >= size.height() &&
         transient_parent_rect.width() >= size.width()) {
       parent_bounds = transient_parent_rect;
     }
   }
@@ skipping 22 matching lines @@
   } else if (IsMaximized()) {
     *show_state = ui::SHOW_STATE_MAXIMIZED;
   } else if (!IsActive()) {
     *show_state = ui::SHOW_STATE_INACTIVE;
   } else {
     *show_state = ui::SHOW_STATE_NORMAL;
   }
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetWindowBoundsInScreen() const {
-  return bounds_;
+  return ScreenToDIPRect(bounds_);
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetClientAreaBoundsInScreen() const {
   // TODO(erg): The NativeWidgetAura version returns |bounds_|, claiming its
   // needed for View::ConvertPointToScreen() to work
   // correctly. DesktopWindowTreeHostWin::GetClientAreaBoundsInScreen() just
   // asks windows what it thinks the client rect is.
   //
   // Attempts to calculate the rect by asking the NonClientFrameView what it
   // thought its GetBoundsForClientView() were broke combobox drop down
   // placement.
-  return bounds_;
+  return ScreenToDIPRect(bounds_);
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetRestoredBounds() const {
   // We can't reliably track the restored bounds of a window, but we can get
   // the 90% case down. When *chrome* is the process that requests maximizing
   // or restoring bounds, we can record the current bounds before we request
   // maximization, and clear it when we detect a state change.
   if (!restored_bounds_.IsEmpty())
-    return restored_bounds_;
+    return ScreenToDIPRect(restored_bounds_);
 
   return GetWindowBoundsInScreen();
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetWorkAreaBoundsInScreen() const {
   std::vector<int> value;
   if (ui::GetIntArrayProperty(x_root_window_, "_NET_WORKAREA", &value) &&
       value.size() >= 4) {
-    return gfx::Rect(value[0], value[1], value[2], value[3]);
+    return ScreenToDIPRect(gfx::Rect(value[0], value[1], value[2], value[3]));
   }
 
   // Fetch the geometry of the root window.
   Window root;
   int x, y;
   unsigned int width, height;
   unsigned int border_width, depth;
   if (!XGetGeometry(xdisplay_, x_root_window_, &root, &x, &y,
                     &width, &height, &border_width, &depth)) {
     NOTIMPLEMENTED();
     return gfx::Rect(0, 0, 10, 10);
   }
 
-  return gfx::Rect(x, y, width, height);
+  return ScreenToDIPRect(gfx::Rect(x, y, width, height));

[Elliot Glaysher, 2014/10/16 00:27:40]

So bounds in screen are also dips?

[scottmg, 2014/10/17 00:09:11]

Yeah, that's confusing, but that one's Screen/Client not Screen/DIP. (I think. I
certainly could be totally wrong.)

 }
 
 void DesktopWindowTreeHostX11::SetShape(gfx::NativeRegion native_region) {
   if (window_shape_)
     XDestroyRegion(window_shape_);
   custom_window_shape_ = false;
   window_shape_ = NULL;
 
   if (native_region) {
     custom_window_shape_ = true;
@@ skipping 577 matching lines @@
 
       // x.org will BadMatch if we don't set a border when the depth isn't the
       // same as the parent depth.
       attribute_mask |= CWBorderPixel;
       swa.border_pixel = 0;
 
       use_argb_visual_ = true;
     }
   }
 
-  bounds_ = gfx::Rect(params.bounds.origin(),
-                      AdjustSize(params.bounds.size()));
+  gfx::Point origin_screen = DIPToScreenPoint(params.bounds.origin());
+  gfx::Size size_screen = DIPToScreenSize(params.bounds.size());
+  bounds_ = gfx::Rect(origin_screen,
+                      AdjustSize(size_screen));
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
-      bounds_.x(), bounds_.y(),
-      bounds_.width(), bounds_.height(),
+      origin_screen.x(), origin_screen.y(),
+      size_screen.width(), size_screen.height(),
       0,               // border width
       depth,
       InputOutput,
       visual,
       attribute_mask,
       &swa);
   if (ui::PlatformEventSource::GetInstance())
     ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
   open_windows().push_back(xwindow_);
 
@@ skipping 838 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views