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

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 14 matching lines @@
 #include "ui/base/hit_test.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/devices/x11/device_data_manager_x11.h"
 #include "ui/events/devices/x11/device_list_cache_x11.h"
 #include "ui/events/devices/x11/touch_factory_x11.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/gfx/display.h"
 #include "ui/gfx/geometry/insets.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/path.h"
 #include "ui/gfx/path_x11.h"
 #include "ui/gfx/screen.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"
@@ skipping 138 matching lines @@
 std::vector<aura::Window*> DesktopWindowTreeHostX11::GetAllOpenWindows() {
   std::vector<aura::Window*> windows(open_windows().size());
   std::transform(open_windows().begin(),
                  open_windows().end(),
                  windows.begin(),
                  GetContentWindowForXID);
   return windows;
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetX11RootWindowBounds() const {
-  return bounds_;
+  return bounds_in_pixels_;
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetX11RootWindowOuterBounds() const {
-  gfx::Rect outer_bounds(bounds_);
-  outer_bounds.Inset(-native_window_frame_borders_);
+  gfx::Rect outer_bounds(bounds_in_pixels_);
+  outer_bounds.Inset(-native_window_frame_borders_in_pixels_);
   return outer_bounds;
 }
 
 ::Region DesktopWindowTreeHostX11::GetWindowShape() const {
   return window_shape_;
 }
 
 void DesktopWindowTreeHostX11::HandleNativeWidgetActivationChanged(
     bool active) {
   if (active) {
@@ skipping 165 matching lines @@
       show_state == ui::SHOW_STATE_MAXIMIZED) {
     Activate();
   }
 
   native_widget_delegate_->AsWidget()->SetInitialFocus(show_state);
 }
 
 void DesktopWindowTreeHostX11::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
   ShowWindowWithState(ui::SHOW_STATE_MAXIMIZED);
-  // Enforce |restored_bounds_| since calling Maximize() could have reset it.
-  restored_bounds_ = restored_bounds;
+  // Enforce |restored_bounds_in_pixels_| since calling Maximize() could have
+  // reset it.
+  restored_bounds_in_pixels_ = ToPixelRect(restored_bounds);
 }
 
 bool DesktopWindowTreeHostX11::IsVisible() const {
   return window_mapped_;
 }
 
 void DesktopWindowTreeHostX11::SetSize(const gfx::Size& requested_size) {
-  gfx::Size size = AdjustSize(requested_size);
-  bool size_changed = bounds_.size() != size;
-  XResizeWindow(xdisplay_, xwindow_, size.width(), size.height());
-  bounds_.set_size(size);
+  gfx::Size size_in_pixels = ToPixelRect(gfx::Rect(requested_size)).size();
+  size_in_pixels = AdjustSize(size_in_pixels);
+  bool size_changed = bounds_in_pixels_.size() != size_in_pixels;
+  XResizeWindow(xdisplay_, xwindow_, size_in_pixels.width(),
+                size_in_pixels.height());
+  bounds_in_pixels_.set_size(size_in_pixels);
   if (size_changed) {
-    OnHostResized(size);
+    OnHostResized(size_in_pixels);
     ResetWindowRegion();
   }
 }
 
 void DesktopWindowTreeHostX11::StackAtTop() {
   XRaiseWindow(xdisplay_, xwindow_);
 }
 
 void DesktopWindowTreeHostX11::CenterWindow(const gfx::Size& size) {
-  gfx::Rect parent_bounds = GetWorkAreaBoundsInScreen();
+  gfx::Size size_in_pixels = ToPixelRect(gfx::Rect(size)).size();
+  gfx::Rect parent_bounds_in_pixels = GetWorkAreaBoundsInPixels();
 
-  // If |window_|'s transient parent bounds are big enough to contain |size|,
-  // use them instead.
+  // If |window_|'s transient parent bounds are big enough to contain
+  // |size_in_pixels|, 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;
+    if (transient_parent_rect.height() >= size_in_pixels.height() &&
+        transient_parent_rect.width() >= size_in_pixels.width()) {

[pkotwicz, 2015/02/19 03:07:20]

You meant to compare against |size| not |size_in_pixels|?

[sadrul, 2015/02/24 00:11:27]

Good catch. Done.

+      parent_bounds_in_pixels = ToPixelRect(transient_parent_rect);
     }
   }
 
   gfx::Rect window_bounds(
-      parent_bounds.x() + (parent_bounds.width() - size.width()) / 2,
-      parent_bounds.y() + (parent_bounds.height() - size.height()) / 2,
-      size.width(),
-      size.height());
+      parent_bounds_in_pixels.x() +
+          (parent_bounds_in_pixels.width() - size_in_pixels.width()) / 2,
+      parent_bounds_in_pixels.y() +
+          (parent_bounds_in_pixels.height() - size_in_pixels.height()) / 2,
+      size_in_pixels.width(), size_in_pixels.height());
   // Don't size the window bigger than the parent, otherwise the user may not be
   // able to close or move it.
