Fix aura_unittests for Ozone X11.

ui/platform_window/x11/x11_window_base.cc

 // Copyright 2016 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/platform_window/x11/x11_window_base.h"
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
@@ skipping 23 matching lines @@
 
 XID FindXEventTarget(const XEvent& xev) {
   XID target = xev.xany.window;
   if (xev.type == GenericEvent)
     target = static_cast<XIDeviceEvent*>(xev.xcookie.data)->event;
   return target;
 }
 
 }  // namespace
 
-X11WindowBase::X11WindowBase(PlatformWindowDelegate* delegate)
+X11WindowBase::X11WindowBase(PlatformWindowDelegate* delegate,
+                             const gfx::Rect& bounds)
     : delegate_(delegate),
       xdisplay_(gfx::GetXDisplay()),
       xwindow_(None),
       xroot_window_(DefaultRootWindow(xdisplay_)),
-      atom_cache_(xdisplay_, kAtomsToCache) {
+      atom_cache_(xdisplay_, kAtomsToCache),
+      bounds_(bounds) {
   DCHECK(delegate_);
   TouchFactory::SetTouchDeviceListFromCommandLine();
 }
 
 X11WindowBase::~X11WindowBase() {
   Destroy();
 }
 
 void X11WindowBase::Destroy() {
   if (xwindow_ == None)
     return;
 
   // Stop processing events.
   XID xwindow = xwindow_;
   XDisplay* xdisplay = xdisplay_;
   xwindow_ = None;
   delegate_->OnClosed();
   // |this| might be deleted because of the above call.
 
   XDestroyWindow(xdisplay, xwindow);
 }
 
 void X11WindowBase::Create() {
+  DCHECK(!bounds_.size().IsEmpty());
+
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   swa.bit_gravity = NorthWestGravity;
   swa.override_redirect = g_override_redirect;
-  xwindow_ = XCreateWindow(
-      xdisplay_, xroot_window_, requested_bounds_.x(), requested_bounds_.y(),
-      requested_bounds_.width(), requested_bounds_.height(),
-      0,               // border width
-      CopyFromParent,  // depth
-      InputOutput,
-      CopyFromParent,  // visual
-      CWBackPixmap | CWBitGravity | CWOverrideRedirect, &swa);
+  xwindow_ =
+      XCreateWindow(xdisplay_, xroot_window_, bounds_.x(), bounds_.y(),
+                    bounds_.width(), bounds_.height(),
+                    0,               // border width
+                    CopyFromParent,  // depth
+                    InputOutput,
+                    CopyFromParent,  // visual
+                    CWBackPixmap | CWBitGravity | CWOverrideRedirect, &swa);
 
   // Setup XInput event mask.
   long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
                     KeyPressMask | KeyReleaseMask | EnterWindowMask |
                     LeaveWindowMask | ExposureMask | VisibilityChangeMask |
                     StructureNotifyMask | PropertyChangeMask |
                     PointerMotionMask;
   xwindow_events_.reset(new ui::XScopedEventSelector(xwindow_, event_mask));
 
   // Setup XInput2 event mask.
@@ skipping 32 matching lines @@
   static_assert(sizeof(long) >= sizeof(pid_t),
                 "pid_t should not be larger than long");
   long pid = getpid();
   XChangeProperty(xdisplay_, xwindow_, atom_cache_.GetAtom("_NET_WM_PID"),
                   XA_CARDINAL, 32, PropModeReplace,
                   reinterpret_cast<unsigned char*>(&pid), 1);
   // Before we map the window, set size hints. Otherwise, some window managers
   // will ignore toplevel XMoveWindow commands.
   XSizeHints size_hints;
   size_hints.flags = PPosition | PWinGravity;
-  size_hints.x = requested_bounds_.x();
-  size_hints.y = requested_bounds_.y();
+  size_hints.x = bounds_.x();
+  size_hints.y = bounds_.y();
   // Set StaticGravity so that the window position is not affected by the
   // frame width when running with window manager.
   size_hints.win_gravity = StaticGravity;
   XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
 
   // TODO(sky): provide real scale factor.
   delegate_->OnAcceleratedWidgetAvailable(xwindow_, 1.f);
 }
 
 void X11WindowBase::Show() {
@@ skipping 17 matching lines @@
     return;
   XWithdrawWindow(xdisplay_, xwindow_, 0);
   window_mapped_ = false;
 }
 
 void X11WindowBase::Close() {
   Destroy();
 }
 
 void X11WindowBase::SetBounds(const gfx::Rect& bounds) {
-  requested_bounds_ = bounds;
-  if (!window_mapped_ || bounds == confirmed_bounds_)
+  if (bounds == bounds_)
     return;
-  XWindowChanges changes = {0};
-  unsigned value_mask = CWX | CWY | CWWidth | CWHeight;
-  changes.x = bounds.x();
-  changes.y = bounds.y();
-  changes.width = bounds.width();
-  changes.height = bounds.height();
-  XConfigureWindow(xdisplay_, xwindow_, value_mask, &changes);
+
+  if (window_mapped_) {
+    XWindowChanges changes = {0};
+    unsigned value_mask = CWX | CWY | CWWidth | CWHeight;
+    changes.x = bounds.x();
+    changes.y = bounds.y();
+    changes.width = bounds.width();
+    changes.height = bounds.height();
+    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;
+  delegate_->OnBoundsChanged(bounds_);
 }
 
 gfx::Rect X11WindowBase::GetBounds() {
-  return confirmed_bounds_;
+  return bounds_;
 }
 
 void X11WindowBase::SetTitle(const base::string16& title) {
   if (window_title_ == title)
     return;
   window_title_ = title;
   std::string utf8str = base::UTF16ToUTF8(title);
   XChangeProperty(xdisplay_, xwindow_, atom_cache_.GetAtom("_NET_WM_NAME"),
                   atom_cache_.GetAtom("UTF8_STRING"), 8, PropModeReplace,
                   reinterpret_cast<const unsigned char*>(utf8str.c_str()),
@@ skipping 14 matching lines @@
 void X11WindowBase::ToggleFullscreen() {}
 
 void X11WindowBase::Maximize() {}
 
 void X11WindowBase::Minimize() {}
 
 void X11WindowBase::Restore() {}
 
 void X11WindowBase::MoveCursorTo(const gfx::Point& location) {
   XWarpPointer(xdisplay_, None, xroot_window_, 0, 0, 0, 0,
-               confirmed_bounds_.x() + location.x(),
-               confirmed_bounds_.y() + location.y());
+               bounds_.x() + location.x(), bounds_.y() + location.y());
 }
 
 void X11WindowBase::ConfineCursorToBounds(const gfx::Rect& bounds) {}
 
 PlatformImeController* X11WindowBase::GetPlatformImeController() {
   return nullptr;
 }
 
 bool X11WindowBase::IsEventForXWindow(const XEvent& xev) const {
   return xwindow_ != None && FindXEventTarget(xev) == xwindow_;
@@ skipping 22 matching lines @@
       int translated_x_in_pixels = xev->xconfigure.x;
       int translated_y_in_pixels = xev->xconfigure.y;
       if (!xev->xconfigure.send_event && !xev->xconfigure.override_redirect) {
         Window unused;
         XTranslateCoordinates(xdisplay_, xwindow_, xroot_window_, 0, 0,
                               &translated_x_in_pixels, &translated_y_in_pixels,
                               &unused);
       }
       gfx::Rect bounds(translated_x_in_pixels, translated_y_in_pixels,
                        xev->xconfigure.width, xev->xconfigure.height);
-      if (confirmed_bounds_ != bounds) {
-        confirmed_bounds_ = bounds;
-        delegate_->OnBoundsChanged(confirmed_bounds_);
+      if (bounds_ != bounds) {
+        bounds_ = bounds;
+        delegate_->OnBoundsChanged(bounds_);
       }
       break;
     }
 
     case ClientMessage: {
       Atom message = static_cast<Atom>(xev->xclient.data.l[0]);
       if (message == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
         delegate_->OnCloseRequest();
       } else if (message == atom_cache_.GetAtom("_NET_WM_PING")) {
         XEvent reply_event = *xev;
@@ skipping 10 matching lines @@
 }
 
 namespace test {
 
 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) {
   g_override_redirect = override_redirect;
 }
 
 }  // namespace test
 }  // namespace ui