x11: Don't wait on a MapNotify on override-redirect windows.

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/Xatom.h>
 #include <X11/Xregion.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 148 matching lines @@
 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),
       is_fullscreen_(false),
       is_always_on_top_(false),
+      is_override_redirect_(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),
       custom_window_shape_(false),
       urgency_hint_set_(false),
@@ skipping 783 matching lines @@
 
 void DesktopWindowTreeHostX11::ShowImpl() {
   ShowWindowWithState(ui::SHOW_STATE_NORMAL);
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(true);
 }
 
 void DesktopWindowTreeHostX11::HideImpl() {
   if (window_mapped_) {
     XWithdrawWindow(xdisplay_, xwindow_, 0);
     window_mapped_ = false;
+    if (is_override_redirect_) {
+      // If we're override-redirect, we won't receive an UnmapNotify message,
+      // so run the unmap handler directly.
+      OnX11WindowUnmapped();
+    }
   }
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(false);
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetBounds() const {
   return bounds_in_pixels_;
 }
 
 void DesktopWindowTreeHostX11::SetBounds(
     const gfx::Rect& requested_bounds_in_pixel) {
@@ skipping 134 matching lines @@
       window_type = atom_cache_.GetAtom("_NET_WM_WINDOW_TYPE_NORMAL");
       break;
   }
   // An in-activatable window should not interact with the system wm.
   if (!activatable_)
     swa.override_redirect = True;
 
   if (swa.override_redirect)
     attribute_mask |= CWOverrideRedirect;
 
+  is_override_redirect_ = swa.override_redirect;
+
   Visual* visual;
   int depth;
   ui::ChooseVisualForWindow(&visual, &depth);
   if (depth == 32) {
     attribute_mask |= CWColormap;
     swa.colormap =
         XCreateColormap(xdisplay_, x_root_window_, visual, AllocNone);
 
     // x.org will BadMatch if we don't set a border when the depth isn't the
     // same as the parent depth.
@@ skipping 239 matching lines @@
   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_in_pixels_ =
         gfx::Insets(insets[2], insets[0], insets[3], insets[1]);
   } else {
     native_window_frame_borders_in_pixels_ = gfx::Insets();
   }
 }
 
+void DesktopWindowTreeHostX11::OnX11WindowMapped() {
+  if (!window_mapped_) {
+    window_mapped_ = true;
+
+    FOR_EACH_OBSERVER(DesktopWindowTreeHostObserverX11,
+                      observer_list_,
+                      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;
+    }
+  }
+
+  // If we're an override redirect window, we need to perform a full redraw
+  // because on AMD drivers we might get a MapNotify event after performing the
+  // initial draw, which can result in a blank window. crbug.com/606661.
+  if (is_override_redirect_)
+    compositor()->ScheduleFullRedraw();
+}
+
+void DesktopWindowTreeHostX11::OnX11WindowUnmapped() {
+  window_mapped_ = false;
+  FOR_EACH_OBSERVER(DesktopWindowTreeHostObserverX11,
+                    observer_list_,
+                    OnWindowUnmapped(xwindow_));
+}
+
 void DesktopWindowTreeHostX11::UpdateMinAndMaxSize() {
   if (!window_mapped_)
     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)
@@ skipping 252 matching lines @@
                     xwindow_,
                     atom_cache_.GetAtom("_NET_WM_USER_TIME"),
                     XA_CARDINAL,
                     32,
                     PropModeReplace,
                     reinterpret_cast<const unsigned char *>(&wm_user_time_ms),
                     1);
   }
 
   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.
-  if (ui::X11EventSource::GetInstance())
-    ui::X11EventSource::GetInstance()->BlockUntilWindowMapped(xwindow_);
+  if (is_override_redirect_) {
+    // Override redirect windows don't get routed through the window manager;
+    // we won't reliably get a MapNotify.
+    OnX11WindowMapped();
+  } else {
+    // 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.
+    if (ui::X11EventSource::GetInstance())
+      ui::X11EventSource::GetInstance()->BlockUntilWindowMapped(xwindow_);
+  }
 }
 
 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 193 matching lines @@
         default:
           NOTREACHED();
       }
 
       // If we coalesced an event we need to free its cookie.
       if (num_coalesced > 0)
         XFreeEventData(xev->xgeneric.display, &last_event.xcookie);
       break;
     }
     case MapNotify: {
-      window_mapped_ = true;
-
-      FOR_EACH_OBSERVER(DesktopWindowTreeHostObserverX11,
-                        observer_list_,
-                        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;
-      }
-
+      OnX11WindowMapped();
       break;
     }
     case UnmapNotify: {
-      FOR_EACH_OBSERVER(DesktopWindowTreeHostObserverX11,
-                        observer_list_,
-                        OnWindowUnmapped(xwindow_));
+      OnX11WindowUnmapped();
       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.
           OnHostCloseRequested();
         } else if (protocol == atom_cache_.GetAtom("_NET_WM_PING")) {
@@ skipping 132 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeThemeAura::instance();
 }
 
 }  // namespace views