-  window_bounds.AdjustToFit(parent_bounds);
+  window_bounds.AdjustToFit(parent_bounds_in_pixels);

[pkotwicz, 2015/02/19 03:07:20]

window_bounds -> window_bounds_in_pixels

[sadrul, 2015/02/24 00:11:28]

Done.

 
   SetBounds(window_bounds);
 }
 
 void DesktopWindowTreeHostX11::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   *bounds = GetRestoredBounds();
 
   if (IsFullscreen()) {
     *show_state = ui::SHOW_STATE_FULLSCREEN;
   } else if (IsMinimized()) {
     *show_state = ui::SHOW_STATE_MINIMIZED;
   } 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 ToDIPRect(bounds_in_pixels_);
 }
 
 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.
+  // TODO(erg): The NativeWidgetAura version returns |bounds_in_pixels_|,
+  // claiming it's 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 GetWindowBoundsInScreen();
 }
 
 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_;
+  if (!restored_bounds_in_pixels_.IsEmpty())
+    return ToDIPRect(restored_bounds_in_pixels_);
 
   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 ToDIPRect(GetWorkAreaBoundsInPixels());
 }
 
 void DesktopWindowTreeHostX11::SetShape(gfx::NativeRegion native_region) {

[pkotwicz, 2015/02/19 03:07:20]

|native_region| is in "DIP" coordinates. I quickly tried ultra-violet and the
bubble is not big enough.

I am ok if you fix this as part of a follow on CL

   if (window_shape_)
     XDestroyRegion(window_shape_);
   custom_window_shape_ = false;
   window_shape_ = NULL;
 
   if (native_region) {
     custom_window_shape_ = true;
     window_shape_ = gfx::CreateRegionFromSkRegion(*native_region);
     delete native_region;
   }
@@ skipping 22 matching lines @@
 void DesktopWindowTreeHostX11::Maximize() {
   if (HasWMSpecProperty("_NET_WM_STATE_FULLSCREEN")) {
     // Unfullscreen the window if it is fullscreen.
     SetWMSpecState(false,
                    atom_cache_.GetAtom("_NET_WM_STATE_FULLSCREEN"),
                    None);
 
     // Resize the window so that it does not have the same size as a monitor.
     // (Otherwise, some window managers immediately put the window back in
     // fullscreen mode).
-    gfx::Rect adjusted_bounds(bounds_.origin(), AdjustSize(bounds_.size()));
-    if (adjusted_bounds != bounds_)
+    gfx::Rect adjusted_bounds(bounds_in_pixels_.origin(),
+                              AdjustSize(bounds_in_pixels_.size()));

[pkotwicz, 2015/02/19 03:07:20]

adjusted_bounds -> adjusted_bounds_in_pixels

[sadrul, 2015/02/24 00:11:28]

Done.

+    if (adjusted_bounds != bounds_in_pixels_)
       SetBounds(adjusted_bounds);
   }
 
   // Some WMs do not respect maximization hints on unmapped windows, so we
   // save this one for later too.
   should_maximize_after_map_ = !window_mapped_;
 
   // When we are in the process of requesting to maximize a window, we can
   // accurately keep track of our restored bounds instead of relying on the
   // heuristics that are in the PropertyNotify and ConfigureNotify handlers.
-  restored_bounds_ = bounds_;
+  restored_bounds_in_pixels_ = bounds_in_pixels_;
 
   SetWMSpecState(true,
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
   if (IsMinimized())
     ShowWindowWithState(ui::SHOW_STATE_NORMAL);
 }
 
 void DesktopWindowTreeHostX11::Minimize() {
   ReleaseCapture();
@@ skipping 165 matching lines @@
                  None);
   if (unmaximize_and_remaximize)
     Maximize();
 
   // Try to guess the size we will have after the switch to/from fullscreen:
   // - (may) avoid transient states
   // - works around Flash content which expects to have the size updated
   //   synchronously.
   // See https://crbug.com/361408
   if (fullscreen) {
-    restored_bounds_ = bounds_;
+    restored_bounds_in_pixels_ = bounds_in_pixels_;
     const gfx::Display display =
         gfx::Screen::GetScreenFor(NULL)->GetDisplayNearestWindow(window());
-    bounds_ = display.bounds();
+    bounds_in_pixels_ = ToPixelRect(display.bounds());
   } else {
-    bounds_ = restored_bounds_;
+    bounds_in_pixels_ = restored_bounds_in_pixels_;
   }
-  OnHostMoved(bounds_.origin());
-  OnHostResized(bounds_.size());
+  OnHostMoved(bounds_in_pixels_.origin());
+  OnHostResized(bounds_in_pixels_.size());
 
   if (HasWMSpecProperty("_NET_WM_STATE_FULLSCREEN") == fullscreen) {
     Relayout();
     ResetWindowRegion();
   }
   // Else: the widget will be relaid out either when the window bounds change or
   // when |xwindow_|'s fullscreen state changes.
 }
 
 bool DesktopWindowTreeHostX11::IsFullscreen() const {
@@ skipping 96 matching lines @@
   return false;
 }
 
 void DesktopWindowTreeHostX11::SizeConstraintsChanged() {
   UpdateMinAndMaxSize();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostX11, aura::WindowTreeHost implementation:
 
+gfx::Transform DesktopWindowTreeHostX11::GetRootTransform() const {
+  gfx::Display display = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
+  if (window_mapped_) {
+    aura::Window* win = const_cast<aura::Window*>(window());
+    display = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(win);

[pkotwicz, 2015/02/19 03:07:20]

Nit: Why bother? We are going to use the scale factor of the primary display
anyways. If the scale factors of the displays was different, perhaps we should
do things differently when |window_mapped_| is false

(I can see a future version of myself trying to figure out why we have special
logic when |window_mapped_| is true)

[sadrul, 2015/02/24 00:11:28]

It makes sense to use the DSF of the display this window belongs to. That's what
this block of code does. In the case where we don't still know what display the
window belongs to (so when |window_mapped_| is false), we get it from the
primary display.

I think on linux, we can have only one scale factor on all displays, so always
using the DSF from the primary display should be sufficient. But it feels a bit
cleaner to try to do the right thing and get the DSF from the relevant display
(esp. since it's trivial to do so).

+  }
+
+  float scale = display.device_scale_factor();
+  gfx::Transform transform;
+  transform.Scale(scale, scale);
+  return transform;
+}
+
 ui::EventSource* DesktopWindowTreeHostX11::GetEventSource() {
   return this;
 }
 
 gfx::AcceleratedWidget DesktopWindowTreeHostX11::GetAcceleratedWidget() {
   return xwindow_;
 }
 
 void DesktopWindowTreeHostX11::Show() {
   ShowWindowWithState(ui::SHOW_STATE_NORMAL);
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(true);
 }
 
 void DesktopWindowTreeHostX11::Hide() {
   if (window_mapped_) {
     XWithdrawWindow(xdisplay_, xwindow_, 0);
     window_mapped_ = false;
   }
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(false);
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetBounds() const {
-  return bounds_;
+  return bounds_in_pixels_;
 }
 
-void DesktopWindowTreeHostX11::SetBounds(const gfx::Rect& requested_bounds) {
-  gfx::Rect bounds(requested_bounds.origin(),
-                   AdjustSize(requested_bounds.size()));
-  bool origin_changed = bounds_.origin() != bounds.origin();
-  bool size_changed = bounds_.size() != bounds.size();
+void DesktopWindowTreeHostX11::SetBounds(
+    const gfx::Rect& requested_bounds_in_pixel) {
+  gfx::Rect bounds(requested_bounds_in_pixel.origin(),
+                   AdjustSize(requested_bounds_in_pixel.size()));

[pkotwicz, 2015/02/19 03:07:20]

bounds -> bounds_in_pixels

[sadrul, 2015/02/24 00:11:27]

Done.

+  bool origin_changed = bounds_in_pixels_.origin() != bounds.origin();
+  bool size_changed = bounds_in_pixels_.size() != bounds.size();
   XWindowChanges changes = {0};
   unsigned value_mask = 0;
 
   if (size_changed) {
-    if (bounds.width() < min_size_.width() ||
-        bounds.height() < min_size_.height() ||
-        (!max_size_.IsEmpty() &&
-         (bounds.width() > max_size_.width() ||
-          bounds.height() > max_size_.height()))) {
+    if (bounds.width() < min_size_in_pixels_.width() ||
+        bounds.height() < min_size_in_pixels_.height() ||
+        (!max_size_in_pixels_.IsEmpty() &&
+         (bounds.width() > max_size_in_pixels_.width() ||
+          bounds.height() > max_size_in_pixels_.height()))) {
       // Update the minimum and maximum sizes in case they have changed.
       UpdateMinAndMaxSize();
 
       gfx::Size size = bounds.size();

[pkotwicz, 2015/02/19 03:07:20]

size -> size_in_pixels

[sadrul, 2015/02/24 00:11:27]

Done.

-      size.SetToMin(max_size_);
-      size.SetToMax(min_size_);
+      size.SetToMin(max_size_in_pixels_);
+      size.SetToMax(min_size_in_pixels_);
       bounds.set_size(size);
     }
 
     changes.width = bounds.width();
     changes.height = bounds.height();
     value_mask |= CWHeight | CWWidth;
   }
 
   if (origin_changed) {
     changes.x = bounds.x();
     changes.y = bounds.y();
     value_mask |= CWX | CWY;
   }
   if (value_mask)
     XConfigureWindow(xdisplay_, xwindow_, value_mask, &changes);
 
   // Assume that the resize will go through as requested, which should be the
   // case if we're running without a window manager.  If there's a window
   // manager, it can modify or ignore the request, but (per ICCCM) we'll get a
   // (possibly synthetic) ConfigureNotify about the actual size and correct
-  // |bounds_| later.
-  bounds_ = bounds;
+  // |bounds_in_pixels_| later.
+  bounds_in_pixels_ = bounds;
 
   if (origin_changed)
     native_widget_delegate_->AsWidget()->OnNativeWidgetMove();
   if (size_changed) {
     OnHostResized(bounds.size());
     ResetWindowRegion();
   }
 }
 
 gfx::Point DesktopWindowTreeHostX11::GetLocationOnNativeScreen() const {
-  return bounds_.origin();
+  return bounds_in_pixels_.origin();
 }
 
 void DesktopWindowTreeHostX11::SetCapture() {
   if (HasCapture())
     return;
 
   // Grabbing the mouse is asynchronous. However, we synchronously start
   // forwarding all mouse events received by Chrome to the
   // aura::WindowEventDispatcher which has capture. This makes capture
   // synchronous for all intents and purposes if either:
@@ skipping 22 matching lines @@
     OnHostLostWindowCapture();
   }
 }
 
 void DesktopWindowTreeHostX11::SetCursorNative(gfx::NativeCursor cursor) {
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
 void DesktopWindowTreeHostX11::MoveCursorToNative(const gfx::Point& location) {
   XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0,
-               bounds_.x() + location.x(), bounds_.y() + location.y());
+               bounds_in_pixels_.x() + location.x(),
+               bounds_in_pixels_.y() + location.y());
 }
 
 void DesktopWindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
   // TODO(erg): Conditional on us enabling touch on desktop linux builds, do
   // the same tap-to-click disabling here that chromeos does.
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostX11, ui::EventSource implementation:
 
@@ skipping 55 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()));
-  xwindow_ = XCreateWindow(
-      xdisplay_, x_root_window_,
-      bounds_.x(), bounds_.y(),
-      bounds_.width(), bounds_.height(),
-      0,               // border width
-      depth,
-      InputOutput,
-      visual,
-      attribute_mask,
-      &swa);
+  bounds_in_pixels_ = ToPixelRect(params.bounds);
+  bounds_in_pixels_ = gfx::Rect(bounds_in_pixels_.origin(),
+                                AdjustSize(bounds_in_pixels_.size()));

[pkotwicz, 2015/02/19 03:07:20]

Nit: bounds_in_pixels_.set_size(AdjustSize(bounds_in_pixels_.size()));

[sadrul, 2015/02/24 00:11:28]

Done.

+  xwindow_ = XCreateWindow(xdisplay_, x_root_window_, bounds_in_pixels_.x(),
+                           bounds_in_pixels_.y(), bounds_in_pixels_.width(),
+                           bounds_in_pixels_.height(),
+                           0,  // border width
+                           depth, InputOutput, visual, attribute_mask, &swa);
   if (ui::PlatformEventSource::GetInstance())
     ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
   open_windows().push_back(xwindow_);
 
   // TODO(erg): Maybe need to set a ViewProp here like in RWHL::RWHL().
 
   long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
                     KeyPressMask | KeyReleaseMask |
                     EnterWindowMask | LeaveWindowMask |
                     ExposureMask | VisibilityChangeMask |
@@ skipping 118 matching lines @@
   // icon.
   gfx::ImageSkia* window_icon = ViewsDelegate::views_delegate ?
       ViewsDelegate::views_delegate->GetDefaultWindowIcon() : NULL;
   if (window_icon) {
     SetWindowIcons(gfx::ImageSkia(), *window_icon);
   }
   CreateCompositor(GetAcceleratedWidget());
 }
 
 gfx::Size DesktopWindowTreeHostX11::AdjustSize(
-    const gfx::Size& requested_size) {
+    const gfx::Size& requested_size_in_pixels) {
   std::vector<gfx::Display> displays =
       gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_NATIVE)->GetAllDisplays();
   // Compare against all monitor sizes. The window manager can move the window
   // to whichever monitor it wants.
   for (size_t i = 0; i < displays.size(); ++i) {
-    if (requested_size == displays[i].size()) {
-      return gfx::Size(requested_size.width() - 1,
-                       requested_size.height() - 1);
+    if (requested_size_in_pixels == displays[i].GetSizeInPixel()) {
+      return gfx::Size(requested_size_in_pixels.width() - 1,
+                       requested_size_in_pixels.height() - 1);
     }
   }
 
   // Do not request a 0x0 window size. It causes an XError.
-  gfx::Size size = requested_size;
+  gfx::Size size = requested_size_in_pixels;

[pkotwicz, 2015/02/19 03:07:20]

size -> size_in_pixels

[sadrul, 2015/02/24 00:11:28]

Done.

   size.SetToMax(gfx::Size(1,1));
   return size;
 }
 
 void DesktopWindowTreeHostX11::OnWMStateUpdated() {
   std::vector< ::Atom> atom_list;
   // Ignore the return value of ui::GetAtomArrayProperty(). Fluxbox removes the
   // _NET_WM_STATE property when no _NET_WM_STATE atoms are set.
   ui::GetAtomArrayProperty(xwindow_, "_NET_WM_STATE", &atom_list);
 
@@ skipping 19 matching lines @@
   if (is_minimized != was_minimized) {
     if (is_minimized) {
       compositor()->SetVisible(false);
       content_window_->Hide();
     } else {
       content_window_->Show();
       compositor()->SetVisible(true);
     }
   }
 
-  if (restored_bounds_.IsEmpty()) {
+  if (restored_bounds_in_pixels_.IsEmpty()) {
     DCHECK(!IsFullscreen());
     if (IsMaximized()) {
       // The request that we become maximized originated from a different
-      // process. |bounds_| already contains our maximized bounds. Do a best
-      // effort attempt to get restored bounds by setting it to our previously
-      // set bounds (and if we get this wrong, we aren't any worse off since
-      // we'd otherwise be returning our maximized bounds).
-      restored_bounds_ = previous_bounds_;
+      // process. |bounds_in_pixels_| already contains our maximized bounds. Do
+      // a best effort attempt to get restored bounds by setting it to our
+      // previously set bounds (and if we get this wrong, we aren't any worse
+      // off since we'd otherwise be returning our maximized bounds).
+      restored_bounds_in_pixels_ = previous_bounds_in_pixels_;
     }
   } else if (!IsMaximized() && !IsFullscreen()) {
     // If we have restored bounds, but WM_STATE no longer claims to be
     // maximized or fullscreen, we should clear our restored bounds.
-    restored_bounds_ = gfx::Rect();
+    restored_bounds_in_pixels_ = gfx::Rect();
   }
 
   // Ignore requests by the window manager to enter or exit fullscreen (e.g. as
   // a result of pressing a window manager accelerator key). Chrome does not
   // handle window manager initiated fullscreen. In particular, Chrome needs to
   // do preprocessing before the x window's fullscreen state is toggled.
 
   is_always_on_top_ = HasWMSpecProperty("_NET_WM_STATE_ABOVE");
 
   // Now that we have different window properties, we may need to relayout the
   // window. (The windows code doesn't need this because their window change is
   // synchronous.)
   Relayout();
   ResetWindowRegion();
 }
 
 void DesktopWindowTreeHostX11::OnFrameExtentsUpdated() {
   std::vector<int> insets;
   if (ui::GetIntArrayProperty(xwindow_, "_NET_FRAME_EXTENTS", &insets) &&
       insets.size() == 4) {
     // |insets| are returned in the order: [left, right, top, bottom].
-    native_window_frame_borders_ = gfx::Insets(
-        insets[2],
-        insets[0],
-        insets[3],
-        insets[1]);
+    native_window_frame_borders_in_pixels_ =
+        gfx::Insets(insets[2], insets[0], insets[3], insets[1]);
   } else {
-    native_window_frame_borders_ = gfx::Insets();
+    native_window_frame_borders_in_pixels_ = gfx::Insets();
   }
 }
 
 void DesktopWindowTreeHostX11::UpdateMinAndMaxSize() {
   if (!window_mapped_)
     return;
 
-  gfx::Size minimum = native_widget_delegate_->GetMinimumSize();
-  gfx::Size maximum = native_widget_delegate_->GetMaximumSize();
-  if (min_size_ == minimum && max_size_ == maximum)
+  gfx::Size minimum =
+      ToPixelRect(gfx::Rect(native_widget_delegate_->GetMinimumSize())).size();
+  gfx::Size maximum =
+      ToPixelRect(gfx::Rect(native_widget_delegate_->GetMaximumSize())).size();

[pkotwicz, 2015/02/19 03:07:20]

minimum -> minimum_in_pixels
maximum -> maximum_in_pixels

[sadrul, 2015/02/24 00:11:27]

Done.

+  if (min_size_in_pixels_ == minimum && max_size_in_pixels_ == maximum)
     return;
 
-  min_size_ = minimum;
-  max_size_ = maximum;
+  min_size_in_pixels_ = minimum;
+  max_size_in_pixels_ = maximum;
 
   XSizeHints hints;
   long supplied_return;
   XGetWMNormalHints(xdisplay_, xwindow_, &hints, &supplied_return);
 
   if (minimum.IsEmpty()) {
     hints.flags &= ~PMinSize;
   } else {
     hints.flags |= PMinSize;
-    hints.min_width = min_size_.width();
-    hints.min_height = min_size_.height();
+    hints.min_width = min_size_in_pixels_.width();
+    hints.min_height = min_size_in_pixels_.height();
   }
 
   if (maximum.IsEmpty()) {
     hints.flags &= ~PMaxSize;
   } else {
     hints.flags |= PMaxSize;
-    hints.max_width = max_size_.width();
-    hints.max_height = max_size_.height();
+    hints.max_width = max_size_in_pixels_.width();
+    hints.max_height = max_size_in_pixels_.height();
   }
 
   XSetWMNormalHints(xdisplay_, xwindow_, &hints);
 }
 
 void DesktopWindowTreeHostX11::UpdateWMUserTime(
     const ui::PlatformEvent& event) {
   if (!IsActive())
     return;
 
@@ skipping 10 matching lines @@
                     32,
                     PropModeReplace,
                     reinterpret_cast<const unsigned char *>(&wm_user_time_ms),
                     1);
     X11DesktopHandler::get()->set_wm_user_time_ms(wm_user_time_ms);
   }
 }
 
 void DesktopWindowTreeHostX11::SetWMSpecState(bool enabled,
                                                 ::Atom state1,
                                                 ::Atom state2) {

[pkotwicz, 2015/02/19 03:07:20]

Nit: Can you please fix the alignment here?

[sadrul, 2015/02/24 00:11:27]

Done.

   XEvent xclient;
   memset(&xclient, 0, sizeof(xclient));
   xclient.type = ClientMessage;
   xclient.xclient.window = xwindow_;
   xclient.xclient.message_type = atom_cache_.GetAtom("_NET_WM_STATE");
   xclient.xclient.format = 32;
   xclient.xclient.data.l[0] =
       enabled ? k_NET_WM_STATE_ADD : k_NET_WM_STATE_REMOVE;
   xclient.xclient.data.l[1] = state1;
   xclient.xclient.data.l[2] = state2;
@@ skipping 94 matching lines @@
   if (window_shape_)
     XDestroyRegion(window_shape_);
   window_shape_ = NULL;
 
   if (!IsMaximized() && !IsFullscreen()) {
     gfx::Path window_mask;
     views::Widget* widget = native_widget_delegate_->AsWidget();
     if (widget->non_client_view()) {
       // Some frame views define a custom (non-rectangular) window mask. If
       // so, use it to define the window shape. If not, fall through.
-      widget->non_client_view()->GetWindowMask(bounds_.size(), &window_mask);
+      widget->non_client_view()->GetWindowMask(bounds_in_pixels_.size(),
+                                               &window_mask);
       if (window_mask.countPoints() > 0) {
         window_shape_ = gfx::CreateRegionFromSkPath(window_mask);
         XShapeCombineRegion(xdisplay_, xwindow_, ShapeBounding,
                             0, 0, window_shape_, false);
         return;
       }
     }
   }
 
   // If we didn't set the shape for any reason, reset the shaping information.
   // How this is done depends on the border style, due to quirks and bugs in
   // various window managers.
   if (ShouldUseNativeFrame()) {
     // If the window has system borders, the mask must be set to null (not a
     // rectangle), because several window managers (eg, KDE, XFCE, XMonad) will
     // not put borders on a window with a custom shape.
     XShapeCombineMask(xdisplay_, xwindow_, ShapeBounding, 0, 0, None, ShapeSet);
   } else {
     // Conversely, if the window does not have system borders, the mask must be
     // manually set to a rectangle that covers the whole window (not null). This
     // is due to a bug in KWin <= 4.11.5 (KDE bug #330573) where setting a null
     // shape causes the hint to disable system borders to be ignored (resulting
     // in a double border).
-    XRectangle r = {0, 0, static_cast<unsigned short>(bounds_.width()),
-                    static_cast<unsigned short>(bounds_.height())};
+    XRectangle r = {0,
+                    0,
+                    static_cast<unsigned short>(bounds_in_pixels_.width()),
+                    static_cast<unsigned short>(bounds_in_pixels_.height())};
     XShapeCombineRectangles(
         xdisplay_, xwindow_, ShapeBounding, 0, 0, &r, 1, ShapeSet, YXBanded);
   }
 }
 
 void DesktopWindowTreeHostX11::SerializeImageRepresentation(
     const gfx::ImageSkiaRep& rep,
     std::vector<unsigned long>* data) {
   int width = rep.GetWidth();
   data->push_back(width);
@@ skipping 54 matching lines @@
       show_state != ui::SHOW_STATE_INACTIVE &&
       show_state != ui::SHOW_STATE_MAXIMIZED) {
     // It will behave like SHOW_STATE_NORMAL.
     NOTIMPLEMENTED();
   }
 
   // Before we map the window, set size hints. Otherwise, some window managers
   // will ignore toplevel XMoveWindow commands.
   XSizeHints size_hints;
   size_hints.flags = PPosition;
