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/dpi.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 328 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(gfx::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 = gfx::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 gfx::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 gfx::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 gfx::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]);
   }
 
   // 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 gfx::ScreenToDIPRect(gfx::Rect(x, y, width, height));
 }
 
 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 = gfx::DIPToScreenPoint(params.bounds.origin());
+  gfx::Size size_screen = gfx::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 297 matching lines @@
       window_properties_.end();
 }
 
 void DesktopWindowTreeHostX11::SetUseNativeFrame(bool use_native_frame) {
   use_native_frame_ = use_native_frame;
   ui::SetUseOSWindowFrame(xwindow_, use_native_frame);
   ResetWindowRegion();
 }
 
 void DesktopWindowTreeHostX11::DispatchMouseEvent(ui::MouseEvent* event) {
+  event->set_location(gfx::ScreenToDIPPoint(event->location()));
   // In Windows, the native events sent to chrome are separated into client
   // and non-client versions of events, which we record on our LocatedEvent
   // structures. On X11, we emulate the concept of non-client. Before we pass
   // this event to the cross platform event handling framework, we need to
   // make sure it is appropriately marked as non-client if it's in the non
   // client area, or otherwise, we can get into a state where the a window is
   // set as the |mouse_pressed_handler_| in window_event_dispatcher.cc
   // despite the mouse button being released.
   //
   // We can't do this later in the dispatch process because we share that
   // with ash, and ash gets confused about event IS_NON_CLIENT-ness on
   // events, since ash doesn't expect this bit to be set, because it's never
   // been set before. (This works on ash on Windows because none of the mouse
   // events on the ash desktop are clicking in what Windows considers to be a
   // non client area.) Likewise, we won't want to do the following in any
   // WindowTreeHost that hosts ash.
   if (content_window_ && content_window_->delegate()) {
     int flags = event->flags();
-    int hit_test_code =
-        content_window_->delegate()->GetNonClientComponent(event->location());
+    int hit_test_code = content_window_->delegate()->GetNonClientComponent(
+        gfx::ScreenToDIPPoint(event->location()));
     if (hit_test_code != HTCLIENT && hit_test_code != HTNOWHERE)
       flags |= ui::EF_IS_NON_CLIENT;
     event->set_flags(flags);
   }
 
   // While we unset the urgency hint when we gain focus, we also must remove it
   // on mouse clicks because we can call FlashFrame() on an active window.
   if (event->IsAnyButton() || event->IsMouseWheelEvent())
     FlashFrame(false);
 
   if (!g_current_capture || g_current_capture == this) {
+    event->set_location(gfx::DIPToScreenPoint(event->location()));
     SendEventToProcessor(event);
   } else {
     // Another DesktopWindowTreeHostX11 has installed itself as
     // capture. Translate the event's location and dispatch to the other.
     event->ConvertLocationToTarget(window(), g_current_capture->window());
+    event->set_location(gfx::DIPToScreenPoint(event->location()));
     g_current_capture->SendEventToProcessor(event);
   }
 }
 
 void DesktopWindowTreeHostX11::DispatchTouchEvent(ui::TouchEvent* event) {
   if (g_current_capture && g_current_capture != this &&
       event->type() == ui::ET_TOUCH_PRESSED) {
     event->ConvertLocationToTarget(window(), g_current_capture->window());
     g_current_capture->SendEventToProcessor(event);
   } else {
@@ skipping 485 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