linux/x11: Fix setting window bounds in High DPI.

ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h

 // 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.
 
 #ifndef UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_WINDOW_TREE_HOST_X11_H_
 #define UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_WINDOW_TREE_HOST_X11_H_
 
 #include <X11/extensions/shape.h>
 #include <X11/Xlib.h>
 
@@ skipping 129 matching lines @@
   void InitModalType(ui::ModalType modal_type) override;
   void FlashFrame(bool flash_frame) override;
   void OnRootViewLayout() override;
   void OnNativeWidgetFocus() override;
   void OnNativeWidgetBlur() override;
   bool IsAnimatingClosed() const override;
   bool IsTranslucentWindowOpacitySupported() const override;
   void SizeConstraintsChanged() override;
 
   // Overridden from aura::WindowTreeHost:
+  gfx::Transform GetRootTransform() const override;
   ui::EventSource* GetEventSource() override;
   gfx::AcceleratedWidget GetAcceleratedWidget() override;
   void Show() override;
   void Hide() override;
   gfx::Rect GetBounds() const override;
-  void SetBounds(const gfx::Rect& requested_bounds) override;
+  void SetBounds(const gfx::Rect& requested_bounds_in_pixels) override;
   gfx::Point GetLocationOnNativeScreen() const override;
   void SetCapture() override;
   void ReleaseCapture() override;
   void SetCursorNative(gfx::NativeCursor cursor) override;
   void MoveCursorToNative(const gfx::Point& location) override;
   void OnCursorVisibilityChangedNative(bool show) override;
 
   // Overridden frm ui::EventSource
   ui::EventProcessor* GetEventProcessor() override;
 
@@ skipping 68 matching lines @@
 
   void SetWindowTransparency();
 
   // Relayout the widget's client and non-client views.
   void Relayout();
 
   // ui::PlatformEventDispatcher:
   bool CanDispatchEvent(const ui::PlatformEvent& event) override;
   uint32_t DispatchEvent(const ui::PlatformEvent& event) override;
 
-  void DelayedResize(const gfx::Size& size);
+  void DelayedResize(const gfx::Size& size_in_pixels);
+
+  gfx::Rect GetWorkAreaBoundsInPixels() const;
+  gfx::Rect ToDIPRect(const gfx::Rect& rect_in_pixels) const;
+  gfx::Rect ToPixelRect(const gfx::Rect& rect_in_dip) const;
 
   // X11 things
   // The display and the native X window hosting the root window.
   XDisplay* xdisplay_;
   ::Window xwindow_;
 
   // The native root window.
   ::Window x_root_window_;
 
   ui::X11AtomCache atom_cache_;
 
   // Is the window mapped to the screen?
   bool window_mapped_;
 
   // The bounds of |xwindow_|.
-  gfx::Rect bounds_;
+  gfx::Rect bounds_in_pixels_;
 
   // Whenever the bounds are set, we keep the previous set of bounds around so
-  // we can have a better chance of getting the real |restored_bounds_|. Window
-  // managers tend to send a Configure message with the maximized bounds, and
-  // then set the window maximized property. (We don't rely on this for when we
-  // request that the window be maximized, only when we detect that some other
-  // process has requested that we become the maximized window.)
-  gfx::Rect previous_bounds_;
+  // we can have a better chance of getting the real
+  // |restored_bounds_in_pixels_|. Window managers tend to send a Configure
+  // message with the maximized bounds, and then set the window maximized
+  // property. (We don't rely on this for when we request that the window be
+  // maximized, only when we detect that some other process has requested that
+  // we become the maximized window.)
+  gfx::Rect previous_bounds_in_pixels_;
 
   // The bounds of our window before we were maximized.
-  gfx::Rect restored_bounds_;
+  gfx::Rect restored_bounds_in_pixels_;
 
   // |xwindow_|'s minimum size.
-  gfx::Size min_size_;
+  gfx::Size min_size_in_pixels_;
 
   // |xwindow_|'s maximum size.
-  gfx::Size max_size_;
+  gfx::Size max_size_in_pixels_;
 
   // The window manager state bits.
   std::set< ::Atom> window_properties_;
 
   // Whether |xwindow_| was requested to be fullscreen via SetFullscreen().
   bool is_fullscreen_;
 
   // True if the window should stay on top of most other windows.
   bool is_always_on_top_;
 
@@ skipping 26 matching lines @@
 
   ObserverList<DesktopWindowTreeHostObserverX11> observer_list_;
 
   // The window shape if the window is non-rectangular.
   ::Region window_shape_;
 
   // Whether |window_shape_| was set via SetShape().
   bool custom_window_shape_;
 
   // The size of the window manager provided borders (if any).
-  gfx::Insets native_window_frame_borders_;
+  gfx::Insets native_window_frame_borders_in_pixels_;
 
   // The current DesktopWindowTreeHostX11 which has capture. Set synchronously
   // when capture is requested via SetCapture().
   static DesktopWindowTreeHostX11* g_current_capture;
 
   // A list of all (top-level) windows that have been created but not yet
   // destroyed.
   static std::list<XID>* open_windows_;
 
   base::string16 window_title_;
 
   // Whether we currently are flashing our frame. This feature is implemented
   // by setting the urgency hint with the window manager, which can draw
   // attention to the window or completely ignore the hint. We stop flashing
   // the frame when |xwindow_| gains focus or handles a mouse button event.
   bool urgency_hint_set_;
 
   base::CancelableCallback<void()> delayed_resize_task_;
 
   base::WeakPtrFactory<DesktopWindowTreeHostX11> close_widget_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopWindowTreeHostX11);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_WINDOW_TREE_HOST_X11_H_