-  size_hints.x = bounds_.x();
-  size_hints.y = bounds_.y();
+  size_hints.x = bounds_in_pixels_.x();
+  size_hints.y = bounds_in_pixels_.y();
   XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
 
   // If SHOW_STATE_INACTIVE, tell the window manager not to focus the window
   // when mapping. This is done by setting the _NET_WM_USER_TIME to 0. See e.g.
   // http://standards.freedesktop.org/wm-spec/latest/ar01s05.html
   unsigned long wm_user_time_ms = (show_state == ui::SHOW_STATE_INACTIVE) ?
       0 : X11DesktopHandler::get()->wm_user_time_ms();
   if (show_state == ui::SHOW_STATE_INACTIVE || wm_user_time_ms != 0) {
     XChangeProperty(xdisplay_,
                     xwindow_,
@@ skipping 70 matching lines @@
       if (xev->xcrossing.detail == NotifyInferior)
         break;
 
       ui::MouseEvent mouse_event(xev);
       DispatchMouseEvent(&mouse_event);
       break;
     }
     case Expose: {
       gfx::Rect damage_rect(xev->xexpose.x, xev->xexpose.y,
                             xev->xexpose.width, xev->xexpose.height);
       compositor()->ScheduleRedrawRect(damage_rect);

[pkotwicz, 2015/02/19 03:07:20]

damage_rect -> damage_rect_in_pixels

[sadrul, 2015/02/24 00:11:27]

Done.

       break;
     }
     case KeyPress: {
       ui::KeyEvent keydown_event(xev);
       SendEventToProcessor(&keydown_event);
       break;
     }
     case KeyRelease: {
       // There is no way to deactivate a window in X11 so ignore input if
       // window is supposed to be 'inactive'. See comments in
@@ skipping 46 matching lines @@
       // It's possible that the X window may be resized by some other means than
       // from within aura (e.g. the X window manager can change the size). Make
       // sure the root window size is maintained properly.
       int translated_x = xev->xconfigure.x;
       int translated_y = xev->xconfigure.y;
       if (!xev->xconfigure.send_event && !xev->xconfigure.override_redirect) {
         Window unused;
         XTranslateCoordinates(xdisplay_, xwindow_, x_root_window_,
             0, 0, &translated_x, &translated_y, &unused);
       }
       gfx::Rect bounds(translated_x, translated_y,

[pkotwicz, 2015/02/19 03:07:20]

bounds -> bounds_in_pixels
translated_x -> translated_x_in_pixels
translated_y -> translated_y_in_pixels

[sadrul, 2015/02/24 00:11:27]

Done.

                        xev->xconfigure.width, xev->xconfigure.height);
-      bool size_changed = bounds_.size() != bounds.size();
-      bool origin_changed = bounds_.origin() != bounds.origin();
-      previous_bounds_ = bounds_;
-      bounds_ = bounds;
+      bool size_changed = bounds_in_pixels_.size() != bounds.size();
+      bool origin_changed = bounds_in_pixels_.origin() != bounds.origin();
+      previous_bounds_in_pixels_ = bounds_in_pixels_;
+      bounds_in_pixels_ = bounds;
 
       if (origin_changed)
-        OnHostMoved(bounds_.origin());
+        OnHostMoved(bounds_in_pixels_.origin());
 
       if (size_changed) {
         delayed_resize_task_.Reset(base::Bind(
             &DesktopWindowTreeHostX11::DelayedResize,
             close_widget_factory_.GetWeakPtr(),
             bounds.size()));
         base::MessageLoop::current()->PostTask(
             FROM_HERE, delayed_resize_task_.callback());
       }
       break;
@@ skipping 155 matching lines @@
       break;
     }
     case SelectionNotify: {
       drag_drop_client_->OnSelectionNotify(xev->xselection);
       break;
     }
   }
   return ui::POST_DISPATCH_STOP_PROPAGATION;
 }
 
 void DesktopWindowTreeHostX11::DelayedResize(const gfx::Size& size) {

[pkotwicz, 2015/02/19 03:07:20]

size -> size_in_pixels

[sadrul, 2015/02/24 00:11:27]

Done.

   OnHostResized(size);
   ResetWindowRegion();
   delayed_resize_task_.Cancel();
 }
 
+gfx::Rect DesktopWindowTreeHostX11::GetWorkAreaBoundsInPixels() 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);
+}
+
+gfx::Rect DesktopWindowTreeHostX11::ToDIPRect(
+    const gfx::Rect& rect_in_pixels) const {
+  gfx::RectF rect_in_dip = rect_in_pixels;
+  GetRootTransform().TransformRectReverse(&rect_in_dip);
+  return gfx::ToEnclosingRect(rect_in_dip);
+}
+
+gfx::Rect DesktopWindowTreeHostX11::ToPixelRect(
+    const gfx::Rect& rect_in_dip) const {
+  gfx::RectF rect_in_pixels = rect_in_dip;
+  GetRootTransform().TransformRect(&rect_in_pixels);
+  return gfx::ToEnclosingRect(rect_in_pixels);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHost, public:
 
 // static
 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   return new DesktopWindowTreeHostX11(native_widget_delegate,
                                       desktop_native_widget_aura);
 }
 
 // static
 ui::NativeTheme* DesktopWindowTreeHost::GetNativeTheme(aura::Window* window) {
   const views::LinuxUI* linux_ui = views::LinuxUI::instance();
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views