Allows menu host windows to be enumerated in DragTargetWindowFinder

ui/base/x/x11_util.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.
 
 // 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 "ui/base/x/x11_util.h"
 
@@ skipping 1049 matching lines @@
 
   XFree(prop.value);
   return true;
 }
 
 bool EnumerateChildren(EnumerateWindowsDelegate* delegate, XID window,
                        const int max_depth, int depth) {
   if (depth > max_depth)
     return false;
 
+  std::vector<XID> windows;
+  std::vector<XID>::iterator iter;
+  if (depth == 0) {
+    XMenuList::GetInstance()->InsertMenuWindowXIDs(&windows);

[sadrul, 2014/03/26 18:01:07]

Is this necessary when XQueryTree is used?

[varkha, 2014/03/27 04:48:13]

Yes (I think). We call IsWindowNamed(*iter) on the children (line 1097) to
verify and the menus or their hosts and containers are not named. Since the
menus stack is never long this should not be a perf burden, certainly less than
adding an alternative check here for the menu type which would be a round trip
to X.

+    // Enumerate the menus first.
+    for (iter = windows.begin(); iter != windows.end(); iter++) {
+      if (delegate->ShouldStopIterating(*iter))
+        return true;
+    }
+    windows.clear();
+  }
+
   XID root, parent, *children;
   unsigned int num_children;
   int status = XQueryTree(gfx::GetXDisplay(), window, &root, &parent, &children,
                           &num_children);
   if (status == 0)
     return false;
 
-  std::vector<XID> windows;
   for (int i = static_cast<int>(num_children) - 1; i >= 0; i--)
     windows.push_back(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::vector<XID>::iterator iter;
   for (iter = windows.begin(); iter != windows.end(); iter++) {
     if (IsWindowNamed(*iter) && delegate->ShouldStopIterating(*iter))
       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.
   if (++depth <= max_depth) {
@@ skipping 15 matching lines @@
   std::vector<XID> stack;
   if (!ui::GetXWindowStack(ui::GetX11RootWindow(), &stack)) {
     // Window Manager doesn't support _NET_CLIENT_LIST_STACKING, so fall back
     // to old school enumeration of all X windows.  Some WMs parent 'top-level'
     // windows in unnamed actual top-level windows (ion WM), so extend the
     // search depth to all children of top-level windows.
     const int kMaxSearchDepth = 1;
     ui::EnumerateAllWindows(delegate, kMaxSearchDepth);
     return;
   }
+  XMenuList::GetInstance()->InsertMenuWindowXIDs(&stack);
 
   std::vector<XID>::iterator iter;
   for (iter = stack.begin(); iter != stack.end(); iter++) {
     if (delegate->ShouldStopIterating(*iter))
       return;
   }
 }
 
 bool GetXWindowStack(Window window, std::vector<XID>* windows) {
   windows->clear();
@@ skipping 328 matching lines @@
 ::Cursor XScopedCursor::get() const {
   return cursor_;
 }
 
 void XScopedCursor::reset(::Cursor cursor) {
   if (cursor_)
     XFreeCursor(display_, cursor_);
   cursor_ = cursor;
 }
 
+// static
+XMenuList* XMenuList::GetInstance() {
+  return Singleton<XMenuList>::get();
+}
+
+XMenuList::XMenuList()
+    : menu_type_atom_(GetAtom("_NET_WM_WINDOW_TYPE_MENU")) {
+}
+
+XMenuList::~XMenuList() {
+  menus_.clear();
+}
+
+void XMenuList::MaybeRegisterMenu(XID menu) {
+  int value = 0;
+  if (!GetIntProperty(menu, "_NET_WM_WINDOW_TYPE", &value) ||
+      static_cast<Atom>(value) != menu_type_atom_) {
+    return;
+  }
+  menus_.push_back(menu);
+}
+
+void XMenuList::MaybeUnregisterMenu(XID menu) {
+  std::vector<XID>::iterator iter = std::find(menus_.begin(), menus_.end(),
+                                              menu);
+  if (iter == menus_.end())
+    return;
+  menus_.erase(iter);
+}
+
+void XMenuList::InsertMenuWindowXIDs(std::vector<XID>* stack) {
+  std::vector<XID>::iterator iter;
+  for (iter = menus_.begin(); iter != menus_.end(); ++iter)
+    stack->insert(stack->begin(), *iter);
+}
+
 // ----------------------------------------------------------------------------
 // These functions are declared in x11_util_internal.h because they require
 // XLib.h to be included, and it conflicts with many other headers.
 XRenderPictFormat* GetRenderARGB32Format(XDisplay* dpy) {
   static XRenderPictFormat* pictformat = NULL;
   if (pictformat)
     return pictformat;
 
   // First look for a 32-bit format which ignores the alpha value
   XRenderPictFormat templ;
@@ skipping 110 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui