Make browser windows override_redirect when dragging tabs.

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 286 matching lines @@
   window()->SetProperty(kViewsWindowForRootWindow, content_window_);
   window()->SetProperty(kHostForRootWindow, this);
 
   // Ensure that the X11DesktopHandler exists so that it dispatches activation
   // messages to us.
   X11DesktopHandler::get();
 
   // TODO(erg): Unify this code once the other consumer goes away.
   SwapNonClientEventHandler(
       scoped_ptr<ui::EventHandler>(new X11WindowEventFilter(this)).Pass());
-  SetUseNativeFrame(params.type == Widget::InitParams::TYPE_WINDOW &&
+  SetUseNativeFrame((params.type == Widget::InitParams::TYPE_WINDOW ||
+                     params.type == Widget::InitParams::TYPE_DRAG_BROWSER) &&
                     !params.remove_standard_frame);
 
   x11_window_move_client_.reset(new X11DesktopWindowMoveClient);
   aura::client::SetWindowMoveClient(window(), x11_window_move_client_.get());
 
   SetWindowTransparency();
 
   native_widget_delegate_->OnNativeWidgetCreated(true);
 }
 
@@ skipping 774 matching lines @@
       window_type = atom_cache_.GetAtom("_NET_WM_WINDOW_TYPE_TOOLTIP");
       break;
     case Widget::InitParams::TYPE_POPUP:
       swa.override_redirect = True;
       window_type = atom_cache_.GetAtom("_NET_WM_WINDOW_TYPE_NOTIFICATION");
       break;
     case Widget::InitParams::TYPE_DRAG:
       swa.override_redirect = True;
       window_type = atom_cache_.GetAtom("_NET_WM_WINDOW_TYPE_DND");
       break;
+    case Widget::InitParams::TYPE_DRAG_BROWSER:
+      swa.override_redirect = True;
+      break;
     default:
       window_type = atom_cache_.GetAtom("_NET_WM_WINDOW_TYPE_NORMAL");
       break;
   }
   if (swa.override_redirect)
     attribute_mask |= CWOverrideRedirect;
 
   // Detect whether we're running inside a compositing manager. If so, try to
   // use the ARGB visual. Otherwise, just use our parent's visual.
   Visual* visual = CopyFromParent;
@@ skipping 160 matching lines @@
       ViewsDelegate::GetInstance()
           ? ViewsDelegate::GetInstance()->GetDefaultWindowIcon()
           : NULL;
   if (window_icon) {
     SetWindowIcons(gfx::ImageSkia(), *window_icon);
   }
   CreateCompositor();
   OnAcceleratedWidgetAvailable();
 }
 
+void DesktopWindowTreeHostX11::RemapWindow() {
+  XUnmapWindow(xdisplay_, xwindow_);
+  XSetWindowAttributes swa;
+  swa.override_redirect = False;
+  XChangeWindowAttributes(xdisplay_, xwindow_, CWOverrideRedirect, &swa);
+  XMapWindow(xdisplay_, xwindow_);

[Elliot Glaysher, 2015/11/18 18:20:21]

Have you tested this in other window managers? This seems like the sort of state
that could be improperly cached, and I vaguely remember a bug like that in the
handling of override redirect.

[Daniel Erat, 2015/11/18 18:38:36]

oh, yeah. i was recommending creating a new window and reparenting the contents
into it to avoid this.

i think it depends on the window manager -- some may create an internal object
to track a window when it's first created, while others may wait until it's
first mapped. i wouldn't trust any of them to do something reasonable if the
override-redirect state of a window that they're already tracking changes. :-P

(it's almost as if the people who wrote ICCCM and EWMH should've also written
exhaustive tests so WM developers could verify that their code behaves
correctly! :-P)

[stapelberg, 2015/12/23 13:17:24]

Not entirely sure what you mean by “other window managers”, do you have a list
of window managers in which you’d like me to test this code?

Note that we’re creating the window with override-redirect=True, meaning it will
override any redirects, including the MapWindow redirect on the root window, so
window managers will not even be informed that this window exists. I’d be very
surprised to find out that some window manager felt the need to come up with a
non-standard way of figuring out when new windows are created (repeatedly
querying the tree?) and then tracking the override-redirect state and not
updating it.

I’ve considered doing the reparenting regardless, but it actually blows up the
code a lot for two reasons:

1. AFAICT, there is no way to identify the content window (the GL surface
window) from within the code itself, because it is created and maintained by the
GPU process. Hence, I’d need to use XQueryTree() to find all child windows of
xwindow_.

2. I’d need to create a new X11 window which has the same attributes (doable)
and the same properties (ugh) as the original window. This strikes me as
complicated and error-prone.

I’d prefer if we could keep the current approach of unmapping the window,
changing override-redirect to False and mapping it.

+}
+
 gfx::Size DesktopWindowTreeHostX11::AdjustSize(
     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_in_pixels == displays[i].GetSizeInPixel()) {
       return gfx::Size(requested_size_in_pixels.width() - 1,
                        requested_size_in_pixels.height() - 1);
@@ skipping 764 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views