Two tab dragging fixes for various window managers:...

chrome/common/x11_util.cc

 // Copyright (c) 2009 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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "chrome/common/x11_util.h"
 
 #include <string.h>
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
 
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
+#include <set>
+
 #include "base/logging.h"
 #include "base/gfx/size.h"
 #include "base/thread.h"
 #include "chrome/common/x11_util_internal.h"
 
 namespace x11_util {
 
 Display* GetXDisplay() {
   static Display* display = NULL;
 
@@ skipping 124 matching lines @@
     return false;
 
   if (!XTranslateCoordinates(GetSecondaryDisplay(), window, root,
                              0, 0, &x, &y, &child))
     return false;
 
   *rect = gfx::Rect(x, y, width, height);
   return true;
 }
 
-bool EnumerateAllWindows(EnumerateWindowsDelegate* delegate) {
-  XID root = GetX11RootWindow();
-  XID parent;
-  XID* children;
+// Returns true if |window| is a named window.
+bool IsWindowNamed(XID window) {
+  XTextProperty prop;
+  if (!XGetWMName(GetXDisplay(), window, &prop) || !prop.value)
+    return false;
+
+  XFree(prop.value);
+  return true;
+}
+
+bool EnumerateChildren(EnumerateWindowsDelegate* delegate, XID window,
+                       const int max_depth, int depth) {
+  if (depth > max_depth)
+    return false;
+
+  XID root, parent, *children;
   unsigned int num_children;
-  int status = XQueryTree(GetXDisplay(), root, &root, &parent,
-                          &children, &num_children);
+  int status = XQueryTree(GetXDisplay(), window, &root, &parent, &children,
+                          &num_children);
   if (status == 0)
     return false;
 
-  for (unsigned int i = 0; i < num_children; i++) {
-    if (delegate->ShouldStopIterating(children[i]))
-      break;
+  std::set<XID> windows;
+  for (unsigned int i = 0; i < num_children; i++)
+    windows.insert(children[i]);
+
+  XFree(children);
+
+  // XQueryTree returns the children of |window| in bottom-to-top order, so
+  // reverse-iterate the list to check the windows from top-to-bottom.
+  std::set<XID>::reverse_iterator iter;
+  for (iter = windows.rbegin(); iter != windows.rend(); iter++) {
+    if (IsWindowNamed(*iter) && delegate->ShouldStopIterating(*iter))
+      return true;
   }
 
-  XFree(children);
-  return true;
+  // If we're at this point, we didn't find the window we're looking for at the
+  // current level, so we need to recurse to the next level.  We use a second
+  // loop because the recursion and call to XQueryTree are expensive and is only
+  // needed for a small number of cases.
+  depth++;
+  for (iter = windows.rbegin(); iter != windows.rend(); iter++) {
+    if (EnumerateChildren(delegate, *iter, max_depth, depth))
+      return true;
+  }
+
+  return false;
+}
+
+bool EnumerateAllWindows(EnumerateWindowsDelegate* delegate, int max_depth) {
+  XID root = GetX11RootWindow();
+  return EnumerateChildren(delegate, root, max_depth, 0);
 }
 
 XRenderPictFormat* GetRenderVisualFormat(Display* dpy, Visual* visual) {
   static XRenderPictFormat* pictformat = NULL;
   if (pictformat)
     return pictformat;
 
   DCHECK(QueryRenderSupport(dpy));
 
   pictformat = XRenderFindVisualFormat(dpy, visual);
@@ skipping 120 matching lines @@
     return false;
 
   if (children)
     XFree(children);
 
   *parent_is_root = root_window == *parent_window;
   return true;
 }
 
 }  // namespace x11_util