Merge three implementations for getting the topmost x11 window at a point

ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.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_drag_drop_client_aurax11.h"
 
 #include <X11/Xatom.h>
 
 #include "base/event_types.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drop_target_event.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_aurax11.h"
 #include "ui/base/x/selection_utils.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/event.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
+#include "ui/views/widget/desktop_aura/x11_topmost_window_finder.h"
 #include "ui/wm/public/drag_drop_client.h"
 #include "ui/wm/public/drag_drop_delegate.h"
 
 using aura::client::DragDropDelegate;
 using ui::OSExchangeData;
 
 namespace {
 
 const int kMinXdndVersion = 5;
 
@@ skipping 23 matching lines @@
   "XdndDrop",
   "XdndEnter",
   "XdndFinished",
   "XdndLeave",
   "XdndPosition",
   "XdndProxy",  // Proxy windows?
   kXdndSelection,
   "XdndStatus",
   "XdndTypeList",
   ui::Clipboard::kMimeTypeText,
-  "_NET_WM_WINDOW_TYPE_MENU",
   NULL
 };
 
 // The time to wait for the target to respond after the user has released the
 // mouse button before ending the move loop.
 const int kEndMoveLoopTimeoutMs = 1000;
 
 static base::LazyInstance<
     std::map< ::Window, views::DesktopDragDropClientAuraX11*> >::Leaky
         g_live_client_map = LAZY_INSTANCE_INITIALIZER;
 
-// Helper class to FindWindowFor which looks for a drag target under the
-// cursor.
-class DragTargetWindowFinder : public ui::EnumerateWindowsDelegate {
- public:
-  DragTargetWindowFinder(XID ignored_icon_window,
-                         Atom menu_type_atom,
-                         gfx::Point screen_loc)
-      : ignored_icon_window_(ignored_icon_window),
-        output_window_(None),
-        menu_type_atom_(menu_type_atom),
-        screen_loc_(screen_loc) {
-    ui::EnumerateTopLevelWindows(this);
-  }
-
-  virtual ~DragTargetWindowFinder() {}
-
-  XID window() const { return output_window_; }
-
- protected:
-  virtual bool ShouldStopIterating(XID window) OVERRIDE {
-    if (window == ignored_icon_window_)
-      return false;
-
-    if (!ui::IsWindowVisible(window))
-      return false;
-
-    if (!ui::WindowContainsPoint(window, screen_loc_))
-      return false;
-
-    int value = 0;
-    if (ui::PropertyExists(window, "WM_STATE") ||
-        (ui::GetIntProperty(window, "_NET_WM_WINDOW_TYPE", &value) &&
-         static_cast<Atom>(value) == menu_type_atom_)) {
-      output_window_ = window;
-      return true;
-    }
-
-    return false;
-  }
-
- private:
-  XID ignored_icon_window_;
-  XID output_window_;
-  const Atom menu_type_atom_;
-  gfx::Point screen_loc_;
-
-  DISALLOW_COPY_AND_ASSIGN(DragTargetWindowFinder);
-};
-
 // Returns the topmost X11 window at |screen_point| if it is advertising that
 // is supports the Xdnd protocol. Will return the window under the pointer as
 // |mouse_window|. If there's a Xdnd aware window, it will be returned in
 // |dest_window|.
 void FindWindowFor(const gfx::Point& screen_point,
-                   ::Window* mouse_window, ::Window* dest_window,
-                   Atom menu_type_atom) {
-  DragTargetWindowFinder finder(None, menu_type_atom, screen_point);
-  *mouse_window = finder.window();
+                   ::Window* mouse_window,
+                   ::Window* dest_window) {
+  views::X11TopmostWindowFinder finder;
+  *mouse_window = finder.FindWindowAt(screen_point);
   *dest_window = None;
 
-  if (finder.window() == None)
+  if (*mouse_window == None)
     return;
 
   // Figure out which window we should test as XdndAware. If mouse_window has
   // XdndProxy, it will set that proxy on target, and if not, |target|'s
   // original value will remain.
   XID target = *mouse_window;
   ui::GetXIDProperty(*mouse_window, "XdndProxy", &target);
 
   int version;
   if (ui::GetIntProperty(target, "XdndAware", &version) &&
@@ skipping 562 matching lines @@
 
 void DesktopDragDropClientAuraX11::OnMouseMovement(XMotionEvent* event) {
   gfx::Point screen_point(event->x_root, event->y_root);
 
   if (source_state_ != SOURCE_STATE_OTHER)
     return;
 
   // Find the current window the cursor is over.
   ::Window mouse_window = None;
   ::Window dest_window = None;
-  FindWindowFor(screen_point, &mouse_window, &dest_window,
-                atom_cache_.GetAtom("_NET_WM_WINDOW_TYPE_MENU"));
+  FindWindowFor(screen_point, &mouse_window, &dest_window);
 
   if (source_current_window_ != dest_window) {
     if (source_current_window_ != None)
       SendXdndLeave(source_current_window_);
 
     source_current_window_ = dest_window;
 
     if (source_current_window_ != None) {
       negotiated_operation_.erase(source_current_window_);
       SendXdndEnter(source_current_window_);
@@ skipping 309 matching lines @@
   // GdkEvent about the failed drag. (And sending this message doesn't appear
   // to go through normal xlib machinery, but instead passes through the low
   // level xProto (the x11 wire format) that I don't understand.
   //
   // I'm unsure if I have to jump through those hoops, or if XSendEvent is
   // sufficient.
   XSendEvent(xdisplay_, xid, False, 0, xev);
 }
 
 }  // namespace views