Avoid blocking while mapping an X11 window

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 170 matching lines @@
 // 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),
       window_mapped_(false),
-      wait_for_unmap_(false),
+      is_visible_(false),
       is_fullscreen_(false),
       is_always_on_top_(false),
       use_native_frame_(false),
       should_maximize_after_map_(false),
       use_argb_visual_(false),
       drag_drop_client_(NULL),
       native_widget_delegate_(native_widget_delegate),
       desktop_native_widget_aura_(desktop_native_widget_aura),
       content_window_(NULL),
       window_parent_(NULL),
@@ skipping 384 matching lines @@
 
 void DesktopWindowTreeHostX11::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
   ShowWindowWithState(ui::SHOW_STATE_MAXIMIZED);
   // 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_ && !wait_for_unmap_;
+  return is_visible_;
 }
 
 void DesktopWindowTreeHostX11::SetSize(const gfx::Size& requested_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) {
@@ skipping 599 matching lines @@
   return xwindow_;
 }
 
 void DesktopWindowTreeHostX11::ShowImpl() {
   ShowWindowWithState(ui::SHOW_STATE_NORMAL);
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(true);
 }
 
 void DesktopWindowTreeHostX11::HideImpl() {
   if (IsVisible()) {
     XWithdrawWindow(xdisplay_, xwindow_, 0);

[Daniel Erat, 2017/03/09 15:07:22]

this also unmaps the window, right? is there a reason why we don't set
window_mapped_ to false here and instead wait for UnmapNotify?

[Tom (Use chromium acct), 2017/03/10 01:29:57]

Before, we had wait_for_unmap_ that sort of did this.  But, now there's no point
in adding a BlockUntilWindowUnmapped

-    wait_for_unmap_ = true;
+    is_visible_ = false;
   }
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(false);
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetBoundsInPixels() const {
   return bounds_in_pixels_;
 }
 
 void DesktopWindowTreeHostX11::SetBoundsInPixels(
     const gfx::Rect& requested_bounds_in_pixel) {
   gfx::Rect bounds_in_pixels(requested_bounds_in_pixel.origin(),
                              AdjustSize(requested_bounds_in_pixel.size()));
   bool origin_changed = bounds_in_pixels_.origin() != bounds_in_pixels.origin();
   bool size_changed = bounds_in_pixels_.size() != bounds_in_pixels.size();
   XWindowChanges changes = {0};
   unsigned value_mask = 0;
 
-  delayed_resize_task_.Cancel();
 
   if (size_changed) {
+    // Only cancel the delayed resize task if we're already about to call
+    // OnHostResized in this function.
+    delayed_resize_task_.Cancel();
+
     // Update the minimum and maximum sizes in case they have changed.
     UpdateMinAndMaxSize();
 
     if (bounds_in_pixels.width() < min_size_in_pixels_.width() ||
         bounds_in_pixels.height() < min_size_in_pixels_.height() ||
         (!max_size_in_pixels_.IsEmpty() &&
          (bounds_in_pixels.width() > max_size_in_pixels_.width() ||
           bounds_in_pixels.height() > max_size_in_pixels_.height()))) {
       gfx::Size size_in_pixels = bounds_in_pixels.size();
       if (!max_size_in_pixels_.IsEmpty())
@@ skipping 399 matching lines @@
       insets.size() == 4) {
     // |insets| are returned in the order: [left, right, top, bottom].
     native_window_frame_borders_in_pixels_ =
         gfx::Insets(insets[2], insets[0], insets[3], insets[1]);
   } else {
     native_window_frame_borders_in_pixels_ = gfx::Insets();
   }
 }
 
 void DesktopWindowTreeHostX11::UpdateMinAndMaxSize() {
-  if (!IsVisible())
-    return;
-
   gfx::Size minimum_in_pixels =
       ToPixelRect(gfx::Rect(native_widget_delegate_->GetMinimumSize())).size();
   gfx::Size maximum_in_pixels =
       ToPixelRect(gfx::Rect(native_widget_delegate_->GetMaximumSize())).size();
   if (min_size_in_pixels_ == minimum_in_pixels &&
       max_size_in_pixels_ == maximum_in_pixels)
     return;
 
   min_size_in_pixels_ = minimum_in_pixels;
   max_size_in_pixels_ = maximum_in_pixels;
@@ skipping 250 matching lines @@
   if (show_state == ui::SHOW_STATE_INACTIVE || wm_user_time_ms != 0) {
     XChangeProperty(
         xdisplay_, xwindow_, atom_cache_.GetAtom("_NET_WM_USER_TIME"),
         XA_CARDINAL, 32, PropModeReplace,
         reinterpret_cast<const unsigned char*>(&wm_user_time_ms), 1);
   }
 
   ui::X11EventSource* event_source = ui::X11EventSource::GetInstance();
   DCHECK(event_source);
 
-  if (wait_for_unmap_) {
-    // Block until our window is unmapped. This avoids a race condition when
-    // remapping an unmapped window.
-    event_source->BlockUntilWindowUnmapped(xwindow_);
-    DCHECK(!wait_for_unmap_);
-  }
+  UpdateMinAndMaxSize();
 
   XMapWindow(xdisplay_, xwindow_);
-
-  // We now block until our window is mapped. Some X11 APIs will crash and
-  // burn if passed |xwindow_| before the window is mapped, and XMapWindow is
-  // asynchronous.
-  event_source->BlockUntilWindowMapped(xwindow_);
+  is_visible_ = true;
 }
 
 void DesktopWindowTreeHostX11::SetWindowTransparency() {
   compositor()->SetHostHasTransparentBackground(use_argb_visual_);
   window()->SetTransparent(use_argb_visual_);
   content_window_->SetTransparent(use_argb_visual_);
 }
 
 void DesktopWindowTreeHostX11::Relayout() {
   Widget* widget = native_widget_delegate_->AsWidget();
@@ skipping 207 matching lines @@
       if (num_coalesced > 0)
         XFreeEventData(xev->xgeneric.display, &last_event.xcookie);
       break;
     }
     case MapNotify: {
       window_mapped_ = true;
 
       for (DesktopWindowTreeHostObserverX11& observer : observer_list_)
         observer.OnWindowMapped(xwindow_);
 
-      UpdateMinAndMaxSize();
-
       // Some WMs only respect maximize hints after the window has been mapped.
       // Check whether we need to re-do a maximization.
       if (should_maximize_after_map_) {
         Maximize();
         should_maximize_after_map_ = false;
       }
 
       break;
     }
     case UnmapNotify: {
       window_mapped_ = false;
-      wait_for_unmap_ = false;
       has_pointer_ = false;
       has_pointer_grab_ = false;
       has_pointer_focus_ = false;
       has_window_focus_ = false;

[sadrul, 2017/02/04 02:27:51]

Should this update is_visible_ too?

[Tom (Use chromium acct), 2017/02/04 17:58:54]

no, is_visible is updated when the (un)map notify request is sent, window_mapped
is updated on a (un)map notify

       for (DesktopWindowTreeHostObserverX11& observer : observer_list_)
         observer.OnWindowUnmapped(xwindow_);
       break;
     }
     case ClientMessage: {
       Atom message_type = xev->xclient.message_type;
       if (message_type == atom_cache_.GetAtom("WM_PROTOCOLS")) {
         Atom protocol = static_cast<Atom>(xev->xclient.data.l[0]);
         if (protocol == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
           // We have received a close message from the window manager.
@@ skipping 159 matching lines @@
 
 // static
 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   return new DesktopWindowTreeHostX11(native_widget_delegate,
                                       desktop_native_widget_aura);
 }
 
 }  // namespace views